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