use nihav_codec_support::codecs::h263::decoder::*;
use nihav_codec_support::codecs::h263::data::*;
-#[allow(dead_code)]
struct Tables {
intra_mcbpc_cb: Codebook<u8>,
inter_mcbpc_cb: Codebook<u8>,
cbpy_cb: Codebook<u8>,
rl_cb: Codebook<H263RLSym>,
- aic_rl_cb: Codebook<H263RLSym>,
mv_cb: Codebook<u8>,
}
const ROW_SHIFT: u8 = 8;
const COL_SHIFT: u8 = 14;
-#[allow(clippy::erasing_op)]
fn idct_row(row: &mut [i16]) {
let in0 = ((i32::from(row[0])) << 11) + (1 << (ROW_SHIFT - 1));
let in1 = (i32::from(row[4])) << 11;
}
#[allow(clippy::erasing_op)]
+#[allow(clippy::identity_op)]
fn idct_col(blk: &mut [i16; 64], off: usize) {
let in0 = ((i32::from(blk[off + 0*8])) << 8) + (1 << (COL_SHIFT - 1));
let in1 = (i32::from(blk[off + 4*8])) << 8;
];
#[allow(clippy::erasing_op)]
+#[allow(clippy::identity_op)]
fn deblock_hor(buf: &mut NAVideoBuffer<u8>, comp: usize, strength: u8, off: usize) {
let stride = buf.get_stride(comp);
let dptr = buf.get_data_mut().unwrap();
let buf = dptr.as_mut_slice();
for x in 0..8 {
- let a = buf[off - 2 * stride + x] as i16;
- let b = buf[off - 1 * stride + x] as i16;
- let c = buf[off + 0 * stride + x] as i16;
- let d = buf[off + 1 * stride + x] as i16;
+ let a = i16::from(buf[off - 2 * stride + x]);
+ let b = i16::from(buf[off - 1 * stride + x]);
+ let c = i16::from(buf[off + 0 * stride + x]);
+ let d = i16::from(buf[off + 1 * stride + x]);
let diff = (3 * (a - d) + 8 * (c - b)) / 16;
if (diff != 0) && (diff > -24) && (diff < 24) {
- let d1a = (diff.abs() - 2 * (diff.abs() - (strength as i16)).max(0)).max(0);
+ let d1a = (diff.abs() - 2 * (diff.abs() - i16::from(strength)).max(0)).max(0);
let d1 = if diff < 0 { -d1a } else { d1a };
buf[off - 1 * stride + x] = (b + d1).max(0).min(255) as u8;
}
}
+#[allow(clippy::identity_op)]
fn deblock_ver(buf: &mut NAVideoBuffer<u8>, comp: usize, strength: u8, off: usize) {
let stride = buf.get_stride(comp);
let dptr = buf.get_data_mut().unwrap();
let buf = dptr.as_mut_slice();
for y in 0..8 {
- let a = buf[off - 2 + y * stride] as i16;
- let b = buf[off - 1 + y * stride] as i16;
- let c = buf[off + 0 + y * stride] as i16;
- let d = buf[off + 1 + y * stride] as i16;
+ let a = i16::from(buf[off - 2 + y * stride]);
+ let b = i16::from(buf[off - 1 + y * stride]);
+ let c = i16::from(buf[off + 0 + y * stride]);
+ let d = i16::from(buf[off + 1 + y * stride]);
let diff = (3 * (a - d) + 8 * (c - b)) / 16;
if (diff != 0) && (diff > -24) && (diff < 24) {
- let d1a = (diff.abs() - 2 * (diff.abs() - (strength as i16)).max(0)).max(0);
+ let d1a = (diff.abs() - 2 * (diff.abs() - i16::from(strength)).max(0)).max(0);
let d1 = if diff < 0 { -d1a } else { d1a };
buf[off - 1 + y * stride] = (b + d1).max(0).min(255) as u8;
blockdsp::copy_block(&mut dst, src.clone(), 0, xpos, ypos, mv.x >> 1, mv.y >> 1, 16, 16, 0, 1, mode, H263_INTERP_FUNCS);
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);
- blockdsp::copy_block(&mut dst, src.clone(), 2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_FUNCS);
+ 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);
}
fn copy_blocks8x8(&self, dst: &mut NAVideoBuffer<u8>, src: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, mvs: &[MV; 4]) {
let mut dst = NASimpleVideoFrame::from_video_buf(dst).unwrap();
- for i in 0..4 {
+ for (i, mv) in mvs.iter().enumerate() {
let xadd = (i & 1) * 8;
let yadd = (i & 2) * 4;
- let mode = ((mvs[i].x & 1) + (mvs[i].y & 1) * 2) as usize;
+ let mode = ((mv.x & 1) + (mv.y & 1) * 2) as usize;
- blockdsp::copy_block(&mut dst, src.clone(), 0, xpos + xadd, ypos + yadd, mvs[i].x >> 1, mvs[i].y >> 1, 8, 8, 0, 1, mode, H263_INTERP_FUNCS);
+ 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);
}
let sum_mv = mvs[0] + mvs[1] + mvs[2] + mvs[3];
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);
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);
- blockdsp::copy_block(&mut dst, src.clone(), 2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_AVG_FUNCS);
+ 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);
}
fn avg_blocks8x8(&self, dst: &mut NAVideoBuffer<u8>, src: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, mvs: &[MV; 4]) {
let mut dst = NASimpleVideoFrame::from_video_buf(dst).unwrap();
- for i in 0..4 {
+ for (i, mv) in mvs.iter().enumerate() {
let xadd = (i & 1) * 8;
let yadd = (i & 2) * 4;
- let mode = ((mvs[i].x & 1) + (mvs[i].y & 1) * 2) as usize;
+ let mode = ((mv.x & 1) + (mv.y & 1) * 2) as usize;
- blockdsp::copy_block(&mut dst, src.clone(), 0, xpos + xadd, ypos + yadd, mvs[i].x >> 1, mvs[i].y >> 1, 8, 8, 0, 1, mode, H263_INTERP_AVG_FUNCS);
+ 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);
}
let sum_mv = mvs[0] + mvs[1] + mvs[2] + mvs[3];
let coded0 = cbpi.is_coded(mb_x, 0);
let coded1 = cbpi.is_coded(mb_x, 1);
let q = cbpi.get_q(mb_w + mb_x);
- let str = if q < 32 { FILTER_STRENGTH[q as usize] } else { 0 };
+ let strength = if q < 32 { FILTER_STRENGTH[q as usize] } else { 0 };
if mb_y != 0 {
- if coded0 && cbpi.is_coded_top(mb_x, 0) { deblock_hor(buf, 0, str, coff); }
- if coded1 && cbpi.is_coded_top(mb_x, 1) { deblock_hor(buf, 0, str, coff + 8); }
+ if coded0 && cbpi.is_coded_top(mb_x, 0) { deblock_hor(buf, 0, strength, coff); }
+ if coded1 && cbpi.is_coded_top(mb_x, 1) { deblock_hor(buf, 0, strength, coff + 8); }
}
let coff = off + 8 * stride;
if cbpi.is_coded(mb_x, 2) && coded0 { deblock_hor(buf, 0, q, coff); }
let ccur0 = cbpi.is_coded(mb_x, 0);
let ccur1 = cbpi.is_coded(mb_x, 1);
let q = cbpi.get_q(mb_w + mb_x);
- let str = if q < 32 { FILTER_STRENGTH[q as usize] } else { 0 };
+ let strength = if q < 32 { FILTER_STRENGTH[q as usize] } else { 0 };
if mb_y != 0 {
let coff = off - 8 * stride;
let qtop = cbpi.get_q(mb_x);
if leftt && ctop0 { deblock_ver(buf, 0, strtop, coff); }
if ctop0 && ctop1 { deblock_ver(buf, 0, strtop, coff + 8); }
}
- if leftc && ccur0 { deblock_ver(buf, 0, str, off); }
- if ccur0 && ccur1 { deblock_ver(buf, 0, str, off + 8); }
+ if leftc && ccur0 { deblock_ver(buf, 0, strength, off); }
+ if ccur0 && ccur1 { deblock_ver(buf, 0, strength, off + 8); }
leftt = ctop1;
leftc = ccur1;
off += 16;
let ctv = cbpi.is_coded_top(mb_x, 5);
let ccv = cbpi.is_coded(mb_x, 5);
let q = cbpi.get_q(mb_w + mb_x);
- let str = if q < 32 { FILTER_STRENGTH[q as usize] } else { 0 };
- if ctu && ccu { deblock_hor(buf, 1, str, offu + mb_x * 8); }
- if ctv && ccv { deblock_hor(buf, 2, str, offv + mb_x * 8); }
+ let strength = if q < 32 { FILTER_STRENGTH[q as usize] } else { 0 };
+ if ctu && ccu { deblock_hor(buf, 1, strength, offu + mb_x * 8); }
+ if ctv && ccv { deblock_hor(buf, 2, strength, offv + mb_x * 8); }
}
let mut leftu = false;
let mut leftv = false;
}
}
-fn check_marker<'a>(br: &mut BitReader<'a>) -> DecoderResult<()> {
+fn check_marker(br: &mut BitReader) -> DecoderResult<()> {
let mark = br.read(1)?;
validate!(mark == 1);
Ok(())
impl<'a> BlockDecoder for Intel263BR<'a> {
-#[allow(unused_variables)]
fn decode_pichdr(&mut self) -> DecoderResult<PicInfo> {
let br = &mut self.br;
let syncw = br.read(22)?;
let cpm = br.read_bool()?;
validate!(!cpm);
- let pbinfo;
- if self.is_pb {
- let trb = br.read(3)?;
- let dbquant = br.read(2)?;
- pbinfo = Some(PBInfo::new(trb as u8, dbquant as u8, pbplus));
- } else {
- pbinfo = None;
- }
+ let pbinfo = if self.is_pb {
+ let trb = br.read(3)?;
+ let dbquant = br.read(2)?;
+ Some(PBInfo::new(trb as u8, dbquant as u8, pbplus))
+ } else {
+ None
+ };
while br.read_bool()? { // skip PEI
br.read(8)?;
}
Ok(picinfo)
}
- #[allow(unused_variables)]
- fn decode_slice_header(&mut self, info: &PicInfo) -> DecoderResult<SliceInfo> {
+ fn decode_slice_header(&mut self, _info: &PicInfo) -> DecoderResult<SliceInfo> {
let br = &mut self.br;
let gbsc = br.read(17)?;
validate!(gbsc == 1);
- let gn = br.read(5)?;
- let gfid = br.read(2)?;
+ let _gn = br.read(5)?;
+ let _gfid = br.read(2)?;
let gquant = br.read(5)?;
//println!("GOB gn {:X} id {} q {}", gn, gfid, gquant);
let ret = SliceInfo::new_gob(0, self.gob_no, gquant as u8);
Ok(ret)
}
- #[allow(unused_variables)]
- fn decode_block_header(&mut self, info: &PicInfo, slice: &SliceInfo, sstate: &SliceState) -> DecoderResult<BlockInfo> {
+ fn decode_block_header(&mut self, info: &PicInfo, slice: &SliceInfo, _sstate: &SliceState) -> DecoderResult<BlockInfo> {
let br = &mut self.br;
let mut q = slice.get_quant();
match info.get_mode() {
}
}
- #[allow(unused_variables)]
- fn decode_block_intra(&mut self, info: &BlockInfo, sstate: &SliceState, quant: u8, no: usize, coded: bool, blk: &mut [i16; 64]) -> DecoderResult<()> {
+ fn decode_block_intra(&mut self, _info: &BlockInfo, _sstate: &SliceState, quant: u8, _no: usize, coded: bool, blk: &mut [i16; 64]) -> DecoderResult<()> {
self.decode_block(quant, true, coded, blk)
}
- #[allow(unused_variables)]
- fn decode_block_inter(&mut self, info: &BlockInfo, sstate: &SliceState, quant: u8, no: usize, coded: bool, blk: &mut [i16; 64]) -> DecoderResult<()> {
+ fn decode_block_inter(&mut self, _info: &BlockInfo, _sstate: &SliceState, quant: u8, _no: usize, coded: bool, blk: &mut [i16; 64]) -> DecoderResult<()> {
self.decode_block(quant, false, coded, blk)
}
let cbpy_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
let mut coderead = H263RLCodeReader::new(H263_RL_CODES);
let rl_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
- let mut coderead = H263RLCodeReader::new(H263_RL_CODES_AIC);
- let aic_rl_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
let mut coderead = H263ShortCodeReader::new(H263_MV);
let mv_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
let tables = Tables {
inter_mcbpc_cb,
cbpy_cb,
rl_cb,
- aic_rl_cb,
mv_cb,
};
}
}
+impl NAOptionHandler for Intel263Decoder {
+ 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() -> Box<dyn NADecoder + Send> {
Box::new(Intel263Decoder::new())
use nihav_core::codecs::RegisteredDecoders;
use nihav_core::demuxers::RegisteredDemuxers;
use nihav_codec_support::test::dec_video::*;
- use crate::indeo_register_all_codecs;
+ use crate::indeo_register_all_decoders;
use nihav_commonfmt::generic_register_all_demuxers;
#[test]
fn test_intel263() {
let mut dmx_reg = RegisteredDemuxers::new();
generic_register_all_demuxers(&mut dmx_reg);
let mut dec_reg = RegisteredDecoders::new();
- indeo_register_all_codecs(&mut dec_reg);
+ indeo_register_all_decoders(&mut dec_reg);
+ // sample: https://samples.mplayerhq.hu/A-codecs/IMC/neal73_saber.avi
test_decoding("avi", "intel263", "assets/Indeo/neal73_saber.avi", Some(16),
&dmx_reg, &dec_reg, ExpectedTestResult::MD5Frames(vec![
[0x698c4f70, 0xf727bfc1, 0x96e687e9, 0xc9e37073],
projects / nihav.git / blobdiff