5 use super::blockdec::*;
6 use super::h263data::*;
10 intra_mcbpc_cb: Codebook<u8>,
11 inter_mcbpc_cb: Codebook<u8>,
12 cbpy_cb: Codebook<u8>,
13 rl_cb: Codebook<H263RLSym>,
14 aic_rl_cb: Codebook<H263RLSym>,
18 struct Intel263Decoder {
19 info: Rc<NACodecInfo>,
20 dec: DCT8x8VideoDecoder,
24 struct Intel263BR<'a> {
32 fn check_marker<'a>(br: &mut BitReader<'a>) -> DecoderResult<()> {
33 let mark = br.read(1)?;
38 impl<'a> Intel263BR<'a> {
39 fn new(src: &'a [u8], tables: &'a Tables) -> Self {
41 br: BitReader::new(src, src.len(), BitReaderMode::BE),
49 fn decode_block(&mut self, quant: u8, intra: bool, coded: bool, blk: &mut [i16; 64]) -> DecoderResult<()> {
50 let mut br = &mut self.br;
53 let mut dc = br.read(8)?;
54 if dc == 255 { dc = 128; }
55 blk[0] = (dc as i16) << 3;
58 if !coded { return Ok(()); }
60 let rl_cb = &self.tables.rl_cb; // could be aic too
61 let q_add = if quant == 0 { 0i16 } else { ((quant - 1) | 1) as i16 };
62 let q = (quant * 2) as i16;
64 let code = br.read_cb(rl_cb)?;
68 if !code.is_escape() {
70 level = code.get_level();
71 last = code.is_last();
72 if br.read_bool()? { level = -level; }
73 level = (level * q) + q_add;
75 last = br.read_bool()?;
76 run = br.read(6)? as u8;
77 level = br.read_s(8)? as i16;
79 let low = br.read(5)? as i16;
80 let top = br.read_s(6)? as i16;
81 level = (top << 5) | low;
83 level = (level * q) + q_add;
84 if level < -2048 { level = -2048; }
85 if level > 2047 { level = 2047; }
89 let oidx = H263_ZIGZAG[idx as usize];
98 fn decode_mv_component(br: &mut BitReader, mv_cb: &Codebook<u8>) -> DecoderResult<i16> {
99 let code = br.read_cb(mv_cb)? as i16;
100 if code == 0 { return Ok(0) }
101 if !br.read_bool()? {
108 fn decode_mv(br: &mut BitReader, mv_cb: &Codebook<u8>) -> DecoderResult<MV> {
109 let xval = decode_mv_component(br, mv_cb)?;
110 let yval = decode_mv_component(br, mv_cb)?;
111 Ok(MV::new(xval, yval))
114 impl<'a> BlockDecoder for Intel263BR<'a> {
116 #[allow(unused_variables)]
117 fn decode_pichdr(&mut self) -> DecoderResult<PicInfo> {
118 let mut br = &mut self.br;
119 let syncw = br.read(22)?;
120 validate!(syncw == 0x000020);
121 let tr = br.read(8)? as u8;
123 let id = br.read(1)?;
125 br.read(1)?; // split screen indicator
126 br.read(1)?; // document camera indicator
127 br.read(1)?; // freeze picture release
128 let mut sfmt = br.read(3)?;
129 validate!((sfmt != 0b000) && (sfmt != 0b110));
130 let is_intra = !br.read_bool()?;
131 let umv = br.read_bool()?;
132 br.read(1)?; // syntax arithmetic coding
133 let apm = br.read_bool()?;
134 self.is_pb = br.read_bool()?;
137 validate!((sfmt != 0b000) && (sfmt != 0b111));
138 br.read(2)?; // unknown flags
139 let deblock = br.read_bool()?;
140 br.read(1)?; // unknown flag
141 let pbplus = br.read_bool()?;
142 br.read(5)?; // unknown flags
143 let marker = br.read(5)?;
144 validate!(marker == 1);
148 let par = br.read(4)?;
149 w = ((br.read(9)? + 1) * 4) as usize;
151 h = ((br.read(9)? + 1) * 4) as usize;
153 let pixw = br.read(8)?;
154 let pixh = br.read(8)?;
155 validate!((pixw != 0) && (pixh != 0));
158 let (w_, h_) = H263_SIZES[sfmt as usize];
162 let quant = br.read(5)?;
163 let cpm = br.read_bool()?;
166 let trb = br.read(3)?;
167 let dbquant = br.read(2)?;
169 while br.read_bool()? { // skip PEI
172 println!("frame {}x{} intra: {} q {} pb {} apm {} umv {} @{}", w, h, is_intra, quant, self.is_pb, apm, umv, br.tell());
174 self.mb_w = (w + 15) >> 4;
176 let ftype = if is_intra { Type::I } else { Type::P };
177 let picinfo = PicInfo::new(w, h, ftype, quant as u8, apm, umv, self.is_pb, tr);
181 #[allow(unused_variables)]
182 fn decode_slice_header(&mut self, info: &PicInfo) -> DecoderResult<Slice> {
183 let mut br = &mut self.br;
184 let gbsc = br.read(17)?;
185 println!("GBSC = {}", gbsc);
186 validate!(gbsc == 1);
187 let gn = br.read(5)?;
188 let gfid = br.read(2)?;
189 let gquant = br.read(5)?;
190 println!("GOB gn {:X} id {} q {}", gn, gfid, gquant);
191 let ret = Slice::new(0, self.gob_no, gquant as u8);
196 fn decode_block_header(&mut self, info: &PicInfo, slice: &Slice) -> DecoderResult<BlockInfo> {
197 let mut br = &mut self.br;
198 let mut q = slice.get_quant();
199 match info.get_mode() {
201 let mut cbpc = br.read_cb(&self.tables.intra_mcbpc_cb)?;
202 while cbpc == 8 { cbpc = br.read_cb(&self.tables.intra_mcbpc_cb)?; }
203 let cbpy = br.read_cb(&self.tables.cbpy_cb)?;
204 let cbp = (cbpy << 2) | (cbpc & 3);
205 let dquant = (cbpc & 4) != 0;
207 let idx = br.read(2)? as usize;
208 q = ((q as i16) + (H263_DQUANT_TAB[idx] as i16)) as u8;
210 //println!("got cbp {:X}", cbp);
211 Ok(BlockInfo::new(Type::I, cbp, q))
214 //println!("@{}",br.tell());
215 if br.read_bool()? { return Ok(BlockInfo::new(Type::Skip, 0, info.get_quant())); }
216 let mut cbpc = br.read_cb(&self.tables.inter_mcbpc_cb)?;
217 while cbpc == 20 { cbpc = br.read_cb(&self.tables.inter_mcbpc_cb)?; }
218 let is_intra = (cbpc & 0x04) != 0;
219 let dquant = (cbpc & 0x08) != 0;
220 let is_4x4 = (cbpc & 0x10) != 0;
222 let mut mvec: Vec<MV> = Vec::new();
224 let pb_mv_count: usize;
225 if self.is_pb && br.read_bool()? {
226 let c = br.read_bool()?;
228 pb_mv_count = 2 - (br.read(1)? as usize);
229 cbpb = br.read(6)? as u8;
234 //println!(" mvc {} cbpb {:02X}", pb_mv_count, cbpb);
239 let cbpy = br.read_cb(&self.tables.cbpy_cb)?;
240 let cbp = (cbpy << 2) | (cbpc & 3);
242 let idx = br.read(2)? as usize;
243 q = ((q as i16) + (H263_DQUANT_TAB[idx] as i16)) as u8;
245 let mut binfo = BlockInfo::new(Type::I, cbp, q);
247 for _ in 0..pb_mv_count {
248 mvec.push(decode_mv(br, &self.tables.mv_cb)?);
250 binfo.set_mv2(cbpb, mvec.as_slice());
252 //println!("@{}",br.tell());
257 let pb_mv_count: usize;
258 if self.is_pb && br.read_bool()?{
259 let c = br.read_bool()?;
261 pb_mv_count = 1 - (br.read(1)? as usize);
262 cbpb = br.read(6)? as u8;
271 let mut cbpy = br.read_cb(&self.tables.cbpy_cb)?;
272 // if /* !aiv && */(cbpc & 3) != 3 {
275 let cbp = (cbpy << 2) | (cbpc & 3);
277 let idx = br.read(2)? as usize;
278 q = ((q as i16) + (H263_DQUANT_TAB[idx] as i16)) as u8;
280 let mut binfo = BlockInfo::new(Type::P, cbp, q);
282 let mvec: [MV; 1] = [decode_mv(br, &self.tables.mv_cb)?];
283 //println!("@{} CBPB = {:X} mv2 {}",br.tell(), cbpb, pb_mv_count);
286 let mvec: [MV; 4] = [
287 decode_mv(br, &self.tables.mv_cb)?,
288 decode_mv(br, &self.tables.mv_cb)?,
289 decode_mv(br, &self.tables.mv_cb)?,
290 decode_mv(br, &self.tables.mv_cb)?
295 let mut mvec: Vec<MV> = Vec::with_capacity(pb_mv_count);
296 for _ in 0..pb_mv_count {
297 let mv = decode_mv(br, &self.tables.mv_cb)?;
300 binfo.set_mv2(cbpb, mvec.as_slice());
302 //println!("@{}",br.tell());
305 _ => { Err(DecoderError::InvalidData) },
309 #[allow(unused_variables)]
310 fn decode_block_intra(&mut self, info: &BlockInfo, no: usize, coded: bool, blk: &mut [i16; 64]) -> DecoderResult<()> {
311 self.decode_block(info.get_q(), true, coded, blk)
314 #[allow(unused_variables)]
315 fn decode_block_inter(&mut self, info: &BlockInfo, no: usize, coded: bool, blk: &mut [i16; 64]) -> DecoderResult<()> {
316 self.decode_block(info.get_q(), false, coded, blk)
319 #[allow(unused_variables)]
320 fn calc_mv(&mut self, vec: MV) {}
322 fn is_slice_end(&mut self) -> bool { self.br.peek(16) == 0 }
325 impl Intel263Decoder {
327 let mut coderead = H263ShortCodeReader::new(H263_INTRA_MCBPC);
328 let intra_mcbpc_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
329 let mut coderead = H263ShortCodeReader::new(H263_INTER_MCBPC);
330 let inter_mcbpc_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
331 let mut coderead = H263ShortCodeReader::new(H263_CBPY);
332 let cbpy_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
333 let mut coderead = H263RLCodeReader::new(H263_RL_CODES);
334 let rl_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
335 let mut coderead = H263RLCodeReader::new(H263_RL_CODES_AIC);
336 let aic_rl_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
337 let mut coderead = H263ShortCodeReader::new(H263_MV);
338 let mv_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
339 let tables = Tables {
340 intra_mcbpc_cb: intra_mcbpc_cb,
341 inter_mcbpc_cb: inter_mcbpc_cb,
344 aic_rl_cb: aic_rl_cb,
349 info: Rc::new(DUMMY_CODEC_INFO),
350 dec: DCT8x8VideoDecoder::new(),
356 impl NADecoder for Intel263Decoder {
357 fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
358 if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
359 let w = vinfo.get_width();
360 let h = vinfo.get_height();
361 let fmt = formats::YUV420_FORMAT;
362 let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
363 self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
366 Err(DecoderError::InvalidData)
369 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
370 let src = pkt.get_buffer();
373 let bret = self.dec.get_stored_pframe();
376 if let Ok(btype) = bret {
380 buftype = NABufferType::None;
383 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), buftype);
384 frm.set_keyframe(false);
385 frm.set_frame_type(if is_skip { FrameType::Skip } else { FrameType::P });
386 return Ok(Rc::new(RefCell::new(frm)));
388 //println!("frame size {}", src.len());
389 let mut ibr = Intel263BR::new(&src, &self.tables);
391 let bufinfo = self.dec.parse_frame(&mut ibr)?;
393 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
394 frm.set_keyframe(self.dec.is_intra());
395 frm.set_frame_type(if self.dec.is_intra() { FrameType::I } else { FrameType::P });
396 Ok(Rc::new(RefCell::new(frm)))
401 pub fn get_decoder() -> Box<NADecoder> {
402 Box::new(Intel263Decoder::new())
413 let avi_dmx = find_demuxer("avi").unwrap();
414 let mut file = File::open("assets/neal73_saber.avi").unwrap();
415 let mut fr = FileReader::new_read(&mut file);
416 let mut br = ByteReader::new(&mut fr);
417 let mut dmx = avi_dmx.new_demuxer(&mut br);
420 let mut decs: Vec<Option<Box<NADecoder>>> = Vec::new();
421 for i in 0..dmx.get_num_streams() {
422 let s = dmx.get_stream(i).unwrap();
423 let info = s.get_info();
424 let decfunc = find_decoder(info.get_name());
425 if let Some(df) = decfunc {
426 let mut dec = (df)();
427 dec.init(info).unwrap();
428 decs.push(Some(dec));
435 let pktres = dmx.get_frame();
436 if let Err(e) = pktres {
437 if e == DemuxerError::EOF { break; }
440 let pkt = pktres.unwrap();
441 //if pkt.get_pts().unwrap() > 263 { break; }
442 let streamno = pkt.get_stream().get_id() as usize;
443 if let Some(ref mut dec) = decs[streamno] {
444 let frm = dec.decode(&pkt).unwrap();
445 if pkt.get_stream().get_info().is_video() {
446 write_pgmyuv("ih263_", streamno, pkt.get_pts().unwrap(), frm);