+ fn decode_intra_mb(&mut self, bd: &mut dyn BlockDecoder, bdsp: &dyn BlockDSP, mb_pos: usize, binfo: &BlockInfo, sstate: &SliceState, apply_acpred: bool) -> DecoderResult<()> {
+ for i in 0..6 {
+ bd.decode_block_intra(&binfo, &sstate, binfo.get_q(), i, (binfo.cbp & (1 << (5 - i))) != 0, &mut self.blk[i])?;
+ if apply_acpred && (binfo.acpred != ACPredMode::None) {
+ let has_b = (i == 1) || (i == 3) || !sstate.first_mb;
+ let has_a = (i == 2) || (i == 3) || !sstate.first_line;
+ let (b_mb, b_blk) = if has_b {
+ if (i == 1) || (i == 3) {
+ (mb_pos, i - 1)
+ } else if i < 4 {
+ (mb_pos - 1, i + 1)
+ } else {
+ (mb_pos - 1, i)
+ }
+ } else { (0, 0) };
+ let (a_mb, a_blk) = if has_a {
+ if (i == 2) || (i == 3) {
+ (mb_pos, i - 2)
+ } else if i < 4 {
+ (mb_pos - self.mb_w, i + 2)
+ } else {
+ (mb_pos - self.mb_w, i)
+ }
+ } else { (0, 0) };
+ match binfo.acpred {
+ ACPredMode::DC => {
+ let dc;
+ if has_a && has_b {
+ dc = (self.pred_coeffs[b_mb].hor[b_blk][0] + self.pred_coeffs[a_mb].ver[a_blk][0]) / 2;
+ } else if has_a {
+ dc = self.pred_coeffs[a_mb].ver[a_blk][0];
+ } else if has_b {
+ dc = self.pred_coeffs[b_mb].hor[b_blk][0];
+ } else {
+ dc = 1024;
+ }
+ self.blk[i][0] = clip_dc(self.blk[i][0] + dc);
+ },
+ ACPredMode::Hor => {
+ if has_b {
+ for k in 0..8 {
+ self.blk[i][k * 8] += self.pred_coeffs[b_mb].hor[b_blk][k];
+ }
+ for k in 1..8 {
+ self.blk[i][k * 8] = clip_ac(self.blk[i][k * 8]);
+ }
+ } else {
+ self.blk[i][0] += 1024;
+ }
+ self.blk[i][0] = clip_dc(self.blk[i][0]);
+ },
+ ACPredMode::Ver => {
+ if has_a {
+ for k in 0..8 {
+ self.blk[i][k] += self.pred_coeffs[a_mb].ver[a_blk][k];
+ }
+ for k in 1..8 {
+ self.blk[i][k] = clip_ac(self.blk[i][k]);
+ }
+ } else {
+ self.blk[i][0] += 1024;
+ }
+ self.blk[i][0] = clip_dc(self.blk[i][0]);
+ },
+ ACPredMode::None => {},
+ };
+ for t in 0..8 { self.pred_coeffs[mb_pos].hor[i][t] = self.blk[i][t * 8]; }
+ for t in 0..8 { self.pred_coeffs[mb_pos].ver[i][t] = self.blk[i][t]; }
+ }
+ bdsp.idct(&mut self.blk[i]);
+ }
+ Ok(())
+ }
+ #[allow(clippy::comparison_chain)]
+ fn decode_intra_mb_pred_quant(&mut self, bd: &mut dyn BlockDecoder, bdsp: &dyn BlockDSP, mb_pos: usize, binfo: &BlockInfo, sstate: &SliceState, apply_acpred: bool) -> DecoderResult<()> {
+ for i in 0..6 {
+ bd.decode_block_intra(&binfo, &sstate, binfo.get_q(), i, (binfo.cbp & (1 << (5 - i))) != 0, &mut self.blk[i])?;
+ let q = if binfo.get_q() < 8 {
+ 8
+ } else {
+ i16::from(binfo.get_q() * 2)
+ };
+ let qadd = (q + 1) >> 1;
+ let quant_gray = 1024 / q;
+ if apply_acpred && (binfo.acpred != ACPredMode::None) {
+ let has_b = (i == 1) || (i == 3) || !sstate.first_mb;
+ let has_a = (i == 2) || (i == 3) || !sstate.first_line;
+ let (b_mb, b_blk) = if has_b {
+ if (i == 1) || (i == 3) {
+ (mb_pos, i - 1)
+ } else if i < 4 {
+ (mb_pos - 1, i + 1)
+ } else {
+ (mb_pos - 1, i)
+ }
+ } else { (0, 0) };
+ let (a_mb, a_blk) = if has_a {
+ if (i == 2) || (i == 3) {
+ (mb_pos, i - 2)
+ } else if i < 4 {
+ (mb_pos - self.mb_w, i + 2)
+ } else {
+ (mb_pos - self.mb_w, i)
+ }
+ } else { (0, 0) };
+ let dc_a = if has_a && self.pred_coeffs[a_mb].ver[a_blk][0] != 0x7FFF {
+ self.pred_coeffs[a_mb].ver[a_blk][0]
+ } else {
+ quant_gray
+ };
+ let dc_b = if has_b && self.pred_coeffs[b_mb].hor[b_blk][0] != 0x7FFF {
+ self.pred_coeffs[b_mb].hor[b_blk][0]
+ } else {
+ quant_gray
+ };
+ let dc = match binfo.acpred {
+ ACPredMode::DC => {
+ if has_a && has_b {
+ (dc_a + dc_b + 1) >> 1
+ } else if has_a {
+ dc_a
+ } else if has_b {
+ dc_b
+ } else {
+ quant_gray
+ }
+ },
+ ACPredMode::Hor => {
+ if has_b {
+ for k in 1..8 {
+ self.blk[i][k * 8] += self.pred_coeffs[b_mb].hor[b_blk][k];
+ }
+ for k in 1..8 {
+ self.blk[i][k * 8] = clip_ac(self.blk[i][k * 8]);
+ }
+ dc_b
+ } else {
+ quant_gray
+ }
+ },
+ ACPredMode::Ver => {
+ if has_a {
+ for k in 1..8 {
+ self.blk[i][k] += self.pred_coeffs[a_mb].ver[a_blk][k];
+ }
+ for k in 1..8 {
+ self.blk[i][k] = clip_ac(self.blk[i][k]);
+ }
+ dc_a
+ } else {
+ quant_gray
+ }
+ },
+ ACPredMode::None => { 0 },
+ };
+ self.blk[i][0] += dc;
+ for t in 0..8 { self.pred_coeffs[mb_pos].hor[i][t] = self.blk[i][t * 8]; }
+ for t in 0..8 { self.pred_coeffs[mb_pos].ver[i][t] = self.blk[i][t]; }
+ }
+ if apply_acpred {
+ let start = if binfo.get_q() < 8 {
+ self.blk[i][0] <<= 3;
+ 1
+ } else {
+ 0
+ };
+ for el in self.blk[i].iter_mut().skip(start) {
+ if *el > 0 {
+ *el = *el * q + qadd;
+ } else if *el < 0 {
+ *el = *el * q - qadd;
+ }
+ }
+ }
+ bdsp.idct(&mut self.blk[i]);
+ }
+ Ok(())
+ }
+ fn decode_inter_mb(&mut self, bd: &mut dyn BlockDecoder, bdsp: &dyn BlockDSP, binfo: &BlockInfo, sstate: &SliceState) -> DecoderResult<()> {
+ for i in 0..6 {
+ bd.decode_block_inter(&binfo, &sstate, binfo.get_q(), i, ((binfo.cbp >> (5 - i)) & 1) != 0, &mut self.blk[i])?;
+ bdsp.idct(&mut self.blk[i]);
+ }
+ Ok(())
+ }
+ fn get_obmc_mv(&self, mb_idx: usize, blk_no: usize, cur_mv: MV) -> MV {
+ let (mbt, ref bi) = self.obmc_blk[mb_idx];
+ if mbt == Type::I {
+ cur_mv
+ } else if mbt == Type::Skip {
+ ZERO_MV
+ } else if bi.num_mv == 1 {
+ bi.mv_f[0]
+ } else {
+ bi.mv_f[blk_no]
+ }
+ }
+ #[allow(clippy::cognitive_complexity)]
+ fn reconstruct_obmc(&mut self, buf: &mut NAVideoBuffer<u8>, slice_start: usize, start: usize, end: usize, slice_end: bool) -> usize {
+ let mut mb_x = start % self.mb_w;
+ let mut mb_y = start / self.mb_w;
+ let mut mb_pos = start;
+ while mb_pos < end {
+ let has_top = mb_pos >= slice_start + self.mb_w;
+ let has_left = (mb_x > 0) && (mb_pos > slice_start);
+ let has_right = (mb_x + 1 < self.mb_w) && (mb_pos + 1 < end);
+ let has_bottom = mb_pos + self.mb_w < end;
+
+ if !has_bottom && !slice_end {
+ break;
+ }
+
+ let (mbt, ref bi) = self.obmc_blk[mb_pos];
+ if mbt == Type::P || mbt == Type::Skip {
+ let single_mv = bi.num_mv != 4;
+ for blk in 0..4 {
+ let cur_mv = if single_mv { bi.mv_f[0] } else { bi.mv_f[blk] };
+ let top_mv = if (blk & 2) == 0 {
+ if has_top {
+ self.get_obmc_mv(mb_pos - self.mb_w, blk + 2, cur_mv)
+ } else { cur_mv }
+ } else {
+ if single_mv { cur_mv } else { bi.mv_f[blk - 2] }
+ };
+ let left_mv = if (blk & 1) == 0 {
+ if has_left {
+ self.get_obmc_mv(mb_pos - 1, blk + 1, cur_mv)
+ } else { cur_mv }
+ } else {
+ if single_mv { cur_mv } else { bi.mv_f[blk - 1] }
+ };
+ let bottom_mv = if (blk & 2) != 0 {
+ if has_bottom {
+ self.get_obmc_mv(mb_pos + self.mb_w, blk - 2, cur_mv)
+ } else { cur_mv }
+ } else {
+ if single_mv { cur_mv } else { bi.mv_f[blk + 2] }
+ };
+ let right_mv = if (blk & 1) != 0 {
+ if has_right {
+ self.get_obmc_mv(mb_pos + 1, blk - 1, cur_mv)
+ } else { cur_mv }
+ } else {
+ if single_mv { cur_mv } else { bi.mv_f[blk + 1] }
+ };
+
+ let mut obmcbuf = NASimpleVideoFrame::from_video_buf(&mut self.obmc_buf).unwrap();
+
+ if let Some(ref srcbuf) = self.ipbs.get_lastref() {
+ let dx = (mb_x * 16 + (blk & 1) * 8) as i16;
+ let dy = (mb_y * 16 + (blk & 2) * 4) as i16;
+
+ let block_params = [(8, 0, top_mv), (0, 8, left_mv), (8, 8, cur_mv), (16, 8, right_mv), (8, 16, bottom_mv)];
+
+ for (off_x, off_y, mv) in block_params.iter() {
+ let mx = dx + (mv.x >> 1) - off_x;
+ let my = dy + (mv.y >> 1) - off_y;
+ let mode = ((mv.x & 1) + (mv.y & 1) * 2) as usize;
+ blockdsp::copy_block(&mut obmcbuf, srcbuf.clone(), 0,
+ *off_x as usize, *off_y as usize, mx, my,
+ 8, 8, 0, 1, mode, H263_INTERP_FUNCS);
+ }
+ let stride = buf.get_stride(0);
+ let off = buf.get_offset(0) + (dx as usize) + (dy as usize) * stride;
+ let data = buf.get_data_mut().unwrap();
+ obmc_filter(&mut data[off..], stride, obmcbuf.data, obmcbuf.stride[0]);
+ }
+ }
+ if let Some(ref srcbuf) = self.ipbs.get_lastref() {
+ let mut dst = NASimpleVideoFrame::from_video_buf(buf).unwrap();
+ let xpos = mb_x * 8;
+ let ypos = mb_y * 8;
+
+ let (mvx, mvy, cmode) = if single_mv {
+ let mv = bi.mv_f[0];
+ let cmode = (if (mv.x & 3) != 0 { 1 } else { 0 }) + (if (mv.y & 3) != 0 { 2 } else { 0 });
+ (mv.x >> 2, mv.y >> 2, cmode)
+ } else {
+ let sum_mv = bi.mv_f[0] + bi.mv_f[1] + bi.mv_f[2] + bi.mv_f[3];
+ let cmx = (sum_mv.x >> 3) + H263_CHROMA_ROUND[(sum_mv.x & 0xF) as usize];
+ let cmy = (sum_mv.y >> 3) + H263_CHROMA_ROUND[(sum_mv.y & 0xF) as usize];
+ let cmode = ((cmx & 1) + (cmy & 1) * 2) as usize;
+ (cmx, cmy, cmode)
+ };
+ blockdsp::copy_block(&mut dst, srcbuf.clone(), 1, xpos, ypos, mvx, mvy, 8, 8, 0, 1, cmode, H263_INTERP_FUNCS);
+ blockdsp::copy_block(&mut dst, srcbuf.clone(), 2, xpos, ypos, mvx, mvy, 8, 8, 0, 1, cmode, H263_INTERP_FUNCS);
+ }
+ if mbt != Type::Skip {
+ blockdsp::add_blocks(buf, mb_x, mb_y, &bi.blk);
+ }
+ }
+
+ mb_pos += 1;
+ mb_x += 1;
+ if mb_x == self.mb_w {
+ mb_x = 0;
+ mb_y += 1;
+ }
+ }
+ mb_pos
+ }
+ #[allow(clippy::cognitive_complexity)]
+ pub fn parse_frame(&mut self, bd: &mut dyn BlockDecoder, bdsp: &dyn BlockDSP) -> DecoderResult<NABufferType> {