1 use nihav_core::codecs::*;
2 use nihav_core::io::byteio::*;
3 use nihav_core::io::bitreader::*;
4 use nihav_core::io::intcode::*;
6 const SAMPLE_RATES: [u32; 15] = [
7 6000, 8000, 9600, 11025, 12000, 16000, 22050, 24000,
8 32000, 44100, 48000, 64000, 88200, 96000, 192000
10 const WV_FLAG_MONO: u32 = 1 << 2;
11 const WV_FLAG_HYBRID: u32 = 1 << 3;
12 const WV_FLAG_JSTEREO: u32 = 1 << 4;
13 //const WV_FLAG_CH_DECORR: u32 = 1 << 5;
14 //const WV_FLAG_HYB_NOISE_SHAPING: u32 = 1 << 6;
15 const WV_FLAG_FLOATS: u32 = 1 << 7;
16 const WV_FLAG_EXT_INTEGERS: u32 = 1 << 8;
17 const WV_FLAG_HYB_BITRATE: u32 = 1 << 9;
18 //const WV_FLAG_HYB_BALANCED_NOISE: u32 = 1 << 10;
19 const WV_FLAG_START_BLOCK: u32 = 1 << 11;
20 const WV_FLAG_END_BLOCK: u32 = 1 << 12;
21 //const WV_FLAG_HAS_CRC: u32 = 1 << 28;
22 const WV_FLAG_FALSE_STEREO: u32 = 1 << 30;
23 const WV_FLAG_DSD_AUDIO: u32 = 1 << 31;
25 const WV_STREAM_FLAGS: u32 = 0x8000008B;
27 #[derive(Clone,Copy,Default)]
38 const WV_HEADER_SIZE: usize = 32;
41 #[allow(clippy::field_reassign_with_default)]
42 fn parse(src: &[u8]) -> DecoderResult<Self> {
43 let mut mr = MemoryReader::new_read(src);
44 let mut br = ByteReader::new(&mut mr);
45 let tag = br.read_tag()?;
46 validate!(&tag == b"wvpk");
47 let mut hdr = Self::default();
48 hdr.size = br.read_u32le()? as usize;
49 validate!(hdr.size >= 24);
50 hdr.ver = br.read_u16le()?;
51 validate!(hdr.ver >= 0x402 || hdr.ver <= 0x410);
52 let top_idx = br.read_byte()?;
53 let top_samps = br.read_byte()?;
54 hdr.tot_samples = u64::from(br.read_u32le()?) | (u64::from(top_samps) << 32);
55 hdr.block_index = u64::from(br.read_u32le()?) | (u64::from(top_idx) << 32);
56 hdr.block_samples = br.read_u32le()?;
57 hdr.flags = br.read_u32le()?;
58 hdr.crc = br.read_u32le()?;
61 fn stream_eq(&self, rval: &Self) -> bool {
62 self.ver == rval.ver &&
63 (self.flags & WV_STREAM_FLAGS) == (rval.flags & WV_STREAM_FLAGS)
65 fn block_eq(&self, rval: &Self) -> bool {
66 self.stream_eq(rval) && self.block_index == rval.block_index &&
67 self.tot_samples == rval.tot_samples &&
68 self.block_samples == rval.block_samples
70 fn is_start_block(&self) -> bool {
71 (self.flags & WV_FLAG_START_BLOCK) != 0
73 fn is_end_block(&self) -> bool {
74 (self.flags & WV_FLAG_END_BLOCK) != 0
76 fn get_num_channels(&self) -> u8 {
77 if (self.flags & WV_FLAG_MONO) != 0 && (self.flags & WV_FLAG_FALSE_STEREO) == 0 { 1 } else { 2 }
79 fn get_sample_rate(&self) -> u32 {
80 let idx = ((self.flags >> 23) & 0xF) as usize;
87 fn get_size(&self) -> usize {
88 self.size - (WV_HEADER_SIZE - 8)
90 fn get_bits(&self) -> u8 {
91 (((self.flags & 3) + 1) * 8) as u8
95 fn wv_log2lin(val: i32) -> i32 {
98 let mant = 0x100 | i32::from(WV_EXP_TABLE[(aval & 0xFF) as usize]);
100 let aval = if exp >= 9 {
112 fn wv_lin2log(val: u32) -> u32 {
118 let val = val + (val >> 9);
119 let bits = 32 - val.leading_zeros();
121 (bits << 8) + u32::from(WV_LOG_TABLE[((val << (9 - bits)) & 0xFF) as usize])
123 (bits << 8) + u32::from(WV_LOG_TABLE[((val >> (bits - 9)) & 0xFF) as usize])
128 #[derive(Clone,Copy,Default)]
129 struct Decorrelator {
139 fn decorrelate_mono(&mut self, l: i32, pos: usize) -> i32 {
140 let mode = self.value;
141 let (a, npos) = if mode > 8 {
142 let a = if (mode & 1) != 0 {
143 2 * self.samples_a[0] - self.samples_a[1]
145 (3 * self.samples_a[0] - self.samples_a[1]) >> 1
147 self.samples_a[1] = self.samples_a[0];
150 (self.samples_a[pos], (pos + mode as usize) & 7)
152 let l2 = l + ((i64::from(self.weight_a) * i64::from(a) + 512) >> 10) as i32;
153 if (a != 0) && (l != 0) {
154 self.weight_a -= ((((l ^ a) >> 30) & 2) - 1) * self.delta;
156 self.samples_a[npos] = l2;
159 fn decorrelate_stereo(&mut self, l: i32, r: i32, pos: usize) -> (i32, i32) {
160 let mode = self.value;
162 let (a, b, npos) = if mode > 8 {
163 let (a, b) = if (mode & 1) != 0 {
164 (2 * self.samples_a[0] - self.samples_a[1],
165 2 * self.samples_b[0] - self.samples_b[1])
167 ((3 * self.samples_a[0] - self.samples_a[1]) >> 1,
168 (3 * self.samples_b[0] - self.samples_b[1]) >> 1)
170 self.samples_a[1] = self.samples_a[0];
171 self.samples_b[1] = self.samples_b[0];
174 (self.samples_a[pos], self.samples_b[pos], (pos + mode as usize) & 7)
176 let l2 = l + ((i64::from(self.weight_a) * i64::from(a) + 512) >> 10) as i32;
177 let r2 = r + ((i64::from(self.weight_b) * i64::from(b) + 512) >> 10) as i32;
178 if (a != 0) && (l != 0) {
179 self.weight_a -= ((((l ^ a) >> 30) & 2) - 1) * self.delta;
181 if (b != 0) && (r != 0) {
182 self.weight_b -= ((((r ^ b) >> 30) & 2) - 1) * self.delta;
184 self.samples_a[npos] = l2;
185 self.samples_b[npos] = r2;
187 } else if mode == -1 {
188 let l2 = l + ((i64::from(self.weight_a) * i64::from(self.samples_a[0]) + 512) >> 10) as i32;
189 let r2 = r + ((i64::from(self.weight_b) * i64::from(l2) + 512) >> 10) as i32;
190 self.update_weight_a(self.samples_a[0], l);
191 self.update_weight_b(l2, r);
192 self.samples_a[0] = r2;
195 let r2 = r + ((i64::from(self.weight_b) * i64::from(self.samples_b[0]) + 512) >> 10) as i32;
196 self.update_weight_b(self.samples_b[0], r);
197 let rr = if mode == -3 {
198 let nr = self.samples_a[0];
199 self.samples_a[0] = r2;
204 let l2 = l + ((i64::from(self.weight_a) * i64::from(rr) + 512) >> 10) as i32;
205 self.update_weight_a(rr, l);
206 self.samples_b[0] = l2;
210 fn update_weight_a(&mut self, l: i32, r: i32) {
211 if (l != 0) && (r != 0) {
213 self.weight_a = (self.weight_a - self.delta).max(-1024)
215 self.weight_a = (self.weight_a + self.delta).min(1024)
219 fn update_weight_b(&mut self, l: i32, r: i32) {
220 if (l != 0) && (r != 0) {
222 self.weight_b = (self.weight_b - self.delta).max(-1024)
224 self.weight_b = (self.weight_b + self.delta).min(1024)
232 median: [[u32; 3]; 2],
241 slow_level: [u32; 2],
251 fn read_biased_code(br: &mut BitReader) -> DecoderResult<u32> {
252 let val = br.read_code(UintCodeType::UnaryOnes)?;
258 Ok((1 << bits) | br.read(bits as u8)?)
261 fn read_tail(br: &mut BitReader, bits: u32) -> DecoderResult<u32> {
265 let p = 31 - bits.leading_zeros();
266 let esc = (1 << (p + 1)) - (bits + 1);
267 let val = br.read(p as u8)?;
271 Ok(val * 2 - esc + br.read(1)?)
277 fn read_sample(&mut self, br: &mut BitReader, channel: usize) -> DecoderResult<i32> {
278 if (self.median[0][0] < 2) && (self.median[1][0] < 2) && !self.zero && !self.one {
279 if self.num_zeroes > 0 {
280 self.num_zeroes -= 1;
281 if self.num_zeroes != 0 {
285 self.num_zeroes = read_biased_code(br)?;
286 if self.num_zeroes != 0 {
287 self.median = [[0; 3]; 2];
292 let val = if self.zero {
296 let mut val = br.read_code(UintCodeType::UnaryOnes)?;
297 validate!(val <= 16);
299 val += read_biased_code(br)?;
301 let one = (val & 1) != 0;
311 let (base, add) = match val {
313 let add = self.get_median(channel, 0) - 1;
314 self.dec_median(channel, 0);
318 let base = self.get_median(channel, 0);
319 let add = self.get_median(channel, 1) - 1;
320 self.inc_median(channel, 0);
321 self.dec_median(channel, 1);
325 let base = self.get_median(channel, 0) + self.get_median(channel, 1);
326 let add = self.get_median(channel, 2) - 1;
327 self.inc_median(channel, 0);
328 self.inc_median(channel, 1);
329 self.dec_median(channel, 2);
333 let base = self.get_median(channel, 0) + self.get_median(channel, 1) + self.get_median(channel, 2) * (val - 2);
334 let add = self.get_median(channel, 2) - 1;
335 self.inc_median(channel, 0);
336 self.inc_median(channel, 1);
337 self.inc_median(channel, 2);
341 let val = base + read_tail(br, add)?;
343 if !br.read_bool()? {
349 fn read_sample_hyb(&mut self, br: &mut BitReader, channel: usize) -> DecoderResult<i32> {
350 if (self.median[0][0] < 2) && (self.median[1][0] < 2) && !self.zero && !self.one {
351 if self.num_zeroes > 0 {
352 self.num_zeroes -= 1;
353 if self.num_zeroes != 0 {
354 self.decay_slev(channel);
358 self.num_zeroes = read_biased_code(br)?;
359 if self.num_zeroes != 0 {
360 self.median = [[0; 3]; 2];
361 self.decay_slev(channel);
366 let val = if self.zero {
370 let mut val = br.read_code(UintCodeType::UnaryOnes)?;
371 validate!(val <= 16);
373 val += read_biased_code(br)?;
375 let one = (val & 1) != 0;
386 self.update_error_limit();
389 let (mut base, mut add) = match val {
391 let add = self.get_median(channel, 0) - 1;
392 self.dec_median(channel, 0);
396 let base = self.get_median(channel, 0);
397 let add = self.get_median(channel, 1) - 1;
398 self.inc_median(channel, 0);
399 self.dec_median(channel, 1);
403 let base = self.get_median(channel, 0) + self.get_median(channel, 1);
404 let add = self.get_median(channel, 2) - 1;
405 self.inc_median(channel, 0);
406 self.inc_median(channel, 1);
407 self.dec_median(channel, 2);
411 let base = self.get_median(channel, 0) + self.get_median(channel, 1) + self.get_median(channel, 2) * (val - 2);
412 let add = self.get_median(channel, 2) - 1;
413 self.inc_median(channel, 0);
414 self.inc_median(channel, 1);
415 self.inc_median(channel, 2);
419 let val = if self.error_lim[channel] == 0 {
420 base + read_tail(br, add)?
422 let mut mid = (base * 2 + add + 1) >> 1;
423 while add > self.error_lim[channel] {
429 add = mid - base - 1;
431 mid = (base * 2 + add + 1) >> 1;
437 self.decay_slev(channel);
438 self.slow_level[channel] += wv_lin2log(val);
441 if !br.read_bool()? {
447 fn decay_slev(&mut self, channel: usize) {
448 self.slow_level[channel] -= (self.slow_level[channel] + 0x80) >> 8;
450 fn update_error_limit(&mut self) {
455 self.br_acc[i] += self.br_delta[i];
456 br[i] = self.br_acc[i] >> 16;
457 sl[i] = (self.slow_level[i] + 0x80) >> 8;
460 if self.stereo && self.has_hbr {
461 let balance = ((sl[1] as i32) - (sl[0] as i32) + (br[1] as i32) + 1) >> 1;
462 if balance > (br[0] as i32) {
465 } else if -balance > (br[0] as i32) {
469 br[1] = ((br[0] as i32) + balance) as u32;
470 br[0] = ((br[0] as i32) - balance) as u32;
474 self.error_lim[i] = if self.has_hbr {
475 if sl[i] + 0x100 > br[i] {
476 wv_log2lin((sl[i] + 0x100 - br[i]) as i32) as u32
481 wv_log2lin(br[i] as i32) as u32
485 fn get_median(&self, channel: usize, idx: usize) -> u32 {
486 (self.median[channel][idx] >> 4) + 1
488 fn inc_median(&mut self, channel: usize, idx: usize) {
489 self.median[channel][idx] += ((self.median[channel][idx] + (128 >> idx)) / (128 >> idx)) * 5;
491 fn dec_median(&mut self, channel: usize, idx: usize) {
492 self.median[channel][idx] -= ((self.median[channel][idx] + (128 >> idx) - 2) / (128 >> idx)) * 2;
494 fn produce_sample_common(&self, ebr: &mut BitReader, mut samp: i32) -> i32 {
497 if ebr.left() >= self.ebits as isize {
498 samp |= ebr.read(self.ebits).unwrap_or(0) as i32;
501 let bit = (samp & self.and) | self.or;
502 ((samp + bit) << self.shift) - bit
504 fn produce_sample(&self, ebr: &mut BitReader, samp: i32) -> i32 {
505 self.produce_sample_common(ebr, samp) << self.post_shift
507 fn produce_sample_hyb(&self, ebr: &mut BitReader, samp: i32) -> i32 {
508 self.produce_sample_common(ebr, samp).max(self.hyb_min).min(self.hyb_max) << self.post_shift
513 decorr: [Decorrelator; 16],
520 decorr: [Decorrelator::default(); 16],
524 fn reset(&mut self) {
525 self.decorr = [Decorrelator::default(); 16];
530 struct WavPackDecoder {
538 fn get_subblock(br: &mut ByteReader) -> DecoderResult<(u8, usize)> {
539 let id1 = br.read_byte()?;
541 let mut len = 2 * if (id1 & 0x80) == 0 {
542 br.read_byte()? as usize
544 br.read_u24le()? as usize
546 if (id1 & 0x40) != 0 {
554 fn set(&mut self, val: i32);
557 impl Output for i16 {
558 fn set(&mut self, val: i32) { *self = val as i16; }
560 impl Output for i32 {
561 fn set(&mut self, val: i32) { *self = val; }
564 fn unpack_mono<T: Output+Copy>(br: &mut BitReader, ebr: &mut BitReader, state: &mut DecState, decorr: &mut DecorrState, dst: &mut [T], len: usize) -> DecoderResult<u32> {
565 let mut crc = 0xFFFFFFFFu32;
567 for (i, dst) in dst[..len].iter_mut().enumerate() {
568 let mut l = state.read_sample(br, 0)?;
569 for decorr in decorr.decorr[..decorr.num_decorr].iter_mut() {
570 l = decorr.decorrelate_mono(l, i & 7);
572 crc = crc.wrapping_mul(3).wrapping_add(l as u32);
573 l = state.produce_sample(ebr, l);
580 #[allow(clippy::too_many_arguments)]
581 fn unpack_stereo<T: Output+Copy>(br: &mut BitReader, ebr: &mut BitReader, state: &mut DecState, decorr: &mut DecorrState, dst: &mut [T], off0: usize, off1: usize, len: usize, is_joint: bool) -> DecoderResult<u32> {
582 let mut crc = 0xFFFFFFFFu32;
585 let mut l = state.read_sample(br, 0)?;
586 let mut r = state.read_sample(br, 1)?;
587 for decorr in decorr.decorr[..decorr.num_decorr].iter_mut() {
588 let (pl, pr) = decorr.decorrelate_stereo(l, r, i & 7);
596 crc = crc.wrapping_mul(3).wrapping_add(l as u32).wrapping_mul(3).wrapping_add(r as u32);
597 l = state.produce_sample(ebr, l);
598 r = state.produce_sample(ebr, r);
599 dst[off0 + i].set(l);
600 dst[off1 + i].set(r);
606 fn unpack_mono_hyb<T: Output+Copy>(br: &mut BitReader, ebr: &mut BitReader, state: &mut DecState, decorr: &mut DecorrState, dst: &mut [T], len: usize) -> DecoderResult<u32> {
607 let mut crc = 0xFFFFFFFFu32;
609 for (i, dst) in dst[..len].iter_mut().enumerate() {
610 let mut l = state.read_sample_hyb(br, 0)?;
611 for decorr in decorr.decorr[..decorr.num_decorr].iter_mut() {
612 l = decorr.decorrelate_mono(l, i & 7);
614 crc = crc.wrapping_mul(3).wrapping_add(l as u32);
615 l = state.produce_sample_hyb(ebr, l);
622 #[allow(clippy::too_many_arguments)]
623 fn unpack_stereo_hyb<T: Output+Copy>(br: &mut BitReader, ebr: &mut BitReader, state: &mut DecState, decorr: &mut DecorrState, dst: &mut [T], off0: usize, off1: usize, len: usize, is_joint: bool) -> DecoderResult<u32> {
624 let mut crc = 0xFFFFFFFFu32;
627 let mut l = state.read_sample_hyb(br, 0)?;
628 let mut r = state.read_sample_hyb(br, 1)?;
629 for decorr in decorr.decorr[..decorr.num_decorr].iter_mut() {
630 let (pl, pr) = decorr.decorrelate_stereo(l, r, i & 7);
638 crc = crc.wrapping_mul(3).wrapping_add(l as u32).wrapping_mul(3).wrapping_add(r as u32);
639 l = state.produce_sample_hyb(ebr, l);
640 r = state.produce_sample_hyb(ebr, r);
641 dst[off0 + i].set(l);
642 dst[off1 + i].set(r);
648 impl WavPackDecoder {
651 ainfo: NAAudioInfo::new(0, 1, SND_S16P_FORMAT, 0),
652 chmap: NAChannelMap::new(),
653 header: WVHeader::default(),
655 dstate: DecorrState::new(),
658 #[allow(clippy::cognitive_complexity)]
659 fn decode_block(&mut self, hdr: &WVHeader, src: &[u8], start_ch: usize, abuf: &mut NABufferType) -> DecoderResult<()> {
660 let mut mr = MemoryReader::new_read(src);
661 let mut br = ByteReader::new(&mut mr);
662 let mut has_terms = false;
663 let mut has_weights = false;
664 let mut has_samples = false;
665 let mut has_hybrid = false;
666 let is_mono = (hdr.flags & (WV_FLAG_MONO | WV_FLAG_FALSE_STEREO)) != 0;
667 let cur_channels = if is_mono { 1 } else { 2 };
668 let mut data_pos = 0;
669 let mut data_len = 0;
670 let mut ebits_pos = 0;
671 let mut ebits_len = 0;
672 let mut dec_state = DecState::default();
674 dec_state.post_shift = if (hdr.get_bits() & 8) != 0 { 8 } else { 0 };
675 dec_state.post_shift += ((hdr.flags >> 13) & 0x1F) as u8;
676 validate!(dec_state.post_shift < 32);
677 dec_state.hyb_max = 0x7FFFFFFF >> (32 - hdr.get_bits());
678 dec_state.hyb_min = -dec_state.hyb_max - 1;
679 let is_hybrid = (hdr.flags & WV_FLAG_HYBRID) != 0;
680 let has_hybrid_br = (hdr.flags & WV_FLAG_HYB_BITRATE) != 0;
681 dec_state.has_hbr = has_hybrid_br;
682 dec_state.stereo = !is_mono;
683 while br.left() > 0 {
684 let (id, len) = get_subblock(&mut br)?;
686 0x02 => { //decorr terms
687 self.dstate.num_decorr = len;
688 validate!(self.dstate.num_decorr <= self.dstate.decorr.len());
689 for decorr in self.dstate.decorr[..self.dstate.num_decorr].iter_mut().rev() {
690 let val = br.read_byte()?;
691 decorr.value = i32::from(val & 0x1F) - 5;
692 decorr.delta = i32::from(val >> 5);
696 0x03 => { //decorr weights
697 validate!(has_terms);
698 validate!(len <= self.dstate.num_decorr * cur_channels);
699 for decorr in self.dstate.decorr[..self.dstate.num_decorr].iter_mut().rev().take(len / cur_channels) {
700 let val = br.read_byte()? as i8;
701 decorr.weight_a = i32::from(val) << 3;
702 if decorr.weight_a > 0 {
703 decorr.weight_a += (decorr.weight_a + 64) >> 7;
706 let val = br.read_byte()? as i8;
707 decorr.weight_b = i32::from(val) << 3;
708 if decorr.weight_b > 0 {
709 decorr.weight_b += (decorr.weight_b + 64) >> 7;
715 0x04 => { //decorr samples
716 validate!(has_weights);
717 let end = br.tell() + (len as u64);
718 for decorr in self.dstate.decorr[..self.dstate.num_decorr].iter_mut().rev() {
719 if br.tell() == end {
722 if decorr.value > 8 {
723 let a0 = br.read_u16le()? as i16;
724 let a1 = br.read_u16le()? as i16;
725 decorr.samples_a[0] = wv_log2lin(i32::from(a0));
726 decorr.samples_a[1] = wv_log2lin(i32::from(a1));
728 let b0 = br.read_u16le()? as i16;
729 let b1 = br.read_u16le()? as i16;
730 decorr.samples_b[0] = wv_log2lin(i32::from(b0));
731 decorr.samples_b[1] = wv_log2lin(i32::from(b1));
733 } else if decorr.value < 0 {
734 let a0 = br.read_u16le()? as i16;
735 let b0 = br.read_u16le()? as i16;
736 decorr.samples_a[0] = wv_log2lin(i32::from(a0));
737 decorr.samples_b[0] = wv_log2lin(i32::from(b0));
739 let len = decorr.value as usize;
741 let a = br.read_u16le()? as i16;
742 decorr.samples_a[i] = wv_log2lin(i32::from(a));
744 let b = br.read_u16le()? as i16;
745 decorr.samples_b[i] = wv_log2lin(i32::from(b));
752 0x05 => { //entropy vars
753 validate!(len == 6 * cur_channels);
754 for el in dec_state.median[0].iter_mut() {
755 *el = wv_log2lin(i32::from(br.read_u16le()? as i16)) as u32;
758 for el in dec_state.median[1].iter_mut() {
759 *el = wv_log2lin(i32::from(br.read_u16le()? as i16)) as u32;
763 0x06 => { //hybrid parameters
764 validate!(is_hybrid);
765 let end = br.tell() + (len as u64);
767 for el in dec_state.slow_level.iter_mut().take(cur_channels) {
768 *el = wv_log2lin(i32::from(br.read_u16le()? as i16)) as u32;
771 for el in dec_state.br_acc.iter_mut().take(cur_channels) {
772 *el = u32::from(br.read_u16le()?) << 16;
775 for el in dec_state.br_delta.iter_mut().take(cur_channels) {
776 *el = wv_log2lin(i32::from(br.read_u16le()? as i16)) as u32;
779 validate!(br.tell() == end);
783 validate!((hdr.flags & WV_FLAG_FLOATS) != 0);
784 return Err(DecoderError::NotImplemented);
787 validate!((hdr.flags & WV_FLAG_EXT_INTEGERS) != 0);
789 let ebits = br.read_byte()?;
790 let mode1 = br.read_byte()?;
791 let mode2 = br.read_byte()?;
792 let mode3 = br.read_byte()?;
794 dec_state.ebits = ebits;
795 } else if mode1 != 0 {
796 dec_state.shift = mode1;
797 } else if mode2 != 0 {
800 dec_state.shift = mode2;
801 } else if mode3 != 0 {
803 dec_state.shift = mode3;
805 if is_hybrid && hdr.get_bits() == 32 && dec_state.post_shift < 8 && dec_state.shift > 8 {
806 dec_state.post_shift += 8;
807 dec_state.shift -= 8;
808 dec_state.hyb_min >>= 8;
809 dec_state.hyb_max >>= 8;
812 0x0A => { // normal stream
813 validate!(has_samples);
814 data_pos = br.tell() as usize;
819 ebits_pos = br.tell() as usize;
823 0x0E => return Err(DecoderError::NotImplemented), // DSD
824 _ => { br.read_skip(len)?; },
830 validate!(data_pos > 0 && data_len > 0);
832 validate!(has_hybrid);
835 let mut br = BitReader::new(&src[data_pos..][..data_len], BitReaderMode::LE);
836 let mut ebr = BitReader::new(&src[ebits_pos..][..ebits_len], BitReaderMode::LE);
838 let is_fstereo = (hdr.flags & WV_FLAG_FALSE_STEREO) != 0;
840 NABufferType::AudioI16(ref mut adata) => {
841 let off0 = adata.get_offset(start_ch);
842 let off1 = adata.get_offset(start_ch + 1);
843 let dst = adata.get_data_mut().unwrap();
844 let crc = if !is_hybrid {
845 unpack_mono(&mut br, &mut ebr, &mut dec_state, &mut self.dstate, &mut dst[off0..], hdr.block_samples as usize)?
847 unpack_mono_hyb(&mut br, &mut ebr, &mut dec_state, &mut
848 self.dstate, &mut dst[off0..], hdr.block_samples as usize)?
851 return Err(DecoderError::ChecksumError);
854 for i in 0..(hdr.block_samples as usize) {
855 dst[off1 + i] = dst[off0 + i];
859 NABufferType::AudioI32(ref mut adata) => {
860 let off0 = adata.get_offset(start_ch);
861 let off1 = adata.get_offset(start_ch + 1);
862 let dst = adata.get_data_mut().unwrap();
863 let crc = if !is_hybrid {
864 unpack_mono(&mut br, &mut ebr, &mut dec_state, &mut self.dstate, &mut dst[off0..], hdr.block_samples as usize)?
866 unpack_mono_hyb(&mut br, &mut ebr, &mut dec_state, &mut
867 self.dstate, &mut dst[off0..], hdr.block_samples as usize)?
870 return Err(DecoderError::ChecksumError);
873 for i in 0..(hdr.block_samples as usize) {
874 dst[off1 + i] = dst[off0 + i];
881 let is_joint = (hdr.flags & WV_FLAG_JSTEREO) != 0;
883 NABufferType::AudioI16(ref mut adata) => {
884 let off0 = adata.get_offset(start_ch);
885 let off1 = adata.get_offset(start_ch + 1);
886 let dst = adata.get_data_mut().unwrap();
887 let crc = if !is_hybrid {
888 unpack_stereo(&mut br, &mut ebr, &mut dec_state, &mut self.dstate, dst, off0, off1, hdr.block_samples as usize, is_joint)?
890 unpack_stereo_hyb(&mut br, &mut ebr, &mut dec_state, &mut self.dstate, dst, off0, off1, hdr.block_samples as usize, is_joint)?
893 return Err(DecoderError::ChecksumError);
896 NABufferType::AudioI32(ref mut adata) => {
897 let off0 = adata.get_offset(start_ch);
898 let off1 = adata.get_offset(start_ch + 1);
899 let dst = adata.get_data_mut().unwrap();
900 let crc = if !is_hybrid {
901 unpack_stereo(&mut br, &mut ebr, &mut dec_state, &mut self.dstate, dst, off0, off1, hdr.block_samples as usize, is_joint)?
903 unpack_stereo_hyb(&mut br, &mut ebr, &mut dec_state, &mut self.dstate, dst, off0, off1, hdr.block_samples as usize, is_joint)?
906 return Err(DecoderError::ChecksumError);
917 impl NADecoder for WavPackDecoder {
918 fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
919 if let NACodecTypeInfo::Audio(_ainfo) = info.get_properties() {
920 if let Some(buf) = info.get_extradata() {
921 let mut channels = 0;
922 let mut decl_channels = 0;
923 let mut channel_map = 0;
925 while off < buf.len() {
926 let hdr = WVHeader::parse(&buf[off..])?;
927 if (hdr.flags & (WV_FLAG_FLOATS | WV_FLAG_DSD_AUDIO)) != 0 {
928 return Err(DecoderError::NotImplemented);
931 off += WV_HEADER_SIZE;
932 let size = hdr.get_size();
933 let mut mr = MemoryReader::new_read(&buf[off..][..size]);
934 let mut br = ByteReader::new(&mut mr);
935 while br.left() > 0 {
936 let (id, len) = get_subblock(&mut br)?;
940 decl_channels = br.read_byte()?;
941 if decl_channels == 0 {
942 return Err(DecoderError::NotImplemented);
944 channel_map = match len {
945 2 => u32::from(br.read_byte()?),
946 3 => u32::from(br.read_u16le()?),
947 4 => br.read_u24le()?,
948 5 => br.read_u32le()?,
949 _ => return Err(DecoderError::NotImplemented),
952 _ => br.read_skip(len)?,
958 channels += hdr.get_num_channels();
960 if hdr.is_end_block() {
965 if decl_channels != 0 {
966 validate!(decl_channels == channels);
968 self.chmap = if channel_map != 0 {
969 NAChannelMap::from_ms_mapping(channel_map)
970 } else if channels == 1 {
971 NAChannelMap::from_str("C").unwrap()
972 } else if channels == 2 {
973 NAChannelMap::from_str("L,R").unwrap()
975 return Err(DecoderError::NotImplemented);
977 let bsamps = if self.header.block_samples == 0 {
978 self.header.get_sample_rate()
980 self.header.block_samples
983 let bits = self.header.get_bits();
984 let fmt = if (self.header.flags & WV_FLAG_FLOATS) != 0 {
986 } else if bits <= 16 {
992 self.ainfo = NAAudioInfo::new(self.header.get_sample_rate(), channels, fmt, bsamps);
995 Err(DecoderError::InvalidData)
998 Err(DecoderError::InvalidData)
1001 fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
1002 let info = pkt.get_stream().get_info();
1003 if let NACodecTypeInfo::Audio(_) = info.get_properties() {
1004 let pktbuf = pkt.get_buffer();
1005 validate!(pktbuf.len() > WV_HEADER_SIZE);
1006 let refhdr = WVHeader::parse(&pktbuf)?;
1008 if refhdr.block_samples == 0 {
1009 let mut frm = NAFrame::new_from_pkt(pkt, info, NABufferType::None);
1010 frm.set_frame_type(FrameType::Skip);
1011 frm.set_keyframe(false);
1012 return Ok(frm.into_ref());
1015 let mut abuf = alloc_audio_buffer(self.ainfo, refhdr.block_samples as usize, self.chmap.clone())?;
1016 let mut start_ch = 0;
1018 let mut first = true;
1019 let mut refhdr = WVHeader::default();
1021 let hdr = WVHeader::parse(&pktbuf[roff..])?;
1023 validate!(hdr.is_start_block());
1024 validate!(self.header.stream_eq(&hdr));
1028 validate!(refhdr.block_eq(&hdr));
1030 roff += WV_HEADER_SIZE;
1031 let blk_size = hdr.get_size();
1032 self.decode_block(&hdr, &pktbuf[roff..][..blk_size], start_ch, &mut abuf)?;
1034 if hdr.is_end_block() {
1037 start_ch += hdr.get_num_channels() as usize;
1039 let mut frm = NAFrame::new_from_pkt(pkt, info, abuf);
1040 frm.set_duration(Some(u64::from(refhdr.block_samples)));
1043 Err(DecoderError::InvalidData)
1046 fn flush(&mut self) {
1050 impl NAOptionHandler for WavPackDecoder {
1051 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
1052 fn set_options(&mut self, _options: &[NAOption]) { }
1053 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
1056 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
1057 Box::new(WavPackDecoder::new())
1062 use nihav_core::codecs::RegisteredDecoders;
1063 use nihav_core::demuxers::RegisteredDemuxers;
1064 use nihav_codec_support::test::dec_video::*;
1065 use crate::llaudio_register_all_decoders;
1066 use crate::llaudio_register_all_demuxers;
1067 // samples come from the official WavPack test samples set
1069 fn test_wavpack_8bit() {
1070 let mut dmx_reg = RegisteredDemuxers::new();
1071 llaudio_register_all_demuxers(&mut dmx_reg);
1072 let mut dec_reg = RegisteredDecoders::new();
1073 llaudio_register_all_decoders(&mut dec_reg);
1075 test_decoding("wavpack", "wavpack", "assets/LLaudio/wv/8bit-partial.wv", Some(100000), &dmx_reg, &dec_reg,
1076 ExpectedTestResult::MD5([0x8157bf0f, 0xeb441905, 0xeb6b815d, 0x113480a8]));
1079 fn test_wavpack_12bit() {
1080 let mut dmx_reg = RegisteredDemuxers::new();
1081 llaudio_register_all_demuxers(&mut dmx_reg);
1082 let mut dec_reg = RegisteredDecoders::new();
1083 llaudio_register_all_decoders(&mut dec_reg);
1085 test_decoding("wavpack", "wavpack", "assets/LLaudio/wv/12bit-partial.wv", Some(100000), &dmx_reg, &dec_reg,
1086 ExpectedTestResult::MD5([0xe5faf18c, 0xbf2d3b12, 0x5b0b8f00, 0x162b805a]));
1089 fn test_wavpack_16bit() {
1090 let mut dmx_reg = RegisteredDemuxers::new();
1091 llaudio_register_all_demuxers(&mut dmx_reg);
1092 let mut dec_reg = RegisteredDecoders::new();
1093 llaudio_register_all_decoders(&mut dec_reg);
1095 test_decoding("wavpack", "wavpack", "assets/LLaudio/wv/16bit-partial.wv", Some(100000), &dmx_reg, &dec_reg,
1096 ExpectedTestResult::MD5([0xaf31b252, 0xdf8b282a, 0x2dc38947, 0xf64c68a1]));
1099 fn test_wavpack_24bit() {
1100 let mut dmx_reg = RegisteredDemuxers::new();
1101 llaudio_register_all_demuxers(&mut dmx_reg);
1102 let mut dec_reg = RegisteredDecoders::new();
1103 llaudio_register_all_decoders(&mut dec_reg);
1105 test_decoding("wavpack", "wavpack", "assets/LLaudio/wv/24bit-partial.wv", Some(100000), &dmx_reg, &dec_reg,
1106 ExpectedTestResult::MD5([0xf5649972, 0xfe757241, 0x383d5ded, 0x0176a75b]));
1109 fn test_wavpack_hybrid() {
1110 let mut dmx_reg = RegisteredDemuxers::new();
1111 llaudio_register_all_demuxers(&mut dmx_reg);
1112 let mut dec_reg = RegisteredDecoders::new();
1113 llaudio_register_all_decoders(&mut dec_reg);
1115 test_decoding("wavpack", "wavpack", "assets/LLaudio/wv/4.0_16-bit.wv", Some(100000), &dmx_reg, &dec_reg,
1116 ExpectedTestResult::MD5([0x9cfa469a, 0x54af50e1, 0xe45434d1, 0x1bf987e2]));
1119 fn test_wavpack_hybrid_32bit() {
1120 let mut dmx_reg = RegisteredDemuxers::new();
1121 llaudio_register_all_demuxers(&mut dmx_reg);
1122 let mut dec_reg = RegisteredDecoders::new();
1123 llaudio_register_all_decoders(&mut dec_reg);
1125 test_decoding("wavpack", "wavpack", "assets/LLaudio/wv/4.0_32-bit_int.wv", Some(100000), &dmx_reg, &dec_reg,
1126 ExpectedTestResult::MD5([0x21415549, 0xf48ddb55, 0xef5c4e7f, 0xa48d5ab9]));
1130 const WV_EXP_TABLE: [u8; 256] = [
1131 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05,
1132 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
1133 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10,
1134 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
1135 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
1136 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
1137 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29,
1138 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
1139 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36,
1140 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
1141 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44,
1142 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
1143 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52,
1144 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
1145 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61,
1146 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
1147 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71,
1148 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
1149 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81,
1150 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
1151 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92,
1152 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
1153 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
1154 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
1155 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7,
1156 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
1157 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca,
1158 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
1159 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde,
1160 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
1161 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4,
1162 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
1164 const WV_LOG_TABLE: [u8; 256] = [
1165 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a,
1166 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
1167 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20,
1168 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
1169 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34,
1170 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
1171 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48,
1172 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
1173 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
1174 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
1175 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c,
1176 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
1177 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d,
1178 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
1179 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d,
1180 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
1181 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c,
1182 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
1183 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab,
1184 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
1185 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9,
1186 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
1187 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7,
1188 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
1189 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4,
1190 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
1191 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1,
1192 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
1193 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee,
1194 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
1195 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9,
1196 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff