[nihav.git] / nihav-qt / src / codecs / qdmcommon.rs

use nihav_core::codecs::*;
use nihav_core::io::bitreader::*;
use nihav_core::io::codebook::*;

/// Bitstream reader.
#[derive(Debug,Clone)]
pub struct QdmBitReader<'a> {
    cache: u32,
    bits:  u8,
    pos:   usize,
    src:   &'a [u8],
}

#[allow(clippy::identity_op)]
#[allow(dead_code)]
impl<'a> QdmBitReader<'a> {
    pub fn new(src: &'a [u8]) -> Self {
        Self{ cache: 0, pos: 0, bits: 0, src }
    }
    pub fn tell(&self) -> usize {
        self.pos * 8 - (self.bits as usize)
    }
    pub fn left(&self) -> isize {
        ((self.src.len() as isize) - (self.pos as isize)) * 8 + (self.bits as isize)
    }
    fn refill(&mut self) {
        while self.bits <= 24 {
            let byte = if self.pos < self.src.len() {
                    self.pos += 1;
                    self.src[self.pos - 1]
                } else {
                    self.pos += 1;
                    0
                };
            self.cache |= u32::from(byte) << self.bits;
            self.bits += 8;
        }
    }
    fn read_cache(&mut self, nbits: u8) -> u32 {
        ((1 << nbits) - 1) & self.cache
    }
    fn skip_cache(&mut self, nbits: u8) {
        self.cache >>= nbits;
        self.bits -= nbits;
    }
    fn reset_cache(&mut self) {
        self.bits = 0;
        self.cache = 0;
    }
    pub fn read(&mut self, nbits: u8) -> u32 {
        if nbits == 0 { return 0; }
        if nbits > 32 { return 0; }
        if self.bits < nbits {
            self.refill();
        }
        let res = self.read_cache(nbits);
        self.skip_cache(nbits);
        res
    }
    pub fn read_bool(&mut self) -> bool {
        if self.bits < 1 {
            self.refill();
        }
        let res = self.read_cache(1);
        self.skip_cache(1);
        res == 1
    }
    pub fn peek(&mut self, nbits: u8) -> u32 {
        if nbits > 32 { return 0 }
        if self.bits < nbits { self.refill(); }
        self.read_cache(nbits)
    }
    pub fn skip(&mut self, nbits: u32) {
        if u32::from(self.bits) >= nbits {
            self.skip_cache(nbits as u8);
            return;
        }
        let mut skip_bits = nbits - u32::from(self.bits);
        self.reset_cache();
        self.pos += ((skip_bits / 32) * 4) as usize;
        skip_bits &= 0x1F;
        self.refill();
        if skip_bits > 0 {
            self.skip_cache(skip_bits as u8);
        }
    }
}

impl<'a, S: Copy> CodebookReader<S> for QdmBitReader<'a> {
    #[allow(unused_variables)]
    fn read_cb(&mut self, cb: &Codebook<S>) -> CodebookResult<S> {
        let mut esc = true;
        let mut idx = 0;
        let mut lut_bits = cb.lut_bits;
        while esc {
            let lut_idx = (self.peek(lut_bits) as usize) + idx;
            if cb.table[lut_idx] == TABLE_FILL_VALUE { return Err(CodebookError::InvalidCode); }
            let bits = cb.table[lut_idx] & 0x7F;
            esc  = (cb.table[lut_idx] & 0x80) != 0;
            idx  = (cb.table[lut_idx] >> 8) as usize;
            let skip_bits = if esc { u32::from(lut_bits) } else { bits };
            self.skip(skip_bits);
            lut_bits = bits as u8;
        }
        Ok(cb.syms[idx])
    }
}


pub fn to_signed(val: i32) -> i32 {
    if (val & 1) != 0 {
        (val + 1) >> 1
    } else {
        -(val >> 1)
    }
}

pub trait QdmcCodeReader {
    fn read_code(&mut self, cb: &Codebook<u8>) -> DecoderResult<u32>;
    fn read_code_long(&mut self, cb: &Codebook<u8>) -> DecoderResult<u32>;
}

