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