src/codecs/h263/rv10.rs

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