nihav-realmedia/src/codecs/rv10.rs

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