nihav-llaudio/src/codecs/wavpack.rs

   1 use nihav_core::codecs::*;
   2 use nihav_core::io::byteio::*;
   3 use nihav_core::io::bitreader::*;
   4 use nihav_core::io::intcode::*;
   5
   6 const SAMPLE_RATES: [u32; 15] = [
   7      6000,  8000,  9600, 11025, 12000, 16000,  22050, 24000,
   8     32000, 44100, 48000, 64000, 88200, 96000, 192000
   9 ];
  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;
  24
  25 const WV_STREAM_FLAGS: u32 = 0x8000008B;
  26
  27 #[derive(Clone,Copy,Default)]
  28 struct WVHeader {
  29     size:           usize,
  30     ver:            u16,
  31     tot_samples:    u64,
  32     block_index:    u64,
  33     block_samples:  u32,
  34     flags:          u32,
  35     crc:            u32,
  36 }
  37
  38 const WV_HEADER_SIZE: usize = 32;
  39
  40 impl WVHeader {
  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()?;
  59         Ok(hdr)
  60     }
  61     fn stream_eq(&self, rval: &Self) -> bool {
  62         self.ver == rval.ver &&
  63         (self.flags & WV_STREAM_FLAGS) == (rval.flags & WV_STREAM_FLAGS)
  64     }
  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
  69     }
  70     fn is_start_block(&self) -> bool {
  71         (self.flags & WV_FLAG_START_BLOCK) != 0
  72     }
  73     fn is_end_block(&self) -> bool {
  74         (self.flags & WV_FLAG_END_BLOCK) != 0
  75     }
  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 }
  78     }
  79     fn get_sample_rate(&self) -> u32 {
  80         let idx = ((self.flags >> 23) & 0xF) as usize;
  81         if idx != 15 {
  82             SAMPLE_RATES[idx]
  83         } else {
  84             0
  85         }
  86     }
  87     fn get_size(&self) -> usize {
  88         self.size - (WV_HEADER_SIZE - 8)
  89     }
  90     fn get_bits(&self) -> u8 {
  91         (((self.flags & 3) + 1) * 8) as u8
  92     }
  93 }
  94
  95 fn wv_log2lin(val: i32) -> i32 {
  96     let sign = val < 0;
  97     let aval = val.abs();
  98     let mant = 0x100 | i32::from(WV_EXP_TABLE[(aval & 0xFF) as usize]);
  99     let exp = aval >> 8;
 100     let aval = if exp >= 9 {
 101             mant << (exp - 9)
 102         } else {
 103             mant >> (9 - exp)
 104         };
 105     if !sign {
 106         aval
 107     } else {
 108         -aval
 109     }
 110 }
 111
 112 fn wv_lin2log(val: u32) -> u32 {
 113     if val == 0 {
 114         0
 115     } else if val == 1 {
 116         0x100
 117     } else {
 118         let val = val + (val >> 9);
 119         let bits = 32 - val.leading_zeros();
 120         if bits < 9 {
 121             (bits << 8) + u32::from(WV_LOG_TABLE[((val << (9 - bits)) & 0xFF) as usize])
 122         } else {
 123             (bits << 8) + u32::from(WV_LOG_TABLE[((val >> (bits - 9)) & 0xFF) as usize])
 124         }
 125     }
 126 }
 127
 128 #[derive(Clone,Copy,Default)]
 129 struct Decorrelator {
 130     delta:      i32,
 131     value:      i32,
 132     weight_a:   i32,
 133     weight_b:   i32,
 134     samples_a:  [i32; 8],
 135     samples_b:  [i32; 8],
 136 }
 137
 138 impl 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]
 144                     } else {
 145                         (3 * self.samples_a[0] - self.samples_a[1]) >> 1
 146                     };
 147                 self.samples_a[1] = self.samples_a[0];
 148                 (a, 0)
 149             } else {
 150                 (self.samples_a[pos], (pos + mode as usize) & 7)
 151             };
 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;
 155         }
 156         self.samples_a[npos] = l2;
 157         l2
 158     }
 159     fn decorrelate_stereo(&mut self, l: i32, r: i32, pos: usize) -> (i32, i32) {
 160         let mode = self.value;
 161         if mode > 0 {
 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])
 166                         } else {
 167                             ((3 * self.samples_a[0] - self.samples_a[1]) >> 1,
 168                              (3 * self.samples_b[0] - self.samples_b[1]) >> 1)
 169                         };
 170                     self.samples_a[1] = self.samples_a[0];
 171                     self.samples_b[1] = self.samples_b[0];
 172                     (a, b, 0)
 173                 } else {
 174                     (self.samples_a[pos], self.samples_b[pos], (pos + mode as usize) & 7)
 175                 };
 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;
 180             }
 181             if (b != 0) && (r != 0) {
 182                 self.weight_b -= ((((r ^ b) >> 30) & 2) - 1) * self.delta;
 183             }
 184             self.samples_a[npos] = l2;
 185             self.samples_b[npos] = r2;
 186             (l2, 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;
 193             (l2, r2)
 194         } else {
 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;
 200                     nr
 201                 } else {
 202                     r2
 203                 };
 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;
 207             (l2, r2)
 208         }
 209     }
 210     fn update_weight_a(&mut self, l: i32, r: i32) {
 211         if (l != 0) && (r != 0) {
 212             if (l ^ r) < 0 {
 213                 self.weight_a = (self.weight_a - self.delta).max(-1024)
 214             } else {
 215                 self.weight_a = (self.weight_a + self.delta).min(1024)
 216             }
 217         }
 218     }
 219     fn update_weight_b(&mut self, l: i32, r: i32) {
 220         if (l != 0) && (r != 0) {
 221             if (l ^ r) < 0 {
 222                 self.weight_b = (self.weight_b - self.delta).max(-1024)
 223             } else {
 224                 self.weight_b = (self.weight_b + self.delta).min(1024)
 225             }
 226         }
 227     }
 228 }
 229
 230 #[derive(Default)]
 231 struct DecState {
 232     median:     [[u32; 3]; 2],
 233     zero:       bool,
 234     one:        bool,
 235     num_zeroes: u32,
 236     ebits:      u8,
 237     shift:      u8,
 238     and:        i32,
 239     or:         i32,
 240     post_shift: u8,
 241     slow_level: [u32; 2],
 242     br_acc:     [u32; 2],
 243     br_delta:   [u32; 2],
 244     hyb_max:    i32,
 245     hyb_min:    i32,
 246     has_hbr:    bool,
 247     stereo:     bool,
 248     error_lim:  [u32; 2],
 249 }
 250
 251 fn read_biased_code(br: &mut BitReader) -> DecoderResult<u32> {
 252     let val                             = br.read_code(UintCodeType::UnaryOnes)?;
 253     validate!(val < 25);
 254     if val < 2 {
 255         Ok(val)
 256     } else {
 257         let bits = val - 1;
 258         Ok((1 << bits) | br.read(bits as u8)?)
 259     }
 260 }
 261 fn read_tail(br: &mut BitReader, bits: u32) -> DecoderResult<u32> {
 262     if bits < 1 {
 263         Ok(0)
 264     } else {
 265         let p = 31 - bits.leading_zeros();
 266         let esc = (1 << (p + 1)) - (bits + 1);
 267         let val                         = br.read(p as u8)?;
 268         if val < esc {
 269             Ok(val)
 270         } else {
 271             Ok(val * 2 - esc + br.read(1)?)
 272         }
 273     }
 274 }
 275
 276 impl DecState {
 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 {
 282                     return Ok(0);
 283                 }
 284             } else {
 285                 self.num_zeroes = read_biased_code(br)?;
 286                 if self.num_zeroes != 0 {
 287                     self.median = [[0; 3]; 2];
 288                     return Ok(0);
 289                 }
 290             }
 291         }
 292         let val = if self.zero {
 293                 self.zero = false;
 294                 0
 295             } else {
 296                 let mut val             = br.read_code(UintCodeType::UnaryOnes)?;
 297                 validate!(val <= 16);
 298                 if val == 16 {
 299                     val += read_biased_code(br)?;
 300                 }
 301                 let one = (val & 1) != 0;
 302                 val >>= 1;
 303                 if self.one {
 304                     val += 1;
 305                 }
 306                 self.one = one;
 307                 self.zero = !one;
 308                 val
 309             };
 310
 311         let (base, add) = match val {
 312                 0 => {
 313                     let add = self.get_median(channel, 0) - 1;
 314                     self.dec_median(channel, 0);
 315                     (0, add)
 316                 },
 317                 1 => {
 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);
 322                     (base, add)
 323                 },
 324                 2 => {
 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);
 330                     (base, add)
 331                 },
 332                 _ => {
 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);
 338                     (base, add)
 339                 },
 340             };
 341         let val = base + read_tail(br, add)?;
 342
 343         if !br.read_bool()? {
 344             Ok(val as i32)
 345         } else {
 346             Ok(!val as i32)
 347         }
 348     }
 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);
 355                     return Ok(0);
 356                 }
 357             } else {
 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);
 362                     return Ok(0);
 363                 }
 364             }
 365         }
 366         let val = if self.zero {
 367                 self.zero = false;
 368                 0
 369             } else {
 370                 let mut val             = br.read_code(UintCodeType::UnaryOnes)?;
 371                 validate!(val <= 16);
 372                 if val == 16 {
 373                     val += read_biased_code(br)?;
 374                 }
 375                 let one = (val & 1) != 0;
 376                 val >>= 1;
 377                 if self.one {
 378                     val += 1;
 379                 }
 380                 self.one = one;
 381                 self.zero = !one;
 382                 val
 383             };
 384
 385         if channel == 0 {
 386             self.update_error_limit();
 387         }
 388
 389         let (mut base, mut add) = match val {
 390                 0 => {
 391                     let add = self.get_median(channel, 0) - 1;
 392                     self.dec_median(channel, 0);
 393                     (0, add)
 394                 },
 395                 1 => {
 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);
 400                     (base, add)
 401                 },
 402                 2 => {
 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);
 408                     (base, add)
 409                 },
 410                 _ => {
 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);
 416                     (base, add)
 417                 },
 418             };
 419         let val = if self.error_lim[channel] == 0 {
 420                 base + read_tail(br, add)?
 421             } else {
 422                 let mut mid = (base * 2 + add + 1) >> 1;
 423                 while add > self.error_lim[channel] {
 424                     if br.read_bool()? {
 425                         add += base;
 426                         add -= mid;
 427                         base = mid;
 428                     } else {
 429                         add = mid - base - 1;
 430                     }
 431                     mid = (base * 2 + add + 1) >> 1;
 432                 }
 433                 mid
 434             };
 435
 436         if self.has_hbr {
 437             self.decay_slev(channel);
 438             self.slow_level[channel] += wv_lin2log(val);
 439         }
 440
 441         if !br.read_bool()? {
 442             Ok(val as i32)
 443         } else {
 444             Ok(!val as i32)
 445         }
 446     }
 447     fn decay_slev(&mut self, channel: usize) {
 448         self.slow_level[channel] -= (self.slow_level[channel] + 0x80) >> 8;
 449     }
 450     fn update_error_limit(&mut self) {
 451         let mut br = [0; 2];
 452         let mut sl = [0; 2];
 453
 454         for i in 0..2 {
 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;
 458         }
 459
 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) {
 463                 br[1] = br[0] << 1;
 464                 br[0] = 0;
 465             } else if -balance > (br[0] as i32) {
 466                 br[0] <<= 1;
 467                 br[1]   = 0;
 468             } else {
 469                 br[1] = ((br[0] as i32) + balance) as u32;
 470                 br[0] = ((br[0] as i32) - balance) as u32;
 471             }
 472         }
 473         for i in 0..2 {
 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
 477                     } else {
 478                         0
 479                     }
 480                 } else {
 481                     wv_log2lin(br[i] as i32) as u32
 482                 };
 483         }
 484     }
 485     fn get_median(&self, channel: usize, idx: usize) -> u32 {
 486         (self.median[channel][idx] >> 4) + 1
 487     }
 488     fn inc_median(&mut self, channel: usize, idx: usize) {
 489         self.median[channel][idx] += ((self.median[channel][idx] + (128 >> idx)) / (128 >> idx)) * 5;
 490     }
 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;
 493     }
 494     fn produce_sample_common(&self, ebr: &mut BitReader, mut samp: i32) -> i32 {
 495         if self.ebits > 0 {
 496             samp <<= self.ebits;
 497             if ebr.left() >= self.ebits as isize {
 498                 samp |=                 ebr.read(self.ebits).unwrap_or(0) as i32;
 499             }
 500         }
 501         let bit = (samp & self.and) | self.or;
 502         ((samp + bit) << self.shift) - bit
 503     }
 504     fn produce_sample(&self, ebr: &mut BitReader, samp: i32) -> i32 {
 505         self.produce_sample_common(ebr, samp) << self.post_shift
 506     }
 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
 509     }
 510 }
 511
 512 struct DecorrState {
 513     decorr:     [Decorrelator; 16],
 514     num_decorr: usize,
 515 }
 516
 517 impl DecorrState {
 518     fn new() -> Self {
 519         Self {
 520             decorr:     [Decorrelator::default(); 16],
 521             num_decorr: 0,
 522         }
 523     }
 524     fn reset(&mut self) {
 525         self.decorr = [Decorrelator::default(); 16];
 526         self.num_decorr = 0;
 527     }
 528 }
 529
 530 struct WavPackDecoder {
 531     ainfo:      NAAudioInfo,
 532     chmap:      NAChannelMap,
 533     header:     WVHeader,
 534
 535     dstate:     DecorrState,
 536 }
 537
 538 fn get_subblock(br: &mut ByteReader) -> DecoderResult<(u8, usize)> {
 539     let id1                             = br.read_byte()?;
 540     let id = id1 & 0x3F;
 541     let mut len = 2 * if (id1 & 0x80) == 0 {
 542                                           br.read_byte()? as usize
 543         } else {
 544                                           br.read_u24le()? as usize
 545         };
 546     if (id1 & 0x40) != 0 {
 547         validate!(len > 0);
 548         len -= 1;
 549     }
 550     Ok((id, len))
 551 }
 552
 553 trait Output {
 554     fn set(&mut self, val: i32);
 555 }
 556
 557 impl Output for i16 {
 558     fn set(&mut self, val: i32) { *self = val as i16; }
 559 }
 560 impl Output for i32 {
 561     fn set(&mut self, val: i32) { *self = val; }
 562 }
 563
 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;
 566
 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);
 571         }
 572         crc = crc.wrapping_mul(3).wrapping_add(l as u32);
 573         l = state.produce_sample(ebr, l);
 574         dst.set(l);
 575     }
 576
 577     Ok(crc)
 578 }
 579
 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;
 583
 584     for i in 0..len {
 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);
 589             l = pl;
 590             r = pr;
 591         }
 592         if is_joint {
 593             r -= l >> 1;
 594             l += r;
 595         }
 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);
 601     }
 602
 603     Ok(crc)
 604 }
 605
 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;
 608
 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);
 613         }
 614         crc = crc.wrapping_mul(3).wrapping_add(l as u32);
 615         l = state.produce_sample_hyb(ebr, l);
 616         dst.set(l);
 617     }
 618
 619     Ok(crc)
 620 }
 621
 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;
 625
 626     for i in 0..len {
 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);
 631             l = pl;
 632             r = pr;
 633         }
 634         if is_joint {
 635             r -= l >> 1;
 636             l += r;
 637         }
 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);
 643     }
 644
 645     Ok(crc)
 646 }
 647
 648 impl WavPackDecoder {
 649     fn new() -> Self {
 650         Self {
 651             ainfo:      NAAudioInfo::new(0, 1, SND_S16P_FORMAT, 0),
 652             chmap:      NAChannelMap::new(),
 653             header:     WVHeader::default(),
 654
 655             dstate:     DecorrState::new(),
 656         }
 657     }
 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();
 673         self.dstate.reset();
 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)?;
 685             match id {
 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);
 693                     }
 694                     has_terms = true;
 695                 },
 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;
 704                         }
 705                         if !is_mono {
 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;
 710                             }
 711                         }
 712                     }
 713                     has_weights = true;
 714                 },
 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 {
 720                             break;
 721                         }
 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));
 727                             if !is_mono {
 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));
 732                             }
 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));
 738                         } else {
 739                             let len = decorr.value as usize;
 740                             for i in 0..len {
 741                                 let a   = br.read_u16le()? as i16;
 742                                 decorr.samples_a[i] = wv_log2lin(i32::from(a));
 743                                 if !is_mono {
 744                                     let b = br.read_u16le()? as i16;
 745                                     decorr.samples_b[i] = wv_log2lin(i32::from(b));
 746                                 }
 747                             }
 748                         }
 749                     }
 750                     has_samples = true;
 751                 },
 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;
 756                     }
 757                     if !is_mono {
 758                         for el in dec_state.median[1].iter_mut() {
 759                             *el         = wv_log2lin(i32::from(br.read_u16le()? as i16)) as u32;
 760                         }
 761                     }
 762                 },
 763                 0x06 => { //hybrid parameters
 764                     validate!(is_hybrid);
 765                     let end = br.tell() + (len as u64);
 766                     if has_hybrid_br {
 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;
 769                         }
 770                     }
 771                     for el in dec_state.br_acc.iter_mut().take(cur_channels) {
 772                         *el             = u32::from(br.read_u16le()?) << 16;
 773                     }
 774                     if br.tell() < end {
 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;
 777                         }
 778                     }
 779                     validate!(br.tell() == end);
 780                     has_hybrid = true;
 781                 },
 782                 0x08 => {
 783                     validate!((hdr.flags & WV_FLAG_FLOATS) != 0);
 784                     return Err(DecoderError::NotImplemented);
 785                 },
 786                 0x09 => {
 787                     validate!((hdr.flags & WV_FLAG_EXT_INTEGERS) != 0);
 788                     validate!(len == 4);
 789                     let ebits           = br.read_byte()?;
 790                     let mode1           = br.read_byte()?;
 791                     let mode2           = br.read_byte()?;
 792                     let mode3           = br.read_byte()?;
 793                     if ebits != 0 {
 794                         dec_state.ebits = ebits;
 795                     } else if mode1 != 0 {
 796                         dec_state.shift = mode1;
 797                     } else if mode2 != 0 {
 798                         dec_state.and = 1;
 799                         dec_state.or  = 1;
 800                         dec_state.shift = mode2;
 801                     } else if mode3 != 0 {
 802                         dec_state.and = 1;
 803                         dec_state.shift = mode3;
 804                     }
 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;
 810                     }
 811                 },
 812                 0x0A => { // normal stream
 813                     validate!(has_samples);
 814                     data_pos = br.tell() as usize;
 815                     data_len = len;
 816                     br.read_skip(len)?;
 817                 },
 818                 0x0C => {
 819                     ebits_pos = br.tell() as usize;
 820                     ebits_len = len;
 821                     br.read_skip(len)?;
 822                 },
 823                 0x0E => return Err(DecoderError::NotImplemented), // DSD
 824                 _ => { br.read_skip(len)?; },
 825             };
 826             if (len & 1) != 0 {
 827                                         br.read_skip(1)?;
 828             }
 829         }
 830         validate!(data_pos > 0 && data_len > 0);
 831         if is_hybrid {
 832             validate!(has_hybrid);
 833         }
 834
 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);
 837         if is_mono {
 838             let is_fstereo = (hdr.flags & WV_FLAG_FALSE_STEREO) != 0;
 839             match abuf {
 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)?
 846                         } else {
 847                             unpack_mono_hyb(&mut br, &mut ebr, &mut dec_state, &mut
 848  self.dstate, &mut dst[off0..], hdr.block_samples as usize)?
 849                         };
 850                     if crc != hdr.crc {
 851                         return Err(DecoderError::ChecksumError);
 852                     }
 853                     if is_fstereo {
 854                         for i in 0..(hdr.block_samples as usize) {
 855                             dst[off1 + i] = dst[off0 + i];
 856                         }
 857                     }
 858                 },
 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)?
 865                         } else {
 866                             unpack_mono_hyb(&mut br, &mut ebr, &mut dec_state, &mut
 867  self.dstate, &mut dst[off0..], hdr.block_samples as usize)?
 868                         };
 869                     if crc != hdr.crc {
 870                         return Err(DecoderError::ChecksumError);
 871                     }
 872                     if is_fstereo {
 873                         for i in 0..(hdr.block_samples as usize) {
 874                             dst[off1 + i] = dst[off0 + i];
 875                         }
 876                     }
 877                 },
 878                 _ => unreachable!(),
 879             }
 880         } else {
 881             let is_joint = (hdr.flags & WV_FLAG_JSTEREO) != 0;
 882             match abuf {
 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)?
 889                         } else {
 890                             unpack_stereo_hyb(&mut br, &mut ebr, &mut dec_state, &mut self.dstate, dst, off0, off1, hdr.block_samples as usize, is_joint)?
 891                         };
 892                     if crc != hdr.crc {
 893                         return Err(DecoderError::ChecksumError);
 894                     }
 895                 },
 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)?
 902                         } else {
 903                             unpack_stereo_hyb(&mut br, &mut ebr, &mut dec_state, &mut self.dstate, dst, off0, off1, hdr.block_samples as usize, is_joint)?
 904                         };
 905                     if crc != hdr.crc {
 906                         return Err(DecoderError::ChecksumError);
 907                     }
 908                 },
 909                 _ => unreachable!(),
 910             }
 911         }
 912
 913         Ok(())
 914     }
 915 }
 916
 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;
 924                 let mut off = 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);
 929                     }
 930                     self.header = hdr;
 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)?;
 937                         match id {
 938                             0xD => {
 939                                 validate!(len > 1);
 940                                 decl_channels = br.read_byte()?;
 941                                 if decl_channels == 0 {
 942                                     return Err(DecoderError::NotImplemented);
 943                                 }
 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),
 950                                     };
 951                             },
 952                             _ =>          br.read_skip(len)?,
 953                         };
 954                         if (len & 1) != 0 {
 955                                           br.read_skip(1)?;
 956                         }
 957                     }
 958                     channels += hdr.get_num_channels();
 959
 960                     if hdr.is_end_block() {
 961                         break;
 962                     }
 963                     off += size;
 964                 }
 965                 if decl_channels != 0 {
 966                     validate!(decl_channels == channels);
 967                 }
 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()
 974                     } else {
 975                         return Err(DecoderError::NotImplemented);
 976                     };
 977                 let bsamps = if self.header.block_samples == 0 {
 978                         self.header.get_sample_rate()
 979                     } else {
 980                         self.header.block_samples
 981                     } as usize;
 982
 983                 let bits = self.header.get_bits();
 984                 let fmt = if (self.header.flags & WV_FLAG_FLOATS) != 0 {
 985                         SND_F32P_FORMAT
 986                     } else if bits <= 16 {
 987                         SND_S16P_FORMAT
 988                     } else {
 989                         SND_S32P_FORMAT
 990                     };
 991
 992                 self.ainfo = NAAudioInfo::new(self.header.get_sample_rate(), channels, fmt, bsamps);
 993                 Ok(())
 994             } else {
 995                 Err(DecoderError::InvalidData)
 996             }
 997         } else {
 998             Err(DecoderError::InvalidData)
 999         }
