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 fn decode_b_info(br: &mut BitReader, is_pb: bool, is_intra: bool) -> DecoderResult<BBlockInfo> {
115 if is_pb { // as improved pb
116 let pb_mv_add = if is_intra { 1 } else { 0 };
119 let pb_mv_count = 1 - (br.read(1)? as usize);
120 let cbpb = br.read(6)? as u8;
121 Ok(BBlockInfo::new(true, cbpb, pb_mv_count + pb_mv_add, pb_mv_count == 1))
123 Ok(BBlockInfo::new(true, 0, 1 + pb_mv_add, true))
126 Ok(BBlockInfo::new(true, 0, pb_mv_add, false))
129 Ok(BBlockInfo::new(false, 0, 0, false))
133 impl<'a> BlockDecoder for Intel263BR<'a> {
135 #[allow(unused_variables)]
136 fn decode_pichdr(&mut self) -> DecoderResult<PicInfo> {
137 let mut br = &mut self.br;
138 let syncw = br.read(22)?;
139 validate!(syncw == 0x000020);
140 let tr = br.read(8)? as u8;
142 let id = br.read(1)?;
144 br.read(1)?; // split screen indicator
145 br.read(1)?; // document camera indicator
146 br.read(1)?; // freeze picture release
147 let mut sfmt = br.read(3)?;
148 validate!((sfmt != 0b000) && (sfmt != 0b110));
149 let is_intra = !br.read_bool()?;
150 let umv = br.read_bool()?;
151 br.read(1)?; // syntax arithmetic coding
152 let apm = br.read_bool()?;
153 self.is_pb = br.read_bool()?;
157 validate!((sfmt != 0b000) && (sfmt != 0b111));
158 br.read(2)?; // unknown flags
159 deblock = br.read_bool()?;
160 br.read(1)?; // unknown flag
161 let pbplus = br.read_bool()?;
162 br.read(5)?; // unknown flags
163 let marker = br.read(5)?;
164 validate!(marker == 1);
170 let par = br.read(4)?;
171 w = ((br.read(9)? + 1) * 4) as usize;
173 h = ((br.read(9)? + 1) * 4) as usize;
175 let pixw = br.read(8)?;
176 let pixh = br.read(8)?;
177 validate!((pixw != 0) && (pixh != 0));
180 let (w_, h_) = H263_SIZES[sfmt as usize];
184 let quant = br.read(5)?;
185 let cpm = br.read_bool()?;
190 let trb = br.read(3)?;
191 let dbquant = br.read(2)?;
192 pbinfo = Some(PBInfo::new(trb as u8, dbquant as u8));
196 while br.read_bool()? { // skip PEI
199 //println!("frame {}x{} intra: {} q {} pb {} apm {} umv {} @{}", w, h, is_intra, quant, self.is_pb, apm, umv, br.tell());
201 self.mb_w = (w + 15) >> 4;
203 let ftype = if is_intra { Type::I } else { Type::P };
204 let picinfo = PicInfo::new(w, h, ftype, quant as u8, apm, umv, tr, pbinfo, deblock);
208 #[allow(unused_variables)]
209 fn decode_slice_header(&mut self, info: &PicInfo) -> DecoderResult<Slice> {
210 let mut br = &mut self.br;
211 let gbsc = br.read(17)?;
212 validate!(gbsc == 1);
213 let gn = br.read(5)?;
214 let gfid = br.read(2)?;
215 let gquant = br.read(5)?;
216 //println!("GOB gn {:X} id {} q {}", gn, gfid, gquant);
217 let ret = Slice::new(0, self.gob_no, gquant as u8);
222 fn decode_block_header(&mut self, info: &PicInfo, slice: &Slice) -> DecoderResult<BlockInfo> {
223 let mut br = &mut self.br;
224 let mut q = slice.get_quant();
225 match info.get_mode() {
227 let mut cbpc = br.read_cb(&self.tables.intra_mcbpc_cb)?;
228 while cbpc == 8 { cbpc = br.read_cb(&self.tables.intra_mcbpc_cb)?; }
229 let cbpy = br.read_cb(&self.tables.cbpy_cb)?;
230 let cbp = (cbpy << 2) | (cbpc & 3);
231 let dquant = (cbpc & 4) != 0;
233 let idx = br.read(2)? as usize;
234 q = ((q as i16) + (H263_DQUANT_TAB[idx] as i16)) as u8;
236 Ok(BlockInfo::new(Type::I, cbp, q))
239 if br.read_bool()? { return Ok(BlockInfo::new(Type::Skip, 0, info.get_quant())); }
240 let mut cbpc = br.read_cb(&self.tables.inter_mcbpc_cb)?;
241 while cbpc == 20 { cbpc = br.read_cb(&self.tables.inter_mcbpc_cb)?; }
242 let is_intra = (cbpc & 0x04) != 0;
243 let dquant = (cbpc & 0x08) != 0;
244 let is_4x4 = (cbpc & 0x10) != 0;
246 let mut mvec: Vec<MV> = Vec::new();
247 let bbinfo = decode_b_info(br, self.is_pb, true)?;
248 let cbpy = br.read_cb(&self.tables.cbpy_cb)?;
249 let cbp = (cbpy << 2) | (cbpc & 3);
251 let idx = br.read(2)? as usize;
252 q = ((q as i16) + (H263_DQUANT_TAB[idx] as i16)) as u8;
254 let mut binfo = BlockInfo::new(Type::I, cbp, q);
255 binfo.set_bpart(bbinfo);
257 for _ in 0..bbinfo.get_num_mv() {
258 mvec.push(decode_mv(br, &self.tables.mv_cb)?);
260 binfo.set_b_mv(mvec.as_slice());
265 let bbinfo = decode_b_info(br, self.is_pb, false)?;
266 let mut cbpy = br.read_cb(&self.tables.cbpy_cb)?;
267 // if /* !aiv && */(cbpc & 3) != 3 {
270 let cbp = (cbpy << 2) | (cbpc & 3);
272 let idx = br.read(2)? as usize;
273 q = ((q as i16) + (H263_DQUANT_TAB[idx] as i16)) as u8;
275 let mut binfo = BlockInfo::new(Type::P, cbp, q);
276 binfo.set_bpart(bbinfo);
278 let mvec: [MV; 1] = [decode_mv(br, &self.tables.mv_cb)?];
281 let mvec: [MV; 4] = [
282 decode_mv(br, &self.tables.mv_cb)?,
283 decode_mv(br, &self.tables.mv_cb)?,
284 decode_mv(br, &self.tables.mv_cb)?,
285 decode_mv(br, &self.tables.mv_cb)?
290 let mut mvec: Vec<MV> = Vec::with_capacity(bbinfo.get_num_mv());
291 for _ in 0..bbinfo.get_num_mv() {
292 let mv = decode_mv(br, &self.tables.mv_cb)?;
295 binfo.set_b_mv(mvec.as_slice());
299 _ => { Err(DecoderError::InvalidData) },
303 #[allow(unused_variables)]
304 fn decode_block_intra(&mut self, info: &BlockInfo, quant: u8, no: usize, coded: bool, blk: &mut [i16; 64]) -> DecoderResult<()> {
305 self.decode_block(quant, true, coded, blk)
308 #[allow(unused_variables)]
309 fn decode_block_inter(&mut self, info: &BlockInfo, quant: u8, no: usize, coded: bool, blk: &mut [i16; 64]) -> DecoderResult<()> {
310 self.decode_block(quant, false, coded, blk)
313 fn is_slice_end(&mut self) -> bool { self.br.peek(16) == 0 }
315 fn filter_row(&mut self, buf: &mut NAVideoBuffer<u8>, mb_y: usize, mb_w: usize, cbpi: &CBPInfo) {
316 let stride = buf.get_stride(0);
317 let mut off = buf.get_offset(0) + mb_y * 16 * stride;
318 for mb_x in 0..mb_w {
320 let coded0 = cbpi.is_coded(mb_x, 0);
321 let coded1 = cbpi.is_coded(mb_x, 1);
322 let q = cbpi.get_q(mb_w + mb_x);
324 if coded0 && cbpi.is_coded_top(mb_x, 0) { deblock_hor(buf, 0, q, coff); }
325 if coded1 && cbpi.is_coded_top(mb_x, 1) { deblock_hor(buf, 0, q, coff + 8); }
327 let coff = off + 8 * stride;
328 if cbpi.is_coded(mb_x, 2) && coded0 { deblock_hor(buf, 0, q, coff); }
329 if cbpi.is_coded(mb_x, 3) && coded1 { deblock_hor(buf, 0, q, coff + 8); }
332 let mut leftt = false;
333 let mut leftc = false;
334 let mut off = buf.get_offset(0) + mb_y * 16 * stride;
335 for mb_x in 0..mb_w {
336 let ctop0 = cbpi.is_coded_top(mb_x, 0);
337 let ctop1 = cbpi.is_coded_top(mb_x, 0);
338 let ccur0 = cbpi.is_coded(mb_x, 0);
339 let ccur1 = cbpi.is_coded(mb_x, 1);
340 let q = cbpi.get_q(mb_w + mb_x);
342 let coff = off - 8 * stride;
343 let qtop = cbpi.get_q(mb_x);
344 if leftt && ctop0 { deblock_ver(buf, 0, qtop, coff); }
345 if ctop0 && ctop1 { deblock_ver(buf, 0, qtop, coff + 8); }
347 if leftc && ccur0 { deblock_ver(buf, 0, q, off); }
348 if ccur0 && ccur1 { deblock_ver(buf, 0, q, off + 8); }
353 let strideu = buf.get_stride(1);
354 let stridev = buf.get_stride(2);
355 let offu = buf.get_offset(1) + mb_y * 8 * strideu;
356 let offv = buf.get_offset(2) + mb_y * 8 * stridev;
358 for mb_x in 0..mb_w {
359 let ctu = cbpi.is_coded_top(mb_x, 4);
360 let ccu = cbpi.is_coded(mb_x, 4);
361 let ctv = cbpi.is_coded_top(mb_x, 5);
362 let ccv = cbpi.is_coded(mb_x, 5);
363 let q = cbpi.get_q(mb_w + mb_x);
364 if ctu && ccu { deblock_hor(buf, 1, q, offu + mb_x * 8); }
365 if ctv && ccv { deblock_hor(buf, 2, q, offv + mb_x * 8); }
367 let mut leftu = false;
368 let mut leftv = false;
369 let offu = buf.get_offset(1) + (mb_y - 1) * 8 * strideu;
370 let offv = buf.get_offset(2) + (mb_y - 1) * 8 * stridev;
371 for mb_x in 0..mb_w {
372 let ctu = cbpi.is_coded_top(mb_x, 4);
373 let ctv = cbpi.is_coded_top(mb_x, 5);
374 let qt = cbpi.get_q(mb_x);
375 if leftu && ctu { deblock_ver(buf, 1, qt, offu + mb_x * 8); }
376 if leftv && ctv { deblock_ver(buf, 2, qt, offv + mb_x * 8); }
384 fn deblock_hor(buf: &mut NAVideoBuffer<u8>, comp: usize, q: u8, off: usize) {
385 let stride = buf.get_stride(comp);
386 let mut dptr = buf.get_data_mut();
387 let mut buf = dptr.as_mut_slice();
389 let a = buf[off - 2 * stride + x] as i16;
390 let b = buf[off - 1 * stride + x] as i16;
391 let c = buf[off + 0 * stride + x] as i16;
392 let d = buf[off + 1 * stride + x] as i16;
393 let diff = ((a - d) * 3 + (c - b) * 8) >> 4;
394 if (diff != 0) && (diff >= -32) && (diff < 32) {
395 let d0 = diff.abs() * 2 - (q as i16);
396 let d1 = if d0 < 0 { 0 } else { d0 };
397 let d2 = diff.abs() - d1;
398 let d3 = if d2 < 0 { 0 } else { d2 };
400 let delta = if diff < 0 { -d3 } else { d3 };
403 if b1 < 0 { buf[off - 1 * stride + x] = 0; }
404 else if b1 > 255 { buf[off - 1 * stride + x] = 0xFF; }
405 else { buf[off - 1 * stride + x] = b1 as u8; }
407 if c1 < 0 { buf[off + x] = 0; }
408 else if c1 > 255 { buf[off + x] = 0xFF; }
409 else { buf[off + x] = c1 as u8; }
414 fn deblock_ver(buf: &mut NAVideoBuffer<u8>, comp: usize, q: u8, off: usize) {
415 let stride = buf.get_stride(comp);
416 let mut dptr = buf.get_data_mut();
417 let mut buf = dptr.as_mut_slice();
419 let a = buf[off - 2 + y * stride] as i16;
420 let b = buf[off - 1 + y * stride] as i16;
421 let c = buf[off + 0 + y * stride] as i16;
422 let d = buf[off + 1 + y * stride] as i16;
423 let diff = ((a - d) * 3 + (c - b) * 8) >> 4;
424 if (diff != 0) && (diff >= -32) && (diff < 32) {
425 let d0 = diff.abs() * 2 - (q as i16);
426 let d1 = if d0 < 0 { 0 } else { d0 };
427 let d2 = diff.abs() - d1;
428 let d3 = if d2 < 0 { 0 } else { d2 };
430 let delta = if diff < 0 { -d3 } else { d3 };
433 if b1 < 0 { buf[off - 1 + y * stride] = 0; }
434 else if b1 > 255 { buf[off - 1 + y * stride] = 0xFF; }
435 else { buf[off - 1 + y * stride] = b1 as u8; }
437 if c1 < 0 { buf[off + y * stride] = 0; }
438 else if c1 > 255 { buf[off + y * stride] = 0xFF; }
439 else { buf[off + y * stride] = c1 as u8; }
444 impl Intel263Decoder {
446 let mut coderead = H263ShortCodeReader::new(H263_INTRA_MCBPC);
447 let intra_mcbpc_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
448 let mut coderead = H263ShortCodeReader::new(H263_INTER_MCBPC);
449 let inter_mcbpc_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
450 let mut coderead = H263ShortCodeReader::new(H263_CBPY);
451 let cbpy_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
452 let mut coderead = H263RLCodeReader::new(H263_RL_CODES);
453 let rl_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
454 let mut coderead = H263RLCodeReader::new(H263_RL_CODES_AIC);
455 let aic_rl_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
456 let mut coderead = H263ShortCodeReader::new(H263_MV);
457 let mv_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
458 let tables = Tables {
459 intra_mcbpc_cb: intra_mcbpc_cb,
460 inter_mcbpc_cb: inter_mcbpc_cb,
463 aic_rl_cb: aic_rl_cb,
468 info: Rc::new(DUMMY_CODEC_INFO),
469 dec: DCT8x8VideoDecoder::new(),
475 impl NADecoder for Intel263Decoder {
476 fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
477 if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
478 let w = vinfo.get_width();
479 let h = vinfo.get_height();
480 let fmt = formats::YUV420_FORMAT;
481 let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
482 self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
485 Err(DecoderError::InvalidData)
488 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
489 let src = pkt.get_buffer();
492 let bret = self.dec.get_bframe();
495 if let Ok(btype) = bret {
499 buftype = NABufferType::None;
502 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), buftype);
503 frm.set_keyframe(false);
504 frm.set_frame_type(if is_skip { FrameType::Skip } else { FrameType::B });
505 return Ok(Rc::new(RefCell::new(frm)));
507 let mut ibr = Intel263BR::new(&src, &self.tables);
509 let bufinfo = self.dec.parse_frame(&mut ibr)?;
511 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
512 frm.set_keyframe(self.dec.is_intra());
513 frm.set_frame_type(if self.dec.is_intra() { FrameType::I } else { FrameType::P });
514 Ok(Rc::new(RefCell::new(frm)))
519 pub fn get_decoder() -> Box<NADecoder> {
520 Box::new(Intel263Decoder::new())
531 let avi_dmx = find_demuxer("avi").unwrap();
532 let mut file = File::open("assets/neal73_saber.avi").unwrap();
533 let mut fr = FileReader::new_read(&mut file);
534 let mut br = ByteReader::new(&mut fr);
535 let mut dmx = avi_dmx.new_demuxer(&mut br);
538 let mut decs: Vec<Option<Box<NADecoder>>> = Vec::new();
539 for i in 0..dmx.get_num_streams() {
540 let s = dmx.get_stream(i).unwrap();
541 let info = s.get_info();
542 let decfunc = find_decoder(info.get_name());
543 if let Some(df) = decfunc {
544 let mut dec = (df)();
545 dec.init(info).unwrap();
546 decs.push(Some(dec));
553 let pktres = dmx.get_frame();
554 if let Err(e) = pktres {
555 if e == DemuxerError::EOF { break; }
558 let pkt = pktres.unwrap();
559 //if pkt.get_pts().unwrap() > 263 { break; }
560 let streamno = pkt.get_stream().get_id() as usize;
561 if let Some(ref mut dec) = decs[streamno] {
562 let frm = dec.decode(&pkt).unwrap();
563 if pkt.get_stream().get_info().is_video() {
564 write_pgmyuv("ih263_", streamno, pkt.get_pts().unwrap(), frm);