nihav-realmedia/src/codecs/rv20.rs

   1 use nihav_core::io::bitreader::*;
   2 use nihav_core::io::codebook::*;
   3 use nihav_core::formats;
   4 use nihav_core::frame::*;
   5 use nihav_core::codecs::*;
   6 use nihav_codec_support::codecs::{MV, ZIGZAG};
   7 use nihav_codec_support::codecs::h263::*;
   8 use nihav_codec_support::codecs::h263::code::H263BlockDSP;
   9 use nihav_codec_support::codecs::h263::decoder::*;
  10 use nihav_codec_support::codecs::h263::data::*;
  11
  12
  13 #[allow(dead_code)]
  14 struct Tables {
  15     intra_mcbpc_cb: Codebook<u8>,
  16     inter_mcbpc_cb: Codebook<u8>,
  17     mbtype_b_cb:    Codebook<u8>,
  18     cbpy_cb:        Codebook<u8>,
  19     cbpc_b_cb:      Codebook<u8>,
  20     rl_cb:          Codebook<H263RLSym>,
  21     aic_rl_cb:      Codebook<H263RLSym>,
  22     mv_cb:          Codebook<u8>,
  23 }
  24
  25 #[derive(Clone,Copy)]
  26 struct RPRInfo {
  27     present:    bool,
  28     bits:       u8,
  29     widths:     [usize; 8],
  30     heights:    [usize; 8],
  31 }
  32
  33 struct RealVideo20Decoder {
  34     info:       NACodecInfoRef,
  35     dec:        H263BaseDecoder,
  36     tables:     Tables,
  37     w:          usize,
  38     h:          usize,
  39     minor_ver:  u8,
  40     rpr:        RPRInfo,
  41     bdsp:       H263BlockDSP,
  42     base_ts:    u64,
  43     last_ts:    u16,
  44     next_ts:    u16,
  45 }
  46
  47 struct RealVideo20BR<'a> {
  48     br:         BitReader<'a>,
  49     tables:     &'a Tables,
  50     num_slices: usize,
  51     slice_no:   usize,
  52     slice_off:  Vec<u32>,
  53     w:          usize,
  54     h:          usize,
  55     mb_w:       usize,
  56     mb_h:       usize,
  57     mb_pos_bits: u8,
  58     minor_ver:  u8,
  59     rpr:        RPRInfo,
  60     pts:        u16,
  61 }
  62
  63 struct RV20SliceInfo {
  64     ftype:  Type,
  65     seq:    u32,
  66     qscale: u8,
  67     mb_x:   usize,
  68     mb_y:   usize,
  69     mb_pos: usize,
  70     w:      usize,
  71     h:      usize,
  72 }
  73
  74 impl RV20SliceInfo {
  75     fn new(ftype: Type, seq: u32, qscale: u8, mb_x: usize, mb_y: usize, mb_pos: usize, w: usize, h: usize) -> Self {
  76         RV20SliceInfo { ftype, seq, qscale, mb_x, mb_y, mb_pos, w, h }
  77     }
  78 }
  79
  80 impl<'a> RealVideo20BR<'a> {
  81     fn new(src: &'a [u8], tables: &'a Tables, width: usize, height: usize, minor_ver: u8, rpr: RPRInfo) -> Self {
  82         let nslices = (src[0] as usize) + 1;
  83         let mut slice_offs = Vec::with_capacity(nslices);
  84         {
  85             let offs = &src[1..][..nslices * 8];
  86             let mut br = BitReader::new(offs, BitReaderMode::BE);
  87             for _ in 0..nslices {
  88                 br.skip(32).unwrap();
  89                 let off = br.read(32).unwrap();
  90                 slice_offs.push(off);
  91             }
  92         }
  93         let soff = nslices * 8 + 1;
  94         let mb_w = (width  + 15) >> 4;
  95         let mb_h = (height + 15) >> 4;
  96         let max_pos = mb_w * mb_h - 1;
  97         let mut mbpb = 0;
  98         for i in 0..H263_MBB.len() {
  99             if max_pos <= H263_MBB[i].blocks {
 100                 mbpb = H263_MBB[i].bits;
 101                 break;
 102             }
 103         }
 104         RealVideo20BR {
 105             br:         BitReader::new(&src[soff..], BitReaderMode::BE),
 106             tables,
 107             num_slices: nslices,
 108             slice_no:   0,
 109             slice_off:  slice_offs,
 110             w:          width,
 111             h:          height,
 112             mb_w,
 113             mb_h,
 114             mb_pos_bits: mbpb,
 115             minor_ver,
 116             rpr,
 117             pts:        0,
 118         }
 119     }
 120
 121 #[allow(unused_variables)]
 122     fn decode_block(&mut self, sstate: &SliceState, quant: u8, intra: bool, coded: bool, blk: &mut [i16; 64], plane_no: usize, acpred: ACPredMode) -> DecoderResult<()> {
 123         let br = &mut self.br;
 124         let mut idx = 0;
 125         if !sstate.is_iframe && intra {
 126             let mut dc = br.read(8)? as i16;
 127             if dc == 255 { dc = 128; }
 128             blk[0] = dc << 3;
 129             idx = 1;
 130         }
 131         if !coded { return Ok(()); }
 132         let scan = match acpred {
 133                     ACPredMode::Hor => H263_SCAN_V,
 134                     ACPredMode::Ver => H263_SCAN_H,
 135                     _               => &ZIGZAG,
 136                 };
 137
 138         let rl_cb = if sstate.is_iframe { &self.tables.aic_rl_cb } else { &self.tables.rl_cb };
 139         let q_add = if quant == 0 || sstate.is_iframe { 0i16 } else { ((quant - 1) | 1) as i16 };
 140         let q = if plane_no == 0 { (quant * 2) as i16 } else { H263_CHROMA_QUANT[quant as usize] as i16 };
 141         while idx < 64 {
 142             let code = br.read_cb(rl_cb)?;
 143             let run;
 144             let mut level;
 145             let last;
 146             if !code.is_escape() {
 147                 run   = code.get_run();
 148                 level = code.get_level();
 149                 last  = code.is_last();
 150                 if br.read_bool()? { level = -level; }
 151                 level = (level * q) + q_add;
 152             } else {
 153                 last  = br.read_bool()?;
 154                 run   = br.read(6)? as u8;
 155                 level = br.read_s(8)? as i16;
 156                 if level == -128 {
 157                     let low = br.read(5)? as i16;
 158                     let top = br.read_s(6)? as i16;
 159                     level = (top << 5) | low;
 160                 }
 161                 level = (level * q) + q_add;
 162                 if level < -2048 { level = -2048; }
 163                 if level >  2047 { level =  2047; }
 164             }
 165             idx += run;
 166             validate!(idx < 64);
 167             let oidx = scan[idx as usize];
 168             blk[oidx] = level;
 169             idx += 1;
 170             if last { break; }
 171         }
 172         Ok(())
 173     }
 174 }
 175
 176 fn decode_mv_component(br: &mut BitReader, mv_cb: &Codebook<u8>) -> DecoderResult<i16> {
 177     let code = br.read_cb(mv_cb)? as i16;
 178     if code == 0 { return Ok(0) }
 179     if !br.read_bool()? {
 180         Ok(code)
 181     } else {
 182         Ok(-code)
 183     }
 184 }
 185
 186 fn decode_mv(br: &mut BitReader, mv_cb: &Codebook<u8>) -> DecoderResult<MV> {
 187     let xval = decode_mv_component(br, mv_cb)?;
 188     let yval = decode_mv_component(br, mv_cb)?;
 189     Ok(MV::new(xval, yval))
 190 }
 191
 192 fn read_dquant(br: &mut BitReader, q: u8) -> DecoderResult<u8> {
 193     if br.read_bool()? {
 194         Ok(H263_MODIFIED_QUANT[br.read(1)? as usize][q as usize])
 195     } else {
 196         Ok(br.read(5)? as u8)
 197     }
 198 }
 199
 200 impl<'a> BlockDecoder for RealVideo20BR<'a> {
 201
 202 #[allow(unused_variables)]
 203     fn decode_pichdr(&mut self) -> DecoderResult<PicInfo> {
 204         self.slice_no = 0;
 205         let shdr = self.read_slice_header()?;
 206 //        self.slice_no += 1;
 207         validate!((shdr.mb_x == 0) && (shdr.mb_y == 0));
 208 /*        let mb_count;
 209         if self.slice_no < self.num_slices {
 210             let pos = self.br.tell();
 211             let shdr2 = self.read_slice_header()?;
 212             self.br.seek(pos as u32)?;
 213             mb_count = shdr2.mb_pos - shdr.mb_pos;
 214         } else {
 215             mb_count = self.mb_w * self.mb_h;
 216         }*/
 217
 218         let plusinfo = Some(PlusInfo::new(shdr.ftype == Type::I, false, false, false));
 219         let picinfo = PicInfo::new(shdr.w, shdr.h, shdr.ftype, MVMode::Long, false, false, shdr.qscale, shdr.seq as u16, None, plusinfo);
 220         Ok(picinfo)
 221     }
 222
 223     #[allow(unused_variables)]
 224     fn decode_slice_header(&mut self, info: &PicInfo) -> DecoderResult<SliceInfo> {
 225         let shdr = self.read_slice_header()?;
 226         self.slice_no += 1;
 227         let mb_count;
 228         if self.slice_no < self.num_slices {
 229             let pos = self.br.tell();
 230             let shdr2 = self.read_slice_header()?;
 231             mb_count = shdr2.mb_pos - shdr.mb_pos;
 232             self.br.seek(pos as u32)?;
 233         } else {
 234             mb_count = self.mb_w * self.mb_h - shdr.mb_pos;
 235         }
 236         let ret = SliceInfo::new(shdr.mb_x, shdr.mb_y, shdr.mb_pos + mb_count, shdr.qscale);
 237
 238         Ok(ret)
 239     }
 240
 241     fn decode_block_header(&mut self, info: &PicInfo, _slice: &SliceInfo, sstate: &SliceState) -> DecoderResult<BlockInfo> {
 242         let br = &mut self.br;
 243         let mut q = sstate.quant;
 244         match info.get_mode() {
 245             Type::I => {
 246                     let mut cbpc = br.read_cb(&self.tables.intra_mcbpc_cb)?;
 247                     while cbpc == 8 { cbpc = br.read_cb(&self.tables.intra_mcbpc_cb)?; }
 248                     let mut acpred = ACPredMode::None;
 249                     if let Some(ref pi) = info.plusinfo {
 250                         if pi.aic {
 251                             let acpp = br.read_bool()?;
 252                             acpred = ACPredMode::DC;
 253                             if acpp {
 254                                 acpred = if br.read_bool()? { ACPredMode::Hor } else { ACPredMode::Ver };
 255                             }
 256                         }
 257                     }
 258                     let cbpy = br.read_cb(&self.tables.cbpy_cb)?;
 259                     let cbp = (cbpy << 2) | (cbpc & 3);
 260                     let dquant = (cbpc & 4) != 0;
 261                     if dquant {
 262                         q = read_dquant(br, q)?;
 263                     }
 264                     let mut binfo = BlockInfo::new(Type::I, cbp, q);
 265                     binfo.set_acpred(acpred);
 266                     Ok(binfo)
 267                 },
 268             Type::P => {
 269                     if br.read_bool()? {
 270                         return Ok(BlockInfo::new(Type::Skip, 0, info.get_quant()));
 271                     }
 272                     let mut cbpc = br.read_cb(&self.tables.inter_mcbpc_cb)?;
 273                     while cbpc == 20 { cbpc = br.read_cb(&self.tables.inter_mcbpc_cb)?; }
 274                     let is_intra = (cbpc & 0x04) != 0;
 275                     let dquant   = (cbpc & 0x08) != 0;
 276                     let is_4x4   = (cbpc & 0x10) != 0;
 277                     if is_intra {
 278                         let cbpy = br.read_cb(&self.tables.cbpy_cb)?;
 279                         let cbp = (cbpy << 2) | (cbpc & 3);
 280                         if dquant {
 281                             q = read_dquant(br, q)?;
 282                         }
 283                         let binfo = BlockInfo::new(Type::I, cbp, q);
 284                         return Ok(binfo);
 285                     }
 286
 287                     let mut cbpy = br.read_cb(&self.tables.cbpy_cb)?;
 288 //                    if /* !aiv && */(cbpc & 3) != 3 {
 289                         cbpy ^= 0xF;
 290 //                    }
 291                     let cbp = (cbpy << 2) | (cbpc & 3);
 292                     if dquant {
 293                         q = read_dquant(br, q)?;
 294                     }
 295                     let mut binfo = BlockInfo::new(Type::P, cbp, q);
 296                     if !is_4x4 {
 297                         let mvec: [MV; 1] = [decode_mv(br, &self.tables.mv_cb)?];
 298                         binfo.set_mv(&mvec);
 299                     } else {
 300                         let mvec: [MV; 4] = [
 301                                 decode_mv(br, &self.tables.mv_cb)?,
 302                                 decode_mv(br, &self.tables.mv_cb)?,
 303                                 decode_mv(br, &self.tables.mv_cb)?,
 304                                 decode_mv(br, &self.tables.mv_cb)?
 305                             ];
 306                         binfo.set_mv(&mvec);
 307                     }
 308                     Ok(binfo)
 309                 },
 310             Type::B => { // B
 311                     let mut mbtype = br.read_cb(&self.tables.mbtype_b_cb)? as usize;
 312                     while mbtype == 14 { mbtype = br.read_cb(&self.tables.mbtype_b_cb)? as usize; }
 313
 314                     let is_coded  = (H263_MBTYPE_B_CAPS[mbtype] & H263_MBB_CAP_CODED) != 0;
 315                     let is_intra  = (H263_MBTYPE_B_CAPS[mbtype] & H263_MBB_CAP_INTRA) != 0;
 316                     let dquant    = (H263_MBTYPE_B_CAPS[mbtype] & H263_MBB_CAP_DQUANT) != 0;
 317                     let is_fwd    = (H263_MBTYPE_B_CAPS[mbtype] & H263_MBB_CAP_FORWARD) != 0;
 318                     let is_bwd    = (H263_MBTYPE_B_CAPS[mbtype] & H263_MBB_CAP_BACKWARD) != 0;
 319
 320                     let cbp = if is_coded {
 321                             let cbpc = br.read_cb(&self.tables.cbpc_b_cb)?;
 322                             let mut cbpy = br.read_cb(&self.tables.cbpy_cb)?;
 323                             if !is_intra { cbpy ^= 0xF; }
 324                             (cbpy << 2) | (cbpc & 3)
 325                         } else { 0 };
 326
 327                     if dquant {
 328                         q = read_dquant(br, q)?;
 329                     }
 330
 331                     if is_intra {
 332                         let binfo = BlockInfo::new(Type::I, cbp, q);
 333                         return Ok(binfo);
 334                     }
 335
 336                     let mut binfo = BlockInfo::new(Type::B, cbp, q);
 337                     if is_fwd {
 338                         let mvec: [MV; 1] = [decode_mv(br, &self.tables.mv_cb)?];
 339                         binfo.set_mv(&mvec);
 340                     }
 341                     if is_bwd {
 342                         let mvec: [MV; 1] = [decode_mv(br, &self.tables.mv_cb)?];
 343                         binfo.set_b_mv(&mvec);
 344                     }
 345                     Ok(binfo)
 346                 },
 347             _ => { unreachable!(); },
 348         }
 349     }
 350
 351     fn decode_block_intra(&mut self, info: &BlockInfo, sstate: &SliceState, quant: u8, no: usize, coded: bool, blk: &mut [i16; 64]) -> DecoderResult<()> {
 352         self.decode_block(sstate, quant, true, coded, blk, if no < 4 { 0 } else { no - 3 }, info.get_acpred())
 353     }
 354
 355     #[allow(unused_variables)]
 356     fn decode_block_inter(&mut self, info: &BlockInfo, sstate: &SliceState, quant: u8, no: usize, coded: bool, blk: &mut [i16; 64]) -> DecoderResult<()> {
 357         self.decode_block(sstate, quant, false, coded, blk, if no < 4 { 0 } else { no - 3 }, ACPredMode::None)
 358     }
 359
 360     fn is_slice_end(&mut self) -> bool { false }
 361 }
 362
 363 impl<'a> RealVideo20BR<'a> {
 364 #[allow(unused_variables)]
 365     fn read_slice_header(&mut self) -> DecoderResult<RV20SliceInfo> {
 366         validate!(self.slice_no < self.num_slices);
 367
 368         let br = &mut self.br;
 369         br.seek(self.slice_off[self.slice_no] * 8)?;
 370
 371         let frm_type    = br.read(2)?;
 372         let ftype = match frm_type {
 373                 0 | 1 => { Type::I },
 374                 2     => { Type::P },
 375                 _     => { Type::B },
 376             };
 377
 378         let marker      = br.read(1)?;
 379         validate!(marker == 0);
 380         let qscale      = br.read(5)? as u8;
 381         validate!(qscale > 0);
 382         if self.minor_ver >= 2 {
 383             br.skip(1)?; // loop filter
 384         }
 385         let seq = if self.minor_ver <= 1 {
 386                 br.read(8)?  << 8
 387             } else {
 388                 br.read(13)? << 3
 389             };
 390         self.pts = seq as u16;
 391         let w;
 392         let h;
 393         if self.rpr.present {
 394             let rpr = br.read(self.rpr.bits)? as usize;
 395             if rpr == 0 {
 396                 w = self.w;
 397                 h = self.h;
 398             } else {
 399                 w = self.rpr.widths[rpr - 1];
 400                 h = self.rpr.heights[rpr - 1];
 401                 validate!((w != 0) && (h != 0));
 402             }
 403         } else {
 404             w = self.w;
 405             h = self.h;
 406         }
 407
 408         let mb_pos = br.read(self.mb_pos_bits)? as usize;
 409         let mb_x = mb_pos % self.mb_w;
 410         let mb_y = mb_pos / self.mb_w;
 411
 412         br.skip(1)?; // no rounding
 413
 414         if (self.minor_ver <= 1) && (frm_type == 3) {
 415             br.skip(5)?;
 416         }
 417
 418         Ok(RV20SliceInfo::new(ftype, seq, qscale, mb_x, mb_y, mb_pos, w, h))
 419     }
 420 }
 421
 422 impl RealVideo20Decoder {
 423     fn new() -> Self {
 424         let mut coderead = H263ShortCodeReader::new(H263_INTRA_MCBPC);
 425         let intra_mcbpc_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 426         let mut coderead = H263ShortCodeReader::new(H263_INTER_MCBPC);
 427         let inter_mcbpc_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 428         let mut coderead = H263ShortCodeReader::new(H263_MBTYPE_B);
 429         let mbtype_b_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 430         let mut coderead = H263ShortCodeReader::new(H263_CBPY);
 431         let cbpy_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 432         let mut coderead = H263ShortCodeReader::new(H263_CBPC_B);
 433         let cbpc_b_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 434         let mut coderead = H263RLCodeReader::new(H263_RL_CODES);
 435         let rl_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 436         let mut coderead = H263RLCodeReader::new(H263_RL_CODES_AIC);
 437         let aic_rl_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 438         let mut coderead = H263ShortCodeReader::new(H263_MV);
 439         let mv_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 440
 441         let tables = Tables {
 442             intra_mcbpc_cb,
 443             inter_mcbpc_cb,
 444             mbtype_b_cb,
 445             cbpy_cb,
 446             cbpc_b_cb,
 447             rl_cb,
 448             aic_rl_cb,
 449             mv_cb,
 450         };
 451
 452         RealVideo20Decoder{
 453             info:           NACodecInfoRef::default(),
 454             dec:            H263BaseDecoder::new_b_frames(false),
 455             tables,
 456             w:              0,
 457             h:              0,
 458             minor_ver:      0,
 459             rpr:            RPRInfo { present: false, bits: 0, widths: [0; 8], heights: [0; 8] },
 460             bdsp:           H263BlockDSP::new(),
 461             base_ts:        0,
 462             last_ts:        0,
 463             next_ts:        0,
 464         }
 465     }
 466 }
 467
 468 impl NADecoder for RealVideo20Decoder {
 469 #[allow(unused_variables)]
 470     fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
 471         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
 472             let w = vinfo.get_width();
 473             let h = vinfo.get_height();
 474             let fmt = formats::YUV420_FORMAT;
 475             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
 476             self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
 477             self.w = w;
 478             self.h = h;
 479
 480             let edata = info.get_extradata().unwrap();
 481             let src: &[u8] = &edata;
 482             let ver = ((src[4] as u32) << 12) | ((src[5] as u32) << 4) | ((src[6] as u32) >> 4);
 483             let maj_ver = ver >> 16;
 484             let min_ver = (ver >> 8) & 0xFF;
 485             let mic_ver = ver & 0xFF;
 486             validate!(maj_ver == 2);
 487             self.minor_ver = min_ver as u8;
 488             let rprb = src[1] & 7;
 489             if rprb == 0 {
 490                 self.rpr.present = false;
 491             } else {
 492                 self.rpr.present = true;
 493                 self.rpr.bits    = ((rprb >> 1) + 1) as u8;
 494                 for i in 4..(src.len()/2) {
 495                     self.rpr.widths [i - 4] = (src[i * 2]     as usize) * 4;
 496                     self.rpr.heights[i - 4] = (src[i * 2 + 1] as usize) * 4;
 497                 }
 498             }
 499             Ok(())
 500         } else {
 501             Err(DecoderError::InvalidData)
 502         }
 503     }
 504     fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
 505         let src = pkt.get_buffer();
 506
 507         let mut ibr = RealVideo20BR::new(&src, &self.tables, self.w, self.h, self.minor_ver, self.rpr);
 508
 509         let bufinfo = self.dec.parse_frame(&mut ibr, &self.bdsp)?;
 510
 511         let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
 512         let ftype = self.dec.get_frame_type();
 513         let pts = ibr.pts;
 514         if ftype != FrameType::B {
 515             self.last_ts = self.next_ts;
 516             self.next_ts = pts;
 517             if self.last_ts > self.next_ts {
 518                 self.base_ts += 1 << 16;
 519             }
 520         }
 521         let ts_diff = self.next_ts.wrapping_sub(pts);
 522         let ts = self.base_ts + (self.next_ts as u64) - (ts_diff as u64);
 523         frm.set_keyframe(self.dec.is_intra());
 524         frm.set_frame_type(ftype);
 525         frm.set_pts(Some(ts >> 3));
 526         Ok(frm.into_ref())
 527     }
 528     fn flush(&mut self) {
 529         self.dec.flush();
 530     }
 531 }
 532
 533 struct MBB { blocks: usize, bits: u8 }
 534 const H263_MBB: &[MBB; 7] = &[
 535     MBB{ blocks:    47, bits:  6 },
 536     MBB{ blocks:    98, bits:  7 },
 537     MBB{ blocks:   395, bits:  9 },
 538     MBB{ blocks:  1583, bits: 11 },
 539     MBB{ blocks:  6335, bits: 13 },
 540     MBB{ blocks:  9215, bits: 14 },
 541     MBB{ blocks: 65536, bits: 14 },
 542 ];
 543
 544 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
 545     Box::new(RealVideo20Decoder::new())
 546 }
 547
 548 #[cfg(test)]
 549 mod test {
 550     use nihav_core::codecs::RegisteredDecoders;
 551     use nihav_core::demuxers::RegisteredDemuxers;
 552     use nihav_codec_support::test::dec_video::*;
 553     use crate::realmedia_register_all_codecs;
 554     use crate::realmedia_register_all_demuxers;
 555     #[test]
 556     fn test_rv20() {
 557         let mut dmx_reg = RegisteredDemuxers::new();
 558         realmedia_register_all_demuxers(&mut dmx_reg);
 559         let mut dec_reg = RegisteredDecoders::new();
 560         realmedia_register_all_codecs(&mut dec_reg);
 561
 562         test_file_decoding("realmedia", "assets/RV/rv20_svt_atrc_640x352_realproducer_plus_8.51.rm", /*None*/Some(3000), true, false, None/*Some("rv20")*/, &dmx_reg, &dec_reg);
 563 //        test_file_decoding("realmedia", "assets/RV/rv20_cook_640x352_realproducer_plus_8.51.rm", /*None*/Some(1000), true, false, Some("rv20"));
 564     }
 565 }