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