X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=nihav-duck%2Fsrc%2Fcodecs%2Fvp56.rs;h=5abea84f07a22fcc62567db91db0f09d2bb50a35;hb=HEAD;hp=807756a495687533836950daa513237d528c2c14;hpb=8dd7f6798f3efb78b5b09dd71229a28c66099d4b;p=nihav.git diff --git a/nihav-duck/src/codecs/vp56.rs b/nihav-duck/src/codecs/vp56.rs index 807756a..7066e89 100644 --- a/nihav-duck/src/codecs/vp56.rs +++ b/nihav-duck/src/codecs/vp56.rs @@ -7,7 +7,6 @@ pub const TOKEN_LARGE: u8 = 5; pub const TOKEN_EOB: u8 = 42; #[derive(Clone,Copy,Debug,Default)] -#[allow(dead_code)] pub struct VP56Header { pub is_intra: bool, pub is_golden: bool, @@ -42,7 +41,6 @@ pub struct VP56MBTypeModel { pub struct VP56CoeffModel { pub dc_token_probs: [[[u8; 5]; 6]; 6], pub dc_value_probs: [u8; 11], - pub ac_ctype_probs: [[[[u8; 5]; 5]; 6]; 3], pub ac_type_probs: [[[[u8; 5]; 6]; 3]; 3], pub ac_val_probs: [[[u8; 11]; 6]; 3], } @@ -78,6 +76,7 @@ fn prob2weight(a: u8, b: u8) -> u8 { } } +#[allow(clippy::identity_op)] impl VP6Huff { fn build_codes(&mut self, probs: &[u8; 11]) { let mut weights = [0u8; 12]; @@ -134,8 +133,8 @@ impl VP6Huff { for w in weights.iter().rev() { let weight = u16::from(*w); let mut pos = nlen; - for i in 0..nlen { - if nodes[i].weight > weight { + for (i, node) in nodes[..nlen].iter().enumerate() { + if node.weight > weight { pos = i; break; } @@ -470,6 +469,7 @@ impl VP56Decoder { pub fn flush(&mut self) { self.shuf.clear(); } + #[allow(clippy::collapsible_else_if)] pub fn decode_frame(&mut self, supp: &mut NADecoderSupport, src: &[u8], br: &mut dyn VP56Parser) -> DecoderResult<(NABufferType, FrameType)> { let aoffset; let mut bc; @@ -486,7 +486,7 @@ impl VP56Decoder { let hdr = br.parse_header(&mut bc)?; validate!((hdr.offset as usize) < aoffset); //XXX: take alpha 3 byte offset into account? - if hdr.mb_w != 0 { + if hdr.mb_w != 0 && (usize::from(hdr.mb_w) != self.mb_w || usize::from(hdr.mb_h) != self.mb_h) { self.set_dimensions((hdr.mb_w as usize) * 16, (hdr.mb_h as usize) * 16); } let fmt = if !self.has_alpha { @@ -531,9 +531,7 @@ impl VP56Decoder { std::mem::swap(&mut self.models, &mut self.amodels); let ret = self.decode_planes(br, &mut dframe, &mut bc, &ahdr, asrc, true); std::mem::swap(&mut self.models, &mut self.amodels); - if let Err(err) = ret { - return Err(err); - } + ret?; match (hdr.is_golden, ahdr.is_golden) { (true, true) => { self.shuf.add_golden_frame(buf.clone()); }, (true, false) => { @@ -633,7 +631,7 @@ impl VP56Decoder { self.fstate.last_idx = [24; 4]; for mb_x in 0..self.mb_w { self.fstate.mb_x = mb_x; - self.decode_mb(dframe, bc, &mut cr, br, &hdr, alpha)?; + self.decode_mb(dframe, bc, &mut cr, br, hdr, alpha)?; self.dc_pred.next_mb(); } self.dc_pred.update_row(); @@ -649,11 +647,11 @@ impl VP56Decoder { self.models.prob_xmitted.copy_from_slice(&DEFAULT_XMITTED_PROBS); } fn decode_mode_prob_models(&mut self, bc: &mut BoolCoder) -> DecoderResult<()> { - for ctx in 0..3 { + for (prob_xmitted, vq_modes) in self.models.prob_xmitted.iter_mut().zip(VP56_MODE_VQ.iter()) { if bc.read_prob(174) { let idx = bc.read_bits(4) as usize; - for i in 0..20 { - self.models.prob_xmitted[ctx][i ^ 1] = VP56_MODE_VQ[ctx][idx][i]; + for (i, &vq_mode) in vq_modes[idx].iter().enumerate() { + prob_xmitted[i ^ 1] = vq_mode; } } if bc.read_prob(254) { @@ -675,20 +673,19 @@ impl VP56Decoder { validate!(diff < 256); let diff = diff as u8; if !sign { - validate!(self.models.prob_xmitted[ctx][set ^ 1] <= 255 - diff); - self.models.prob_xmitted[ctx][set ^ 1] += diff; + validate!(prob_xmitted[set ^ 1] <= 255 - diff); + prob_xmitted[set ^ 1] += diff; } else { - validate!(self.models.prob_xmitted[ctx][set ^ 1] >= diff); - self.models.prob_xmitted[ctx][set ^ 1] -= diff; + validate!(prob_xmitted[set ^ 1] >= diff); + prob_xmitted[set ^ 1] -= diff; } } } } } - for ctx in 0..3 { - let prob_xmitted = &self.models.prob_xmitted[ctx]; - for mode in 0..10 { - let mdl = &mut self.models.mbtype_models[ctx][mode]; + for (prob_xmitted, mbtype_models) in self.models.prob_xmitted.iter() + .zip(self.models.mbtype_models.iter_mut()) { + for (mode, mdl) in mbtype_models.iter_mut().enumerate() { let mut cnt = [0u32; 10]; let mut total = 0; for i in 0..10 { @@ -699,16 +696,16 @@ impl VP56Decoder { let sum = u32::from(prob_xmitted[mode * 2]) + u32::from(prob_xmitted[mode * 2 + 1]); mdl.probs[9] = 255 - rescale_mb_mode_prob(u32::from(prob_xmitted[mode * 2 + 1]), sum); - let inter_mv0_weight = (cnt[0] as u32) + (cnt[2] as u32); - let inter_mv1_weight = (cnt[3] as u32) + (cnt[4] as u32); - let gold_mv0_weight = (cnt[5] as u32) + (cnt[6] as u32); - let gold_mv1_weight = (cnt[8] as u32) + (cnt[9] as u32); - let mix_weight = (cnt[1] as u32) + (cnt[7] as u32); + let inter_mv0_weight = cnt[0] + cnt[2]; + let inter_mv1_weight = cnt[3] + cnt[4]; + let gold_mv0_weight = cnt[5] + cnt[6]; + let gold_mv1_weight = cnt[8] + cnt[9]; + let mix_weight = cnt[1] + cnt[7]; mdl.probs[0] = 1 + rescale_mb_mode_prob(inter_mv0_weight + inter_mv1_weight, total); mdl.probs[1] = 1 + rescale_mb_mode_prob(inter_mv0_weight, inter_mv0_weight + inter_mv1_weight); mdl.probs[2] = 1 + rescale_mb_mode_prob(mix_weight, mix_weight + gold_mv0_weight + gold_mv1_weight); - mdl.probs[3] = 1 + rescale_mb_mode_prob(cnt[0] as u32, inter_mv0_weight); - mdl.probs[4] = 1 + rescale_mb_mode_prob(cnt[3] as u32, inter_mv1_weight); + mdl.probs[3] = 1 + rescale_mb_mode_prob(cnt[0], inter_mv0_weight); + mdl.probs[4] = 1 + rescale_mb_mode_prob(cnt[3], inter_mv1_weight); mdl.probs[5] = 1 + rescale_mb_mode_prob(cnt[1], mix_weight); mdl.probs[6] = 1 + rescale_mb_mode_prob(gold_mv0_weight, gold_mv0_weight + gold_mv1_weight); mdl.probs[7] = 1 + rescale_mb_mode_prob(cnt[5], gold_mv0_weight); @@ -789,6 +786,7 @@ impl VP56Decoder { Ok(self.last_mbt) } #[allow(clippy::cognitive_complexity)] + #[allow(clippy::collapsible_else_if)] fn decode_mb(&mut self, frm: &mut NASimpleVideoFrame, bc: &mut BoolCoder, cr: &mut CoeffReader, br: &mut dyn VP56Parser, hdr: &VP56Header, alpha: bool) -> DecoderResult<()> { const FOURMV_SUB_TYPE: [VPMBType; 4] = [ VPMBType::InterNoMV, VPMBType::InterMV, VPMBType::InterNearest, VPMBType::InterNear ]; @@ -837,21 +835,21 @@ impl VP56Decoder { self.mb_info[mb_pos].mv = near_mv; }, VPMBType::InterFourMV => { - for i in 0..4 { - four_mbt[i] = FOURMV_SUB_TYPE[bc.read_bits(2) as usize]; + for mbt in four_mbt.iter_mut() { + *mbt = FOURMV_SUB_TYPE[bc.read_bits(2) as usize]; } - for i in 0..4 { - match four_mbt[i] { + for (&mbt, mv) in four_mbt.iter().zip(four_mv.iter_mut()) { + match mbt { VPMBType::InterNoMV => {}, VPMBType::InterMV => { let diff_mv = self.decode_mv(bc, br); - four_mv[i] = pred_mv + diff_mv; + *mv = pred_mv + diff_mv; }, VPMBType::InterNearest => { - four_mv[i] = nearest_mv; + *mv = nearest_mv; }, VPMBType::InterNear => { - four_mv[i] = near_mv; + *mv = near_mv; }, _ => unreachable!(), }; @@ -964,6 +962,7 @@ impl VP56Decoder { } Ok(()) } + #[allow(clippy::identity_op)] fn do_mc(&mut self, br: &dyn VP56Parser, frm: &mut NASimpleVideoFrame, mb_type: VPMBType, mv: MV, alpha: bool) { let x = self.fstate.mb_x * 16; let y = self.fstate.mb_y * 16; @@ -990,10 +989,10 @@ impl VP56Decoder { let y = self.fstate.mb_y * 16; let plane = if !alpha { 0 } else { 3 }; let src = self.shuf.get_last().unwrap(); - for blk_no in 0..4 { + for (blk_no, &mv) in mvs.iter().enumerate() { br.mc_block(frm, self.mc_buf.clone(), src.clone(), plane, x + (blk_no & 1) * 8, y + (blk_no & 2) * 4, - mvs[blk_no], self.loop_thr); + mv, self.loop_thr); } if !alpha { let x = self.fstate.mb_x * 8;