mbtype_cb: Codebook<VPMBType>,
}
-fn map_mbt(idx: usize) -> VPMBType {
- VP30_MBTYPE_SYMS[idx]
-}
-
impl VP30Codes {
fn new() -> Self {
- let mut dc_cb: [Codebook<u8>; 5];
- let mut ac_i_cb: [Codebook<u8>; 5];
- let mut ac_p_cb: [Codebook<u8>; 5];
- let mut cr = TableCodebookDescReader::new(&VP30_MBTYPE_CODES, &VP30_MBTYPE_BITS, map_mbt);
+ let dc_cb;
+ let ac_i_cb;
+ let ac_p_cb;
+ let mut cr = TableCodebookDescReader::new(&VP30_MBTYPE_CODES, &VP30_MBTYPE_BITS, |idx| VP30_MBTYPE_SYMS[idx]);
let mbtype_cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
unsafe {
- dc_cb = mem::uninitialized();
- ac_i_cb = mem::uninitialized();
- ac_p_cb = mem::uninitialized();
+ let mut udc_cb: mem::MaybeUninit::<[Codebook<u8>; 5]> = mem::MaybeUninit::uninit();
+ let mut uac_i_cb: mem::MaybeUninit::<[Codebook<u8>; 5]> = mem::MaybeUninit::uninit();
+ let mut uac_p_cb: mem::MaybeUninit::<[Codebook<u8>; 5]> = mem::MaybeUninit::uninit();
for i in 0..5 {
let mut cr = TableCodebookDescReader::new(&VP30_DC_CODES[i], &VP30_DC_BITS[i], map_idx);
let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
- ptr::write(&mut dc_cb[i], cb);
+ ptr::write(&mut (*udc_cb.as_mut_ptr())[i], cb);
let mut cr = TableCodebookDescReader::new(&VP30_AC_INTRA_CODES[i], &VP30_AC_INTRA_BITS[i], map_idx);
let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
- ptr::write(&mut ac_i_cb[i], cb);
+ ptr::write(&mut (*uac_i_cb.as_mut_ptr())[i], cb);
let mut cr = TableCodebookDescReader::new(&VP30_AC_INTER_CODES[i], &VP30_AC_INTER_BITS[i], map_idx);
let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
- ptr::write(&mut ac_p_cb[i], cb);
+ ptr::write(&mut (*uac_p_cb.as_mut_ptr())[i], cb);
}
+ dc_cb = udc_cb.assume_init();
+ ac_i_cb = uac_i_cb.assume_init();
+ ac_p_cb = uac_p_cb.assume_init();
}
Self { dc_cb, ac_i_cb, ac_p_cb, mbtype_cb }
}
impl VP31Codes {
fn new() -> Self {
- let mut dc_cb: [Codebook<u8>; 16];
- let mut ac0_cb: [Codebook<u8>; 16];
- let mut ac1_cb: [Codebook<u8>; 16];
- let mut ac2_cb: [Codebook<u8>; 16];
- let mut ac3_cb: [Codebook<u8>; 16];
+ let dc_cb;
+ let ac0_cb;
+ let ac1_cb;
+ let ac2_cb;
+ let ac3_cb;
unsafe {
- dc_cb = mem::uninitialized();
- ac0_cb = mem::uninitialized();
- ac1_cb = mem::uninitialized();
- ac2_cb = mem::uninitialized();
- ac3_cb = mem::uninitialized();
+ let mut udc_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
+ let mut uac0_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
+ let mut uac1_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
+ let mut uac2_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
+ let mut uac3_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
for i in 0..16 {
let mut cr = TableCodebookDescReader::new(&VP31_DC_CODES[i], &VP31_DC_BITS[i], map_idx);
let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
- ptr::write(&mut dc_cb[i], cb);
+ ptr::write(&mut (*udc_cb.as_mut_ptr())[i], cb);
let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT0_CODES[i], &VP31_AC_CAT0_BITS[i], map_idx);
let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
- ptr::write(&mut ac0_cb[i], cb);
+ ptr::write(&mut (*uac0_cb.as_mut_ptr())[i], cb);
let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT1_CODES[i], &VP31_AC_CAT1_BITS[i], map_idx);
let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
- ptr::write(&mut ac1_cb[i], cb);
+ ptr::write(&mut (*uac1_cb.as_mut_ptr())[i], cb);
let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT2_CODES[i], &VP31_AC_CAT2_BITS[i], map_idx);
let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
- ptr::write(&mut ac2_cb[i], cb);
+ ptr::write(&mut (*uac2_cb.as_mut_ptr())[i], cb);
let mut cr = TableCodebookDescReader::new(&VP31_AC_CAT3_CODES[i], &VP31_AC_CAT3_BITS[i], map_idx);
let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
- ptr::write(&mut ac3_cb[i], cb);
+ ptr::write(&mut (*uac3_cb.as_mut_ptr())[i], cb);
}
+ dc_cb = udc_cb.assume_init();
+ ac0_cb = uac0_cb.assume_init();
+ ac1_cb = uac1_cb.assume_init();
+ ac2_cb = uac2_cb.assume_init();
+ ac3_cb = uac3_cb.assume_init();
}
Self { dc_cb, ac0_cb, ac1_cb, ac2_cb, ac3_cb }
}
fn new_vp4() -> VP31Codes {
- let mut dc_cb: [Codebook<u8>; 16];
- let mut ac0_cb: [Codebook<u8>; 16];
- let mut ac1_cb: [Codebook<u8>; 16];
- let mut ac2_cb: [Codebook<u8>; 16];
- let mut ac3_cb: [Codebook<u8>; 16];
+ let dc_cb;
+ let ac0_cb;
+ let ac1_cb;
+ let ac2_cb;
+ let ac3_cb;
unsafe {
- dc_cb = mem::uninitialized();
- ac0_cb = mem::uninitialized();
- ac1_cb = mem::uninitialized();
- ac2_cb = mem::uninitialized();
- ac3_cb = mem::uninitialized();
+ let mut udc_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
+ let mut uac0_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
+ let mut uac1_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
+ let mut uac2_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
+ let mut uac3_cb: mem::MaybeUninit::<[Codebook<u8>; 16]> = mem::MaybeUninit::uninit();
for i in 0..16 {
let mut cr = TableCodebookDescReader::new(&VP40_DC_CODES[i], &VP40_DC_BITS[i], map_idx);
let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
- ptr::write(&mut dc_cb[i], cb);
+ ptr::write(&mut (*udc_cb.as_mut_ptr())[i], cb);
let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT0_CODES[i], &VP40_AC_CAT0_BITS[i], map_idx);
let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
- ptr::write(&mut ac0_cb[i], cb);
+ ptr::write(&mut (*uac0_cb.as_mut_ptr())[i], cb);
let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT1_CODES[i], &VP40_AC_CAT1_BITS[i], map_idx);
let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
- ptr::write(&mut ac1_cb[i], cb);
+ ptr::write(&mut (*uac1_cb.as_mut_ptr())[i], cb);
let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT2_CODES[i], &VP40_AC_CAT2_BITS[i], map_idx);
let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
- ptr::write(&mut ac2_cb[i], cb);
+ ptr::write(&mut (*uac2_cb.as_mut_ptr())[i], cb);
let mut cr = TableCodebookDescReader::new(&VP40_AC_CAT3_CODES[i], &VP40_AC_CAT3_BITS[i], map_idx);
let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
- ptr::write(&mut ac3_cb[i], cb);
+ ptr::write(&mut (*uac3_cb.as_mut_ptr())[i], cb);
}
+ dc_cb = udc_cb.assume_init();
+ ac0_cb = uac0_cb.assume_init();
+ ac1_cb = uac1_cb.assume_init();
+ ac2_cb = uac2_cb.assume_init();
+ ac3_cb = uac3_cb.assume_init();
}
VP31Codes { dc_cb, ac0_cb, ac1_cb, ac2_cb, ac3_cb }
}
impl VP40AuxCodes {
fn new() -> Self {
- let mut mv_x_cb: [Codebook<i8>; 7];
- let mut mv_y_cb: [Codebook<i8>; 7];
+ let mv_x_cb;
+ let mv_y_cb;
unsafe {
- mv_x_cb = mem::uninitialized();
- mv_y_cb = mem::uninitialized();
+ let mut umv_x_cb: mem::MaybeUninit::<[Codebook<i8>; 7]> = mem::MaybeUninit::uninit();
+ let mut umv_y_cb: mem::MaybeUninit::<[Codebook<i8>; 7]> = mem::MaybeUninit::uninit();
for i in 0..7 {
let mut cr = TableCodebookDescReader::new(&VP40_MV_X_CODES[i], &VP40_MV_X_BITS[i], map_mv);
let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
- ptr::write(&mut mv_x_cb[i], cb);
+ ptr::write(&mut (*umv_x_cb.as_mut_ptr())[i], cb);
let mut cr = TableCodebookDescReader::new(&VP40_MV_Y_CODES[i], &VP40_MV_Y_BITS[i], map_mv);
let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
- ptr::write(&mut mv_y_cb[i], cb);
+ ptr::write(&mut (*umv_y_cb.as_mut_ptr())[i], cb);
}
+ mv_x_cb = umv_x_cb.assume_init();
+ mv_y_cb = umv_y_cb.assume_init();
}
let mut cr0 = TableCodebookDescReader::new(&VP40_MBPAT_CODES[0], &VP40_MBPAT_BITS[0], map_idx);
let mut cr1 = TableCodebookDescReader::new(&VP40_MBPAT_CODES[1], &VP40_MBPAT_BITS[1], map_idx);
}
}
+#[allow(clippy::large_enum_variant)]
enum Codes {
None,
VP30(VP30Codes),
let idx = br.peek(5) as usize;
let sym = (VP30_CRUN1_LUT[idx] >> 4) as usize;
let bits = VP30_CRUN1_LUT[idx] & 0xF;
- br.skip(bits as u32)?;
- if sym < 7 {
- Ok(sym)
- } else if sym == 7 {
- Ok(7 + (br.read(3)? as usize))
- } else {
- let len = br.read_code(UintCodeType::Unary012)?;
- match len {
- 0 => Ok(15 + (br.read(5)? as usize)),
- 1 => Ok(47 + (br.read(8)? as usize)),
- _ => Ok(303 + (br.read(16)? as usize)),
+ br.skip(u32::from(bits))?;
+ match sym {
+ 0..=6 => Ok(sym),
+ 7 => Ok(7 + (br.read(3)? as usize)),
+ _ => {
+ let len = br.read_code(UintCodeType::Unary012)?;
+ match len {
+ 0 => Ok(15 + (br.read(5)? as usize)),
+ 1 => Ok(47 + (br.read(8)? as usize)),
+ _ => Ok(303 + (br.read(16)? as usize)),
+ }
}
}
}
macro_rules! fill_dc_pred {
($self: expr, $ref_id: expr, $pred: expr, $pp: expr, $bit: expr, $idx: expr) => {
if $self.blocks[$idx].coded && $self.blocks[$idx].btype.get_ref_id() == $ref_id {
- $pred[$bit] = $self.blocks[$idx].coeffs[0] as i32;
+ $pred[$bit] = i32::from($self.blocks[$idx].coeffs[0]);
$pp |= 1 << $bit;
}
};
let nblks = *nblk as usize;
if *coded {
let mut cb = [false; 4];
- for j in 0..nblks {
+ for cb in cb[..nblks].iter_mut() {
if run == 0 {
bit = !bit;
run = if bit { vp30_read_coded_run1(br)? } else { vp30_read_coded_run0(br)? };
}
run -= 1;
- cb[j] = bit;
+ *cb = bit;
}
- for j in 0..nblks {
- let addr = self.blk_addr[cur_blk + j] >> 2;
- self.blocks[addr].coded = cb[j];
+ for (&cb, &blk_addr) in cb.iter()
+ .zip(self.blk_addr[cur_blk..].iter()).take(nblks) {
+ self.blocks[blk_addr >> 2].coded = cb;
}
}
cur_blk += nblks;
}
Ok(())
}
+ #[allow(clippy::identity_op)]
fn vp31_unpack_mv_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
let mut last_mv = ZERO_MV;
let mut last2_mv = ZERO_MV;
}
}
}
- for i in 0..nblks {
- self.blocks[addrs[i]].coded = (pat & 8) != 0;
+ for &addr in addrs[..nblks].iter() {
+ self.blocks[addr].coded = (pat & 8) != 0;
pat <<= 1;
cur_blk += 1;
}
if let Some(ref codes) = self.aux_codes {
for _ in 0..self.y_blocks/4 {
if self.blocks[self.blk_addr[cur_blk] >> 2].btype == VPMBType::InterFourMV {
- let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv.x.abs() as usize]];
- let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv.y.abs() as usize]];
+ let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv.x.unsigned_abs() as usize]];
+ let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv.y.unsigned_abs() as usize]];
let x_sign = last_mv.x < 0;
let y_sign = last_mv.y < 0;
last2_mv = last_mv;
let saddr = (self.blk_addr[cur_blk] >> 2).min(self.blk_addr[cur_blk + 1] >> 2).min(self.blk_addr[cur_blk + 2] >> 2).min(self.blk_addr[cur_blk + 3] >> 2);
for i in 0..4 {
let blk = &mut self.blocks[saddr + (i & 1) + (i >> 1) * self.mb_w * 2];
- blk.mv.x = br.read_cb(x_cb)? as i16;
+ blk.mv.x = i16::from(br.read_cb(x_cb)?);
if x_sign {
blk.mv.x = -blk.mv.x;
}
- blk.mv.y = br.read_cb(y_cb)? as i16;
+ blk.mv.y = i16::from(br.read_cb(y_cb)?);
if y_sign {
blk.mv.y = -blk.mv.y;
}
cur_mv = ZERO_MV;
},
VPMBType::InterMV => {
- let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv.x.abs() as usize]];
- let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv.y.abs() as usize]];
+ let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv.x.unsigned_abs() as usize]];
+ let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv.y.unsigned_abs() as usize]];
let x_sign = last_mv.x < 0;
let y_sign = last_mv.y < 0;
- let x = br.read_cb(x_cb)? as i16;
- let y = br.read_cb(y_cb)? as i16;
+ let x = i16::from(br.read_cb(x_cb)?);
+ let y = i16::from(br.read_cb(y_cb)?);
cur_mv = MV { x: if !x_sign { x } else { -x }, y: if !y_sign { y } else { -y } };
last2_mv = last_mv;
last_mv = cur_mv;
std::mem::swap(&mut last_mv, &mut last2_mv);
},
_ => { // GoldenMV
- let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv_g.x.abs() as usize]];
- let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv_g.y.abs() as usize]];
+ let x_cb = &codes.mv_x_cb[VP40_MV_LUT_INDEX[last_mv_g.x.unsigned_abs() as usize]];
+ let y_cb = &codes.mv_y_cb[VP40_MV_LUT_INDEX[last_mv_g.y.unsigned_abs() as usize]];
let x_sign = last_mv_g.x < 0;
let y_sign = last_mv_g.y < 0;
- let x = br.read_cb(x_cb)? as i16;
- let y = br.read_cb(y_cb)? as i16;
+ let x = i16::from(br.read_cb(x_cb)?);
+ let y = i16::from(br.read_cb(y_cb)?);
cur_mv = MV { x: if !x_sign { x } else { -x }, y: if !y_sign { y } else { -y } };
last_mv_g = cur_mv;
},
}
if pp == 0 { return self.last_dc[ref_id as usize]; }
let mut pred = 0i32;
- for i in 0..4 {
+ for (i, (&pred_val, &dc_weight)) in preds.iter().zip(VP31_DC_WEIGHTS[pp].iter()).enumerate() {
if (pp & (1 << i)) != 0 {
- pred += (preds[i] as i32) * (VP31_DC_WEIGHTS[pp][i] as i32);
+ pred += pred_val * i32::from(dc_weight);
}
}
- pred /= VP31_DC_WEIGHTS[pp][4] as i32;
+ pred /= i32::from(VP31_DC_WEIGHTS[pp][4]);
if (pp & 7) == 7 {
if (pred - preds[2]).abs() > 128 { return preds[2] as i16; }
if (pred - preds[0]).abs() > 128 { return preds[0] as i16; }
}
pred as i16
}
+ #[allow(clippy::identity_op)]
fn vp40_predict_dc(&self, bx: usize, by: usize, bw: usize, bh: usize, blk_idx: usize, mask: usize, is_luma: bool) -> i16 {
let mut preds = [0i32; 4];
let mut pp: usize = 0;
if pp == 0 { return self.last_dc[ref_id as usize]; }
let mut pred = 0i32;
let mut npred = 0;
- for i in 0..4 {
+ for (i, &pred_val) in preds.iter().enumerate() {
if (pp & (1 << i)) != 0 {
- pred += preds[i] as i32;
+ pred += pred_val;
npred += 1;
if npred == 2 {
return (pred / 2) as i16;
let mut biter = self.blocks.iter_mut();
for by in 0..self.mb_h*2 {
for bx in 0..self.mb_w*2 {
- let mut blk = biter.next().unwrap();
+ let blk = biter.next().unwrap();
let qmat = &self.qmat_y;
blk.coeffs[0] *= qmat[0];
if blk.has_ac {
for plane in 1..3 {
for by in 0..self.mb_h {
for bx in 0..self.mb_w {
- let mut blk = biter.next().unwrap();
+ let blk = biter.next().unwrap();
let qmat = &self.qmat_c;
blk.coeffs[0] *= qmat[0];
if blk.has_ac {
}
}
}
+ #[allow(clippy::cognitive_complexity)]
+ #[allow(clippy::collapsible_else_if)]
fn output_blocks_inter(&mut self, frm: &mut NASimpleVideoFrame<u8>) {
let mut blk_idx = 0;
let bstride = self.mb_w * 2;
mv_sum.y = (mv_sum.y + 2) >> 2;
let src = self.shuf.get_last().unwrap();
- for i in 0..4 {
+ for (i, mv) in mvs.iter().enumerate() {
let xoff = (i & 1) * 8;
let yoff = (i >> 1) * 8;
- let mode = vp3_mv_mode(mvs[i].x, mvs[i].y);
+ let mode = vp3_mv_mode(mv.x, mv.y);
if self.version != 4 {
copy_block(frm, src.clone(), 0, bx * 8 + xoff, by * 8 + yoff,
- mvs[i].x >> 1, mvs[i].y >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
+ mv.x >> 1, mv.y >> 1, 8, 8, 0, 1, mode, VP3_INTERP_FUNCS);
} else {
vp_copy_block(frm, src.clone(), 0, bx * 8 + xoff, by * 8 + yoff,
- mvs[i].x >> 1, mvs[i].y >> 1, 0, 1, self.loop_str,
+ mv.x >> 1, mv.y >> 1, 0, 1, self.loop_str,
mode, VP3_INTERP_FUNCS, self.mc_buf.clone());
}
}
let mut biter = self.blocks.iter_mut();
for by in 0..self.mb_h*2 {
for bx in 0..self.mb_w*2 {
- let mut blk = biter.next().unwrap();
+ let blk = biter.next().unwrap();
// do MC for whole macroblock
if !blk.btype.is_intra() && (((bx | by) & 1) == 0) && (blk.btype != VPMBType::InterFourMV) {
let src = if blk.btype.get_ref_id() == 1 {
for plane in 1..3 {
for by in 0..self.mb_h {
for bx in 0..self.mb_w {
- let mut blk = biter.next().unwrap();
+ let blk = biter.next().unwrap();
let qmat = if blk.btype.is_intra() { &self.qmat_c } else { &self.qmat_c_p };
blk.coeffs[0] *= qmat[0];
if blk.has_ac {
self.sb_mbs.push(nmbs);
let mut nblocks = 0;
- for blk_no in 0..16 {
- let bx = x * 4 + HILBERT_ORDER[blk_no][0];
- let by = y * 4 + HILBERT_ORDER[blk_no][1];
+ for (blk_no, order) in HILBERT_ORDER.iter().enumerate() {
+ let bx = x * 4 + order[0];
+ let by = y * 4 + order[1];
if (bx >= blk_w) || (by >= blk_h) { continue; }
let idx = base_idx + bx + by * blk_w;
self.blk_addr.push(idx * 4 + plane);
Err(DecoderError::InvalidData)
}
}
+ #[allow(clippy::collapsible_else_if)]
fn decode(&mut self, supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
let src = pkt.get_buffer();
validate!(src.len() > 0);
}
}
-pub fn get_decoder_vp3() -> Box<NADecoder + Send> {
+impl NAOptionHandler for VP34Decoder {
+ fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
+ fn set_options(&mut self, _options: &[NAOption]) { }
+ fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
+}
+
+pub fn get_decoder_vp3() -> Box<dyn NADecoder + Send> {
Box::new(VP34Decoder::new(3))
}
-pub fn get_decoder_vp4() -> Box<NADecoder + Send> {
+pub fn get_decoder_vp4() -> Box<dyn NADecoder + Send> {
Box::new(VP34Decoder::new(4))
}
use nihav_core::codecs::RegisteredDecoders;
use nihav_core::demuxers::RegisteredDemuxers;
use nihav_codec_support::test::dec_video::*;
- use crate::duck_register_all_codecs;
+ use crate::duck_register_all_decoders;
use nihav_commonfmt::generic_register_all_demuxers;
#[test]
let mut dmx_reg = RegisteredDemuxers::new();
generic_register_all_demuxers(&mut dmx_reg);
let mut dec_reg = RegisteredDecoders::new();
- duck_register_all_codecs(&mut dec_reg);
+ duck_register_all_decoders(&mut dec_reg);
+ // sample: https://samples.mplayerhq.hu/V-codecs/VP3/vp30-logo.avi
test_decoding("avi", "vp3", "assets/Duck/vp30-logo.avi", Some(23), &dmx_reg, &dec_reg,
ExpectedTestResult::MD5([0x51aba7df, 0x6e42534d, 0xef6c5b13, 0x26c38d1f]));
}
let mut dmx_reg = RegisteredDemuxers::new();
generic_register_all_demuxers(&mut dmx_reg);
let mut dec_reg = RegisteredDecoders::new();
- duck_register_all_codecs(&mut dec_reg);
+ duck_register_all_decoders(&mut dec_reg);
// let file = "assets/Duck/vp31.avi";
// let file = "assets/Duck/vp31_crash.avi";
// let file = "assets/Duck/01-vp31-0500.avi";
// test_file_decoding("avi", file, Some(3), true, false, None/*Some("vp31")*/, &dmx_reg, &dec_reg);
//panic!("end");
+ // sample: https://samples.mplayerhq.hu/V-codecs/VP3/01-vp31-0500.avi
test_decoding("avi", "vp3", "assets/Duck/01-vp31-0500.avi", Some(16), &dmx_reg, &dec_reg,
ExpectedTestResult::MD5([0x65112f7e, 0x2914f29b, 0x2908ed2f, 0xce5fc8c5]));
}
let mut dmx_reg = RegisteredDemuxers::new();
generic_register_all_demuxers(&mut dmx_reg);
let mut dec_reg = RegisteredDecoders::new();
- duck_register_all_codecs(&mut dec_reg);
+ duck_register_all_decoders(&mut dec_reg);
+ // sample: https://samples.mplayerhq.hu/V-codecs/VP4/ot171_vp40.avi
test_decoding("avi", "vp3", "assets/Duck/ot171_vp40.avi", Some(86), &dmx_reg, &dec_reg,
ExpectedTestResult::MD5([0xd41d8cd9, 0x8f00b204, 0xe9800998, 0xecf8427e]));
}
projects / nihav.git / blobdiff