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::*;
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>,
20 luma_dc_cb: Codebook<u8>,
21 chroma_dc_cb: Codebook<u8>,
24 struct RealVideo10Decoder {
35 struct RealVideo10BR<'a> {
51 struct 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 }
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);
70 let offs = &src[1..][..nslices * 8];
71 let mut br = BitReader::new(offs, BitReaderMode::BE);
74 let off = br.read(32).unwrap();
78 let soff = nslices * 8 + 1;
80 br: BitReader::new(&src[soff..], BitReaderMode::BE),
84 slice_off: slice_offs,
87 mb_w: (width + 15) >> 4,
88 mb_h: (height + 15) >> 4,
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;
102 if !self.new_ver || !sstate.is_iframe {
103 dc = br.read(8)? as i16;
104 if dc == 255 { dc = 128; }
106 if self.dc_coded[plane_no] {
108 let bits = br.peek(14);
109 let ret = if plane_no == 0 {
110 br.read_cb(&self.tables.luma_dc_cb)
112 br.read_cb(&self.tables.chroma_dc_cb)
115 println!("Illegal {} code {:X}", if plane_no==0{"luma"}else{"chroma"},bits);
117 let val = ret.unwrap() as i16;
122 let code = br.read(2)?;
124 0x0 => { diff = ((br.read(7)? + 1) as i8) as i16; },
125 0x1 => { diff = (br.read(7)? as i16) - 128; },
129 diff = ((br.read(8)? + 1) as i8) as i16;
131 diff = (br.read(8)? as i8) as i16;
143 return Err(DecoderError::InvalidData);
148 dc = (self.last_dc[plane_no] - diff) & 0xFF;
149 self.last_dc[plane_no] = dc;
151 self.dc_coded[plane_no] = true;
152 dc = self.last_dc[plane_no];
158 if !coded { return Ok(()); }
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;
164 let code = br.read_cb(rl_cb)?;
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; }
174 level = (level * q) + q_add;
176 level = (level * q) - q_add;
179 last = br.read_bool()?;
180 run = br.read(6)? as u8;
181 level = br.read_s(8)? as i16;
183 let low = br.read(5)? as i16;
184 let top = br.read_s(6)? as i16;
185 level = (top << 5) | low;
188 level = (level * q) + q_add;
190 level = (level * q) - q_add;
192 if level < -2048 { level = -2048; }
193 if level > 2047 { level = 2047; }
197 let oidx = ZIGZAG[idx as usize];
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()? {
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))
222 impl<'a> BlockDecoder for RealVideo10BR<'a> {
224 #[allow(unused_variables)]
225 fn decode_pichdr(&mut self) -> DecoderResult<PicInfo> {
227 let shdr = self.read_slice_header()?;
228 validate!((shdr.mb_x == 0) && (shdr.mb_y == 0));
230 let mb_end = shdr.mb_x + shdr.mb_y * self.mb_w + shdr.mb_c;
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);
237 #[allow(unused_variables)]
238 fn decode_slice_header(&mut self, info: &PicInfo) -> DecoderResult<SliceInfo> {
239 let shdr = self.read_slice_header()?;
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);
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() {
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;
258 let idx = br.read(2)? as usize;
259 q = ((q as i16) + (H263_DQUANT_TAB[idx] as i16)) as u8;
262 Ok(BlockInfo::new(Type::I, cbp, q))
266 return Ok(BlockInfo::new(Type::Skip, 0, info.get_quant()));
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;
274 let cbpy = br.read_cb(&self.tables.cbpy_cb)?;
275 let cbp = (cbpy << 2) | (cbpc & 3);
277 let idx = br.read(2)? as usize;
278 q = ((q as i16) + (H263_DQUANT_TAB[idx] as i16)) as u8;
281 let binfo = BlockInfo::new(Type::I, cbp, q);
285 let mut cbpy = br.read_cb(&self.tables.cbpy_cb)?;
286 // if /* !aiv && */(cbpc & 3) != 3 {
289 let cbp = (cbpy << 2) | (cbpc & 3);
291 let idx = br.read(2)? as usize;
292 q = ((q as i16) + (H263_DQUANT_TAB[idx] as i16)) as u8;
295 let mut binfo = BlockInfo::new(Type::P, cbp, q);
297 let mvec: [MV; 1] = [decode_mv(br, &self.tables.mv_cb)?];
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)?
310 _ => { println!("wrong info mode"); Err(DecoderError::InvalidData) },
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 })
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 })
324 fn is_slice_end(&mut self) -> bool { false }
327 impl<'a> RealVideo10BR<'a> {
328 fn read_slice_header(&mut self) -> DecoderResult<RV10SliceInfo> {
329 validate!(self.slice_no < self.num_slices);
331 let br = &mut self.br;
332 br.seek(self.slice_off[self.slice_no] * 8)?;
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);
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;
351 self.dc_coded[0] = false;
352 self.dc_coded[1] = false;
353 self.dc_coded[2] = false;
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;
365 mb_count = self.mb_w * self.mb_h;
368 validate!(mb_x + mb_y * self.mb_w + mb_count <= self.mb_w * self.mb_h);
370 Ok(RV10SliceInfo::new(is_p, qscale, mb_x, mb_y, mb_count))
374 impl RealVideo10Decoder {
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();
393 let tables = Tables {
405 info: NACodecInfoRef::default(),
406 dec: H263BaseDecoder::new_with_opts(0),
411 bdsp: H263BlockDSP::new(),
412 mvmode: MVMode::Long,
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();
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;
436 self.dec = H263BaseDecoder::new_with_opts(H263DEC_OPT_HAS_OBMC);
438 if (src[3] & 1) != 0 {
439 self.mvmode = MVMode::UMV;
443 Err(DecoderError::InvalidData)
446 fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
447 let src = pkt.get_buffer();
449 let mut ibr = RealVideo10BR::new(&src, &self.tables, self.w, self.h, self.new_ver, self.mvmode);
451 let bufinfo = self.dec.parse_frame(&mut ibr, &self.bdsp)?;
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 });
458 fn flush(&mut self) {
463 impl NAOptionHandler for RealVideo10Decoder {
464 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
465 fn set_options(&mut self, _options: &[NAOption]) { }
466 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
470 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
471 Box::new(RealVideo10Decoder::new())
476 use nihav_core::codecs::RegisteredDecoders;
477 use nihav_core::demuxers::RegisteredDemuxers;
478 use nihav_codec_support::test::dec_video::*;
479 use crate::realmedia_register_all_decoders;
480 use crate::realmedia_register_all_demuxers;
483 let mut dmx_reg = RegisteredDemuxers::new();
484 realmedia_register_all_demuxers(&mut dmx_reg);
485 let mut dec_reg = RegisteredDecoders::new();
486 realmedia_register_all_decoders(&mut dec_reg);
488 // sample: https://samples.mplayerhq.hu/real/VC-RV10/thankyou.rm
489 test_decoding("realmedia", "realvideo1", "assets/RV/thankyou.rm",
490 Some(1000), &dmx_reg, &dec_reg, ExpectedTestResult::MD5Frames(vec![
491 [0x8bba459c, 0xe6e8e01c, 0x36f90595, 0xb268adee],
492 [0x32ca9567, 0xedc13b6f, 0xbee77cfd, 0xc7ebe24b],
493 [0xcf1865b6, 0xea7cf1b2, 0x30a5a622, 0xe5775b0d],
494 [0x8d984cfd, 0xcbc81a8d, 0x71d5b37a, 0x74115bba],
495 [0x7ec2a9e8, 0x291fc62a, 0x5fc62722, 0xf2072b87],
496 [0xa150585b, 0x9d608fe7, 0xb8d42676, 0x070103f7],
497 [0x8aadd96f, 0xa02e0627, 0xa89e104f, 0xf47d1227],
498 [0xa4416bb1, 0xc9ca7a61, 0xad43de90, 0x3e9ec5b7]]));
501 fn test_rv10_obmc() {
502 let mut dmx_reg = RegisteredDemuxers::new();
503 realmedia_register_all_demuxers(&mut dmx_reg);
504 let mut dec_reg = RegisteredDecoders::new();
505 realmedia_register_all_decoders(&mut dec_reg);
507 // sample from a private collection
508 test_decoding("realmedia", "realvideo1",
509 "assets/RV/rv10_dnet_640x352_realvideo_encoder_4.0.rm",
510 Some(1000), &dmx_reg, &dec_reg, ExpectedTestResult::MD5Frames(vec![
511 [0x23599d2e, 0xf7212b24, 0x6b34b848, 0xbca84641],
512 [0x23599d2e, 0xf7212b24, 0x6b34b848, 0xbca84641],
513 [0x23599d2e, 0xf7212b24, 0x6b34b848, 0xbca84641],
514 [0x23599d2e, 0xf7212b24, 0x6b34b848, 0xbca84641],
515 [0x23599d2e, 0xf7212b24, 0x6b34b848, 0xbca84641],
516 [0x23599d2e, 0xf7212b24, 0x6b34b848, 0xbca84641],
517 [0x23599d2e, 0xf7212b24, 0x6b34b848, 0xbca84641],
518 [0x23599d2e, 0xf7212b24, 0x6b34b848, 0xbca84641],
519 [0x5cb179dc, 0x56ce9d07, 0x2439dd68, 0x80fec0bf],
520 [0x00de945d, 0xf44b71d3, 0x1dd93df9, 0x468bdcd5],
521 [0x7deb3aae, 0x8856c5da, 0x53011115, 0xed91377b],
522 [0x73afc311, 0xa61d36dc, 0x4e6ba0a3, 0x6dc64514],
523 [0xee35a8ce, 0x8edf5f32, 0x601d238f, 0xe5fa7ea7],
524 [0xe9aeaaa9, 0x876a221b, 0xe2d70923, 0x611849fd],
525 [0x0ff535cf, 0xf9e6ee1c, 0xed3a822c, 0x915056c0]]));
529 pub struct CodeReader { codes: &'static [u16], bits: &'static [u8] }
532 pub fn new(codes: &'static [u16], bits: &'static [u8]) -> Self {
533 CodeReader { codes, bits }
537 impl CodebookDescReader<u8> for CodeReader {
538 fn bits(&mut self, idx: usize) -> u8 { self.bits[idx] }
539 fn code(&mut self, idx: usize) -> u32 { self.codes[idx] as u32 }
540 fn sym (&mut self, idx: usize) -> u8 { idx as u8 }
541 fn len(&mut self) -> usize { self.bits.len() }
544 const RV10_LUMA_DC_CODES: &[u16] = &[
545 0x001f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
546 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
547 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
548 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
549 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
550 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
551 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
552 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
553 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
554 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
555 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
556 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
557 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
558 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
559 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
560 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
561 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
562 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
563 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
564 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
565 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
566 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
567 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
568 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
569 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
570 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
571 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
572 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
573 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
574 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
575 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
576 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
579 const RV10_LUMA_DC_BITS: &[u8] = &[
580 5, 12, 12, 12, 12, 12, 12, 12,
581 12, 12, 12, 12, 12, 12, 12, 12,
582 12, 12, 12, 12, 12, 12, 12, 12,
583 12, 12, 12, 12, 12, 12, 12, 12,
584 12, 12, 12, 12, 12, 12, 12, 12,
585 12, 12, 12, 12, 12, 12, 12, 12,
586 12, 12, 12, 12, 12, 12, 12, 12,
587 12, 12, 12, 12, 12, 12, 12, 12,
588 12, 10, 10, 10, 10, 10, 10, 10,
589 10, 10, 10, 10, 10, 10, 10, 10,
590 10, 10, 10, 10, 10, 10, 10, 10,
591 10, 10, 10, 10, 10, 10, 10, 10,
592 10, 8, 8, 8, 8, 8, 8, 8,
593 8, 8, 8, 8, 8, 8, 8, 8,
594 8, 7, 7, 7, 7, 7, 7, 7,
595 7, 6, 6, 6, 6, 5, 5, 4,
596 2, 4, 5, 5, 6, 6, 6, 6,
597 7, 7, 7, 7, 7, 7, 7, 7,
598 8, 8, 8, 8, 8, 8, 8, 8,
599 8, 8, 8, 8, 8, 8, 8, 8,
600 10, 10, 10, 10, 10, 10, 10, 10,
601 10, 10, 10, 10, 10, 10, 10, 10,
602 10, 10, 10, 10, 10, 10, 10, 10,
603 10, 10, 10, 10, 10, 10, 10, 10,
604 12, 12, 12, 12, 12, 12, 12, 12,
605 12, 12, 12, 12, 12, 12, 12, 12,
606 12, 12, 12, 12, 12, 12, 12, 12,
607 12, 12, 12, 12, 12, 12, 12, 12,
608 12, 12, 12, 12, 12, 12, 12, 12,
609 12, 12, 12, 12, 12, 12, 12, 12,
610 12, 12, 12, 12, 12, 12, 12, 12,
611 12, 12, 12, 12, 12, 12, 12, 12,
614 const RV10_CHROMA_DC_CODES: &[u16] = &[
615 0x0000, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
616 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
617 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
618 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
619 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
620 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
621 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
622 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
623 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
624 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
625 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
626 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
627 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
628 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
629 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
630 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
631 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
632 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
633 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
634 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
635 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
636 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
637 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
638 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
639 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
640 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
641 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
642 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
643 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
644 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
645 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
646 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
649 const RV10_CHROMA_DC_BITS: &[u8] = &[
650 0, 14, 14, 14, 14, 14, 14, 14,
651 14, 14, 14, 14, 14, 14, 14, 14,
652 14, 14, 14, 14, 14, 14, 14, 14,
653 14, 14, 14, 14, 14, 14, 14, 14,
654 14, 14, 14, 14, 14, 14, 14, 14,
655 14, 14, 14, 14, 14, 14, 14, 14,
656 14, 14, 14, 14, 14, 14, 14, 14,
657 14, 14, 14, 14, 14, 14, 14, 14,
658 14, 12, 12, 12, 12, 12, 12, 12,
659 12, 12, 12, 12, 12, 12, 12, 12,
660 12, 12, 12, 12, 12, 12, 12, 12,
661 12, 12, 12, 12, 12, 12, 12, 12,
662 12, 10, 10, 10, 10, 10, 10, 10,
663 10, 10, 10, 10, 10, 10, 10, 10,
664 10, 8, 8, 8, 8, 8, 8, 8,
665 8, 6, 6, 6, 6, 4, 4, 3,
666 2, 3, 4, 4, 6, 6, 6, 6,
667 8, 8, 8, 8, 8, 8, 8, 8,
668 10, 10, 10, 10, 10, 10, 10, 10,
669 10, 10, 10, 10, 10, 10, 10, 10,
670 12, 12, 12, 12, 12, 12, 12, 12,
671 12, 12, 12, 12, 12, 12, 12, 12,
672 12, 12, 12, 12, 12, 12, 12, 12,
673 12, 12, 12, 12, 12, 12, 12, 12,
674 14, 14, 14, 14, 14, 14, 14, 14,
675 14, 14, 14, 14, 14, 14, 14, 14,
676 14, 14, 14, 14, 14, 14, 14, 14,
677 14, 14, 14, 14, 14, 14, 14, 14,
678 14, 14, 14, 14, 14, 14, 14, 14,
679 14, 14, 14, 14, 14, 14, 14, 14,
680 14, 14, 14, 14, 14, 14, 14, 14,
681 14, 14, 14, 14, 14, 14, 14, 14,