1000     }
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)?;
1007
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());
1013             }
1014
1015             let mut abuf = alloc_audio_buffer(self.ainfo, refhdr.block_samples as usize, self.chmap.clone())?;
1016             let mut start_ch = 0;
1017             let mut roff = 0;
1018             let mut first = true;
1019             let mut refhdr = WVHeader::default();
1020             loop {
1021                 let hdr = WVHeader::parse(&pktbuf[roff..])?;
1022                 if first {
1023                     validate!(hdr.is_start_block());
1024                     validate!(self.header.stream_eq(&hdr));
1025                     refhdr = hdr;
1026                     first = false;
1027                 } else {
1028                     validate!(refhdr.block_eq(&hdr));
1029                 }
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)?;
1033                 roff += blk_size;
1034                 if hdr.is_end_block() {
1035                     break;
1036                 }
1037                 start_ch += hdr.get_num_channels() as usize;
1038             }
1039             let mut frm = NAFrame::new_from_pkt(pkt, info, abuf);
1040             frm.set_duration(Some(u64::from(refhdr.block_samples)));
1041             Ok(frm.into_ref())
1042         } else {
1043             Err(DecoderError::InvalidData)
1044         }
1045     }
1046     fn flush(&mut self) {
1047     }
1048 }
1049
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 }
1054 }
1055
1056 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
1057     Box::new(WavPackDecoder::new())
1058 }
1059
1060 #[cfg(test)]
1061 mod test {
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
1068     #[test]
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);
1074
1075         test_decoding("wavpack", "wavpack", "assets/LLaudio/wv/8bit-partial.wv", Some(100000), &dmx_reg, &dec_reg,
1076                       ExpectedTestResult::MD5([0x8157bf0f, 0xeb441905, 0xeb6b815d, 0x113480a8]));
1077     }
1078     #[test]
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);
1084
1085         test_decoding("wavpack", "wavpack", "assets/LLaudio/wv/12bit-partial.wv", Some(100000), &dmx_reg, &dec_reg,
1086                       ExpectedTestResult::MD5([0xe5faf18c, 0xbf2d3b12, 0x5b0b8f00, 0x162b805a]));
1087     }
1088     #[test]
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);
1094
1095         test_decoding("wavpack", "wavpack", "assets/LLaudio/wv/16bit-partial.wv", Some(100000), &dmx_reg, &dec_reg,
1096                       ExpectedTestResult::MD5([0xaf31b252, 0xdf8b282a, 0x2dc38947, 0xf64c68a1]));
1097     }
1098     #[test]
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);
1104
1105         test_decoding("wavpack", "wavpack", "assets/LLaudio/wv/24bit-partial.wv", Some(100000), &dmx_reg, &dec_reg,
1106                       ExpectedTestResult::MD5([0xf5649972, 0xfe757241, 0x383d5ded, 0x0176a75b]));
1107     }
1108     #[test]
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);
1114
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]));
1117     }
1118     #[test]
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);
1124
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]));
1127     }
1128 }
1129
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
1163 ];
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
1197 ];