impl<'a> QdmcCodeReader for BitReader<'a> {
    fn read_code(&mut self, cb: &Codebook<u8>) -> DecoderResult<u32> {
        let idx                         = self.read_cb(cb)?;
        if idx > 0 {
            Ok(u32::from(idx - 1))
        } else {
            let len                     = (self.read(3)? as u8) + 1;
            let val                     = self.read(len)?;
            Ok(val)
        }
    }
    fn read_code_long(&mut self, cb: &Codebook<u8>) -> DecoderResult<u32> {
        let idx                         = self.read_code(cb)? as usize;
        validate!(idx < ESCAPE_PREFIX.len());
        let add                         = self.read((idx >> 2) as u8)?;
        Ok(ESCAPE_PREFIX[idx] + add)
    }
}

impl<'a> QdmcCodeReader for QdmBitReader<'a> {
    fn read_code(&mut self, cb: &Codebook<u8>) -> DecoderResult<u32> {
        let idx                         = self.read_cb(cb)?;
        if idx > 0 {
            Ok(u32::from(idx - 1))
        } else {
            let len                     = (self.read(3) as u8) + 1;
            let val                     = self.read(len);
            Ok(val)
        }
    }
    fn read_code_long(&mut self, cb: &Codebook<u8>) -> DecoderResult<u32> {
        let idx                         = self.read_code(cb)? as usize;
        validate!(idx < ESCAPE_PREFIX.len());
        let add                         = self.read((idx >> 2) as u8);
        Ok(ESCAPE_PREFIX[idx] + add)
    }
}

const ESCAPE_PREFIX: [u32; 65] = [
    0x00000, 0x00001, 0x00002, 0x00003, 0x00004, 0x00006, 0x00008, 0x0000A,
    0x0000C, 0x00010, 0x00014, 0x00018, 0x0001C, 0x00024, 0x0002C, 0x00034,
    0x0003C, 0x0004C, 0x0005C, 0x0006C, 0x0007C, 0x0009C, 0x000BC, 0x000DC,
    0x000FC, 0x0013C, 0x0017C, 0x001BC, 0x001FC, 0x0027C, 0x002FC, 0x0037C,
    0x003FC, 0x004FC, 0x005FC, 0x006FC, 0x007FC, 0x009FC, 0x00BFC, 0x00DFC,
    0x00FFC, 0x013FC, 0x017FC, 0x01BFC, 0x01FFC, 0x027FC, 0x02FFC, 0x037FC,
    0x03FFC, 0x04FFC, 0x05FFC, 0x06FFC, 0x07FFC, 0x09FFC, 0x0BFFC, 0x0DFFC,
    0x0FFFC, 0x13FFC, 0x17FFC, 0x1BFFC, 0x1FFFC, 0x27FFC, 0x2FFFC, 0x37FFC,
    0x3FFFC
];

pub struct RNG {
    pub seed:   u32,
}

impl RNG {
    pub fn new() -> Self { Self { seed: 0 } }
    pub fn next(&mut self) -> u32 {
        self.seed = self.seed.wrapping_mul(0x343FD).wrapping_add(0x269EC3);
        self.seed
    }
    pub fn next_float(&mut self) -> f32 {
        self.next();
        ((((self.seed >> 16) & 0x7FFF) as f32) - 16384.0) / 16384.0
    }
}

#[derive(Clone,Copy)]
pub struct Tone {
    pub ch:         u8,
    pub phase:      u8,
    pub offset:     u8,
    pub freq:       u16,
    pub amp_idx:    u8,
}

