nihav-mpeg/src/codecs/aac/sbr/bs.rs

   1 use nihav_core::codecs::{DecoderResult, DecoderError};
   2 use nihav_core::io::bitreader::*;
   3 use nihav_core::io::codebook::*;
   4
   5 use super::{MAX_SLOTS, NUM_ENVELOPES, SBR_BANDS, SBRState, SBRChannel};
   6 use super::synth::QuantMode;
   7
   8 #[derive(Clone,Copy,Debug,PartialEq)]
   9 pub enum FrameClass {
  10     FixFix,
  11     FixVar,
  12     VarFix,
  13     VarVar,
  14 }
  15
  16 impl FrameClass {
  17     fn read(br: &mut BitReader) -> DecoderResult<Self> {
  18         Ok(match br.read(2)? {
  19             0 => Self::FixFix,
  20             1 => Self::FixVar,
  21             2 => Self::VarFix,
  22             _ => Self::VarVar,
  23         })
  24     }
  25 }
  26
  27 pub fn sbr_read_sce(br: &mut BitReader, orig_amp_res: bool, state: &SBRState, cbs: &SBRCodebooks, ch: &mut SBRChannel) -> DecoderResult<()> {
  28     ch.qmode = QuantMode::Single;
  29     if br.read_bool()? {
  30                                           br.skip(4)?;
  31     }
  32     read_grid(br, ch)?;
  33     read_dtdf(br, ch)?;
  34     read_invf(br, ch, state)?;
  35     ch.set_amp_res(orig_amp_res);
  36     read_envelope(br, ch, false, cbs, state)?;
  37     read_noise(br, ch, false, cbs, state)?;
  38     read_sinusoidal_coding(br, ch, state)?;
  39     read_extensions(br)?;
  40
  41     Ok(())
  42 }
  43 pub fn sbr_read_cpe(br: &mut BitReader, orig_amp_res: bool, state: &SBRState, cbs: &SBRCodebooks, ch: &mut [SBRChannel; 2]) -> DecoderResult<()> {
  44     if br.read_bool()? {
  45                                           br.skip(4)?;
  46                                           br.skip(4)?;
  47     }
  48     let coupling                        = br.read_bool()?;
  49     if coupling {
  50         ch[0].qmode = QuantMode::Left;
  51         ch[1].qmode = QuantMode::Right;
  52         read_grid(br, &mut ch[0])?;
  53         ch[1].fclass            = ch[0].fclass;
  54         ch[1].num_env           = ch[0].num_env;
  55         ch[1].env_border        = ch[0].env_border;
  56         ch[1].freq_res          = ch[0].freq_res;
  57         ch[1].pointer           = ch[0].pointer;
  58         ch[1].num_noise         = ch[0].num_noise;
  59         ch[1].noise_env_border  = ch[0].noise_env_border;
  60
  61         read_dtdf(br, &mut ch[0])?;
  62         read_dtdf(br, &mut ch[1])?;
  63         read_invf(br, &mut ch[0], state)?;
  64         ch[1].invf_mode = ch[0].invf_mode;
  65
  66         ch[0].set_amp_res(orig_amp_res);
  67         read_envelope(br, &mut ch[0], false, cbs, state)?;
  68         read_noise(br, &mut ch[0], false, cbs, state)?;
  69         ch[1].set_amp_res(orig_amp_res);
  70         read_envelope(br, &mut ch[1], true, cbs, state)?;
  71         read_noise(br, &mut ch[1], true, cbs, state)?;
  72
  73         ch[0].data_env2   = ch[1].data_env;
  74         ch[0].data_noise2 = ch[1].data_noise;
  75         ch[1].data_env2   = ch[0].data_env;
  76         ch[1].data_noise2 = ch[0].data_noise;
  77     } else {
  78         ch[0].qmode = QuantMode::Single;
  79         ch[1].qmode = QuantMode::Single;
  80         read_grid(br, &mut ch[0])?;
  81         read_grid(br, &mut ch[1])?;
  82         read_dtdf(br, &mut ch[0])?;
  83         read_dtdf(br, &mut ch[1])?;
  84         read_invf(br, &mut ch[0], state)?;
  85         read_invf(br, &mut ch[1], state)?;
  86
  87         ch[0].set_amp_res(orig_amp_res);
  88         read_envelope(br, &mut ch[0], false, cbs, state)?;
  89         ch[1].set_amp_res(orig_amp_res);
  90         read_envelope(br, &mut ch[1], false, cbs, state)?;
  91         read_noise(br, &mut ch[0], false, cbs, state)?;
  92         read_noise(br, &mut ch[1], false, cbs, state)?;
  93     }
  94     read_sinusoidal_coding(br, &mut ch[0], state)?;
  95     read_sinusoidal_coding(br, &mut ch[1], state)?;
  96     read_extensions(br)?;
  97
  98     Ok(())
  99 }
 100
 101 fn read_grid(br: &mut BitReader, chan: &mut SBRChannel) -> DecoderResult<()> {
 102     chan.fclass = FrameClass::read(br)?;
 103     match chan.fclass {
 104         FrameClass::FixFix => {
 105             chan.num_env                = 1 << br.read(2)?;
 106             let freq_res                = br.read_bool()?;
 107             for el in chan.freq_res[..chan.num_env].iter_mut() {
 108                 *el = freq_res;
 109             }
 110             chan.env_border[0] = 0;
 111             if chan.num_env > 1 {
 112                 let delta = (MAX_SLOTS + chan.num_env / 2) / chan.num_env;
 113                 for i in 1..chan.num_env {
 114                     chan.env_border[i] = chan.env_border[i - 1] + delta;
 115                 }
 116             }
 117             chan.env_border[chan.num_env] = MAX_SLOTS;
 118         },
 119         FrameClass::FixVar => {
 120             let var_bord_1              = br.read(2)? as u8;
 121             chan.num_env                = br.read(2)? as usize + 1;
 122             let mut rel_bord_1 = [0u8; NUM_ENVELOPES];
 123             for el in rel_bord_1[..chan.num_env - 1].iter_mut() {
 124                 *el                 = 2 * (br.read(2)? as u8) + 2;
 125             }
 126             let ptr_bits = 8 - (chan.num_env as u8).leading_zeros();
 127             chan.pointer        = br.read(ptr_bits as u8)? as u8;
 128             for el in chan.freq_res[..chan.num_env].iter_mut().rev() {
 129                 *el                 = br.read_bool()?;
 130             }
 131
 132             chan.env_border[0] = 0;
 133             chan.env_border[chan.num_env] = MAX_SLOTS + usize::from(var_bord_1);
 134             for (i, &delta) in (1..chan.num_env).rev().zip(rel_bord_1.iter()) {
 135                 chan.env_border[i] = chan.env_border[i + 1] - usize::from(delta);
 136             }
 137         },
 138         FrameClass::VarFix => {
 139             let var_bord_0          = br.read(2)? as u8;
 140             chan.num_env        = br.read(2)? as usize + 1;
 141             let mut rel_bord_0 = [0u8; NUM_ENVELOPES];
 142             for el in rel_bord_0[..chan.num_env - 1].iter_mut() {
 143                 *el                 = 2 * (br.read(2)? as u8) + 2;
 144             }
 145             let ptr_bits = 8 - (chan.num_env as u8).leading_zeros();
 146             chan.pointer        = br.read(ptr_bits as u8)? as u8;
 147             for el in chan.freq_res[..chan.num_env].iter_mut() {
 148                 *el                 = br.read_bool()?;
 149             }
 150
 151             chan.env_border[0] = usize::from(var_bord_0);
 152             for i in 0..chan.num_env - 1 {
 153                 chan.env_border[i + 1] = chan.env_border[i] + usize::from(rel_bord_0[i]);
 154             }
 155             chan.env_border[chan.num_env] = MAX_SLOTS;
 156         },
 157         FrameClass::VarVar => {
 158             let var_bord_0          = br.read(2)? as u8;
 159             let var_bord_1          = br.read(2)? as u8;
 160             let num_rel_0           = br.read(2)? as usize;
 161             let num_rel_1           = br.read(2)? as usize;
 162             chan.num_env = num_rel_0 + num_rel_1 + 1;
 163             let mut rel_bord_0 = [0u8; NUM_ENVELOPES];
 164             let mut rel_bord_1 = [0u8; NUM_ENVELOPES];
 165             for el in rel_bord_0[..num_rel_0].iter_mut() {
 166                 *el                 = 2 * (br.read(2)? as u8) + 2;
 167             }
 168             for el in rel_bord_1[..num_rel_1].iter_mut() {
 169                 *el                 = 2 * (br.read(2)? as u8) + 2;
 170             }
 171             let ptr_bits = 8 - (chan.num_env as u8).leading_zeros();
 172             chan.pointer        = br.read(ptr_bits as u8)? as u8;
 173             for el in chan.freq_res[..chan.num_env].iter_mut() {
 174                 *el                 = br.read_bool()?;
 175             }
 176
 177             chan.env_border[0] = usize::from(var_bord_0);
 178             for i in 0..num_rel_0 {
 179                 chan.env_border[i + 1] = chan.env_border[i] + usize::from(rel_bord_0[i]);
 180             }
 181             chan.env_border[chan.num_env] = MAX_SLOTS + usize::from(var_bord_1);
 182             for i in 0..num_rel_1 {
 183                 chan.env_border[chan.num_env - 1 - i] = chan.env_border[chan.num_env - i] - usize::from(rel_bord_1[i]);
 184             }
 185         },
 186     };
 187     for i in 0..chan.num_env {
 188         validate!(chan.env_border[i] < chan.env_border[i + 1]);
 189     }
 190
 191     if chan.num_env > 1 {
 192         chan.num_noise = 2;
 193         let mid = match (chan.fclass, chan.pointer) {
 194                 (FrameClass::FixFix, _) => chan.num_env / 2,
 195                 (FrameClass::VarFix, 0) => 1,
 196                 (FrameClass::VarFix, 1) => chan.num_env - 1,
 197                 (FrameClass::VarFix, _) => chan.pointer as usize - 1,
 198                 (_, 0) | (_, 1)         => chan.num_env - 1,
 199                 (_, _)                  => chan.num_env + 1 - (chan.pointer as usize),
 200             };
 201         chan.noise_env_border[0] = chan.env_border[0];
 202         chan.noise_env_border[1] = chan.env_border[mid];
 203         chan.noise_env_border[2] = chan.env_border[chan.num_env];
 204     } else {
 205         chan.num_noise = 1;
 206         chan.noise_env_border[0] = chan.env_border[0];
 207         chan.noise_env_border[1] = chan.env_border[1];
 208     }
 209
 210
 211     Ok(())
 212 }
 213 fn read_dtdf(br: &mut BitReader, chan: &mut SBRChannel) -> DecoderResult<()> {
 214     for el in chan.df_env[..chan.num_env].iter_mut() {
 215         *el                         = br.read_bool()?;
 216     }
 217     for el in chan.df_noise[..chan.num_noise].iter_mut() {
 218         *el                         = br.read_bool()?;
 219     }
 220     Ok(())
 221 }
 222 fn read_invf(br: &mut BitReader, chan: &mut SBRChannel, state: &SBRState) -> DecoderResult<()> {
 223     for el in chan.invf_mode[..state.num_noise_bands].iter_mut() {
 224         *el                         = br.read(2)? as u8;
 225     }
 226     Ok(())
 227 }
 228 #[allow(clippy::collapsible_else_if)]
 229 fn read_envelope(br: &mut BitReader, chan: &mut SBRChannel, coupled: bool, cbs: &SBRCodebooks, state: &SBRState) -> DecoderResult<()> {
 230     let (f_cb, t_cb) = if coupled {
 231             if chan.amp_res {
 232                 (&cbs.env_bal_3_0db_f_cb, &cbs.env_bal_3_0db_t_cb)
 233             } else {
 234                 (&cbs.env_bal_1_5db_f_cb, &cbs.env_bal_1_5db_t_cb)
 235             }
 236         } else {
 237             if chan.amp_res {
 238                 (&cbs.env_3_0db_f_cb, &cbs.env_3_0db_t_cb)
 239             } else {
 240                 (&cbs.env_1_5db_f_cb, &cbs.env_1_5db_t_cb)
 241             }
 242         };
 243     let scale = if coupled { 2 } else { 1 };
 244     for (envelope, (&df_env, &freq_res)) in chan.data_env[..chan.num_env].iter_mut().zip(chan.df_env.iter().zip(chan.freq_res.iter())) {
 245         let num_env_bands = state.num_env_bands[freq_res as usize];
 246         if !df_env {
 247             if coupled {
 248                 envelope[0]         = br.read(5 + (!chan.amp_res as u8))? as i8;
 249             } else {
 250                 envelope[0]         = br.read(6 + (!chan.amp_res as u8))? as i8;
 251             }
 252             envelope[0] *= scale;
 253             let mut last = envelope[0];
 254             for band_env in envelope[1..num_env_bands].iter_mut() {
 255                 let delta           = br.read_cb(f_cb)?;
 256                 *band_env = last + delta * scale;
 257                 last = *band_env
 258             }
 259         } else {
 260             for (i, band_env) in envelope[..num_env_bands].iter_mut().enumerate() {
 261                 let delta           = br.read_cb(t_cb)?;
 262                 let last = match (freq_res, chan.last_freq_res) {
 263                         (false, true) => chan.last_envelope[state.high_to_low_res[i]],
 264                         (true, false) => chan.last_envelope[state.low_to_high_res[i]],
 265                         _ => chan.last_envelope[i],
 266                     };
 267                 *band_env = last + delta * scale;
 268             }
 269         }
 270         chan.last_envelope = *envelope;
 271         chan.last_freq_res = freq_res;
 272     }
 273     Ok(())
 274 }
 275 fn read_noise(br: &mut BitReader, chan: &mut SBRChannel, coupled: bool, cbs: &SBRCodebooks, state: &SBRState) -> DecoderResult<()> {
 276     let (f_cb, t_cb) = if coupled {
 277             (&cbs.env_bal_3_0db_f_cb, &cbs.noise_bal_3_0db_t_cb)
 278         } else {
 279             (&cbs.env_3_0db_f_cb, &cbs.noise_3_0db_t_cb)
 280         };
 281     let scale = if coupled { 2 } else { 1 };
 282     for (noise, &df_noise) in chan.data_noise[..chan.num_noise].iter_mut().zip(chan.df_noise.iter()) {
 283         if !df_noise {
 284             noise[0]                = (br.read(5)? as i8) * scale;
 285             let mut last = noise[0];
 286             for band_noise in noise[1..state.num_noise_bands].iter_mut() {
 287                 let delta           = br.read_cb(f_cb)?;
 288                 *band_noise = last + scale * delta;
 289                 last = *band_noise;
 290             }
 291         } else {
 292             for (band_noise, &last) in noise[..state.num_noise_bands].iter_mut().zip(chan.last_noise_env.iter()) {
 293                 let delta           = br.read_cb(t_cb)?;
 294                 *band_noise = last + delta * scale;
 295             }
 296         }
 297         chan.last_noise_env = *noise;
 298     }
 299     Ok(())
 300 }
 301 fn read_sinusoidal_coding(br: &mut BitReader, chan: &mut SBRChannel, state: &SBRState) -> DecoderResult<()> {
 302     if !br.read_bool()? {
 303         chan.add_harmonic = [false; SBR_BANDS];
 304         return Ok(());
 305     }
 306     for el in chan.add_harmonic[..state.num_env_bands[1]].iter_mut() {
 307         *el                         = br.read_bool()?;
 308     }
 309     Ok(())
 310 }
 311 fn read_extensions(br: &mut BitReader) -> DecoderResult<()> {
 312     if br.read_bool()? {
 313         let mut size                = br.read(4)? as usize;
 314         if size == 15 {
 315             size                   += br.read(8)? as usize;
 316         }
 317         validate!(br.left() >= ((size * 8) as isize));
 318         let end = br.tell() + size * 8;
 319         while br.tell() + 7 < end {
 320             let _extension_id       = br.read(2)?;
 321             // todo parse PS?
 322         }
 323     }
 324     Ok(())
 325 }
 326
 327 pub struct SBRCodebooks {
 328     env_bal_1_5db_f_cb:     Codebook<i8>,
 329     env_bal_1_5db_t_cb:     Codebook<i8>,
 330     env_bal_3_0db_f_cb:     Codebook<i8>,
 331     env_bal_3_0db_t_cb:     Codebook<i8>,
 332     env_1_5db_f_cb:         Codebook<i8>,
 333     env_1_5db_t_cb:         Codebook<i8>,
 334     env_3_0db_f_cb:         Codebook<i8>,
 335     env_3_0db_t_cb:         Codebook<i8>,
 336     noise_bal_3_0db_t_cb:   Codebook<i8>,
 337     noise_3_0db_t_cb:       Codebook<i8>,
 338 }
 339
 340 fn map_idx12(idx: usize) -> i8 { idx as i8 - 12 }
 341 fn map_idx24(idx: usize) -> i8 { idx as i8 - 24 }
 342 fn map_idx31(idx: usize) -> i8 { idx as i8 - 31 }
 343 fn map_idx60(idx: usize) -> i8 { idx as i8 - 60 }
 344
 345 impl SBRCodebooks {
 346     pub fn new() -> Self {
 347         let mut cbr = TableCodebookDescReader::new(ENV_BAL_1_5DB_F_BITS, ENV_BAL_1_5DB_F_LENS, map_idx24);
 348         let env_bal_1_5db_f_cb = Codebook::new(&mut cbr, CodebookMode::MSB).unwrap();
 349         let mut cbr = TableCodebookDescReader::new(ENV_BAL_1_5DB_T_BITS, ENV_BAL_1_5DB_T_LENS, map_idx24);
 350         let env_bal_1_5db_t_cb = Codebook::new(&mut cbr, CodebookMode::MSB).unwrap();
 351
 352         let mut cbr = TableCodebookDescReader::new(ENV_1_5DB_F_BITS, ENV_1_5DB_F_LENS, map_idx60);
 353         let env_1_5db_f_cb = Codebook::new(&mut cbr, CodebookMode::MSB).unwrap();
 354         let mut cbr = TableCodebookDescReader::new(ENV_1_5DB_T_BITS, ENV_1_5DB_T_LENS, map_idx60);
 355         let env_1_5db_t_cb = Codebook::new(&mut cbr, CodebookMode::MSB).unwrap();
 356
 357         let mut cbr = TableCodebookDescReader::new(ENV_BAL_3_0DB_F_BITS, ENV_BAL_3_0DB_F_LENS, map_idx12);
 358         let env_bal_3_0db_f_cb = Codebook::new(&mut cbr, CodebookMode::MSB).unwrap();
 359         let mut cbr = TableCodebookDescReader::new(ENV_BAL_3_0DB_T_BITS, ENV_BAL_3_0DB_T_LENS, map_idx12);
 360         let env_bal_3_0db_t_cb = Codebook::new(&mut cbr, CodebookMode::MSB).unwrap();
 361
 362         let mut cbr = TableCodebookDescReader::new(ENV_3_0DB_F_BITS, ENV_3_0DB_F_LENS, map_idx31);
 363         let env_3_0db_f_cb = Codebook::new(&mut cbr, CodebookMode::MSB).unwrap();
 364         let mut cbr = TableCodebookDescReader::new(ENV_3_0DB_T_BITS, ENV_3_0DB_T_LENS, map_idx31);
 365         let env_3_0db_t_cb = Codebook::new(&mut cbr, CodebookMode::MSB).unwrap();
 366
 367         let mut cbr = TableCodebookDescReader::new(NOISE_BAL_3_0DB_T_BITS, NOISE_BAL_3_0DB_T_LENS, map_idx12);
 368         let noise_bal_3_0db_t_cb = Codebook::new(&mut cbr, CodebookMode::MSB).unwrap();
 369         let mut cbr = TableCodebookDescReader::new(NOISE_3_0DB_T_BITS, NOISE_3_0DB_T_LENS, map_idx31);
 370         let noise_3_0db_t_cb = Codebook::new(&mut cbr, CodebookMode::MSB).unwrap();
 371
 372         Self {
 373             env_bal_1_5db_f_cb, env_bal_1_5db_t_cb,
 374             env_1_5db_f_cb,     env_1_5db_t_cb,
 375             env_bal_3_0db_f_cb, env_bal_3_0db_t_cb,
 376             env_3_0db_f_cb,     env_3_0db_t_cb,
 377             noise_3_0db_t_cb, noise_bal_3_0db_t_cb
 378         }
 379     }
 380 }
 381
 382 const ENV_1_5DB_F_BITS: &[u32; 121] = &[
 383     0x7ffe7, 0x7ffe8, 0xfffd2, 0xfffd3, 0xfffd4, 0xfffd5, 0xfffd6, 0xfffd7,
 384     0xfffd8, 0x7ffda, 0xfffd9, 0xfffda, 0xfffdb, 0xfffdc, 0x7ffdb, 0xfffdd,
 385     0x7ffdc, 0x7ffdd, 0xfffde, 0x3ffe4, 0xfffdf, 0xfffe0, 0xfffe1, 0x7ffde,
 386     0xfffe2, 0xfffe3, 0xfffe4, 0x7ffdf, 0xfffe5, 0x7ffe0, 0x3ffe8, 0x7ffe1,
 387     0x3ffe0, 0x3ffe9, 0x1ffef, 0x3ffe5, 0x1ffec, 0x1ffed, 0x1ffee, 0x0fff4,
 388     0x0fff3, 0x0fff0, 0x07ff7, 0x07ff6, 0x03ffa, 0x01ffa, 0x01ff9, 0x00ffa,
 389     0x00ff8, 0x007f9, 0x003fb, 0x001fc, 0x001fa, 0x000fb, 0x0007c, 0x0003c,
 390     0x0001c, 0x0000c, 0x00005, 0x00001, 0x00000, 0x00004, 0x0000d, 0x0001d,
 391     0x0003d, 0x000fa, 0x000fc, 0x001fb, 0x003fa, 0x007f8, 0x007fa, 0x007fb,
 392     0x00ff9, 0x00ffb, 0x01ff8, 0x01ffb, 0x03ff8, 0x03ff9, 0x0fff1, 0x0fff2,
 393     0x1ffea, 0x1ffeb, 0x3ffe1, 0x3ffe2, 0x3ffea, 0x3ffe3, 0x3ffe6, 0x3ffe7,
 394     0x3ffeb, 0xfffe6, 0x7ffe2, 0xfffe7, 0xfffe8, 0xfffe9, 0xfffea, 0xfffeb,
 395     0xfffec, 0x7ffe3, 0xfffed, 0xfffee, 0xfffef, 0xffff0, 0x7ffe4, 0xffff1,
 396     0x3ffec, 0xffff2, 0xffff3, 0x7ffe5, 0x7ffe6, 0xffff4, 0xffff5, 0xffff6,
 397     0xffff7, 0xffff8, 0xffff9, 0xffffa, 0xffffb, 0xffffc, 0xffffd, 0xffffe,
 398     0xfffff
 399 ];
 400 const ENV_1_5DB_F_LENS: &[u8; 121] = &[
 401     19, 19, 20, 20, 20, 20, 20, 20,
 402     20, 19, 20, 20, 20, 20, 19, 20,
 403     19, 19, 20, 18, 20, 20, 20, 19,
 404     20, 20, 20, 19, 20, 19, 18, 19,
 405     18, 18, 17, 18, 17, 17, 17, 16,
 406     16, 16, 15, 15, 14, 13, 13, 12,
 407     12, 11, 10,  9,  9,  8,  7,  6,
 408      5,  4,  3,  2,  2,  3,  4,  5,
 409      6,  8,  8,  9, 10, 11, 11, 11,
 410     12, 12, 13, 13, 14, 14, 16, 16,
 411     17, 17, 18, 18, 18, 18, 18, 18,
 412     18, 20, 19, 20, 20, 20, 20, 20,
 413     20, 19, 20, 20, 20, 20, 19, 20,
 414     18, 20, 20, 19, 19, 20, 20, 20,
 415     20, 20, 20, 20, 20, 20, 20, 20,
 416     20
 417 ];
 418 const ENV_1_5DB_T_BITS: &[u32; 121] = &[
 419     0x3ffd6, 0x3ffd7, 0x3ffd8, 0x3ffd9, 0x3ffda, 0x3ffdb, 0x7ffb8, 0x7ffb9,
 420     0x7ffba, 0x7ffbb, 0x7ffbc, 0x7ffbd, 0x7ffbe, 0x7ffbf, 0x7ffc0, 0x7ffc1,
 421     0x7ffc2, 0x7ffc3, 0x7ffc4, 0x7ffc5, 0x7ffc6, 0x7ffc7, 0x7ffc8, 0x7ffc9,
 422     0x7ffca, 0x7ffcb, 0x7ffcc, 0x7ffcd, 0x7ffce, 0x7ffcf, 0x7ffd0, 0x7ffd1,
 423     0x7ffd2, 0x7ffd3, 0x1ffe6, 0x3ffd4, 0x0fff0, 0x1ffe9, 0x3ffd5, 0x1ffe7,
 424     0x0fff1, 0x0ffec, 0x0ffed, 0x0ffee, 0x07ff4, 0x03ff9, 0x03ff7, 0x01ffa,
 425     0x01ff9, 0x00ffb, 0x007fc, 0x003fc, 0x001fd, 0x000fd, 0x0007d, 0x0003d,
 426     0x0001d, 0x0000d, 0x00005, 0x00001, 0x00000, 0x00004, 0x0000c, 0x0001c,
 427     0x0003c, 0x0007c, 0x000fc, 0x001fc, 0x003fd, 0x00ffa, 0x01ff8, 0x03ff6,
 428     0x03ff8, 0x07ff5, 0x0ffef, 0x1ffe8, 0x0fff2, 0x7ffd4, 0x7ffd5, 0x7ffd6,
 429     0x7ffd7, 0x7ffd8, 0x7ffd9, 0x7ffda, 0x7ffdb, 0x7ffdc, 0x7ffdd, 0x7ffde,
 430     0x7ffdf, 0x7ffe0, 0x7ffe1, 0x7ffe2, 0x7ffe3, 0x7ffe4, 0x7ffe5, 0x7ffe6,
 431     0x7ffe7, 0x7ffe8, 0x7ffe9, 0x7ffea, 0x7ffeb, 0x7ffec, 0x7ffed, 0x7ffee,
 432     0x7ffef, 0x7fff0, 0x7fff1, 0x7fff2, 0x7fff3, 0x7fff4, 0x7fff5, 0x7fff6,
 433     0x7fff7, 0x7fff8, 0x7fff9, 0x7fffa, 0x7fffb, 0x7fffc, 0x7fffd, 0x7fffe,
 434     0x7ffff
 435 ];
 436 const ENV_1_5DB_T_LENS: &[u8; 121] = &[
 437     18, 18, 18, 18, 18, 18, 19, 19,
 438     19, 19, 19, 19, 19, 19, 19, 19,
 439     19, 19, 19, 19, 19, 19, 19, 19,
 440     19, 19, 19, 19, 19, 19, 19, 19,
 441     19, 19, 17, 18, 16, 17, 18, 17,
 442     16, 16, 16, 16, 15, 14, 14, 13,
 443     13, 12, 11, 10,  9,  8,  7,  6,
 444      5,  4,  3,  2,  2,  3,  4,  5,
 445      6,  7,  8,  9, 10, 12, 13, 14,
 446     14, 15, 16, 17, 16, 19, 19, 19,
 447     19, 19, 19, 19, 19, 19, 19, 19,
 448     19, 19, 19, 19, 19, 19, 19, 19,
 449     19, 19, 19, 19, 19, 19, 19, 19,
 450     19, 19, 19, 19, 19, 19, 19, 19,
 451     19, 19, 19, 19, 19, 19, 19, 19,
 452     19
 453 ];
 454
 455 const ENV_BAL_1_5DB_F_BITS: &[u32; 49] = &[
 456     0x3ffe2, 0x3ffe3, 0x3ffe4, 0x3ffe5, 0x3ffe6, 0x3ffe7, 0x3ffe8, 0x3ffe9,
 457     0x3ffea, 0x3ffeb, 0x3ffec, 0x3ffed, 0x3ffee, 0x3ffef, 0x3fff0, 0x0fff7,
 458     0x1fff0, 0x03ffc, 0x007fe, 0x007fc, 0x000fe, 0x0007e, 0x0000e, 0x00002,
 459     0x00000, 0x00006, 0x0001e, 0x0003e, 0x001fe, 0x007fd, 0x00ffe, 0x07ffa,
 460     0x0fff6, 0x3fff1, 0x3fff2, 0x3fff3, 0x3fff4, 0x3fff5, 0x3fff6, 0x3fff7,
 461     0x3fff8, 0x3fff9, 0x3fffa, 0x3fffb, 0x3fffc, 0x3fffd, 0x3fffe, 0x7fffe,
 462     0x7ffff
 463 ];
 464 const ENV_BAL_1_5DB_F_LENS: &[u8; 49] = &[
 465     18, 18, 18, 18, 18, 18, 18, 18,
 466     18, 18, 18, 18, 18, 18, 18, 16,
 467     17, 14, 11, 11,  8,  7,  4,  2,
 468      1,  3,  5,  6,  9, 11, 12, 15,
 469     16, 18, 18, 18, 18, 18, 18, 18,
 470     18, 18, 18, 18, 18, 18, 18, 19,
 471     19
 472 ];
 473 const ENV_BAL_1_5DB_T_BITS: &[u32; 49] = &[
 474     0x0ffe4, 0x0ffe5, 0x0ffe6, 0x0ffe7, 0x0ffe8, 0x0ffe9, 0x0ffea, 0x0ffeb,
 475     0x0ffec, 0x0ffed, 0x0ffee, 0x0ffef, 0x0fff0, 0x0fff1, 0x0fff2, 0x0fff3,
 476     0x0fff4, 0x0ffe2, 0x00ffc, 0x007fc, 0x001fe, 0x0007e, 0x0001e, 0x00006,
 477     0x00000, 0x00002, 0x0000e, 0x0003e, 0x000fe, 0x007fd, 0x00ffd, 0x07ff0,
 478     0x0ffe3, 0x0fff5, 0x0fff6, 0x0fff7, 0x0fff8, 0x0fff9, 0x0fffa, 0x1fff6,
 479     0x1fff7, 0x1fff8, 0x1fff9, 0x1fffa, 0x1fffb, 0x1fffc, 0x1fffd, 0x1fffe,
 480     0x1ffff
 481 ];
 482 const ENV_BAL_1_5DB_T_LENS: &[u8; 49] = &[
 483     16, 16, 16, 16, 16, 16, 16, 16,
 484     16, 16, 16, 16, 16, 16, 16, 16,
 485     16, 16, 12, 11,  9,  7,  5,  3,
 486      1,  2,  4,  6,  8, 11, 12, 15,
 487     16, 16, 16, 16, 16, 16, 16, 17,
 488     17, 17, 17, 17, 17, 17, 17, 17,
 489     17
 490 ];
 491
 492 const ENV_3_0DB_F_BITS: &[u32; 63] = &[
 493     0xffff0, 0xffff1, 0xffff2, 0xffff3, 0xffff4, 0xffff5, 0xffff6, 0x3fff3,
 494     0x7fff5, 0x7ffee, 0x7ffef, 0x7fff6, 0x3fff4, 0x3fff2, 0xffff7, 0x7fff0,
 495     0x1fff5, 0x3fff0, 0x1fff4, 0x0fff7, 0x0fff6, 0x07ff8, 0x03ffb, 0x00ffd,
 496     0x007fd, 0x003fd, 0x001fd, 0x000fd, 0x0003e, 0x0000e, 0x00002, 0x00000,
 497     0x00006, 0x0001e, 0x000fc, 0x001fc, 0x003fc, 0x007fc, 0x00ffc, 0x01ffc,
 498     0x03ffa, 0x07ff9, 0x07ffa, 0x0fff8, 0x0fff9, 0x1fff6, 0x1fff7, 0x3fff5,
 499     0x3fff6, 0x3fff1, 0xffff8, 0x7fff1, 0x7fff2, 0x7fff3, 0xffff9, 0x7fff7,
 500     0x7fff4, 0xffffa, 0xffffb, 0xffffc, 0xffffd, 0xffffe, 0xfffff
 501 ];
 502 const ENV_3_0DB_F_LENS: &[u8; 63] = &[
 503     20, 20, 20, 20, 20, 20, 20, 18,
 504     19, 19, 19, 19, 18, 18, 20, 19,
 505     17, 18, 17, 16, 16, 15, 14, 12,
 506     11, 10,  9,  8,  6,  4,  2,  1,
 507      3,  5,  8,  9, 10, 11, 12, 13,
 508     14, 15, 15, 16, 16, 17, 17, 18,
 509     18, 18, 20, 19, 19, 19, 20, 19,
 510     19, 20, 20, 20, 20, 20, 20
 511 ];
 512 const ENV_3_0DB_T_BITS: &[u32; 63] = &[
 513     0x3ffed, 0x3ffee, 0x7ffde, 0x7ffdf, 0x7ffe0, 0x7ffe1, 0x7ffe2, 0x7ffe3,
 514     0x7ffe4, 0x7ffe5, 0x7ffe6, 0x7ffe7, 0x7ffe8, 0x7ffe9, 0x7ffea, 0x7ffeb,
 515     0x7ffec, 0x1fff4, 0x0fff7, 0x0fff9, 0x0fff8, 0x03ffb, 0x03ffa, 0x03ff8,
 516     0x01ffa, 0x00ffc, 0x007fc, 0x000fe, 0x0003e, 0x0000e, 0x00002, 0x00000,
 517     0x00006, 0x0001e, 0x0007e, 0x001fe, 0x007fd, 0x01ffb, 0x03ff9, 0x03ffc,
 518     0x07ffa, 0x0fff6, 0x1fff5, 0x3ffec, 0x7ffed, 0x7ffee, 0x7ffef, 0x7fff0,
 519     0x7fff1, 0x7fff2, 0x7fff3, 0x7fff4, 0x7fff5, 0x7fff6, 0x7fff7, 0x7fff8,
 520     0x7fff9, 0x7fffa, 0x7fffb, 0x7fffc, 0x7fffd, 0x7fffe, 0x7ffff
 521 ];
 522 const ENV_3_0DB_T_LENS: &[u8; 63] = &[
 523     18, 18, 19, 19, 19, 19, 19, 19,
 524     19, 19, 19, 19, 19, 19, 19, 19,
 525     19, 17, 16, 16, 16, 14, 14, 14,
 526     13, 12, 11,  8,  6,  4,  2,  1,
 527      3,  5,  7,  9, 11, 13, 14, 14,
 528     15, 16, 17, 18, 19, 19, 19, 19,
 529     19, 19, 19, 19, 19, 19, 19, 19,
 530     19, 19, 19, 19, 19, 19, 19
 531 ];
 532
 533 const ENV_BAL_3_0DB_F_BITS: &[u16; 25] = &[
 534     0x1ff7, 0x1ff8, 0x1ff9, 0x1ffa, 0x1ffb, 0x3ff8, 0x3ff9, 0x07fc,
 535     0x00fe, 0x007e, 0x000e, 0x0002, 0x0000, 0x0006, 0x001e, 0x003e,
 536     0x01fe, 0x0ffa, 0x1ff6, 0x3ffa, 0x3ffb, 0x3ffc, 0x3ffd, 0x3ffe,
 537     0x3fff
 538 ];
 539 const ENV_BAL_3_0DB_F_LENS: &[u8; 25] = &[
 540     13, 13, 13, 13, 13, 14, 14, 11,
 541      8,  7,  4,  2,  1,  3,  5,  6,
 542      9, 12, 13, 14, 14, 14, 14, 14,
 543     14
 544 ];
 545 const ENV_BAL_3_0DB_T_BITS: &[u16; 25] = &[
 546     0x1ff2, 0x1ff3, 0x1ff4, 0x1ff5, 0x1ff6, 0x1ff7, 0x1ff8, 0x0ff8,
 547     0x00fe, 0x007e, 0x000e, 0x0006, 0x0000, 0x0002, 0x001e, 0x003e,
 548     0x01fe, 0x1ff9, 0x1ffa, 0x1ffb, 0x1ffc, 0x1ffd, 0x1ffe, 0x3ffe,
 549     0x3fff
 550 ];
 551 const ENV_BAL_3_0DB_T_LENS: &[u8; 25] = &[
 552     13, 13, 13, 13, 13, 13, 13, 12,
 553      8,  7,  4,  3,  1,  2,  5,  6,
 554      9, 13, 13, 13, 13, 13, 13, 14,
 555     14
 556 ];
 557
 558 const NOISE_3_0DB_T_BITS: &[u16; 63] = &[
 559     0x1fce, 0x1fcf, 0x1fd0, 0x1fd1, 0x1fd2, 0x1fd3, 0x1fd4, 0x1fd5,
 560     0x1fd6, 0x1fd7, 0x1fd8, 0x1fd9, 0x1fda, 0x1fdb, 0x1fdc, 0x1fdd,
 561     0x1fde, 0x1fdf, 0x1fe0, 0x1fe1, 0x1fe2, 0x1fe3, 0x1fe4, 0x1fe5,
 562     0x1fe6, 0x1fe7, 0x07f2, 0x00fd, 0x003e, 0x000e, 0x0006, 0x0000,
 563     0x0002, 0x001e, 0x00fc, 0x03f8, 0x1fcc, 0x1fe8, 0x1fe9, 0x1fea,
 564     0x1feb, 0x1fec, 0x1fcd, 0x1fed, 0x1fee, 0x1fef, 0x1ff0, 0x1ff1,
 565     0x1ff2, 0x1ff3, 0x1ff4, 0x1ff5, 0x1ff6, 0x1ff7, 0x1ff8, 0x1ff9,
 566     0x1ffa, 0x1ffb, 0x1ffc, 0x1ffd, 0x1ffe, 0x3ffe, 0x3fff
 567 ];
 568 const NOISE_3_0DB_T_LENS: &[u8; 63] = &[
 569     13, 13, 13, 13, 13, 13, 13, 13,
 570     13, 13, 13, 13, 13, 13, 13, 13,
 571     13, 13, 13, 13, 13, 13, 13, 13,
 572     13, 13, 11,  8,  6,  4,  3,  1,
 573      2,  5,  8, 10, 13, 13, 13, 13,
 574     13, 13, 13, 13, 13, 13, 13, 13,
 575     13, 13, 13, 13, 13, 13, 13, 13,
 576     13, 13, 13, 13, 13, 14, 14
 577 ];
 578 const NOISE_BAL_3_0DB_T_BITS: &[u8; 25] = &[
 579     0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3,
 580     0xf4, 0xf5, 0x1c, 0x02, 0x00, 0x06, 0x3a, 0xf6,
 581     0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe,
 582     0xff
 583 ];
 584 const NOISE_BAL_3_0DB_T_LENS: &[u8; 25] = &[
 585     8, 8, 8, 8, 8, 8, 8, 8,
 586     8, 8, 5, 2, 1, 3, 6, 8,
 587     8, 8, 8, 8, 8, 8, 8, 8, 8
 588 ];