nihav-realmedia/src/codecs/rv10.rs

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