6 use super::code::H263BlockDSP;
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>,
18 luma_dc_cb: Codebook<u8>,
19 chroma_dc_cb: Codebook<u8>,
22 struct RealVideo10Decoder {
23 info: Rc<NACodecInfo>,
33 struct RealVideo10BR<'a> {
49 struct 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 }
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);
68 let offs = &src[1..][..nslices * 8];
69 let mut br = BitReader::new(offs, offs.len(), BitReaderMode::BE);
72 let off = br.read(32).unwrap();
76 let soff = nslices * 8 + 1;
78 br: BitReader::new(&src[soff..], src.len() - soff, BitReaderMode::BE),
82 slice_off: slice_offs,
85 mb_w: (width + 15) >> 4,
86 mb_h: (height + 15) >> 4,
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;
100 if !self.new_ver || !sstate.is_iframe {
101 dc = br.read(8)? as i16;
102 if dc == 255 { dc = 128; }
104 if self.dc_coded[plane_no] {
106 let bits = br.peek(14);
107 let ret = if plane_no == 0 {
108 br.read_cb(&self.tables.luma_dc_cb)
110 br.read_cb(&self.tables.chroma_dc_cb)
113 println!("Illegal {} code {:X}", if plane_no==0{"luma"}else{"chroma"},bits);
115 let val = ret.unwrap() as i16;
120 let code = br.read(2)?;
122 0x0 => { diff = ((br.read(7)? + 1) as i8) as i16; },
123 0x1 => { diff = (br.read(7)? as i16) - 128; },
127 diff = ((br.read(8)? + 1) as i8) as i16;
129 diff = (br.read(8)? as i8) as i16;
141 return Err(DecoderError::InvalidData);
146 dc = (self.last_dc[plane_no] - diff) & 0xFF;
147 self.last_dc[plane_no] = dc;
149 self.dc_coded[plane_no] = true;
150 dc = self.last_dc[plane_no];
156 if !coded { return Ok(()); }
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;
162 let code = br.read_cb(rl_cb)?;
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;
173 last = br.read_bool()?;
174 run = br.read(6)? as u8;
175 level = br.read_s(8)? as i16;
177 let low = br.read(5)? as i16;
178 let top = br.read_s(6)? as i16;
179 level = (top << 5) | low;
181 level = (level * q) + q_add;
182 if level < -2048 { level = -2048; }
183 if level > 2047 { level = 2047; }
187 let oidx = H263_ZIGZAG[idx as usize];
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()? {
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))
212 impl<'a> BlockDecoder for RealVideo10BR<'a> {
214 #[allow(unused_variables)]
215 fn decode_pichdr(&mut self) -> DecoderResult<PicInfo> {
217 let shdr = self.read_slice_header()?;
218 validate!((shdr.mb_x == 0) && (shdr.mb_y == 0));
220 let mb_end = shdr.mb_x + shdr.mb_y * self.mb_w + shdr.mb_c;
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);
227 #[allow(unused_variables)]
228 fn decode_slice_header(&mut self, info: &PicInfo) -> DecoderResult<SliceInfo> {
229 let shdr = self.read_slice_header()?;
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);
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() {
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;
248 let idx = br.read(2)? as usize;
249 q = ((q as i16) + (H263_DQUANT_TAB[idx] as i16)) as u8;
251 Ok(BlockInfo::new(Type::I, cbp, q))
255 return Ok(BlockInfo::new(Type::Skip, 0, info.get_quant()));
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;
263 let cbpy = br.read_cb(&self.tables.cbpy_cb)?;
264 let cbp = (cbpy << 2) | (cbpc & 3);
266 let idx = br.read(2)? as usize;
267 q = ((q as i16) + (H263_DQUANT_TAB[idx] as i16)) as u8;
269 let binfo = BlockInfo::new(Type::I, cbp, q);
273 let mut cbpy = br.read_cb(&self.tables.cbpy_cb)?;
274 // if /* !aiv && */(cbpc & 3) != 3 {
277 let cbp = (cbpy << 2) | (cbpc & 3);
279 let idx = br.read(2)? as usize;
280 q = ((q as i16) + (H263_DQUANT_TAB[idx] as i16)) as u8;
282 let mut binfo = BlockInfo::new(Type::P, cbp, q);
284 let mvec: [MV; 1] = [decode_mv(br, &self.tables.mv_cb)?];
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)?
297 _ => { println!("wrong info mode"); Err(DecoderError::InvalidData) },
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 })
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 })
311 fn is_slice_end(&mut self) -> bool { false }
314 impl<'a> RealVideo10BR<'a> {
315 fn read_slice_header(&mut self) -> DecoderResult<RV10SliceInfo> {
316 validate!(self.slice_no < self.num_slices);
318 let br = &mut self.br;
319 br.seek(self.slice_off[self.slice_no] * 8)?;
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);
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;
338 self.dc_coded[0] = false;
339 self.dc_coded[1] = false;
340 self.dc_coded[2] = false;
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;
352 mb_count = self.mb_w * self.mb_h;
355 validate!(mb_x + mb_y * self.mb_w + mb_count <= self.mb_w * self.mb_h);
357 Ok(RV10SliceInfo::new(is_p, qscale, mb_x, mb_y, mb_count))
361 impl RealVideo10Decoder {
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();
380 let tables = Tables {
381 intra_mcbpc_cb: intra_mcbpc_cb,
382 inter_mcbpc_cb: inter_mcbpc_cb,
385 aic_rl_cb: aic_rl_cb,
387 luma_dc_cb: luma_dc_cb,
388 chroma_dc_cb: chroma_dc_cb,
392 info: Rc::new(DUMMY_CODEC_INFO),
393 dec: H263BaseDecoder::new_with_opts(false, false, false),
398 bdsp: H263BlockDSP::new(),
399 mvmode: MVMode::Long,
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()));
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;
427 let mut br = BitReader::new(src, src.len(), BitReaderMode::BE);
429 println!("{:08X}", br.read(32).unwrap());
430 println!("{:08X}", br.read(32).unwrap());
435 Err(DecoderError::InvalidData)
438 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
439 let src = pkt.get_buffer();
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);
444 let bufinfo = self.dec.parse_frame(&mut ibr, &self.bdsp)?;
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)))
454 pub fn get_decoder() -> Box<NADecoder> {
455 Box::new(RealVideo10Decoder::new())
460 use test::dec_video::test_file_decoding;
463 test_file_decoding("realmedia", "assets/RV/rv10_dnet_640x352_realvideo_encoder_4.0.rm", Some(1000), true, false, None/*Some("rv10")*/);
467 pub struct CodeReader { codes: &'static [u16], bits: &'static [u8] }
470 pub fn new(codes: &'static [u16], bits: &'static [u8]) -> Self {
471 CodeReader { codes: codes, bits: bits }
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() }
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,
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,
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,
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,