pub const MAX_TONES: usize = 8192;
Commit	Line	Data
	1	use nihav_core::codecs::*;
	2	use nihav_core::io::bitreader::*;
	3	use nihav_core::io::codebook::*;
	4
	5	/// Bitstream reader.
	6	#[derive(Debug,Clone)]
	7	pub struct QdmBitReader<'a> {
	8	cache: u32,
	9	bits: u8,
	10	pos: usize,
	11	src: &'a [u8],
	12	}
	13
	14	#[allow(clippy::identity_op)]
	15	#[allow(dead_code)]
	16	impl<'a> QdmBitReader<'a> {
	17	pub fn new(src: &'a [u8]) -> Self {
	18	Self{ cache: 0, pos: 0, bits: 0, src }
	19	}
	20	pub fn tell(&self) -> usize {
	21	self.pos * 8 - (self.bits as usize)
	22	}
	23	pub fn left(&self) -> isize {
	24	((self.src.len() as isize) - (self.pos as isize)) * 8 + (self.bits as isize)
	25	}
	26	fn refill(&mut self) {
	27	while self.bits <= 24 {
	28	let byte = if self.pos < self.src.len() {
	29	self.pos += 1;
	30	self.src[self.pos - 1]
	31	} else {
	32	self.pos += 1;
	33	0
	34	};
	35	self.cache \|= u32::from(byte) << self.bits;
	36	self.bits += 8;
	37	}
	38	}
	39	fn read_cache(&mut self, nbits: u8) -> u32 {
	40	((1 << nbits) - 1) & self.cache
	41	}
	42	fn skip_cache(&mut self, nbits: u8) {
	43	self.cache >>= nbits;
	44	self.bits -= nbits;
	45	}
	46	fn reset_cache(&mut self) {
	47	self.bits = 0;
	48	self.cache = 0;
	49	}
	50	pub fn read(&mut self, nbits: u8) -> u32 {
	51	if nbits == 0 { return 0; }
	52	if nbits > 32 { return 0; }
	53	if self.bits < nbits {
	54	self.refill();
	55	}
	56	let res = self.read_cache(nbits);
	57	self.skip_cache(nbits);
	58	res
	59	}
	60	pub fn read_bool(&mut self) -> bool {
	61	if self.bits < 1 {
	62	self.refill();
	63	}
	64	let res = self.read_cache(1);
	65	self.skip_cache(1);
	66	res == 1
	67	}
	68	pub fn peek(&mut self, nbits: u8) -> u32 {
	69	if nbits > 32 { return 0 }
	70	if self.bits < nbits { self.refill(); }
	71	self.read_cache(nbits)
	72	}
	73	pub fn skip(&mut self, nbits: u32) {
	74	if u32::from(self.bits) >= nbits {
	75	self.skip_cache(nbits as u8);
	76	return;
	77	}
	78	let mut skip_bits = nbits - u32::from(self.bits);
	79	self.reset_cache();
	80	self.pos += ((skip_bits / 32) * 4) as usize;
	81	skip_bits &= 0x1F;
	82	self.refill();
	83	if skip_bits > 0 {
	84	self.skip_cache(skip_bits as u8);
	85	}
	86	}
	87	}
	88
	89	impl<'a, S: Copy> CodebookReader<S> for QdmBitReader<'a> {
	90	#[allow(unused_variables)]
	91	fn read_cb(&mut self, cb: &Codebook<S>) -> CodebookResult<S> {
	92	let mut esc = true;
	93	let mut idx = 0;
	94	let mut lut_bits = cb.lut_bits;
	95	while esc {
	96	let lut_idx = (self.peek(lut_bits) as usize) + idx;
	97	if cb.table[lut_idx] == TABLE_FILL_VALUE { return Err(CodebookError::InvalidCode); }
	98	let bits = cb.table[lut_idx] & 0x7F;
	99	esc = (cb.table[lut_idx] & 0x80) != 0;
	100	idx = (cb.table[lut_idx] >> 8) as usize;
	101	let skip_bits = if esc { u32::from(lut_bits) } else { bits };
	102	self.skip(skip_bits);
	103	lut_bits = bits as u8;
	104	}
	105	Ok(cb.syms[idx])
	106	}
	107	}
	108
	109
	110	pub fn to_signed(val: i32) -> i32 {
	111	if (val & 1) != 0 {
	112	(val + 1) >> 1
	113	} else {
	114	-(val >> 1)
	115	}
	116	}
	117
	118	pub trait QdmcCodeReader {
	119	fn read_code(&mut self, cb: &Codebook<u8>) -> DecoderResult<u32>;
	120	fn read_code_long(&mut self, cb: &Codebook<u8>) -> DecoderResult<u32>;
	121	}
	122
	123	impl<'a> QdmcCodeReader for BitReader<'a> {
	124	fn read_code(&mut self, cb: &Codebook<u8>) -> DecoderResult<u32> {
	125	let idx = self.read_cb(cb)?;
	126	if idx > 0 {
	127	Ok(u32::from(idx - 1))
	128	} else {
	129	let len = (self.read(3)? as u8) + 1;
	130	let val = self.read(len)?;
	131	Ok(val)
	132	}
	133	}
	134	fn read_code_long(&mut self, cb: &Codebook<u8>) -> DecoderResult<u32> {
	135	let idx = self.read_code(cb)? as usize;
	136	validate!(idx < ESCAPE_PREFIX.len());
	137	let add = self.read((idx >> 2) as u8)?;
	138	Ok(ESCAPE_PREFIX[idx] + add)
	139	}
	140	}
	141
	142	impl<'a> QdmcCodeReader for QdmBitReader<'a> {
	143	fn read_code(&mut self, cb: &Codebook<u8>) -> DecoderResult<u32> {
	144	let idx = self.read_cb(cb)?;
	145	if idx > 0 {
	146	Ok(u32::from(idx - 1))
	147	} else {
	148	let len = (self.read(3) as u8) + 1;
	149	let val = self.read(len);
	150	Ok(val)
	151	}
	152	}
	153	fn read_code_long(&mut self, cb: &Codebook<u8>) -> DecoderResult<u32> {
	154	let idx = self.read_code(cb)? as usize;
	155	validate!(idx < ESCAPE_PREFIX.len());
	156	let add = self.read((idx >> 2) as u8);
	157	Ok(ESCAPE_PREFIX[idx] + add)
	158	}
	159	}
	160
	161	const ESCAPE_PREFIX: [u32; 65] = [
	162	0x00000, 0x00001, 0x00002, 0x00003, 0x00004, 0x00006, 0x00008, 0x0000A,
	163	0x0000C, 0x00010, 0x00014, 0x00018, 0x0001C, 0x00024, 0x0002C, 0x00034,
	164	0x0003C, 0x0004C, 0x0005C, 0x0006C, 0x0007C, 0x0009C, 0x000BC, 0x000DC,
	165	0x000FC, 0x0013C, 0x0017C, 0x001BC, 0x001FC, 0x0027C, 0x002FC, 0x0037C,
	166	0x003FC, 0x004FC, 0x005FC, 0x006FC, 0x007FC, 0x009FC, 0x00BFC, 0x00DFC,
	167	0x00FFC, 0x013FC, 0x017FC, 0x01BFC, 0x01FFC, 0x027FC, 0x02FFC, 0x037FC,
	168	0x03FFC, 0x04FFC, 0x05FFC, 0x06FFC, 0x07FFC, 0x09FFC, 0x0BFFC, 0x0DFFC,
	169	0x0FFFC, 0x13FFC, 0x17FFC, 0x1BFFC, 0x1FFFC, 0x27FFC, 0x2FFFC, 0x37FFC,
	170	0x3FFFC
	171	];
	172
	173	pub struct RNG {
	174	pub seed: u32,
	175	}
	176
	177	impl RNG {
	178	pub fn new() -> Self { Self { seed: 0 } }
	179	pub fn next(&mut self) -> u32 {
	180	self.seed = self.seed.wrapping_mul(0x343FD).wrapping_add(0x269EC3);
	181	self.seed
	182	}
	183	pub fn next_float(&mut self) -> f32 {
	184	self.next();
	185	((((self.seed >> 16) & 0x7FFF) as f32) - 16384.0) / 16384.0
	186	}
	187	}
	188
	189	#[derive(Clone,Copy)]
	190	pub struct Tone {
	191	pub ch: u8,
	192	pub phase: u8,
	193	pub offset: u8,
	194	pub freq: u16,
	195	pub amp_idx: u8,
	196	}
	197
	198	pub const MAX_TONES: usize = 8192;
	199