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

   1 //use std::mem;
   2 use nihav_core::codecs::DecoderError;
   3 use nihav_core::frame::*;
   4 use super::super::*;
   5 use super::super::blockdsp;
   6 use super::*;
   7 //use super::code::*;
   8 use nihav_core::formats;
   9
  10 #[allow(dead_code)]
  11 struct MVInfo {
  12     mv:         Vec<MV>,
  13     mb_w:       usize,
  14     mb_stride:  usize,
  15     mb_start:   usize,
  16     top:        bool,
  17     mvmode:     MVMode,
  18 }
  19
  20 impl MVInfo {
  21     fn new() -> Self { MVInfo{ mv: Vec::new(), mb_w: 0, mb_stride: 0, mb_start: 0, top: true, mvmode: MVMode::Old } }
  22     fn reset(&mut self, mb_w: usize, mb_start: usize, mvmode: MVMode) {
  23         self.mb_start  = mb_start;
  24         self.mb_w      = mb_w;
  25         self.mb_stride = mb_w * 2 + 2;
  26         self.mv.resize(self.mb_stride * 3, ZERO_MV);
  27         self.mvmode    = mvmode;
  28     }
  29     fn update_row(&mut self) {
  30         self.mb_start = self.mb_w + 1;
  31         self.top      = false;
  32         for i in 0..self.mb_stride {
  33             self.mv[i] = self.mv[self.mb_stride * 2 + i];
  34         }
  35     }
  36     #[allow(non_snake_case)]
  37     fn predict(&mut self, mb_x: usize, blk_no: usize, use4: bool, diff: MV, first_line: bool, first_mb: bool) -> MV {
  38         let A;
  39         let B;
  40         let C;
  41         let last = mb_x == self.mb_w - 1;
  42         match blk_no {
  43             0 => {
  44                     if mb_x != self.mb_start {
  45                         A = if !first_mb   { self.mv[self.mb_stride + mb_x * 2 - 1] } else { ZERO_MV };
  46                         B = if !first_line { self.mv[                 mb_x * 2] } else { A };
  47                         C = if !first_line && !last { self.mv[mb_x * 2 + 2] } else { ZERO_MV };
  48                     } else {
  49                         A = ZERO_MV; B = ZERO_MV; C = ZERO_MV;
  50                     }
  51                 },
  52             1 => {
  53                     A = self.mv[self.mb_stride + mb_x * 2];
  54                     B = if !first_line { self.mv[mb_x * 2 + 1] } else { A };
  55                     C = if !first_line && !last { self.mv[mb_x * 2 + 2] } else { ZERO_MV/*A*/ };
  56                 },
  57             2 => {
  58                     A = if mb_x != self.mb_start { self.mv[self.mb_stride * 2 + mb_x * 2 - 1] } else { ZERO_MV };
  59                     B = self.mv[self.mb_stride + mb_x * 2];
  60                     C = self.mv[self.mb_stride + mb_x * 2 + 1];
  61                 },
  62             3 => {
  63                     A = self.mv[self.mb_stride * 2 + mb_x * 2];
  64                     B = self.mv[self.mb_stride * 1 + mb_x * 2 + 1];
  65                     C = self.mv[self.mb_stride * 1 + mb_x * 2];
  66                 },
  67             _ => { return ZERO_MV; }
  68         }
  69         let pred_mv = MV::pred(A, B, C);
  70         let new_mv = MV::add_umv(pred_mv, diff, self.mvmode);
  71         if !use4 {
  72             self.mv[self.mb_stride * 1 + mb_x * 2 + 0] = new_mv;
  73             self.mv[self.mb_stride * 1 + mb_x * 2 + 1] = new_mv;
  74             self.mv[self.mb_stride * 2 + mb_x * 2 + 0] = new_mv;
  75             self.mv[self.mb_stride * 2 + mb_x * 2 + 1] = new_mv;
  76         } else {
  77             match blk_no {
  78                 0 => { self.mv[self.mb_stride * 1 + mb_x * 2 + 0] = new_mv; },
  79                 1 => { self.mv[self.mb_stride * 1 + mb_x * 2 + 1] = new_mv; },
  80                 2 => { self.mv[self.mb_stride * 2 + mb_x * 2 + 0] = new_mv; },
  81                 3 => { self.mv[self.mb_stride * 2 + mb_x * 2 + 1] = new_mv; },
  82                 _ => {},
  83             };
  84         }
  85
  86         new_mv
  87     }
  88     fn set_zero_mv(&mut self, mb_x: usize) {
  89         self.mv[self.mb_stride * 1 + mb_x * 2 + 0] = ZERO_MV;
  90         self.mv[self.mb_stride * 1 + mb_x * 2 + 1] = ZERO_MV;
  91         self.mv[self.mb_stride * 2 + mb_x * 2 + 0] = ZERO_MV;
  92         self.mv[self.mb_stride * 2 + mb_x * 2 + 1] = ZERO_MV;
  93     }
  94     fn get_mv(&self, mb_x: usize, blk_no: usize) -> MV {
  95         self.mv[self.mb_stride + mb_x * 2 + (blk_no & 1) + (blk_no >> 1) * self.mb_stride]
  96     }
  97 }
  98
  99 #[allow(dead_code)]
 100 #[derive(Clone,Copy)]
 101 struct BMB {
 102     num_mv: usize,
 103     mv_f:   [MV; 4],
 104     mv_b:   [MV; 4],
 105     fwd:    bool,
 106     blk:    [[i16; 64]; 6],
 107     cbp:    u8,
 108 }
 109
 110 impl BMB {
 111     fn new() -> Self { BMB {blk: [[0; 64]; 6], cbp: 0, fwd: false, mv_f: [ZERO_MV; 4], mv_b: [ZERO_MV; 4], num_mv: 0} }
 112 }
 113
 114 #[derive(Clone,Copy)]
 115 struct PredCoeffs {
 116     hor: [[i16; 8]; 6],
 117     ver: [[i16; 8]; 6],
 118 }
 119
 120 const ZERO_PRED_COEFFS: PredCoeffs = PredCoeffs { hor: [[0; 8]; 6], ver: [[0; 8]; 6] };
 121
 122 pub struct H263BaseDecoder {
 123     w:          usize,
 124     h:          usize,
 125     mb_w:       usize,
 126     mb_h:       usize,
 127     num_mb:     usize,
 128     ftype:      Type,
 129     ipbs:       IPBShuffler,
 130     next_ts:    u16,
 131     last_ts:    u16,
 132     tsdiff:     u16,
 133     has_b:      bool,
 134     b_data:     Vec<BMB>,
 135     pred_coeffs: Vec<PredCoeffs>,
 136     is_gob:     bool,
 137     slice_reset: bool,
 138     may_have_b_frames: bool,
 139     mv_data:    Vec<BlockMVInfo>,
 140     blk:        [[i16; 64]; 6],
 141 }
 142
 143 #[inline]
 144 fn clip_dc(dc: i16) -> i16 {
 145     if dc <= 0 { 0 }
 146     else if dc > 2046 { 2047 }
 147     else { dc | 1 }
 148 }
 149
 150 #[inline]
 151 fn clip_ac(ac: i16) -> i16 {
 152     if ac < -2048 { -2048 }
 153     else if ac > 2047 { 2047 }
 154     else { ac }
 155 }
 156
 157 #[allow(dead_code)]
 158 impl H263BaseDecoder {
 159     pub fn new_with_opts(is_gob: bool, slice_reset: bool, may_have_b_frames: bool) -> Self {
 160         H263BaseDecoder{
 161             w: 0, h: 0, mb_w: 0, mb_h: 0, num_mb: 0,
 162             ftype: Type::Special,
 163             ipbs: IPBShuffler::new(),
 164             last_ts: 0, next_ts: 0, tsdiff: 0,
 165             has_b: false, b_data: Vec::new(),
 166             pred_coeffs: Vec::new(),
 167             is_gob, slice_reset,
 168             may_have_b_frames,
 169             mv_data: Vec::new(),
 170             blk: [[0; 64]; 6],
 171         }
 172     }
 173     pub fn new(is_gob: bool) -> Self {
 174         Self::new_with_opts(is_gob, true, false)
 175     }
 176     pub fn new_b_frames(is_gob: bool) -> Self {
 177         Self::new_with_opts(is_gob, true, true)
 178     }
 179
 180     pub fn is_intra(&self) -> bool { self.ftype == Type::I }
 181     pub fn get_frame_type(&self) -> FrameType {
 182         match self.ftype {
 183             Type::I       => FrameType::I,
 184             Type::P       => FrameType::P,
 185             Type::B       => FrameType::B,
 186             Type::PB      => FrameType::P,
 187             Type::Skip    => FrameType::Skip,
 188             Type::Special => FrameType::Skip,
 189         }
 190     }
 191     pub fn get_dimensions(&self) -> (usize, usize) { (self.w, self.h) }
 192
 193     fn decode_intra_mb(&mut self, bd: &mut BlockDecoder, bdsp: &BlockDSP, mb_pos: usize, binfo: &BlockInfo, sstate: &SliceState, apply_acpred: bool) -> DecoderResult<()> {
 194         for i in 0..6 {
 195             bd.decode_block_intra(&binfo, &sstate, binfo.get_q(), i, (binfo.cbp & (1 << (5 - i))) != 0, &mut self.blk[i])?;
 196             if apply_acpred && (binfo.acpred != ACPredMode::None) {
 197                 let has_b = (i == 1) || (i == 3) || !sstate.first_mb;
 198                 let has_a = (i == 2) || (i == 3) || !sstate.first_line;
 199                 let (b_mb, b_blk) = if has_b {
 200                         if (i == 1) || (i == 3) {
 201                             (mb_pos, i - 1)
 202                         } else if i < 4 {
 203                             (mb_pos - 1, i + 1)
 204                         } else {
 205                             (mb_pos - 1, i)
 206                         }
 207                     } else { (0, 0) };
 208                 let (a_mb, a_blk) = if has_a {
 209                         if (i == 2) || (i == 3) {
 210                             (mb_pos, i - 2)
 211                         } else if i < 4 {
 212                             (mb_pos - self.mb_w, i + 2)
 213                         } else {
 214                             (mb_pos - self.mb_w, i)
 215                         }
 216                     } else { (0, 0) };
 217                 match binfo.acpred {
 218                     ACPredMode::DC   => {
 219                                 let dc;
 220                                 if has_a && has_b {
 221                                     dc = (self.pred_coeffs[b_mb].hor[b_blk][0] + self.pred_coeffs[a_mb].ver[a_blk][0]) / 2;
 222                                 } else if has_a {
 223                                     dc = self.pred_coeffs[a_mb].ver[a_blk][0];
 224                                 } else if has_b {
 225                                     dc = self.pred_coeffs[b_mb].hor[b_blk][0];
 226                                 } else {
 227                                     dc = 1024;
 228                                 }
 229                                 self.blk[i][0] = clip_dc(self.blk[i][0] + dc);
 230                             },
 231                     ACPredMode::Hor  => {
 232                             if has_b {
 233                                 for k in 0..8 {
 234                                     self.blk[i][k * 8] += self.pred_coeffs[b_mb].hor[b_blk][k];
 235                                 }
 236                                 for k in 1..8 {
 237                                     self.blk[i][k * 8] = clip_ac(self.blk[i][k * 8]);
 238                                 }
 239                             } else {
 240                                 self.blk[i][0] += 1024;
 241                             }
 242                             self.blk[i][0] = clip_dc(self.blk[i][0]);
 243                         },
 244                     ACPredMode::Ver  => {
 245                             if has_a {
 246                                 for k in 0..8 {
 247                                     self.blk[i][k] += self.pred_coeffs[a_mb].ver[a_blk][k];
 248                                 }
 249                                 for k in 1..8 {
 250                                     self.blk[i][k] = clip_ac(self.blk[i][k]);
 251                                 }
 252                             } else {
 253                                 self.blk[i][0] += 1024;
 254                             }
 255                             self.blk[i][0] = clip_dc(self.blk[i][0]);
 256                         },
 257                     ACPredMode::None => {},
 258                 };
 259                 for t in 0..8 { self.pred_coeffs[mb_pos].hor[i][t] = self.blk[i][t * 8]; }
 260                 for t in 0..8 { self.pred_coeffs[mb_pos].ver[i][t] = self.blk[i][t]; }
 261             }
 262             bdsp.idct(&mut self.blk[i]);
 263         }
 264         Ok(())
 265     }
 266     fn decode_inter_mb(&mut self, bd: &mut BlockDecoder, bdsp: &BlockDSP, binfo: &BlockInfo, sstate: &SliceState) -> DecoderResult<()> {
 267         for i in 0..6 {
 268             bd.decode_block_inter(&binfo, &sstate, binfo.get_q(), i, ((binfo.cbp >> (5 - i)) & 1) != 0, &mut self.blk[i])?;
 269             bdsp.idct(&mut self.blk[i]);
 270         }
 271         Ok(())
 272     }
 273     pub fn parse_frame(&mut self, bd: &mut BlockDecoder, bdsp: &BlockDSP) -> DecoderResult<NABufferType> {
 274         let pinfo = bd.decode_pichdr()?;
 275         let mut mvi = MVInfo::new();
 276         let mut mvi2 = MVInfo::new();
 277         let mut cbpi = CBPInfo::new();
 278
 279 //todo handle res change
 280         self.w = pinfo.w;
 281         self.h = pinfo.h;
 282         self.mb_w = (pinfo.w + 15) >> 4;
 283         self.mb_h = (pinfo.h + 15) >> 4;
 284         self.num_mb = self.mb_w * self.mb_h;
 285         self.ftype = pinfo.mode;
 286         self.has_b = pinfo.is_pb();
 287
 288         if self.has_b {
 289             self.mv_data.truncate(0);
 290         }
 291
 292         let save_b_data = pinfo.mode.is_ref() && self.may_have_b_frames;
 293         if save_b_data {
 294             self.mv_data.truncate(0);
 295         }
 296         let is_b = pinfo.mode == Type::B;
 297
 298         if is_b && (self.mv_data.len() < self.mb_w * self.mb_h) {
 299             return Err(DecoderError::MissingReference);
 300         }
 301
 302         let tsdiff = if pinfo.is_pb() { pinfo.ts.wrapping_sub(self.last_ts) >> 1 }
 303                      else { self.last_ts.wrapping_sub(self.next_ts) >> 1 };
 304         let bsdiff = if pinfo.is_pb() { (pinfo.get_pbinfo().get_trb() as u16) << 7 }
 305                      else { pinfo.ts.wrapping_sub(self.next_ts) >> 1 };
 306
 307         let fmt = formats::YUV420_FORMAT;
 308         let vinfo = NAVideoInfo::new(self.w, self.h, false, fmt);
 309         let bufinfo = alloc_video_buffer(vinfo, 4)?;
 310         let mut buf = bufinfo.get_vbuf().unwrap();
 311
 312         let mut slice = if self.is_gob {
 313                 SliceInfo::get_default_slice(&pinfo)
 314             } else {
 315                 bd.decode_slice_header(&pinfo)?
 316             };
 317         mvi.reset(self.mb_w, 0, pinfo.get_mvmode());
 318         if is_b || pinfo.is_pb() {
 319             mvi2.reset(self.mb_w, 0, pinfo.get_mvmode());
 320         }
 321         cbpi.reset(self.mb_w);
 322
 323         let mut sstate = SliceState::new(pinfo.mode == Type::I);
 324         let mut mb_pos = 0;
 325         let apply_acpred = (pinfo.mode == Type::I) && pinfo.plusinfo.is_some() && pinfo.plusinfo.unwrap().aic;
 326         if apply_acpred {
 327             self.pred_coeffs.truncate(0);
 328             self.pred_coeffs.resize(self.mb_w * self.mb_h, ZERO_PRED_COEFFS);
 329         }
 330         sstate.quant = slice.quant;
 331         for mb_y in 0..self.mb_h {
 332             for mb_x in 0..self.mb_w {
 333                 self.blk = [[0; 64]; 6];
 334
 335                 if slice.is_at_end(mb_pos) || (slice.needs_check() && mb_pos > 0 && bd.is_slice_end()) {
 336                     slice = bd.decode_slice_header(&pinfo)?;
 337                     if !self.is_gob && self.slice_reset {
 338                         mvi.reset(self.mb_w, mb_x, pinfo.get_mvmode());
 339                         if is_b || pinfo.is_pb() {
 340                             mvi2.reset(self.mb_w, mb_x, pinfo.get_mvmode());
 341                         }
 342                         cbpi.reset(self.mb_w);
 343                         sstate.reset_slice(mb_x, mb_y);
 344                         sstate.quant = slice.quant;
 345                     }
 346                 }
 347
 348                 let binfo = bd.decode_block_header(&pinfo, &slice, &sstate)?;
 349                 let cbp = binfo.get_cbp();
 350                 cbpi.set_cbp(mb_x, cbp);
 351                 cbpi.set_q(mb_x, binfo.get_q());
 352                 sstate.quant = binfo.get_q();
 353                 if binfo.is_intra() {
 354                     if save_b_data {
 355                         self.mv_data.push(BlockMVInfo::Intra);
 356                     }
 357                     self.decode_intra_mb(bd, bdsp, mb_pos, &binfo, &sstate, apply_acpred)?;
 358                     blockdsp::put_blocks(&mut buf, mb_x, mb_y, &self.blk);
 359                     mvi.set_zero_mv(mb_x);
 360                     if is_b {
 361                         mvi2.set_zero_mv(mb_x);
 362                     } else if pinfo.is_pb() {
 363                         mvi2.predict(mb_x, 0, false, binfo.get_mv2(0), sstate.first_line, sstate.first_mb);
 364                     }
 365                 } else if (binfo.mode != Type::B) && !binfo.is_skipped() {
 366                     if binfo.get_num_mvs() == 1 {
 367                         let mv = mvi.predict(mb_x, 0, false, binfo.get_mv(0), sstate.first_line, sstate.first_mb);
 368                         if save_b_data {
 369                             self.mv_data.push(BlockMVInfo::Inter_1MV(mv));
 370                         }
 371                         if let Some(ref srcbuf) = self.ipbs.get_lastref() {
 372                             bdsp.copy_blocks(&mut buf, srcbuf.clone(), mb_x * 16, mb_y * 16, mv);
 373                         }
 374                         if pinfo.is_pb() {
 375                             mvi2.predict(mb_x, 0, false, binfo.get_mv(0), sstate.first_line, sstate.first_mb);
 376                         }
 377                     } else {
 378                         let mut mv: [MV; 4] = [ZERO_MV, ZERO_MV, ZERO_MV, ZERO_MV];
 379                         for blk_no in 0..4 {
 380                             mv[blk_no] = mvi.predict(mb_x, blk_no, true, binfo.get_mv(blk_no), sstate.first_line, sstate.first_mb);
 381                         }
 382                         if let Some(ref srcbuf) = self.ipbs.get_lastref() {
 383                             bdsp.copy_blocks8x8(&mut buf, srcbuf.clone(), mb_x * 16, mb_y * 16, &mv);
 384                         }
 385                         if pinfo.is_pb() {
 386                             for blk_no in 0..4 {
 387                                 mvi2.predict(mb_x, blk_no, true, binfo.get_mv(blk_no), sstate.first_line, sstate.first_mb);
 388                             }
 389                         }
 390                         if save_b_data {
 391                             self.mv_data.push(BlockMVInfo::Inter_4MV(mv));
 392                         }
 393                     }
 394                     self.decode_inter_mb(bd, bdsp, &binfo, &sstate)?;
 395                     blockdsp::add_blocks(&mut buf, mb_x, mb_y, &self.blk);
 396                     if is_b && !pinfo.is_pb() {
 397                         mvi2.set_zero_mv(mb_x);
 398                     }
 399                 } else if binfo.mode != Type::B {
 400                     self.mv_data.push(BlockMVInfo::Inter_1MV(ZERO_MV));
 401                     mvi.set_zero_mv(mb_x);
 402                     if is_b || pinfo.is_pb() {
 403                         mvi2.set_zero_mv(mb_x);
 404                     }
 405                     if let Some(ref srcbuf) = self.ipbs.get_lastref() {
 406                         bdsp.copy_blocks(&mut buf, srcbuf.clone(), mb_x * 16, mb_y * 16, ZERO_MV);
 407                     }
 408                 } else {
 409                     recon_b_mb(&mut buf, &mut self.ipbs, bdsp, &mut mvi, &mut mvi2, mb_pos, self.mb_w, &sstate, &binfo, &self.mv_data, bsdiff, tsdiff);
 410                     if cbp != 0 {
 411                         self.decode_inter_mb(bd, bdsp, &binfo, &sstate)?;
 412                         blockdsp::add_blocks(&mut buf, mb_x, mb_y, &self.blk);
 413                     }
 414                 }
 415                 if pinfo.is_pb() {
 416                     let mut b_mb = BMB::new();
 417                     let cbp = binfo.get_cbp_b();
 418                     let bq = (((pinfo.get_pbinfo().get_dbquant() + 5) as u16) * (binfo.get_q() as u16)) >> 2;
 419                     let bquant;
 420                     if bq < 1 { bquant = 1; }
 421                     else if bq > 31 { bquant = 31; }
 422                     else { bquant = bq as u8; }
 423
 424                     b_mb.cbp = cbp;
 425                     for i in 0..6 {
 426                         bd.decode_block_inter(&binfo, &sstate, bquant, i, (cbp & (1 << (5 - i))) != 0, &mut b_mb.blk[i])?;
 427                         bdsp.idct(&mut b_mb.blk[i]);
 428                     }
 429
 430                     let is_fwd = binfo.is_b_fwd();
 431                     b_mb.fwd = is_fwd;
 432                     if binfo.get_num_mvs() != 4 {
 433                         let ref_mv = mvi2.get_mv(mb_x, 0);
 434                         let b_mv = if binfo.is_intra() { binfo.get_mv2(1) } else { binfo.get_mv2(0) };
 435                         let src_mv = if is_fwd { ZERO_MV } else { ref_mv.scale(bsdiff, tsdiff) };
 436                         let mv_f = MV::add_umv(src_mv, b_mv, pinfo.get_mvmode());
 437                         let mv_b = MV::b_sub(ref_mv, mv_f, b_mv, bsdiff, tsdiff);
 438                         b_mb.mv_f[0] = mv_f;
 439                         b_mb.mv_b[0] = mv_b;
 440                         b_mb.num_mv = 1;
 441                     } else {
 442                         for blk_no in 0..4 {
 443                             let src_mv = if is_fwd { ZERO_MV } else { mvi2.get_mv(mb_x, blk_no).scale(bsdiff, tsdiff) };
 444                             let mv_f = MV::add_umv(src_mv, binfo.get_mv2(0), pinfo.get_mvmode());
 445                             let mv_b = MV::b_sub(mvi2.get_mv(mb_x, blk_no), mv_f, binfo.get_mv2(0), bsdiff, tsdiff);
 446                             b_mb.mv_f[blk_no] = mv_f;
 447                             b_mb.mv_b[blk_no] = mv_b;
 448                         }
 449                         b_mb.num_mv = 4;
 450                     }
 451                     self.b_data.push(b_mb);
 452                 }
 453                 sstate.next_mb();
 454                 mb_pos += 1;
 455             }
 456             if let Some(plusinfo) = pinfo.plusinfo {
 457                 if plusinfo.deblock {
 458                     bdsp.filter_row(&mut buf, mb_y, self.mb_w, &cbpi);
 459                 }
 460             }
 461             mvi.update_row();
 462             if is_b || pinfo.is_pb() {
 463                 mvi2.update_row();
 464             }
 465             cbpi.update_row();
 466             sstate.new_row();
 467         }
 468
 469         if pinfo.mode.is_ref() {
 470             self.ipbs.add_frame(buf);
 471             self.next_ts = self.last_ts;
 472             self.last_ts = pinfo.ts;
 473             self.tsdiff  = tsdiff;
 474         }
 475
 476         Ok(bufinfo)
 477     }
 478     pub fn flush(&mut self) {
 479         self.ipbs.clear();
 480     }
 481
 482     pub fn get_bframe(&mut self, bdsp: &BlockDSP) -> DecoderResult<NABufferType> {
 483         if !self.has_b || self.ipbs.get_lastref().is_none() || self.ipbs.get_nextref().is_none() {
 484             return Err(DecoderError::MissingReference);
 485         }
 486         self.has_b = false;
 487
 488         let fmt = formats::YUV420_FORMAT;
 489         let vinfo = NAVideoInfo::new(self.w, self.h, false, fmt);
 490         let bufinfo = alloc_video_buffer(vinfo, 4)?;
 491         let b_buf = bufinfo.get_vbuf().unwrap();
 492
 493         if let (Some(ref bck_buf), Some(ref fwd_buf)) = (self.ipbs.get_nextref(), self.ipbs.get_lastref()) {
 494             recon_b_frame(b_buf, fwd_buf.clone(), bck_buf.clone(), self.mb_w, self.mb_h, self.b_data.as_slice(), bdsp);
 495         }
 496
 497         self.b_data.truncate(0);
 498         Ok(bufinfo)
 499     }
 500 }
 501
 502 fn recon_b_mb(buf: &mut NAVideoBuffer<u8>, ipbs: &mut IPBShuffler, bdsp: &BlockDSP, mvi: &mut MVInfo, mvi2: &mut MVInfo, mb_pos: usize, mb_w: usize, sstate: &SliceState, binfo: &BlockInfo, mv_data: &[BlockMVInfo], bsdiff: u16, tsdiff: u16) {
 503     let mb_x = mb_pos % mb_w;
 504     let mb_y = mb_pos / mb_w;
 505
 506     let ref_mv_info = mv_data[mb_pos];
 507     let has_fwd = binfo.get_num_mvs() > 0;
 508     let has_bwd = binfo.get_num_mvs2() > 0;
 509
 510     if has_fwd || has_bwd {
 511         let fwd_mv;
 512         if has_fwd {
 513             fwd_mv = mvi.predict(mb_x, 0, false, binfo.get_mv(0), sstate.first_line, sstate.first_mb);
 514         } else {
 515             fwd_mv = ZERO_MV;
 516             mvi.set_zero_mv(mb_x);
 517         }
 518         let bwd_mv;
 519         if has_bwd {
 520             bwd_mv = mvi2.predict(mb_x, 0, false, binfo.get_mv2(0), sstate.first_line, sstate.first_mb);
 521         } else {
 522             bwd_mv = ZERO_MV;
 523             mvi2.set_zero_mv(mb_x);
 524         }
 525         if let (Some(ref fwd_buf), Some(ref bck_buf)) = (ipbs.get_nextref(), ipbs.get_lastref()) {
 526             if has_fwd && has_bwd {
 527                 bdsp.copy_blocks(buf, fwd_buf.clone(), mb_x * 16, mb_y * 16, fwd_mv);
 528                 bdsp.avg_blocks (buf, bck_buf.clone(), mb_x * 16, mb_y * 16, bwd_mv);
 529             } else if has_fwd {
 530                 bdsp.copy_blocks(buf, fwd_buf.clone(), mb_x * 16, mb_y * 16, fwd_mv);
 531             } else {
 532                 bdsp.copy_blocks(buf, bck_buf.clone(), mb_x * 16, mb_y * 16, bwd_mv);
 533             }
 534         }
 535     } else {
 536         if let BlockMVInfo::Inter_4MV(mvs) = ref_mv_info {
 537             let mut mv_f = [ZERO_MV; 4];
 538             let mut mv_b = [ZERO_MV; 4];
 539             for blk_no in 0..4 {
 540                 let ref_mv = mvs[blk_no];
 541                 let ref_mv_fwd = ref_mv.scale(bsdiff, tsdiff);
 542                 let ref_mv_bwd = ref_mv - ref_mv_fwd;
 543                 mv_f[blk_no] = ref_mv_fwd;
 544                 mv_b[blk_no] = ref_mv_bwd;
 545             }
 546             if let (Some(ref fwd_buf), Some(ref bck_buf)) = (ipbs.get_nextref(), ipbs.get_lastref()) {
 547                 bdsp.copy_blocks8x8(buf, fwd_buf.clone(), mb_x * 16, mb_y * 16, &mv_f);
 548                 bdsp.avg_blocks8x8 (buf, bck_buf.clone(), mb_x * 16, mb_y * 16, &mv_b);
 549             }
 550         } else {
 551             let ref_mv = if let BlockMVInfo::Inter_1MV(mv_) = ref_mv_info { mv_ } else { ZERO_MV };
 552             let ref_mv_fwd = ref_mv.scale(bsdiff, tsdiff);
 553             let ref_mv_bwd = MV::b_sub(ref_mv, ref_mv_fwd, ZERO_MV, bsdiff, tsdiff);
 554
 555             if let (Some(ref fwd_buf), Some(ref bck_buf)) = (ipbs.get_nextref(), ipbs.get_lastref()) {
 556                 bdsp.copy_blocks(buf, fwd_buf.clone(), mb_x * 16, mb_y * 16, ref_mv_fwd);
 557                 bdsp.avg_blocks (buf, bck_buf.clone(), mb_x * 16, mb_y * 16, ref_mv_bwd);
 558             }
 559         }
 560         mvi.set_zero_mv(mb_x);
 561         mvi2.set_zero_mv(mb_x);
 562     }
 563 }
 564
 565 fn recon_b_frame(mut b_buf: NAVideoBufferRef<u8>, bck_buf: NAVideoBufferRef<u8>, fwd_buf: NAVideoBufferRef<u8>,
 566                  mb_w: usize, mb_h: usize, b_data: &[BMB], bdsp: &BlockDSP) {
 567     let mut cbpi = CBPInfo::new();
 568     let mut cur_mb = 0;
 569     cbpi.reset(mb_w);
 570     for mb_y in 0..mb_h {
 571         for mb_x in 0..mb_w {
 572             let num_mv = b_data[cur_mb].num_mv;
 573             let is_fwd = b_data[cur_mb].fwd;
 574             let cbp    = b_data[cur_mb].cbp;
 575             cbpi.set_cbp(mb_x, cbp);
 576             if num_mv == 1 {
 577                 bdsp.copy_blocks(&mut b_buf, fwd_buf.clone(), mb_x * 16, mb_y * 16, b_data[cur_mb].mv_b[0]);
 578                 if !is_fwd {
 579                     bdsp.avg_blocks(&mut b_buf, bck_buf.clone(), mb_x * 16, mb_y * 16, b_data[cur_mb].mv_f[0]);
 580                 }
 581             } else {
 582                 bdsp.copy_blocks8x8(&mut b_buf, fwd_buf.clone(), mb_x * 16, mb_y * 16, &b_data[cur_mb].mv_b);
 583                 if !is_fwd {
 584                     bdsp.avg_blocks8x8(&mut b_buf, bck_buf.clone(), mb_x * 16, mb_y * 16, &b_data[cur_mb].mv_f);
 585                 }
 586             }
 587             if cbp != 0 {
 588                 blockdsp::add_blocks(&mut b_buf, mb_x, mb_y, &b_data[cur_mb].blk);
 589             }
 590             cur_mb += 1;
 591         }
 592         cbpi.update_row();
 593     }
 594 }