nihav-realmedia/src/codecs/rv10.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 struct Tables {
  13     intra_mcbpc_cb: Codebook<u8>,
  14     inter_mcbpc_cb: Codebook<u8>,
  15     cbpy_cb:        Codebook<u8>,
  16     rl_cb:          Codebook<H263RLSym>,
  17     mv_cb:          Codebook<u8>,
  18     luma_dc_cb:     Codebook<u8>,
  19     chroma_dc_cb:   Codebook<u8>,
  20 }
  21
  22 struct RealVideo10Decoder {
  23     info:    NACodecInfoRef,
  24     dec:     H263BaseDecoder,
  25     tables:  Tables,
  26     w:       usize,
  27     h:       usize,
  28     new_ver: bool,
  29     bdsp:    H263BlockDSP,
  30     mvmode:  MVMode,
  31 }
  32
  33 struct RealVideo10BR<'a> {
  34     br:         BitReader<'a>,
  35     tables:     &'a Tables,
  36     num_slices: usize,
  37     slice_no:   usize,
  38     slice_off:  Vec<u32>,
  39     w:          usize,
  40     h:          usize,
  41     mb_w:       usize,
  42     mb_h:       usize,
  43     new_ver:    bool,
  44     dc_coded:   [bool; 3],
  45     last_dc:    [i16; 3],
  46     mvmode:     MVMode,
  47 }
  48
  49 struct RV10SliceInfo {
  50     is_p:   bool,
  51     qscale: u8,
  52     mb_x:   usize,
  53     mb_y:   usize,
  54     mb_c:   usize,
  55 }
  56
  57 impl RV10SliceInfo {
  58     fn new(is_p: bool, qscale: u8, mb_x: usize, mb_y: usize, mb_c: usize) -> Self {
  59         RV10SliceInfo { is_p, qscale, mb_x, mb_y, mb_c }
  60     }
  61 }
  62
  63 impl<'a> RealVideo10BR<'a> {
  64     fn new(src: &'a [u8], tables: &'a Tables, width: usize, height: usize, new_ver: bool, mvmode: MVMode) -> Self {
  65         let nslices = (src[0] as usize) + 1;
  66         let mut slice_offs = Vec::with_capacity(nslices);
  67         {
  68             let offs = &src[1..][..nslices * 8];
  69             let mut br = BitReader::new(offs, BitReaderMode::BE);
  70             for _ in 0..nslices {
  71                 br.skip(32).unwrap();
  72                 let off = br.read(32).unwrap();
  73                 slice_offs.push(off);
  74             }
  75         }
  76         let soff = nslices * 8 + 1;
  77         RealVideo10BR {
  78             br:         BitReader::new(&src[soff..], BitReaderMode::BE),
  79             tables,
  80             num_slices: nslices,
  81             slice_no:   0,
  82             slice_off:  slice_offs,
  83             w:          width,
  84             h:          height,
  85             mb_w:       (width  + 15) >> 4,
  86             mb_h:       (height + 15) >> 4,
  87             new_ver,
  88             dc_coded:   [false; 3],
  89             last_dc:    [0; 3],
  90             mvmode,
  91         }
  92     }
  93
  94     #[allow(clippy::collapsible_else_if)]
  95     fn decode_block(&mut self, sstate: &SliceState, quant: u8, intra: bool, coded: bool, blk: &mut [i16; 64], plane_no: usize) -> DecoderResult<()> {
  96         let br = &mut self.br;
  97         let mut idx = 0;
  98         if intra {
  99             let mut dc;
 100             if !self.new_ver || !sstate.is_iframe {
 101                 dc = br.read(8)? as i16;
 102                 if dc == 255 { dc = 128; }
 103             } else {
 104                 if self.dc_coded[plane_no] {
 105                     let diff;
 106                     let bits = br.peek(14);
 107                     let ret = if plane_no == 0 {
 108                             br.read_cb(&self.tables.luma_dc_cb)
 109                         } else {
 110                             br.read_cb(&self.tables.chroma_dc_cb)
 111                         };
 112                     if ret.is_err() {
 113                         println!("Illegal {} code {:X}", if plane_no==0{"luma"}else{"chroma"},bits);
 114                     }
 115                     let val = ret.unwrap() as i16;
 116
 117                     if val != 0 {
 118                         diff = val - 128;
 119                     } else {
 120                         let code = br.read(2)?;
 121                         match code {
 122                             0x0 => { diff = ((br.read(7)? + 1) as i8) as i16; },
 123                             0x1 => { diff = (br.read(7)? as i16) - 128; },
 124                             0x2 => {
 125                                     if plane_no == 0 {
 126                                         if br.read_bool()? {
 127                                             diff = ((br.read(8)? + 1) as i8) as i16;
 128                                         } else {
 129                                             diff = (br.read(8)? as i8) as i16;
 130                                         }
 131                                     } else {
 132                                         br.skip(9)?;
 133                                         diff = 1;
 134                                     }
 135                                 },
 136                             _   => {
 137                                     if plane_no == 0 {
 138                                         br.skip(4)?;
 139                                         diff = 1;
 140                                     } else {
 141                                         return Err(DecoderError::InvalidData);
 142                                     }
 143                                 },
 144                         };
 145                     }
 146                     dc = (self.last_dc[plane_no] - diff) & 0xFF;
 147                     self.last_dc[plane_no] = dc;
 148                 } else {
 149                     self.dc_coded[plane_no] = true;
 150                     dc = self.last_dc[plane_no];
 151                 }
 152             }
 153             blk[0] = dc << 3;
 154             idx = 1;
 155         }
 156         if !coded { return Ok(()); }
 157
 158         let rl_cb = &self.tables.rl_cb; // could be aic too
 159         let q_add = if quant == 0 { 0i16 } else { ((quant - 1) | 1) as i16 };
 160         let q = (quant * 2) as i16;
 161         while idx < 64 {
 162             let code = br.read_cb(rl_cb)?;
 163             let run;
 164             let mut level;
 165             let last;
 166             if !code.is_escape() {
 167                 run   = code.get_run();
 168                 level = code.get_level();
 169                 last  = code.is_last();
 170                 if br.read_bool()? { level = -level; }
 171                 if level >= 0 {
 172                     level = (level * q) + q_add;
 173                 } else {
 174                     level = (level * q) - q_add;
 175                 }
 176             } else {
 177                 last  = br.read_bool()?;
 178                 run   = br.read(6)? as u8;
 179                 level = br.read_s(8)? as i16;
 180                 if level == -128 {
 181                     let low = br.read(5)? as i16;
 182                     let top = br.read_s(6)? as i16;
 183                     level = (top << 5) | low;
 184                 }
 185                 if level >= 0 {
 186                     level = (level * q) + q_add;
 187                 } else {
 188                     level = (level * q) - q_add;
 189                 }
 190                 if level < -2048 { level = -2048; }
 191                 if level >  2047 { level =  2047; }
 192             }
 193             idx += run;
 194             validate!(idx < 64);
 195             let oidx = ZIGZAG[idx as usize];
 196             blk[oidx] = level;
 197             idx += 1;
 198             if last { break; }
 199         }
 200         Ok(())
 201     }
 202 }
 203
 204 fn decode_mv_component(br: &mut BitReader, mv_cb: &Codebook<u8>) -> DecoderResult<i16> {
 205     let code = br.read_cb(mv_cb)? as i16;
 206     if code == 0 { return Ok(0) }
 207     if !br.read_bool()? {
 208         Ok(code)
 209     } else {
 210         Ok(-code)
 211     }
 212 }
 213
 214 fn decode_mv(br: &mut BitReader, mv_cb: &Codebook<u8>) -> DecoderResult<MV> {
 215     let xval = decode_mv_component(br, mv_cb)?;
 216     let yval = decode_mv_component(br, mv_cb)?;
 217     Ok(MV::new(xval, yval))
 218 }
 219
 220 impl<'a> BlockDecoder for RealVideo10BR<'a> {
 221
 222     fn decode_pichdr(&mut self) -> DecoderResult<PicInfo> {
 223         self.slice_no = 0;
 224         let shdr = self.read_slice_header()?;
 225         validate!((shdr.mb_x == 0) && (shdr.mb_y == 0));
 226
 227         let _mb_end = shdr.mb_x + shdr.mb_y * self.mb_w + shdr.mb_c;
 228
 229         let ftype = if !shdr.is_p { Type::I } else { Type::P };
 230         let picinfo = PicInfo::new(self.w, self.h, ftype, self.mvmode, false, false, shdr.qscale, 0, None, None);
 231         Ok(picinfo)
 232     }
 233
 234     fn decode_slice_header(&mut self, _info: &PicInfo) -> DecoderResult<SliceInfo> {
 235         let shdr = self.read_slice_header()?;
 236         self.slice_no += 1;
 237         let mb_end = shdr.mb_x + shdr.mb_y * self.mb_w + shdr.mb_c;
 238         let ret = SliceInfo::new(shdr.mb_x, shdr.mb_y, mb_end, shdr.qscale);
 239
 240         Ok(ret)
 241     }
 242
 243     fn decode_block_header(&mut self, info: &PicInfo, slice: &SliceInfo, _sstate: &SliceState) -> DecoderResult<BlockInfo> {
 244         let br = &mut self.br;
 245         let mut q = slice.get_quant();
 246         match info.get_mode() {
 247             Type::I => {
 248                     let mut cbpc = br.read_cb(&self.tables.intra_mcbpc_cb)?;
 249                     while cbpc == 8 { cbpc = br.read_cb(&self.tables.intra_mcbpc_cb)?; }
 250                     let cbpy = br.read_cb(&self.tables.cbpy_cb)?;
 251                     let cbp = (cbpy << 2) | (cbpc & 3);
 252                     let dquant = (cbpc & 4) != 0;
 253                     if dquant {
 254                         let idx = br.read(2)? as usize;
 255                         q = ((q as i16) + (H263_DQUANT_TAB[idx] as i16)) as u8;
 256                         validate!(q < 32);
 257                     }
 258                     Ok(BlockInfo::new(Type::I, cbp, q))
 259                 },
 260             Type::P => {
 261                     if br.read_bool()? {
 262                         return Ok(BlockInfo::new(Type::Skip, 0, info.get_quant()));
 263                     }
 264                     let mut cbpc = br.read_cb(&self.tables.inter_mcbpc_cb)?;
 265                     while cbpc == 20 { cbpc = br.read_cb(&self.tables.inter_mcbpc_cb)?; }
 266                     let is_intra = (cbpc & 0x04) != 0;
 267                     let dquant   = (cbpc & 0x08) != 0;
 268                     let is_4x4   = (cbpc & 0x10) != 0;
 269                     if is_intra {
 270                         let cbpy = br.read_cb(&self.tables.cbpy_cb)?;
 271                         let cbp = (cbpy << 2) | (cbpc & 3);
 272                         if dquant {
 273                             let idx = br.read(2)? as usize;
 274                             q = ((q as i16) + (H263_DQUANT_TAB[idx] as i16)) as u8;
 275                             validate!(q < 32);
 276                         }
 277                         let binfo = BlockInfo::new(Type::I, cbp, q);
 278                         return Ok(binfo);
 279                     }
 280
 281                     let mut cbpy = br.read_cb(&self.tables.cbpy_cb)?;
 282 //                    if /* !aiv && */(cbpc & 3) != 3 {
 283                         cbpy ^= 0xF;
 284 //                    }
 285                     let cbp = (cbpy << 2) | (cbpc & 3);
 286                     if dquant {
 287                         let idx = br.read(2)? as usize;
 288                         q = ((q as i16) + (H263_DQUANT_TAB[idx] as i16)) as u8;
 289                         validate!(q < 32);
 290                     }
 291                     let mut binfo = BlockInfo::new(Type::P, cbp, q);
 292                     if !is_4x4 {
 293                         let mvec: [MV; 1] = [decode_mv(br, &self.tables.mv_cb)?];
 294                         binfo.set_mv(&mvec);
 295                     } else {
 296                         let mvec: [MV; 4] = [
 297                                 decode_mv(br, &self.tables.mv_cb)?,
 298                                 decode_mv(br, &self.tables.mv_cb)?,
 299                                 decode_mv(br, &self.tables.mv_cb)?,
 300                                 decode_mv(br, &self.tables.mv_cb)?
 301                             ];
 302                         binfo.set_mv(&mvec);
 303                     }
 304                     Ok(binfo)
 305                 },
 306             _ => { println!("wrong info mode"); Err(DecoderError::InvalidData) },
 307         }
 308     }
 309
 310     fn decode_block_intra(&mut self, _info: &BlockInfo, sstate: &SliceState, quant: u8, no: usize, coded: bool, blk: &mut [i16; 64]) -> DecoderResult<()> {
 311         self.decode_block(sstate, quant, true, coded, blk, if no < 4 { 0 } else { no - 3 })
 312     }
 313
 314     fn decode_block_inter(&mut self, _info: &BlockInfo, sstate: &SliceState, quant: u8, no: usize, coded: bool, blk: &mut [i16; 64]) -> DecoderResult<()> {
 315         self.decode_block(sstate, quant, false, coded, blk, if no < 4 { 0 } else { no - 3 })
 316     }
 317
 318     fn is_slice_end(&mut self) -> bool { false }
 319 }
 320
 321 impl<'a> RealVideo10BR<'a> {
 322     fn read_slice_header(&mut self) -> DecoderResult<RV10SliceInfo> {
 323         validate!(self.slice_no < self.num_slices);
 324
 325         let br = &mut self.br;
 326         br.seek(self.slice_off[self.slice_no] * 8)?;
 327
 328         let marker      = br.read(1)?;
 329         validate!(marker == 1);
 330         let is_p        = br.read_bool()?;
 331         let pb_frame    = br.read_bool()?;
 332         validate!(!pb_frame);
 333         let qscale      = br.read(5)? as u8;
 334         validate!(qscale > 0);
 335
 336         if !is_p && self.new_ver {
 337             self.last_dc[0]  = br.read(8)? as i16;
 338             self.last_dc[1]  = br.read(8)? as i16;
 339             self.last_dc[2]  = br.read(8)? as i16;
 340         } else {
 341             self.last_dc[0] = 0;
 342             self.last_dc[1] = 0;
 343             self.last_dc[2] = 0;
 344         }
 345         self.dc_coded[0] = false;
 346         self.dc_coded[1] = false;
 347         self.dc_coded[2] = false;
 348
 349         let mb_x;
 350         let mb_y;
 351         let mb_count;
 352         if (br.peek(12) == 0) || (self.slice_no > 0) {
 353             mb_x        = br.read(6)? as usize;
 354             mb_y        = br.read(6)? as usize;
 355             mb_count    = br.read(12)? as usize;
 356         } else {
 357             mb_x        = 0;
 358             mb_y        = 0;
 359             mb_count    = self.mb_w * self.mb_h;
 360         }
 361         br.skip(3)?;
 362         validate!(mb_x + mb_y * self.mb_w + mb_count <= self.mb_w * self.mb_h);
 363
 364         Ok(RV10SliceInfo::new(is_p, qscale, mb_x, mb_y, mb_count))
 365     }
 366 }
 367
 368 impl RealVideo10Decoder {
 369     fn new() -> Self {
 370         let mut coderead = H263ShortCodeReader::new(H263_INTRA_MCBPC);
 371         let intra_mcbpc_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 372         let mut coderead = H263ShortCodeReader::new(H263_INTER_MCBPC);
 373         let inter_mcbpc_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 374         let mut coderead = H263ShortCodeReader::new(H263_CBPY);
 375         let cbpy_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 376         let mut coderead = H263RLCodeReader::new(H263_RL_CODES);
 377         let rl_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 378         let mut coderead = H263ShortCodeReader::new(H263_MV);
 379         let mv_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 380         let mut coderead = CodeReader::new(RV10_LUMA_DC_CODES,  RV10_LUMA_DC_BITS);
 381         let luma_dc_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 382         let mut coderead = CodeReader::new(RV10_CHROMA_DC_CODES,  RV10_CHROMA_DC_BITS);
 383         let chroma_dc_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 384
 385         let tables = Tables {
 386             intra_mcbpc_cb,
 387             inter_mcbpc_cb,
 388             cbpy_cb,
 389             rl_cb,
 390             mv_cb,
 391             luma_dc_cb,
 392             chroma_dc_cb,
 393         };
 394
 395         RealVideo10Decoder{
 396             info:           NACodecInfoRef::default(),
 397             dec:            H263BaseDecoder::new_with_opts(0),
 398             tables,
 399             w:              0,
 400             h:              0,
 401             new_ver:        false,
 402             bdsp:           H263BlockDSP::new(),
 403             mvmode:         MVMode::Long,
 404         }
 405     }
 406 }
 407
 408 impl NADecoder for RealVideo10Decoder {
 409     fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
 410         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
 411             let w = vinfo.get_width();
 412             let h = vinfo.get_height();
 413             let fmt = formats::YUV420_FORMAT;
 414             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
 415             self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
 416             self.w = w;
 417             self.h = h;
 418
 419             let edata = info.get_extradata().unwrap();
 420             let src: &[u8] = &edata;
 421             let ver = ((src[4] as u32) << 12) | ((src[5] as u32) << 4) | ((src[6] as u32) >> 4);
 422             let maj_ver = ver >> 16;
 423             let mic_ver = ver & 0xFF;
 424             validate!(maj_ver == 1);
 425             self.new_ver = mic_ver > 0;
 426             if mic_ver == 2 {
 427                 self.dec = H263BaseDecoder::new_with_opts(H263DEC_OPT_HAS_OBMC);
 428             }
 429             if (src[3] & 1) != 0 {
 430                 self.mvmode = MVMode::UMV;
 431             }
 432             Ok(())
 433         } else {
 434             Err(DecoderError::InvalidData)
 435         }
 436     }
 437     fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
 438         let src = pkt.get_buffer();
 439
 440         let mut ibr = RealVideo10BR::new(&src, &self.tables, self.w, self.h, self.new_ver, self.mvmode);
 441
 442         let bufinfo = self.dec.parse_frame(&mut ibr, &self.bdsp)?;
 443
 444         let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
 445         frm.set_keyframe(self.dec.is_intra());
 446         frm.set_frame_type(if self.dec.is_intra() { FrameType::I } else { FrameType::P });
 447         Ok(frm.into_ref())
 448     }
 449     fn flush(&mut self) {
 450         self.dec.flush();
 451     }
 452 }
 453
 454 impl NAOptionHandler for RealVideo10Decoder {
 455     fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
 456     fn set_options(&mut self, _options: &[NAOption]) { }
 457     fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
 458 }
 459
 460
 461 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
 462     Box::new(RealVideo10Decoder::new())
 463 }
 464
 465 #[cfg(test)]
 466 mod test {
 467     use nihav_core::codecs::RegisteredDecoders;
 468     use nihav_core::demuxers::RegisteredDemuxers;
 469     use nihav_codec_support::test::dec_video::*;
 470     use crate::realmedia_register_all_decoders;
 471     use crate::realmedia_register_all_demuxers;
 472     #[test]
 473     fn test_rv10_old() {
 474         let mut dmx_reg = RegisteredDemuxers::new();
 475         realmedia_register_all_demuxers(&mut dmx_reg);
 476         let mut dec_reg = RegisteredDecoders::new();
 477         realmedia_register_all_decoders(&mut dec_reg);
 478
 479         // sample: https://samples.mplayerhq.hu/real/VC-RV10/thankyou.rm
 480         test_decoding("realmedia", "realvideo1", "assets/RV/thankyou.rm",
 481                       Some(1000), &dmx_reg, &dec_reg, ExpectedTestResult::MD5Frames(vec![
 482                             [0x8bba459c, 0xe6e8e01c, 0x36f90595, 0xb268adee],
 483                             [0x32ca9567, 0xedc13b6f, 0xbee77cfd, 0xc7ebe24b],
 484                             [0xcf1865b6, 0xea7cf1b2, 0x30a5a622, 0xe5775b0d],
 485                             [0x8d984cfd, 0xcbc81a8d, 0x71d5b37a, 0x74115bba],
 486                             [0x7ec2a9e8, 0x291fc62a, 0x5fc62722, 0xf2072b87],
 487                             [0xa150585b, 0x9d608fe7, 0xb8d42676, 0x070103f7],
 488                             [0x8aadd96f, 0xa02e0627, 0xa89e104f, 0xf47d1227],
 489                             [0xa4416bb1, 0xc9ca7a61, 0xad43de90, 0x3e9ec5b7]]));
 490     }
 491     #[test]
 492     fn test_rv10_obmc() {
 493         let mut dmx_reg = RegisteredDemuxers::new();
 494         realmedia_register_all_demuxers(&mut dmx_reg);
 495         let mut dec_reg = RegisteredDecoders::new();
 496         realmedia_register_all_decoders(&mut dec_reg);
 497
 498         // sample from a private collection
 499         test_decoding("realmedia", "realvideo1",
 500                       "assets/RV/rv10_dnet_640x352_realvideo_encoder_4.0.rm",
 501                       Some(1000), &dmx_reg, &dec_reg, ExpectedTestResult::MD5Frames(vec![
 502                             [0x23599d2e, 0xf7212b24, 0x6b34b848, 0xbca84641],
 503                             [0x23599d2e, 0xf7212b24, 0x6b34b848, 0xbca84641],
 504                             [0x23599d2e, 0xf7212b24, 0x6b34b848, 0xbca84641],
 505                             [0x23599d2e, 0xf7212b24, 0x6b34b848, 0xbca84641],
 506                             [0x23599d2e, 0xf7212b24, 0x6b34b848, 0xbca84641],
 507                             [0x23599d2e, 0xf7212b24, 0x6b34b848, 0xbca84641],
 508                             [0x23599d2e, 0xf7212b24, 0x6b34b848, 0xbca84641],
 509                             [0x23599d2e, 0xf7212b24, 0x6b34b848, 0xbca84641],
 510                             [0x5cb179dc, 0x56ce9d07, 0x2439dd68, 0x80fec0bf],
 511                             [0x00de945d, 0xf44b71d3, 0x1dd93df9, 0x468bdcd5],
 512                             [0x7deb3aae, 0x8856c5da, 0x53011115, 0xed91377b],
 513                             [0x73afc311, 0xa61d36dc, 0x4e6ba0a3, 0x6dc64514],
 514                             [0xee35a8ce, 0x8edf5f32, 0x601d238f, 0xe5fa7ea7],
 515                             [0xe9aeaaa9, 0x876a221b, 0xe2d70923, 0x611849fd],
 516                             [0x0ff535cf, 0xf9e6ee1c, 0xed3a822c, 0x915056c0]]));
 517     }
 518 }
 519
 520 pub struct CodeReader { codes: &'static [u16], bits: &'static [u8] }
 521
 522 impl CodeReader {
 523     pub fn new(codes: &'static [u16], bits: &'static [u8]) -> Self {
 524         CodeReader { codes, bits }
 525     }
 526 }
 527
 528 impl CodebookDescReader<u8> for CodeReader {
 529     fn bits(&mut self, idx: usize) -> u8  { self.bits[idx] }
 530     fn code(&mut self, idx: usize) -> u32 { self.codes[idx] as u32 }
 531     fn sym (&mut self, idx: usize) -> u8 { idx as u8 }
 532     fn len(&mut self) -> usize { self.bits.len() }
 533 }
 534
 535 const RV10_LUMA_DC_CODES: &[u16] = &[
 536     0x001f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
 537     0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
 538     0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
 539     0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
 540     0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
 541     0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
 542     0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
 543     0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
 544     0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
 545     0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
 546     0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
 547     0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
 548     0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
 549     0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
 550     0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
 551     0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
 552     0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
 553     0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
 554     0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
 555     0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
 556     0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
 557     0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
 558     0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
 559     0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
 560     0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
 561     0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
 562     0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
 563     0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
 564     0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
 565     0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
 566     0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
 567     0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
 568 ];
 569
 570 const RV10_LUMA_DC_BITS: &[u8] = &[
 571      5, 12, 12, 12, 12, 12, 12, 12,
 572     12, 12, 12, 12, 12, 12, 12, 12,
 573     12, 12, 12, 12, 12, 12, 12, 12,
 574     12, 12, 12, 12, 12, 12, 12, 12,
 575     12, 12, 12, 12, 12, 12, 12, 12,
 576     12, 12, 12, 12, 12, 12, 12, 12,
 577     12, 12, 12, 12, 12, 12, 12, 12,
 578     12, 12, 12, 12, 12, 12, 12, 12,
 579     12, 10, 10, 10, 10, 10, 10, 10,
 580     10, 10, 10, 10, 10, 10, 10, 10,
 581     10, 10, 10, 10, 10, 10, 10, 10,
 582     10, 10, 10, 10, 10, 10, 10, 10,
 583     10,  8,  8,  8,  8,  8,  8,  8,
 584      8,  8,  8,  8,  8,  8,  8,  8,
 585      8,  7,  7,  7,  7,  7,  7,  7,
 586      7,  6,  6,  6,  6,  5,  5,  4,
 587      2,  4,  5,  5,  6,  6,  6,  6,
 588      7,  7,  7,  7,  7,  7,  7,  7,
 589      8,  8,  8,  8,  8,  8,  8,  8,
 590      8,  8,  8,  8,  8,  8,  8,  8,
 591     10, 10, 10, 10, 10, 10, 10, 10,
 592     10, 10, 10, 10, 10, 10, 10, 10,
 593     10, 10, 10, 10, 10, 10, 10, 10,
 594     10, 10, 10, 10, 10, 10, 10, 10,
 595     12, 12, 12, 12, 12, 12, 12, 12,
 596     12, 12, 12, 12, 12, 12, 12, 12,
 597     12, 12, 12, 12, 12, 12, 12, 12,
 598     12, 12, 12, 12, 12, 12, 12, 12,
 599     12, 12, 12, 12, 12, 12, 12, 12,
 600     12, 12, 12, 12, 12, 12, 12, 12,
 601     12, 12, 12, 12, 12, 12, 12, 12,
 602     12, 12, 12, 12, 12, 12, 12, 12,
 603 ];
 604
 605 const RV10_CHROMA_DC_CODES: &[u16] = &[
 606     0x0000, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
 607     0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
 608     0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
 609     0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
 610     0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
 611     0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
 612     0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
 613     0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
 614     0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
 615     0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
 616     0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
 617     0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
 618     0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
 619     0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
 620     0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
 621     0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
 622     0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
 623     0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
 624     0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
 625     0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
 626     0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
 627     0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
 628     0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
 629     0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
 630     0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
 631     0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
 632     0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
 633     0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
 634     0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
 635     0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
 636     0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
 637     0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
 638 ];
 639
 640 const RV10_CHROMA_DC_BITS: &[u8] = &[
 641      0, 14, 14, 14, 14, 14, 14, 14,
 642     14, 14, 14, 14, 14, 14, 14, 14,
 643     14, 14, 14, 14, 14, 14, 14, 14,
 644     14, 14, 14, 14, 14, 14, 14, 14,
 645     14, 14, 14, 14, 14, 14, 14, 14,
 646     14, 14, 14, 14, 14, 14, 14, 14,
 647     14, 14, 14, 14, 14, 14, 14, 14,
 648     14, 14, 14, 14, 14, 14, 14, 14,
 649     14, 12, 12, 12, 12, 12, 12, 12,
 650     12, 12, 12, 12, 12, 12, 12, 12,
 651     12, 12, 12, 12, 12, 12, 12, 12,
 652     12, 12, 12, 12, 12, 12, 12, 12,
 653     12, 10, 10, 10, 10, 10, 10, 10,
 654     10, 10, 10, 10, 10, 10, 10, 10,
 655     10,  8,  8,  8,  8,  8,  8,  8,
 656      8,  6,  6,  6,  6,  4,  4,  3,
 657      2,  3,  4,  4,  6,  6,  6,  6,
 658      8,  8,  8,  8,  8,  8,  8,  8,
 659     10, 10, 10, 10, 10, 10, 10, 10,
 660     10, 10, 10, 10, 10, 10, 10, 10,
 661     12, 12, 12, 12, 12, 12, 12, 12,
 662     12, 12, 12, 12, 12, 12, 12, 12,
 663     12, 12, 12, 12, 12, 12, 12, 12,
 664     12, 12, 12, 12, 12, 12, 12, 12,
 665     14, 14, 14, 14, 14, 14, 14, 14,
 666     14, 14, 14, 14, 14, 14, 14, 14,
 667     14, 14, 14, 14, 14, 14, 14, 14,
 668     14, 14, 14, 14, 14, 14, 14, 14,
 669     14, 14, 14, 14, 14, 14, 14, 14,
 670     14, 14, 14, 14, 14, 14, 14, 14,
 671     14, 14, 14, 14, 14, 14, 14, 14,
 672     14, 14, 14, 14, 14, 14, 14, 14,
 673 ];