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::blockdsp;
   8 use nihav_codec_support::codecs::h263::*;
   9 use nihav_codec_support::codecs::h263::code::*;
  10 use nihav_codec_support::codecs::h263::decoder::*;
  11 use nihav_codec_support::codecs::h263::data::*;
  12
  13 #[allow(dead_code)]
  14 struct Tables {
  15     intra_mcbpc_cb: Codebook<u8>,
  16     inter_mcbpc_cb: Codebook<u8>,
  17     cbpy_cb:        Codebook<u8>,
  18     rl_cb:          Codebook<H263RLSym>,
  19     aic_rl_cb:      Codebook<H263RLSym>,
  20     mv_cb:          Codebook<u8>,
  21 }
  22
  23 struct VivoBlockDSP {
  24     dct_tab:        [[f64; 64]; 64],
  25 }
  26
  27 fn gen_coef(i: usize, j: usize) -> f64 {
  28     if i == 0 {
  29         1.0 / 8.0f64.sqrt()
  30     } else {
  31         (((j as f64) + 0.5) * (i as f64) * std::f64::consts::PI / 8.0).cos() * 0.5
  32     }
  33 }
  34
  35 impl VivoBlockDSP {
  36     fn new() -> Self {
  37         let mut dct_tab = [[0.0; 64]; 64];
  38         for i in 0..8 {
  39             for j in 0..8 {
  40                 for k in 0..8 {
  41                     for l in 0..8 {
  42                         let c0 = gen_coef(i, k);
  43                         let c1 = gen_coef(j, l);
  44                         let c = c0 * c1 * 64.0;
  45                         dct_tab[i * 8 + j][k * 8 + l] = c;
  46                     }
  47                 }
  48             }
  49         }
  50         Self {
  51             dct_tab
  52         }
  53     }
  54 }
  55
  56 #[allow(clippy::erasing_op)]
  57 #[allow(clippy::identity_op)]
  58 fn deblock_hor(buf: &mut [u8], stride: usize, off: usize, clip_tab: &[i16; 64]) {
  59     for x in 0..8 {
  60         let p1 = i16::from(buf[off - 2 * stride + x]);
  61         let p0 = i16::from(buf[off - 1 * stride + x]);
  62         let q0 = i16::from(buf[off + 0 * stride + x]);
  63         let q1 = i16::from(buf[off + 1 * stride + x]);
  64         let diff = (3 * (p1 - q1) + 8 * (q0 - p0)) >> 4;
  65         if (diff != 0) && (diff > -32) && (diff < 32) {
  66             let delta = clip_tab[(diff + 32) as usize];
  67             buf[off - 1 * stride + x] = (p0 + delta).max(0).min(255) as u8;
  68             buf[off + 0 * stride + x] = (q0 - delta).max(0).min(255) as u8;
  69         }
  70     }
  71 }
  72
  73 #[allow(clippy::identity_op)]
  74 fn deblock_ver(buf: &mut [u8], stride: usize, off: usize, clip_tab: &[i16; 64]) {
  75     for y in 0..8 {
  76         let p1 = i16::from(buf[off - 2 + y * stride]);
  77         let p0 = i16::from(buf[off - 1 + y * stride]);
  78         let q0 = i16::from(buf[off + 0 + y * stride]);
  79         let q1 = i16::from(buf[off + 1 + y * stride]);
  80         let diff = (3 * (p1 - q1) + 8 * (q0 - p0)) >> 4;
  81         if (diff != 0) && (diff > -32) && (diff < 32) {
  82             let delta = clip_tab[(diff + 32) as usize];
  83             buf[off - 1 + y * stride] = (p0 + delta).max(0).min(255) as u8;
  84             buf[off     + y * stride] = (q0 - delta).max(0).min(255) as u8;
  85         }
  86     }
  87 }
  88
  89 fn gen_clip_tab(clip_tab: &mut [i16; 64], q: u8) {
  90     let q = i16::from(q);
  91     *clip_tab = [0; 64];
  92     let lim = (q + 2) >> 1;
  93     for i in 0..lim {
  94         clip_tab[(32 - i) as usize] = -i;
  95         clip_tab[(32 + i) as usize] =  i;
  96     }
  97     for i in lim..q {
  98         let val = q - i;
  99         clip_tab[(32 - i) as usize] = -val;
 100         clip_tab[(32 + i) as usize] =  val;
 101     }
 102 }
 103
 104 impl BlockDSP for VivoBlockDSP {
 105     fn idct(&self, blk: &mut [i16; 64]) {
 106         let mut tmp = [0i32; 64];
 107         for (i, &el) in blk.iter().enumerate() {
 108             if el != 0 {
 109                 let cmat = self.dct_tab[i];
 110                 for (dst, &src) in tmp.iter_mut().zip(cmat.iter()) {
 111                     *dst += (src * (el as f64)) as i32;
 112                 }
 113             }
 114         }
 115         for (dst, &src) in blk.iter_mut().zip(tmp.iter()) {
 116             *dst = ((src + 0x20) >> 6) as i16;
 117         }
 118     }
 119     fn copy_blocks(&self, dst: &mut NAVideoBuffer<u8>, src: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, mv: MV) {
 120         let mode = ((mv.x & 1) + (mv.y & 1) * 2) as usize;
 121         let cmode = (if (mv.x & 3) != 0 { 1 } else { 0 }) + (if (mv.y & 3) != 0 { 2 } else { 0 });
 122
 123         let mut dst = NASimpleVideoFrame::from_video_buf(dst).unwrap();
 124
 125         blockdsp::copy_block(&mut dst, src.clone(), 0, xpos, ypos, mv.x >> 1, mv.y >> 1, 16, 16, 0, 1, mode, H263_INTERP_FUNCS);
 126         blockdsp::copy_block(&mut dst, src.clone(), 1, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_FUNCS);
 127         blockdsp::copy_block(&mut dst, src,         2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_FUNCS);
 128     }
 129     fn copy_blocks8x8(&self, dst: &mut NAVideoBuffer<u8>, src: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, mvs: &[MV; 4]) {
 130         let mut dst = NASimpleVideoFrame::from_video_buf(dst).unwrap();
 131
 132         for (i, mv) in mvs.iter().enumerate() {
 133             let xadd = (i & 1) * 8;
 134             let yadd = (i & 2) * 4;
 135             let mode = ((mv.x & 1) + (mv.y & 1) * 2) as usize;
 136
 137             blockdsp::copy_block(&mut dst, src.clone(), 0, xpos + xadd, ypos + yadd, mv.x >> 1, mv.y >> 1, 8, 8, 0, 1, mode, H263_INTERP_FUNCS);
 138         }
 139
 140         let sum_mv = mvs[0] + mvs[1] + mvs[2] + mvs[3];
 141         let cmx = (sum_mv.x >> 3) + H263_CHROMA_ROUND[(sum_mv.x & 0xF) as usize];
 142         let cmy = (sum_mv.y >> 3) + H263_CHROMA_ROUND[(sum_mv.y & 0xF) as usize];
 143         let mode = ((cmx & 1) + (cmy & 1) * 2) as usize;
 144         for plane in 1..3 {
 145             blockdsp::copy_block(&mut dst, src.clone(), plane, xpos >> 1, ypos >> 1, cmx >> 1, cmy >> 1, 8, 8, 0, 1, mode, H263_INTERP_FUNCS);
 146         }
 147     }
 148     fn avg_blocks(&self, dst: &mut NAVideoBuffer<u8>, src: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, mv: MV) {
 149         let mode = ((mv.x & 1) + (mv.y & 1) * 2) as usize;
 150         let cmode = (if (mv.x & 3) != 0 { 1 } else { 0 }) + (if (mv.y & 3) != 0 { 2 } else { 0 });
 151
 152         let mut dst = NASimpleVideoFrame::from_video_buf(dst).unwrap();
 153
 154         blockdsp::copy_block(&mut dst, src.clone(), 0, xpos, ypos, mv.x >> 1, mv.y >> 1, 16, 16, 0, 1, mode, H263_INTERP_AVG_FUNCS);
 155         blockdsp::copy_block(&mut dst, src.clone(), 1, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_AVG_FUNCS);
 156         blockdsp::copy_block(&mut dst, src,         2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_AVG_FUNCS);
 157     }
 158     fn avg_blocks8x8(&self, dst: &mut NAVideoBuffer<u8>, src: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, mvs: &[MV; 4]) {
 159         let mut dst = NASimpleVideoFrame::from_video_buf(dst).unwrap();
 160
 161         for (i, mv) in mvs.iter().enumerate() {
 162             let xadd = (i & 1) * 8;
 163             let yadd = (i & 2) * 4;
 164             let mode = ((mv.x & 1) + (mv.y & 1) * 2) as usize;
 165
 166             blockdsp::copy_block(&mut dst, src.clone(), 0, xpos + xadd, ypos + yadd, mv.x >> 1, mv.y >> 1, 8, 8, 0, 1, mode, H263_INTERP_AVG_FUNCS);
 167         }
 168
 169         let sum_mv = mvs[0] + mvs[1] + mvs[2] + mvs[3];
 170         let cmx = (sum_mv.x >> 3) + H263_CHROMA_ROUND[(sum_mv.x & 0xF) as usize];
 171         let cmy = (sum_mv.y >> 3) + H263_CHROMA_ROUND[(sum_mv.y & 0xF) as usize];
 172         let mode = ((cmx & 1) + (cmy & 1) * 2) as usize;
 173         for plane in 1..3 {
 174             blockdsp::copy_block(&mut dst, src.clone(), plane, xpos >> 1, ypos >> 1, cmx >> 1, cmy >> 1, 8, 8, 0, 1, mode, H263_INTERP_AVG_FUNCS);
 175         }
 176     }
 177     fn filter_row(&self, buf: &mut NAVideoBuffer<u8>, mb_y: usize, mb_w: usize, cbpi: &CBPInfo) {
 178         let ystride = buf.get_stride(0);
 179         let ustride = buf.get_stride(1);
 180         let vstride = buf.get_stride(2);
 181         let yoff = buf.get_offset(0) + mb_y * 16 * ystride;
 182         let uoff = buf.get_offset(1) + mb_y * 8 * ustride;
 183         let voff = buf.get_offset(2) + mb_y * 8 * vstride;
 184         let buf = buf.get_data_mut().unwrap();
 185
 186         let mut clip_tab = [0i16; 64];
 187         let mut last_q = 0;
 188         let mut off = yoff;
 189         for mb_x in 0..mb_w {
 190             let q = cbpi.get_q(mb_w + mb_x);
 191             if q != last_q {
 192                 gen_clip_tab(&mut clip_tab, q);
 193                 last_q = q;
 194             }
 195             if mb_y != 0 {
 196                 deblock_hor(buf, ystride, off, &clip_tab);
 197                 deblock_hor(buf, ystride, off + 8, &clip_tab);
 198             }
 199             deblock_hor(buf, ystride, off + 8 * ystride, &clip_tab);
 200             deblock_hor(buf, ystride, off + 8 * ystride + 8, &clip_tab);
 201             off += 16;
 202         }
 203         let mut off = yoff;
 204         for mb_x in 0..mb_w {
 205             let q = cbpi.get_q(mb_w + mb_x);
 206             if q != last_q {
 207                 gen_clip_tab(&mut clip_tab, q);
 208                 last_q = q;
 209             }
 210             if mb_y != 0 {
 211                 let qtop = cbpi.get_q(mb_x);
 212                 if qtop != last_q {
 213                     gen_clip_tab(&mut clip_tab, qtop);
 214                     last_q = qtop;
 215                 }
 216                 if mb_x != 0 {
 217                     deblock_ver(buf, ystride, off - 8 * ystride, &clip_tab);
 218                 }
 219                 deblock_ver(buf, ystride, off - 8 * ystride + 8, &clip_tab);
 220             }
 221             if mb_x != 0 {
 222                 deblock_ver(buf, ystride, off, &clip_tab);
 223                 deblock_ver(buf, ystride, off + 8, &clip_tab);
 224             }
 225             off += 16;
 226         }
 227         if mb_y != 0 {
 228             for mb_x in 0..mb_w {
 229                 let q = cbpi.get_q(mb_w + mb_x);
 230                 if q != last_q {
 231                     gen_clip_tab(&mut clip_tab, q);
 232                     last_q = q;
 233                 }
 234                 deblock_hor(buf, ustride, uoff + mb_x * 8, &clip_tab);
 235                 deblock_hor(buf, vstride, voff + mb_x * 8, &clip_tab);
 236             }
 237             let offu = uoff - 8 * ustride;
 238             let offv = voff - 8 * vstride;
 239             for mb_x in 1..mb_w {
 240                 let qt = cbpi.get_q(mb_x);
 241                 if qt != last_q {
 242                     gen_clip_tab(&mut clip_tab, qt);
 243                     last_q = qt;
 244                 }
 245                 deblock_ver(buf, ustride, offu + mb_x * 8, &clip_tab);
 246                 deblock_ver(buf, vstride, offv + mb_x * 8, &clip_tab);
 247             }
 248         }
 249     }
 250 }
 251
 252 struct VivoDecoder {
 253     info:       NACodecInfoRef,
 254     dec:        H263BaseDecoder,
 255     tables:     Tables,
 256     bdsp:       VivoBlockDSP,
 257     lastframe:  Option<NABufferType>,
 258     lastpts:    Option<u64>,
 259     width:      usize,
 260     height:     usize,
 261 }
 262
 263 struct VivoBR<'a> {
 264     br:     BitReader<'a>,
 265     tables: &'a Tables,
 266     gob_no: usize,
 267     mb_w:   usize,
 268     is_pb:  bool,
 269     is_ipb: bool,
 270     ref_w:  usize,
 271     ref_h:  usize,
 272     aic:    bool,
 273 }
 274
 275 fn check_marker<'a>(br: &mut BitReader<'a>) -> DecoderResult<()> {
 276     let mark = br.read(1)?;
 277     validate!(mark == 1);
 278     Ok(())
 279 }
 280
 281 impl<'a> VivoBR<'a> {
 282     fn new(src: &'a [u8], tables: &'a Tables, ref_w: usize, ref_h: usize) -> Self {
 283         VivoBR {
 284             br:     BitReader::new(src, BitReaderMode::BE),
 285             tables,
 286             gob_no: 0,
 287             mb_w:   0,
 288             is_pb:  false,
 289             is_ipb: false,
 290             ref_w, ref_h,
 291             aic:    false,
 292         }
 293     }
 294
 295     fn decode_block(&mut self, quant: u8, intra: bool, coded: bool, blk: &mut [i16; 64], _plane_no: usize, acpred: ACPredMode) -> DecoderResult<()> {
 296         let br = &mut self.br;
 297         let mut idx = 0;
 298         if !self.aic && intra {
 299             let mut dc = br.read(8)? as i16;
 300             if dc == 255 { dc = 128; }
 301             blk[0] = dc << 3;
 302             idx = 1;
 303         }
 304         if !coded { return Ok(()); }
 305         let scan = match acpred {
 306                     ACPredMode::Hor => H263_SCAN_V,
 307                     ACPredMode::Ver => H263_SCAN_H,
 308                     _               => &ZIGZAG,
 309                 };
 310
 311         let rl_cb = if self.aic && intra { &self.tables.aic_rl_cb } else { &self.tables.rl_cb };
 312         let q = i16::from(quant) * 2;
 313         let q_add = q >> 1;
 314         while idx < 64 {
 315             let code = br.read_cb(rl_cb)?;
 316             let run;
 317             let mut level;
 318             let last;
 319             if !code.is_escape() {
 320                 run   = code.get_run();
 321                 level = code.get_level();
 322                 last  = code.is_last();
 323                 if br.read_bool()? { level = -level; }
 324                 if !intra || !self.aic {
 325                     if level >= 0 {
 326                         level = (level * q) + q_add;
 327                     } else {
 328                         level = (level * q) - q_add;
 329                     }
 330                 }
 331             } else {
 332                 last  = br.read_bool()?;
 333                 run   = br.read(6)? as u8;
 334                 level = br.read_s(8)? as i16;
 335                 if level == -128 {
 336                     let low = br.read(5)? as i16;
 337                     let top = br.read_s(6)? as i16;
 338                     level = (top << 5) | low;
 339                 }
 340                 if !intra || !self.aic {
 341                     if level >= 0 {
 342                         level = (level * q) + q_add;
 343                     } else {
 344                         level = (level * q) - q_add;
 345                     }
 346                     if level < -2048 { level = -2048; }
 347                     if level >  2047 { level =  2047; }
 348                 }
 349             }
 350             idx += run;
 351             validate!(idx < 64);
 352             let oidx = scan[idx as usize];
 353             blk[oidx] = level;
 354             idx += 1;
 355             if last { break; }
 356         }
 357         Ok(())
 358     }
 359 }
 360
 361 fn decode_mv_component(br: &mut BitReader, mv_cb: &Codebook<u8>) -> DecoderResult<i16> {
 362     let code = i16::from(br.read_cb(mv_cb)?);
 363     if code == 0 { return Ok(0) }
 364     if !br.read_bool()? {
 365         Ok(code)
 366     } else {
 367         Ok(-code)
 368     }
 369 }
 370
 371 fn decode_mv(br: &mut BitReader, mv_cb: &Codebook<u8>) -> DecoderResult<MV> {
 372     let xval = decode_mv_component(br, mv_cb)?;
 373     let yval = decode_mv_component(br, mv_cb)?;
 374     Ok(MV::new(xval, yval))
 375 }
 376
 377 fn decode_b_info(br: &mut BitReader, is_pb: bool, is_ipb: bool, is_intra: bool) -> DecoderResult<BBlockInfo> {
 378     if is_pb { // as improved pb
 379         if is_ipb {
 380             let pb_mv_add = if is_intra { 1 } else { 0 };
 381             if br.read_bool()?{
 382                 if br.read_bool()? {
 383                     let pb_mv_count = 1 - (br.read(1)? as usize);
 384                     let cbpb = br.read(6)? as u8;
 385                     Ok(BBlockInfo::new(true, cbpb, pb_mv_count + pb_mv_add, pb_mv_count == 1))
 386                 } else {
 387                     Ok(BBlockInfo::new(true, 0, 1 + pb_mv_add, true))
 388                 }
 389             } else {
 390                 Ok(BBlockInfo::new(true, 0, pb_mv_add, false))
 391             }
 392         } else {
 393             let mvdb = br.read_bool()?;
 394             let cbpb = if mvdb && br.read_bool()? { br.read(6)? as u8 } else { 0 };
 395             Ok(BBlockInfo::new(true, cbpb, if mvdb { 1 } else { 0 }, false))
 396         }
 397     } else {
 398         Ok(BBlockInfo::new(false, 0, 0, false))
 399     }
 400 }
 401
 402 impl<'a> BlockDecoder for VivoBR<'a> {
 403
 404 #[allow(unused_variables)]
 405 #[allow(clippy::unreadable_literal)]
 406     fn decode_pichdr(&mut self) -> DecoderResult<PicInfo> {
 407         let br = &mut self.br;
 408         let syncw = br.read(22)?;
 409         validate!(syncw == 0x000020);
 410         let tr = (br.read(8)? << 8) as u16;
 411         check_marker(br)?;
 412         let id = br.read(1)?;
 413         validate!(id == 0);
 414         br.read(1)?; // split screen indicator
 415         br.read(1)?; // document camera indicator
 416         br.read(1)?; // freeze picture release
 417         let mut sfmt = br.read(3)?;
 418         validate!(sfmt != 0b000);
 419         let is_intra = !br.read_bool()?;
 420         let umv = br.read_bool()?;
 421         br.read(1)?; // syntax arithmetic coding
 422         let apm = br.read_bool()?;
 423         self.is_pb = br.read_bool()?;
 424         let deblock;
 425         let pbplus;
 426         let aic;
 427         if sfmt == 0b110 {
 428             sfmt = br.read(3)?;
 429             validate!(sfmt != 0b000 && sfmt != 0b110);
 430             aic = br.read_bool()?;
 431             deblock = br.read_bool()?;
 432             br.read(4)?; // unknown flags
 433             pbplus = br.read_bool()?;
 434             br.read(1)?; // unknown flag
 435             let _interlaced = br.read_bool()?;
 436             br.read(2)?; // unknown flags
 437         } else {
 438             aic = false;
 439             deblock = false;
 440             pbplus = false;
 441         }
 442         self.is_ipb = pbplus;
 443         let (w, h) = match sfmt {
 444                 0b001 => ( 64,  48),
 445                 0b011 => ( 88,  72),
 446                 0b010 => (176, 144),
 447                 0b100 => (352, 288),
 448                 0b101 => (704, 576),
 449                 0b111 => {
 450                     validate!((self.ref_w != 0) && (self.ref_h != 0));
 451                     ((self.ref_w + 15) & !15, (self.ref_h + 15) & !15)
 452                 },
 453                 _ => return Err(DecoderError::InvalidData),
 454             };
 455         let quant = br.read(5)?;
 456         let cpm = br.read_bool()?;
 457         validate!(!cpm);
 458
 459         let pbinfo;
 460         if self.is_pb {
 461             let trb = br.read(3)?;
 462             let dbquant = br.read(2)?;
 463             pbinfo = Some(PBInfo::new(trb as u8, dbquant as u8, pbplus));
 464         } else {
 465             pbinfo = None;
 466         }
 467         while br.read_bool()? { // skip PEI
 468             br.read(8)?;
 469         }
 470         self.gob_no = 0;
 471         self.mb_w = (w + 15) >> 4;
 472         self.aic = aic;
 473
 474         let ftype = if is_intra { Type::I } else { Type::P };
 475         let plusinfo = Some(PlusInfo::new(aic, deblock, false, false));
 476         let mvmode = if umv { MVMode::UMV } else { MVMode::Old };
 477         let picinfo = PicInfo::new(w, h, ftype, mvmode, umv, apm, quant as u8, tr, pbinfo, plusinfo);
 478         Ok(picinfo)
 479     }
 480
 481     #[allow(unused_variables)]
 482     fn decode_slice_header(&mut self, info: &PicInfo) -> DecoderResult<SliceInfo> {
 483         let br = &mut self.br;
 484         let gbsc = br.read(17)?;
 485         validate!(gbsc == 1);
 486         let gn = br.read(5)?;
 487         let gfid = br.read(2)?;
 488         let gquant = br.read(5)?;
 489         let ret = SliceInfo::new_gob(0, self.gob_no, gquant as u8);
 490         self.gob_no += 1;
 491         Ok(ret)
 492     }
 493
 494     #[allow(unused_variables)]
 495     fn decode_block_header(&mut self, info: &PicInfo, slice: &SliceInfo, sstate: &SliceState) -> DecoderResult<BlockInfo> {
 496         let br = &mut self.br;
 497         let mut q = slice.get_quant();
 498         match info.get_mode() {
 499             Type::I => {
 500                     let mut cbpc = br.read_cb(&self.tables.intra_mcbpc_cb)?;
 501                     while cbpc == 8 { cbpc = br.read_cb(&self.tables.intra_mcbpc_cb)?; }
 502                     let mut acpred = ACPredMode::None;
 503                     if let Some(ref pi) = info.plusinfo {
 504                         if pi.aic {
 505                             let acpp = br.read_bool()?;
 506                             acpred = ACPredMode::DC;
 507                             if acpp {
 508                                 acpred = if !br.read_bool()? { ACPredMode::Hor } else { ACPredMode::Ver };
 509                             }
 510                         }
 511                     }
 512                     let cbpy = br.read_cb(&self.tables.cbpy_cb)?;
 513                     let cbp = (cbpy << 2) | (cbpc & 3);
 514                     let dquant = (cbpc & 4) != 0;
 515                     if dquant {
 516                         let idx = br.read(2)? as usize;
 517                         q = (i16::from(q) + i16::from(H263_DQUANT_TAB[idx])) as u8;
 518                     }
 519                     let mut binfo = BlockInfo::new(Type::I, cbp, q);
 520                     binfo.set_acpred(acpred);
 521                     Ok(binfo)
 522                 },
 523             Type::P => {
 524                     if br.read_bool()? { return Ok(BlockInfo::new(Type::Skip, 0, info.get_quant())); }
 525                     let mut cbpc = br.read_cb(&self.tables.inter_mcbpc_cb)?;
 526                     while cbpc == 20 { cbpc = br.read_cb(&self.tables.inter_mcbpc_cb)?; }
 527                     let is_intra = (cbpc & 0x04) != 0;
 528                     let dquant   = (cbpc & 0x08) != 0;
 529                     let is_4x4   = (cbpc & 0x10) != 0;
 530                     if is_intra {
 531                         let mut acpred = ACPredMode::None;
 532                         if let Some(ref pi) = info.plusinfo {
 533                             if pi.aic {
 534                                 let acpp = br.read_bool()?;
 535                                 acpred = ACPredMode::DC;
 536                                 if acpp {
 537                                     acpred = if !br.read_bool()? { ACPredMode::Hor } else { ACPredMode::Ver };
 538                                 }
 539                             }
 540                         }
 541                         let mut mvec: Vec<MV> = Vec::new();
 542                         let bbinfo = decode_b_info(br, self.is_pb, self.is_ipb, true)?;
 543                         let cbpy = br.read_cb(&self.tables.cbpy_cb)?;
 544                         let cbp = (cbpy << 2) | (cbpc & 3);
 545                         if dquant {
 546                             let idx = br.read(2)? as usize;
 547                             q = (i16::from(q) + i16::from(H263_DQUANT_TAB[idx])) as u8;
 548                         }
 549                         let mut binfo = BlockInfo::new(Type::I, cbp, q);
 550                         binfo.set_bpart(bbinfo);
 551                         binfo.set_acpred(acpred);
 552                         if self.is_pb {
 553                             for _ in 0..bbinfo.get_num_mv() {
 554                                 mvec.push(decode_mv(br, &self.tables.mv_cb)?);
 555                             }
 556                             binfo.set_b_mv(mvec.as_slice());
 557                         }
 558                         return Ok(binfo);
 559                     }
 560
 561                     let bbinfo = decode_b_info(br, self.is_pb, self.is_ipb, false)?;
 562                     let mut cbpy = br.read_cb(&self.tables.cbpy_cb)?;
 563 //                    if /* !aiv && */(cbpc & 3) != 3 {
 564                         cbpy ^= 0xF;
 565 //                    }
 566                     let cbp = (cbpy << 2) | (cbpc & 3);
 567                     if dquant {
 568                         let idx = br.read(2)? as usize;
 569                         q = (i16::from(q) + i16::from(H263_DQUANT_TAB[idx])) as u8;
 570                     }
 571                     let mut binfo = BlockInfo::new(Type::P, cbp, q);
 572                     binfo.set_bpart(bbinfo);
 573                     if !is_4x4 {
 574                         let mvec: [MV; 1] = [decode_mv(br, &self.tables.mv_cb)?];
 575                         binfo.set_mv(&mvec);
 576                     } else {
 577                         let mvec: [MV; 4] = [
 578                                 decode_mv(br, &self.tables.mv_cb)?,
 579                                 decode_mv(br, &self.tables.mv_cb)?,
 580                                 decode_mv(br, &self.tables.mv_cb)?,
 581                                 decode_mv(br, &self.tables.mv_cb)?
 582                             ];
 583                         binfo.set_mv(&mvec);
 584                     }
 585                     if self.is_pb {
 586                         let mut mvec: Vec<MV> = Vec::with_capacity(bbinfo.get_num_mv());
 587                         for _ in 0..bbinfo.get_num_mv() {
 588                             let mv = decode_mv(br, &self.tables.mv_cb)?;
 589                             mvec.push(mv);
 590                         }
 591                         binfo.set_b_mv(mvec.as_slice());
 592                     }
 593                     Ok(binfo)
 594                 },
 595             _ => Err(DecoderError::InvalidData),
 596         }
 597     }
 598
 599     #[allow(unused_variables)]
 600     fn decode_block_intra(&mut self, info: &BlockInfo, _sstate: &SliceState, quant: u8, no: usize, coded: bool, blk: &mut [i16; 64]) -> DecoderResult<()> {
 601         self.decode_block(quant, true, coded, blk, if no < 4 { 0 } else { no - 3 }, info.get_acpred())
 602     }
 603
 604     #[allow(unused_variables)]
 605     fn decode_block_inter(&mut self, info: &BlockInfo, _sstate: &SliceState, quant: u8, no: usize, coded: bool, blk: &mut [i16; 64]) -> DecoderResult<()> {
 606         self.decode_block(quant, false, coded, blk, if no < 4 { 0 } else { no - 3 }, ACPredMode::None)
 607     }
 608
 609     fn is_slice_end(&mut self) -> bool { self.br.peek(16) == 0 }
 610 }
 611
 612 impl VivoDecoder {
 613     fn new() -> Self {
 614         let mut coderead = H263ShortCodeReader::new(H263_INTRA_MCBPC);
 615         let intra_mcbpc_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 616         let mut coderead = H263ShortCodeReader::new(H263_INTER_MCBPC);
 617         let inter_mcbpc_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 618         let mut coderead = H263ShortCodeReader::new(H263_CBPY);
 619         let cbpy_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 620         let mut coderead = H263RLCodeReader::new(H263_RL_CODES);
 621         let rl_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 622         let mut coderead = H263RLCodeReader::new(H263_RL_CODES_AIC);
 623         let aic_rl_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 624         let mut coderead = H263ShortCodeReader::new(H263_MV);
 625         let mv_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 626         let tables = Tables {
 627             intra_mcbpc_cb,
 628             inter_mcbpc_cb,
 629             cbpy_cb,
 630             rl_cb,
 631             aic_rl_cb,
 632             mv_cb,
 633         };
 634
 635         VivoDecoder{
 636             info:           NACodecInfo::new_dummy(),
 637             dec:            H263BaseDecoder::new_with_opts(H263DEC_OPT_SLICE_RESET | H263DEC_OPT_USES_GOB | H263DEC_OPT_PRED_QUANT),
 638             tables,
 639             bdsp:           VivoBlockDSP::new(),
 640             lastframe:      None,
 641             lastpts:        None,
 642             width:          0,
 643             height:         0,
 644         }
 645     }
 646 }
 647
 648 impl NADecoder for VivoDecoder {
 649     fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
 650         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
 651             let w = vinfo.get_width();
 652             let h = vinfo.get_height();
 653             let fmt = formats::YUV420_FORMAT;
 654             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
 655             self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
 656             self.width  = w;
 657             self.height = h;
 658             Ok(())
 659         } else {
 660             Err(DecoderError::InvalidData)
 661         }
 662     }
 663     fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
 664         let src = pkt.get_buffer();
 665
 666         if src.len() == 0 {
 667             let buftype;
 668             let ftype;
 669             if self.lastframe.is_none() {
 670                 buftype = NABufferType::None;
 671                 ftype = FrameType::Skip;
 672             } else {
 673                 let mut buf = None;
 674                 std::mem::swap(&mut self.lastframe, &mut buf);
 675                 buftype = buf.unwrap();
 676                 ftype = FrameType::B;
 677             }
 678             let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), buftype);
 679             frm.set_keyframe(false);
 680             frm.set_frame_type(ftype);
 681             if self.lastpts.is_some() {
 682                 frm.set_pts(self.lastpts);
 683                 self.lastpts = None;
 684             }
 685             return Ok(frm.into_ref());
 686         }
 687         let mut ibr = VivoBR::new(&src, &self.tables, self.width, self.height);
 688
 689         let bufinfo = self.dec.parse_frame(&mut ibr, &self.bdsp)?;
 690
 691         let mut cur_pts = pkt.get_pts();
 692         if !self.dec.is_intra() {
 693             let bret = self.dec.get_bframe(&self.bdsp);
 694             if let Ok(b_buf) = bret {
 695                 self.lastframe = Some(b_buf);
 696                 self.lastpts = pkt.get_pts();
 697                 if let Some(pts) = pkt.get_pts() {
 698                     cur_pts = Some(pts + 1);
 699                 }
 700             }
 701         }
 702
 703         let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
 704         frm.set_keyframe(self.dec.is_intra());
 705         frm.set_frame_type(if self.dec.is_intra() { FrameType::I } else { FrameType::P });
 706         frm.set_pts(cur_pts);
 707         Ok(frm.into_ref())
 708     }
 709     fn flush(&mut self) {
 710         self.dec.flush();
 711     }
 712 }
 713
 714 impl NAOptionHandler for VivoDecoder {
 715     fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
 716     fn set_options(&mut self, _options: &[NAOption]) { }
 717     fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
 718 }
 719
 720
 721 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
 722     Box::new(VivoDecoder::new())
 723 }
 724
 725 #[cfg(test)]
 726 mod test {
 727     use nihav_core::codecs::RegisteredDecoders;
 728     use nihav_core::demuxers::RegisteredDemuxers;
 729     use nihav_codec_support::test::dec_video::*;
 730     use crate::vivo_register_all_decoders;
 731     use crate::vivo_register_all_demuxers;
 732     #[test]
 733     fn test_vivo1() {
 734         let mut dmx_reg = RegisteredDemuxers::new();
 735         vivo_register_all_demuxers(&mut dmx_reg);
 736         let mut dec_reg = RegisteredDecoders::new();
 737         vivo_register_all_decoders(&mut dec_reg);
 738
 739         test_decoding("vivo", "vivo1", "assets/Misc/gr_al.viv", Some(16),
 740                       &dmx_reg, &dec_reg, ExpectedTestResult::MD5Frames(vec![
 741                             [0x59ea0837, 0xdf9b5ca3, 0x73cd45c3, 0xaaf2fbf1],
 742                             [0x5d21c5a0, 0xfb335c4f, 0xe30945e9, 0xec65d54f],
 743                             [0x46916c45, 0x406f1019, 0xba0105e0, 0xfccd0aab],
 744                             [0x11006812, 0xb8e8c959, 0x5f69950b, 0x3578db5e],
 745                             [0xd0b84c1e, 0xad327825, 0x4a98dbbe, 0x48edc280],
 746                             [0xe1be71a4, 0xc7649922, 0x949496a6, 0xed697d09],
 747                             [0x0ed9deea, 0x3e9b9784, 0x4836e38b, 0x363f8108],
 748                             [0x358f2581, 0x95e6b290, 0x35ffde28, 0x003fa23e],
 749                             [0x482385bd, 0x43bb7cee, 0xf1900758, 0x3b5f1255],
 750                             [0x91d7549f, 0x96976ef4, 0xb2920f71, 0x71c7a9a6],
 751                             [0x95736d4f, 0x56748245, 0x5733bd5d, 0x20eacf6d],
 752                             [0xb5045185, 0x55dbe063, 0xb1c96f24, 0xe5d78296],
 753                             [0xa88cadf4, 0xedc4a0aa, 0xbb359ed8, 0x1ea28916],
 754                             [0x4d9f9491, 0x13d29319, 0x57aef355, 0x7e0c9e0b],
 755                             [0xc3b52284, 0xabb74a4b, 0xf03c9503, 0x834d149e],
 756                             [0x35fc95d0, 0x0f583ef0, 0xb176f055, 0xb587839a],
 757                             [0xd5e3b443, 0x3b11b285, 0x78ec3098, 0xe2109aaa]]));
 758     }
 759     #[test]
 760     fn test_vivo2() {
 761         let mut dmx_reg = RegisteredDemuxers::new();
 762         vivo_register_all_demuxers(&mut dmx_reg);
 763         let mut dec_reg = RegisteredDecoders::new();
 764         vivo_register_all_decoders(&mut dec_reg);
 765
 766         test_decoding("vivo", "vivo2", "assets/Misc/02-KimagureOrangeRoad.viv", Some(56),
 767                       &dmx_reg, &dec_reg, ExpectedTestResult::MD5Frames(vec![
 768                             [0x73f2afc2, 0x1cc43762, 0xbcfa886d, 0x7e607dd1],
 769                             [0x45652ef5, 0x7c03046c, 0xcef60a62, 0x4a1e8f24],
 770                             [0x09f6557e, 0x852cf108, 0x13dbb6ff, 0xaa8667e9],
 771                             [0x3668d658, 0xfdc37a56, 0x267cb690, 0xa33924ee],
 772                             [0x0ad13447, 0x26315ca3, 0xfbf43f79, 0xc3951941],
 773                             [0x8c870462, 0x9135c664, 0x586accfa, 0xfe6d9113],
 774                             [0x26b08477, 0xcdef5073, 0x86899b3c, 0x0d911f1d],
 775                             [0x7db88b9c, 0x780729bb, 0xe3195f66, 0xb4f2e7e7],
 776                             [0x9008ed4e, 0x29b05b6c, 0x3f8a2c23, 0x6d396334],
 777                             [0xa255e91b, 0x324b764b, 0x265a08ea, 0x0a5a6ae7],
 778                             [0xf2110e23, 0x8fa53178, 0x675c32cb, 0x63ba9297],
 779                             [0xbe0bb384, 0xde08646e, 0x45d3530c, 0xd5cdf571],
 780                             [0xfa19949a, 0xb9e12931, 0xcaa98f06, 0xa284718a],
 781                             [0x9b1472e5, 0x2d18472c, 0xd5419a58, 0xff16d619],
 782                             [0xeecd4532, 0xa6301dcc, 0x6eed2b15, 0xa456cae0],
 783                             [0xb58b2bb8, 0x1c07bd9a, 0x1913e1c3, 0xa1f4fdc2],
 784                             [0x51b6bef2, 0xd155d675, 0xaba07c15, 0xcf0a673e],
 785                             [0x3c607ce6, 0x3a203449, 0xdda5b7a0, 0x9119b738],
 786                             [0x7e7bae10, 0x4beb488e, 0x33db98bb, 0x8b49311e],
 787                             [0xfff04316, 0xe29afa50, 0xa6f0c921, 0x5b0d29e2],
 788                             [0xe640595a, 0x98bb55a4, 0x50c0a1e5, 0xe4970206],
 789                             [0x63873ec7, 0x03a5fd08, 0xe3154f25, 0xb4ed64c2],
 790                             [0xfa792148, 0x7efebf2c, 0x88d91825, 0x9dce368d],
 791                             [0x5ed17368, 0x0e056059, 0x2c872282, 0xe5a98237],
 792                             [0xd7ed6bd6, 0x01414003, 0x5187d790, 0x0af5b029],
 793                             [0x2991a9c6, 0x8e2dda24, 0xfbf79bbb, 0xbcbfc672],
 794                             [0xf2d23c64, 0xeb7e6094, 0x70a54901, 0x6d9d0204],
 795                             [0x54997451, 0xb4edb3c0, 0x5a873e8f, 0xe89d7aa6],
 796                             [0x94325a5f, 0xe0feb4b3, 0x2b1860bc, 0xc6b6a1a4],
 797                             [0x8fd428de, 0x17f14f9f, 0x94c8d0da, 0xf9feda90],
 798                             [0xed90d455, 0x22745327, 0x0ac511f1, 0x2dc2c29e],
 799                             [0xc50ac6c1, 0xc9eaf8ec, 0x5d9dc7f3, 0x4e55fd09],
 800                             [0x51325c40, 0xa7c01917, 0xdc064cc6, 0x143badc1],
 801                             [0x3fc207ee, 0x2c4b0f91, 0x66555499, 0xdf6dc148],
 802                             [0xd6e7fa33, 0x68ba6ce9, 0x45cac834, 0x1d51b094],
 803                             [0x1ed541a8, 0x8dd0cc41, 0x149024d4, 0x13777a2e],
 804                             [0x7fcbd065, 0xb20e068f, 0x9a5e3ed5, 0x6c35dded],
 805                             [0x07ea66c1, 0xbfadea3b, 0x07bb6580, 0xf40d7d2f],
 806                             [0x2e0fe75e, 0xa03d3011, 0x539c097d, 0x95fb265c],
 807                             [0x2f177f09, 0x63b7172a, 0xb0fdd893, 0xcab516cf],
 808                             [0x7cc5a956, 0xcd1ecff1, 0xf927038c, 0xa0610b48],
 809                             [0xc0518934, 0xf5c38e4b, 0x7fa255cd, 0x9b054c5b],
 810                             [0x0551de82, 0x08253d6b, 0x9144ced8, 0xc5adda55],
 811                             [0xf45735b5, 0x3f2e2111, 0x54d1ff16, 0xe4866157],
 812                             [0x0aad101e, 0xd37001f4, 0xd5734080, 0xfa4cf449],
 813                             [0x65318bdd, 0x68809e67, 0x1e27946a, 0x2ca977e5],
 814                             [0x119cf864, 0x8834473e, 0x721a253e, 0x4e417f19],
 815                             [0x0d887145, 0xa42a05cc, 0x64a4388e, 0xa05de81d],
 816                             [0xc184105a, 0x71ac7a8e, 0xaab0dba5, 0x078a331e],
 817                             [0x078827ea, 0x27670e40, 0x92be9ebb, 0x0fc1f5a0],
 818                             [0x8c82ca58, 0xbae0a643, 0x845afc5b, 0x15052a84],
 819                             [0x92065c13, 0x69d3f6b7, 0x7270aab9, 0xb80921fd],
 820                             [0xa58536b5, 0x6c46d7e1, 0x5f07f282, 0x350900e9],
 821                             [0x13bf3f52, 0x71f8aa99, 0x97e0aaa5, 0xd6c1cff5],
 822                             [0xa760cf95, 0xeb33c24c, 0x8dd35c6a, 0x4d81c8b5],
 823                             [0x50f68b90, 0x41b1f1a0, 0x9847b3ec, 0x1cab5ccc],
 824                             [0xbd71de9e, 0xc097b4ac, 0x003ab1e5, 0x9394b5bd]]));
 825     }
 826 }