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