| 1 | use nihav_core::formats::*; |
| 2 | use nihav_core::frame::*; |
| 3 | use nihav_core::codecs::*; |
| 4 | use nihav_core::io::bitreader::*; |
| 5 | use nihav_core::dsp::fft::*; |
| 6 | use std::str::FromStr; |
| 7 | use std::f32::consts; |
| 8 | |
| 9 | const BLOCK_LEN: usize = 256; |
| 10 | const NBLOCKS: usize = 6; |
| 11 | const MAX_CHANNELS: usize = 5; |
| 12 | const MAX_CPLBANDS: usize = 18; |
| 13 | const MAX_BANDS: usize = 50; |
| 14 | |
| 15 | const MAGIC_BYTE0: u8 = 0x0B; |
| 16 | const MAGIC_BYTE1: u8 = 0x77; |
| 17 | |
| 18 | const STRATEGY_REUSE: u8 = 0; |
| 19 | |
| 20 | const LFE_CHANNEL: usize = MAX_CHANNELS; |
| 21 | const CPL_CHANNEL: usize = MAX_CHANNELS + 1; |
| 22 | |
| 23 | struct IMDCTContext { |
| 24 | xsincos: [FFTComplex; BLOCK_LEN/2], |
| 25 | fft: FFT, |
| 26 | size: usize, |
| 27 | } |
| 28 | |
| 29 | struct IMDCTWorkspace { |
| 30 | z: [FFTComplex; BLOCK_LEN / 2], |
| 31 | y: [FFTComplex; BLOCK_LEN / 2], |
| 32 | out: [f32; BLOCK_LEN * 2], |
| 33 | } |
| 34 | |
| 35 | impl IMDCTContext { |
| 36 | fn new(bits: usize) -> Self { |
| 37 | let size = 1 << bits; |
| 38 | let size4 = 1 << (bits - 2); |
| 39 | let mut xsincos: [FFTComplex; 512/4] = [FFTC_ZERO; 512/4]; |
| 40 | for k in 0..size4 { |
| 41 | let factor = 2.0 * consts::PI * ((8 * k + 1) as f32) / ((8 * size) as f32); |
| 42 | xsincos[k].re = -factor.cos(); |
| 43 | xsincos[k].im = -factor.sin(); |
| 44 | } |
| 45 | let fft = FFTBuilder::new_fft(FFTMode::SplitRadix, size/4); |
| 46 | IMDCTContext { xsincos: xsincos, size: size, fft: fft } |
| 47 | } |
| 48 | #[allow(non_snake_case)] |
| 49 | fn do_imdct(&mut self, coeffs: &[i32; BLOCK_LEN], tmp: &mut IMDCTWorkspace) { |
| 50 | do_imdct_core(&mut self.fft, &self.xsincos, self.size, false, coeffs, &mut tmp.z, &mut tmp.y); |
| 51 | let w = &TS102366_WINDOW; |
| 52 | let N2 = self.size / 2; |
| 53 | let N4 = self.size / 4; |
| 54 | let N8 = self.size / 8; |
| 55 | for n in 0..N8 { |
| 56 | tmp.out[ 2 * n] = -tmp.y[N8 + n] .im * w[ 2 * n]; |
| 57 | tmp.out[ 2 * n + 1] = tmp.y[N8 - n - 1].re * w[ 2 * n + 1]; |
| 58 | tmp.out[ N4 + 2 * n] = -tmp.y[ n] .re * w[N4 + 2 * n]; |
| 59 | tmp.out[ N4 + 2 * n + 1] = tmp.y[N4 - n - 1].im * w[N4 + 2 * n + 1]; |
| 60 | tmp.out[ N2 + 2 * n] = -tmp.y[N8 + n] .re * w[N2 - 2 * n - 1]; |
| 61 | tmp.out[ N2 + 2 * n + 1] = tmp.y[N8 - n - 1].im * w[N2 - 2 * n - 2]; |
| 62 | tmp.out[3 * N4 + 2 * n] = tmp.y[ n] .im * w[N4 - 2 * n - 1]; |
| 63 | tmp.out[3 * N4 + 2 * n + 1] = -tmp.y[N4 - n - 1].re * w[N4 - 2 * n - 2]; |
| 64 | } |
| 65 | } |
| 66 | #[allow(non_snake_case)] |
| 67 | fn do_imdct_ileave(&mut self, coeffs: &[i32; BLOCK_LEN], tmp: &mut IMDCTWorkspace) { |
| 68 | let mut ziter = tmp.z.chunks_mut(self.size / 4); |
| 69 | let z1 = ziter.next().unwrap(); |
| 70 | let z2 = ziter.next().unwrap(); |
| 71 | let mut yiter = tmp.y.chunks_mut(self.size / 4); |
| 72 | let y1 = yiter.next().unwrap(); |
| 73 | let y2 = yiter.next().unwrap(); |
| 74 | do_imdct_core(&mut self.fft, &self.xsincos, self.size, true, coeffs, z1, y1); |
| 75 | do_imdct_core(&mut self.fft, &self.xsincos, self.size, true, &coeffs[1..], z2, y2); |
| 76 | let w = &TS102366_WINDOW; |
| 77 | let N2 = self.size / 2; |
| 78 | let N4 = self.size / 4; |
| 79 | let N8 = self.size / 8; |
| 80 | for n in 0..N8 { |
| 81 | tmp.out[ 2 * n] = -y1[ n] .im * w[ 2 * n]; |
| 82 | tmp.out[ 2 * n + 1] = y1[N8 - n - 1].re * w[ 2 * n + 1]; |
| 83 | tmp.out[ N4 + 2 * n] = -y1[ n] .re * w[N4 + 2 * n]; |
| 84 | tmp.out[ N4 + 2 * n + 1] = y1[N8 - n - 1].im * w[N4 + 2 * n + 1]; |
| 85 | tmp.out[ N2 + 2 * n] = -y2[ n] .re * w[N2 - 2 * n - 1]; |
| 86 | tmp.out[ N2 + 2 * n + 1] = y2[N8 - n - 1].im * w[N2 - 2 * n - 2]; |
| 87 | tmp.out[3 * N4 + 2 * n] = y2[ n] .im * w[N4 - 2 * n - 1]; |
| 88 | tmp.out[3 * N4 + 2 * n + 1] = -y2[N8 - n - 1].re * w[N4 - 2 * n - 2]; |
| 89 | } |
| 90 | } |
| 91 | } |
| 92 | |
| 93 | #[allow(non_snake_case)] |
| 94 | fn do_imdct_core(fft: &mut FFT, xsc: &[FFTComplex; BLOCK_LEN/2], size: usize, ilace: bool, coeffs: &[i32], z: &mut [FFTComplex], y: &mut [FFTComplex]) { |
| 95 | let N = size; |
| 96 | let N2 = size / 2; |
| 97 | let N4 = size / 4; |
| 98 | let scale = 1.0 / ((1 << 24) as f32); |
| 99 | for k in 0..N4 { |
| 100 | let (c0, c1) = if !ilace { |
| 101 | ((coeffs[N2 - 2 * k - 1] as f32) * scale, |
| 102 | (coeffs[ 2 * k] as f32) * scale) |
| 103 | } else { |
| 104 | ((coeffs[N - 4 * k - 2] as f32) * scale, |
| 105 | (coeffs[ 4 * k] as f32) * scale) |
| 106 | }; |
| 107 | let c = FFTComplex { re: c0, im: c1 }; |
| 108 | z[k] = c * xsc[k]; |
| 109 | } |
| 110 | fft.do_fft_inplace(z, false); |
| 111 | for k in 0..N4 { |
| 112 | y[k] = z[k] * xsc[k]; |
| 113 | } |
| 114 | } |
| 115 | |
| 116 | struct AudioDecoder { |
| 117 | info: NACodecInfoRef, |
| 118 | ablk: AudioBlock, |
| 119 | imdct512: IMDCTContext, |
| 120 | imdct256: IMDCTContext, |
| 121 | tmp: IMDCTWorkspace, |
| 122 | delay: [[f32; BLOCK_LEN]; MAX_CHANNELS + 1], |
| 123 | } |
| 124 | |
| 125 | impl AudioDecoder { |
| 126 | fn new() -> Self { |
| 127 | AudioDecoder { |
| 128 | info: NACodecInfo::new_dummy(), |
| 129 | ablk: AudioBlock::new(), |
| 130 | imdct512: IMDCTContext::new(9), |
| 131 | imdct256: IMDCTContext::new(8), |
| 132 | tmp: IMDCTWorkspace { |
| 133 | z: [FFTC_ZERO; BLOCK_LEN / 2], |
| 134 | y: [FFTC_ZERO; BLOCK_LEN / 2], |
| 135 | out: [0.0; BLOCK_LEN * 2], |
| 136 | }, |
| 137 | delay: [[0.0; BLOCK_LEN]; MAX_CHANNELS + 1], |
| 138 | } |
| 139 | } |
| 140 | } |
| 141 | |
| 142 | const SAMPLE_RATES: [u32; 4] = [ 48000, 44100, 32000, 0 ]; |
| 143 | |
| 144 | const FRAME_SIZES: [[usize; 64]; 4] = [ |
| 145 | [ |
| 146 | 64, 64, 80, 80, 96, 96, 112, 112, |
| 147 | 128, 128, 160, 160, 192, 192, 224, 224, |
| 148 | 256, 256, 320, 320, 384, 384, 448, 448, |
| 149 | 512, 512, 640, 640, 768, 768, 896, 896, |
| 150 | 1024, 1024, 1152, 1152, 1280, 1280, |
| 151 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 152 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 153 | ], [ |
| 154 | 69, 70, 87, 88, 104, 105, 121, 122, |
| 155 | 139, 140, 174, 175, 208, 209, 243, 244, |
| 156 | 278, 279, 348, 349, 417, 418, 487, 488, |
| 157 | 557, 558, 696, 697, 835, 836, 975, 976, |
| 158 | 1114, 1115, 1253, 1254, 1393, 1394, |
| 159 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 160 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 161 | ], [ |
| 162 | 96, 96, 120, 120, 144, 144, 168, 168, |
| 163 | 192, 192, 240, 240, 288, 288, 336, 336, |
| 164 | 384, 384, 480, 480, 576, 576, 672, 672, |
| 165 | 768, 768, 960, 960, 1152, 1152, 1344, 1344, |
| 166 | 1536, 1536, 1728, 1728, 1920, 1920, |
| 167 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 168 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 169 | ], [ 0; 64 ], |
| 170 | ]; |
| 171 | |
| 172 | #[derive(Debug,Clone,Copy)] |
| 173 | struct Syncinfo { |
| 174 | crc1: u16, |
| 175 | fscod: u8, |
| 176 | frmsizecod: u8, |
| 177 | samplerate: u32, |
| 178 | frame_size: usize, |
| 179 | } |
| 180 | |
| 181 | impl Syncinfo { |
| 182 | fn read(br: &mut BitReader) -> DecoderResult<Self> { |
| 183 | let syncword = br.read(16)?; |
| 184 | validate!(syncword == ((MAGIC_BYTE0 as u32) * 256) + (MAGIC_BYTE1 as u32)); |
| 185 | let crc1 = br.read(16)? as u16; |
| 186 | let fscod = br.read(2)? as usize; |
| 187 | let frmsizecod = br.read(6)? as usize; |
| 188 | Ok(Syncinfo { crc1: crc1, fscod: fscod as u8, frmsizecod: frmsizecod as u8, |
| 189 | samplerate: SAMPLE_RATES[fscod], frame_size: FRAME_SIZES[fscod][frmsizecod] * 2 }) |
| 190 | } |
| 191 | fn is_valid(&self) -> bool { |
| 192 | (self.samplerate != 0) && (self.frame_size != 0) |
| 193 | } |
| 194 | } |
| 195 | |
| 196 | trait ReadOptional { |
| 197 | fn read_optional8(&mut self) -> BitReaderResult<Option<u8>>; |
| 198 | fn read_optional16(&mut self, bits: u8) -> BitReaderResult<Option<u16>>; |
| 199 | } |
| 200 | |
| 201 | impl<'a> ReadOptional for BitReader<'a> { |
| 202 | fn read_optional8(&mut self) -> BitReaderResult<Option<u8>> { |
| 203 | if self.read_bool()? { |
| 204 | Ok(Some(self.read(8)? as u8)) |
| 205 | } else { |
| 206 | Ok(None) |
| 207 | } |
| 208 | } |
| 209 | fn read_optional16(&mut self, bits: u8) -> BitReaderResult<Option<u16>> { |
| 210 | if self.read_bool()? { |
| 211 | Ok(Some(self.read(bits)? as u16)) |
| 212 | } else { |
| 213 | Ok(None) |
| 214 | } |
| 215 | } |
| 216 | } |
| 217 | |
| 218 | #[derive(Debug,Clone,Copy,PartialEq)] |
| 219 | enum ACMode { |
| 220 | DualMono, |
| 221 | Mono, |
| 222 | Stereo, |
| 223 | Mode3_0, |
| 224 | Mode2_1, |
| 225 | Mode3_1, |
| 226 | Mode2_2, |
| 227 | Mode3_2, |
| 228 | } |
| 229 | |
| 230 | impl ACMode { |
| 231 | fn get_num_channels(&self) -> usize { |
| 232 | match *self { |
| 233 | ACMode::DualMono => 2, |
| 234 | ACMode::Mono => 1, |
| 235 | ACMode::Stereo => 2, |
| 236 | ACMode::Mode3_0 => 3, |
| 237 | ACMode::Mode2_1 => 3, |
| 238 | ACMode::Mode3_1 => 4, |
| 239 | ACMode::Mode2_2 => 4, |
| 240 | ACMode::Mode3_2 => 5, |
| 241 | } |
| 242 | } |
| 243 | fn get_channel_map_str(&self) -> &'static str { |
| 244 | match *self { |
| 245 | ACMode::DualMono => "C,C", |
| 246 | ACMode::Mono => "C", |
| 247 | ACMode::Stereo => "L,R", |
| 248 | ACMode::Mode3_0 => "L,C,R", |
| 249 | ACMode::Mode2_1 => "L,R,Cs", |
| 250 | ACMode::Mode3_1 => "L,C,R,Cs", |
| 251 | ACMode::Mode2_2 => "L,R,Ls,Rs", |
| 252 | ACMode::Mode3_2 => "L,C,R,Ls,Rs", |
| 253 | } |
| 254 | } |
| 255 | fn get_channel_map(&self, has_lfe: bool) -> NAChannelMap { |
| 256 | let mut chmap = NAChannelMap::from_str(self.get_channel_map_str()).unwrap(); |
| 257 | if has_lfe { |
| 258 | chmap.add_channel(NAChannelType::LFE); |
| 259 | } |
| 260 | chmap |
| 261 | } |
| 262 | fn is_3_x(&self) -> bool { |
| 263 | match *self { |
| 264 | ACMode::Mode3_0 | |
| 265 | ACMode::Mode3_1 | |
| 266 | ACMode::Mode3_2 => true, |
| 267 | _ => false, |
| 268 | } |
| 269 | } |
| 270 | fn is_surround(&self) -> bool { |
| 271 | match *self { |
| 272 | ACMode::Mode2_1 | |
| 273 | ACMode::Mode3_1 | |
| 274 | ACMode::Mode2_2 | |
| 275 | ACMode::Mode3_2 => true, |
| 276 | _ => false, |
| 277 | } |
| 278 | } |
| 279 | } |
| 280 | |
| 281 | const AC_MODES: [ACMode; 8] = [ |
| 282 | ACMode::DualMono, ACMode::Mono, ACMode::Stereo, |
| 283 | ACMode::Mode3_0, ACMode::Mode2_1, |
| 284 | ACMode::Mode3_1, ACMode::Mode2_2, |
| 285 | ACMode::Mode3_2 |
| 286 | ]; |
| 287 | |
| 288 | #[derive(Debug,Clone,Copy)] |
| 289 | struct Mixinfo { |
| 290 | dialnorm: u8, |
| 291 | compr: Option<u8>, |
| 292 | langcod: Option<u8>, |
| 293 | mixlevel: Option<u8>, |
| 294 | roomtyp: Option<u8>, |
| 295 | } |
| 296 | |
| 297 | impl Mixinfo { |
| 298 | fn read(br: &mut BitReader) -> DecoderResult<Self> { |
| 299 | let dialnorm = br.read(5)? as u8; |
| 300 | let compr = br.read_optional8()?; |
| 301 | let langcod = br.read_optional8()?; |
| 302 | let (mixlevel, roomtyp) = if br.read_bool()? { |
| 303 | let mlev = br.read(5)? as u8; |
| 304 | let rt = br.read(2)? as u8; |
| 305 | validate!(rt < 3); |
| 306 | (Some(mlev), Some(rt)) |
| 307 | } else { |
| 308 | (None, None) |
| 309 | }; |
| 310 | Ok(Mixinfo { dialnorm, compr, langcod, mixlevel, roomtyp }) |
| 311 | } |
| 312 | } |
| 313 | |
| 314 | #[derive(Debug,Clone,Copy)] |
| 315 | struct BSI { |
| 316 | bsid: u8, |
| 317 | shift: u8, |
| 318 | bsmod: u8, |
| 319 | acmod: ACMode, |
| 320 | cmixlev: Option<u8>, |
| 321 | surmixlev: Option<u8>, |
| 322 | dsurmod: Option<u8>, |
| 323 | lfeon: bool, |
| 324 | mixinfo: Mixinfo, |
| 325 | mixinfo2: Option<Mixinfo>, |
| 326 | copysmth: bool, |
| 327 | origbs: bool, |
| 328 | timecod1: Option<u16>, |
| 329 | timecod2: Option<u16>, |
| 330 | has_addb: bool, |
| 331 | } |
| 332 | |
| 333 | impl BSI { |
| 334 | fn read(br: &mut BitReader) -> DecoderResult<BSI> { |
| 335 | let bsid = br.read(5)? as u8; |
| 336 | validate!(bsid <= 10); |
| 337 | let shift = if bsid < 9 { 0 } else { bsid - 9 + 1 }; |
| 338 | let bsmod = br.read(3)? as u8; |
| 339 | let acmod_id = br.read(3)? as usize; |
| 340 | validate!(acmod_id < AC_MODES.len()); |
| 341 | let acmod = AC_MODES[acmod_id]; |
| 342 | let cmixlev = if acmod.is_3_x() { |
| 343 | let cl = br.read(2)? as u8; |
| 344 | validate!(cl < 3); |
| 345 | Some(cl) |
| 346 | } else { None }; |
| 347 | let surmixlev = if acmod.is_surround() { |
| 348 | let sml = br.read(2)? as u8; |
| 349 | validate!(sml < 3); |
| 350 | Some(sml) |
| 351 | } else { None }; |
| 352 | let dsurmod = if acmod == ACMode::Stereo { |
| 353 | let dsm = br.read(2)? as u8; |
| 354 | validate!(dsm < 3); |
| 355 | Some(dsm) |
| 356 | } else { None }; |
| 357 | let lfeon = br.read_bool()?; |
| 358 | let mixinfo = Mixinfo::read(br)?; |
| 359 | let mixinfo2 = if acmod == ACMode::DualMono { |
| 360 | Some(Mixinfo::read(br)?) |
| 361 | } else { |
| 362 | None |
| 363 | }; |
| 364 | let copysmth = br.read_bool()?; |
| 365 | let origbs = br.read_bool()?; |
| 366 | let timecod1 = br.read_optional16(14)?; |
| 367 | let timecod2 = br.read_optional16(14)?; |
| 368 | let has_addb = br.read_bool()?; |
| 369 | Ok(BSI{ |
| 370 | bsid, shift, bsmod, acmod, lfeon, |
| 371 | cmixlev, surmixlev, dsurmod, |
| 372 | mixinfo: mixinfo, mixinfo2: mixinfo2, |
| 373 | copysmth, origbs, timecod1, timecod2, has_addb, |
| 374 | }) |
| 375 | } |
| 376 | } |
| 377 | |
| 378 | #[derive(Clone, Copy)] |
| 379 | struct ChannelData { |
| 380 | blksw: bool, |
| 381 | dithflag: bool, |
| 382 | |
| 383 | chincpl: bool, |
| 384 | cplcoe: bool, |
| 385 | cplcoexp: [u8; MAX_CPLBANDS], |
| 386 | cplcomant: [u8; MAX_CPLBANDS], |
| 387 | mstrcplco: u8, |
| 388 | |
| 389 | chbwcod: u8, |
| 390 | |
| 391 | expstr: u8, |
| 392 | gainrng: u8, |
| 393 | startmant: usize, |
| 394 | endmant: usize, |
| 395 | groups: usize, |
| 396 | |
| 397 | fsnroffst: u8, |
| 398 | fgaincod: usize, |
| 399 | snroffset: i32, |
| 400 | |
| 401 | deltbae: u8, |
| 402 | deltnseg: usize, |
| 403 | deltoffst: [u8; 8], |
| 404 | deltlen: [usize; 8], |
| 405 | deltba: [u8; 8], |
| 406 | |
| 407 | bap: [u8; 256], |
| 408 | exps: [u8; 256], |
| 409 | mant: [i32; 256], |
| 410 | |
| 411 | psd: [i16; 256], |
| 412 | bndpsd: [i32; 64], |
| 413 | } |
| 414 | |
| 415 | const GROUPS: [usize; 4] = [ 0, 3, 6, 12 ]; |
| 416 | const GROUP_BIAS: [usize; 4] = [ 0, 0, 3, 9 ]; |
| 417 | |
| 418 | fn decode_exps(br: &mut BitReader, dst: &mut [u8], mut prev: u8, grplen: usize) -> DecoderResult<()> { |
| 419 | let repeat = grplen / 3; |
| 420 | |
| 421 | for out in dst.chunks_mut(grplen) { |
| 422 | let val = br.read(7)? as u8; |
| 423 | validate!(val < 125); |
| 424 | let diff: [u8; 3] = [ val / 25, (val / 5) % 5, val % 5 ]; |
| 425 | for (i, exps) in out.chunks_mut(repeat).enumerate() { |
| 426 | exps[0] = (prev + diff[i]).wrapping_sub(2); |
| 427 | validate!(exps[0] <= 24); |
| 428 | for j in 1..repeat { |
| 429 | exps[j] = exps[0]; |
| 430 | } |
| 431 | prev = exps[0]; |
| 432 | } |
| 433 | } |
| 434 | |
| 435 | Ok(()) |
| 436 | } |
| 437 | |
| 438 | macro_rules! read_bap { |
| 439 | ($br: expr, $tab:ident, $nbits:expr) => ({ |
| 440 | let val = $br.read($nbits)? as usize; |
| 441 | validate!(val < $tab.len()); |
| 442 | $tab[val] |
| 443 | }); |
| 444 | ($br:expr, $tab:ident, $nbits:expr, $bufidx:expr, $bap_buf:expr, $bap_buf_fill:expr) => ( |
| 445 | if $bap_buf_fill[$bufidx] > 0 { |
| 446 | $bap_buf_fill[$bufidx] -= 1; |
| 447 | $bap_buf[$bufidx][$bap_buf_fill[$bufidx]] |
| 448 | } else { |
| 449 | let val = $br.read($nbits)? as usize; |
| 450 | validate!(val < $tab.len()); |
| 451 | for i in 1..$tab[0].len() { |
| 452 | $bap_buf[$bufidx][i - 1] = $tab[val][i]; |
| 453 | } |
| 454 | $bap_buf_fill[$bufidx] = $tab[0].len() - 1; |
| 455 | $tab[val][0] |
| 456 | } |
| 457 | ); |
| 458 | } |
| 459 | |
| 460 | impl ChannelData { |
| 461 | fn new() -> Self { |
| 462 | ChannelData { |
| 463 | blksw: false, |
| 464 | dithflag: false, |
| 465 | |
| 466 | chincpl: false, |
| 467 | cplcoe: false, |
| 468 | cplcoexp: [0; MAX_CPLBANDS], |
| 469 | cplcomant: [0; MAX_CPLBANDS], |
| 470 | mstrcplco: 0, |
| 471 | |
| 472 | chbwcod: 0, |
| 473 | |
| 474 | expstr: 0, |
| 475 | gainrng: 0, |
| 476 | startmant: 0, |
| 477 | endmant: 0, |
| 478 | groups: 0, |
| 479 | |
| 480 | fsnroffst: 0, |
| 481 | fgaincod: 0, |
| 482 | snroffset: 0, |
| 483 | |
| 484 | deltbae: 0, |
| 485 | deltnseg: 0, |
| 486 | deltoffst: [0; 8], |
| 487 | deltlen: [0; 8], |
| 488 | deltba: [0; 8], |
| 489 | |
| 490 | bap: [0; 256], |
| 491 | exps: [0; 256], |
| 492 | mant: [0; 256], |
| 493 | |
| 494 | psd: [0; 256], |
| 495 | bndpsd: [0; 64], |
| 496 | } |
| 497 | } |
| 498 | fn read_strategy(&mut self, br: &mut BitReader, blk_no: usize) -> DecoderResult<()> { |
| 499 | self.expstr = br.read(2)? as u8; |
| 500 | validate!(blk_no != 0 || self.expstr != STRATEGY_REUSE); |
| 501 | if self.expstr != STRATEGY_REUSE { |
| 502 | if self.startmant > 0 { |
| 503 | self.groups = (self.endmant - self.startmant) / GROUPS[self.expstr as usize]; |
| 504 | } else if self.endmant != 0{ |
| 505 | let idx = self.expstr as usize; |
| 506 | self.groups = (self.endmant + GROUP_BIAS[idx] - 1) / GROUPS[idx]; |
| 507 | } else { |
| 508 | self.groups = 0; |
| 509 | } |
| 510 | } |
| 511 | Ok(()) |
| 512 | } |
| 513 | fn read_exps(&mut self, br: &mut BitReader, is_cpl: bool, is_lfe: bool) -> DecoderResult<()> { |
| 514 | if self.expstr == STRATEGY_REUSE { return Ok(()); } |
| 515 | let grpsize = GROUPS[self.expstr as usize]; |
| 516 | self.exps = [0; 256]; |
| 517 | if is_cpl { |
| 518 | let first = (br.read(4)? as u8) << 1; |
| 519 | let out = &mut self.exps[self.startmant..self.endmant]; |
| 520 | decode_exps(br, out, first, grpsize)?; |
| 521 | } else if !is_lfe { |
| 522 | self.exps[0] = br.read(4)? as u8; |
| 523 | let first = self.exps[0]; |
| 524 | let out = &mut self.exps[1..self.endmant]; |
| 525 | decode_exps(br, out, first, grpsize)?; |
| 526 | self.gainrng = br.read(2)? as u8; |
| 527 | } else { |
| 528 | self.exps[0] = br.read(4)? as u8; |
| 529 | let first = self.exps[0]; |
| 530 | let out = &mut self.exps[1..7]; |
| 531 | decode_exps(br, out, first, grpsize)?; |
| 532 | } |
| 533 | Ok(()) |
| 534 | } |
| 535 | fn read_snr(&mut self, br: &mut BitReader) -> DecoderResult<()> { |
| 536 | self.fsnroffst = br.read(4)? as u8; |
| 537 | self.fgaincod = br.read(3)? as usize; |
| 538 | Ok(()) |
| 539 | } |
| 540 | fn read_deltbai(&mut self, br: &mut BitReader) -> DecoderResult<()> { |
| 541 | if self.deltbae == 1 { |
| 542 | self.deltnseg = (br.read(3)? as usize) + 1; |
| 543 | for seg in 0..self.deltnseg { |
| 544 | self.deltoffst[seg] = br.read(5)? as u8; |
| 545 | self.deltlen[seg] = br.read(4)? as usize; |
| 546 | self.deltba[seg] = br.read(3)? as u8; |
| 547 | } |
| 548 | } |
| 549 | Ok(()) |
| 550 | } |
| 551 | |
| 552 | fn compute_bndpsd(&mut self) { |
| 553 | let start = self.startmant; |
| 554 | let end = self.endmant; |
| 555 | let exps = &mut self.exps; |
| 556 | let psd = &mut self.psd; |
| 557 | let bndpsd = &mut self.bndpsd; |
| 558 | |
| 559 | for bin in start..end { |
| 560 | psd[bin] = 3072 - ((exps[bin] as i16) << 7); |
| 561 | } |
| 562 | |
| 563 | let mut bin = start; |
| 564 | let mut band = TS102366_BIN_TO_BAND[bin] as usize; |
| 565 | let mut lastbin; |
| 566 | loop { |
| 567 | lastbin = ((TS102366_BAND_START[band] as usize) + (TS102366_BAND_SIZE[band] as usize)).min(end); |
| 568 | bndpsd[band] = psd[bin] as i32; |
| 569 | bin += 1; |
| 570 | while bin < lastbin { |
| 571 | bndpsd[band] = logadd(bndpsd[band], psd[bin] as i32); |
| 572 | bin += 1; |
| 573 | } |
| 574 | band += 1; |
| 575 | if lastbin >= end { break; } |
| 576 | } |
| 577 | } |
| 578 | fn compute_mask(&mut self, mask: &mut [i32; MAX_BANDS], fscod: usize, sgain: u16, fdecay: u8, sdecay: u8, |
| 579 | dbknee: u16, cplfleak: u16, cplsleak: u16, shift: u8) { |
| 580 | let fgain = TS102366_FAST_GAIN[self.fgaincod] as i32; |
| 581 | |
| 582 | let bndstart = TS102366_BIN_TO_BAND[self.startmant] as usize; |
| 583 | let bndend = (TS102366_BIN_TO_BAND[self.endmant - 1] as usize) + 1; |
| 584 | |
| 585 | let mut excite: [i32; MAX_BANDS] = [0; MAX_BANDS]; |
| 586 | |
| 587 | let begin; |
| 588 | let mut fast_leak; |
| 589 | let mut slow_leak; |
| 590 | if bndstart == 0 { |
| 591 | let lowcomp0 = calc_lowcomp(0, self.bndpsd[0], self.bndpsd[1], 0); |
| 592 | excite[0] = self.bndpsd[0] - fgain - lowcomp0; |
| 593 | let lowcomp1 = calc_lowcomp(lowcomp0, self.bndpsd[1], self.bndpsd[2], 1); |
| 594 | excite[1] = self.bndpsd[1] - fgain - lowcomp1; |
| 595 | let mut sband = 7; |
| 596 | let mut lowcomp = lowcomp1; |
| 597 | fast_leak = 0; |
| 598 | slow_leak = 0; |
| 599 | for band in 2..7 { |
| 600 | let not_lfe_case = (bndend != 7) || (band != 6); |
| 601 | if not_lfe_case { |
| 602 | lowcomp = calc_lowcomp(lowcomp, self.bndpsd[band], self.bndpsd[band + 1], band); |
| 603 | } |
| 604 | fast_leak = self.bndpsd[band] - fgain; |
| 605 | slow_leak = self.bndpsd[band] - (sgain as i32); |
| 606 | excite[band] = fast_leak - lowcomp; |
| 607 | if not_lfe_case { |
| 608 | if self.bndpsd[band] <= self.bndpsd[band + 1] { |
| 609 | sband = band + 1; |
| 610 | break; |
| 611 | } |
| 612 | } |
| 613 | } |
| 614 | for band in sband..bndend.min(22) { |
| 615 | if (bndend != 7) || (band != 6) { |
| 616 | lowcomp = calc_lowcomp(lowcomp, self.bndpsd[band], self.bndpsd[band + 1], band); |
| 617 | } |
| 618 | fast_leak = (fast_leak - (fdecay as i32)).max(self.bndpsd[band] - (fgain as i32)); |
| 619 | slow_leak = (slow_leak - (sdecay as i32)).max(self.bndpsd[band] - (sgain as i32)); |
| 620 | excite[band] = slow_leak.max(fast_leak - lowcomp); |
| 621 | } |
| 622 | begin = 22; |
| 623 | } else { |
| 624 | begin = bndstart; |
| 625 | fast_leak = cplfleak as i32; |
| 626 | slow_leak = cplsleak as i32; |
| 627 | } |
| 628 | for band in begin..bndend { |
| 629 | fast_leak = (fast_leak - (fdecay as i32)).max(self.bndpsd[band] - (fgain as i32)); |
| 630 | slow_leak = (slow_leak - (sdecay as i32)).max(self.bndpsd[band] - (sgain as i32)); |
| 631 | excite[band] = fast_leak.max(slow_leak); |
| 632 | } |
| 633 | for band in bndstart..bndend { |
| 634 | if self.bndpsd[band] < (dbknee as i32) { |
| 635 | excite[band] += ((dbknee as i32) - self.bndpsd[band]) >> 2; |
| 636 | } |
| 637 | mask[band] = excite[band].max(TS102366_HTH[fscod][band >> shift] as i32); |
| 638 | } |
| 639 | } |
| 640 | fn apply_delta_info(&mut self, mask: &mut [i32; MAX_BANDS]) { |
| 641 | if self.deltbae == 0 || self.deltbae == 1 { |
| 642 | let mut band = TS102366_BIN_TO_BAND[self.startmant] as usize; |
| 643 | for seg in 0..self.deltnseg { |
| 644 | band += self.deltoffst[seg] as usize; |
| 645 | let delta = if self.deltba[seg] >= 4 { |
| 646 | ((self.deltba[seg] as i32) - 3) << 7 |
| 647 | } else { |
| 648 | ((self.deltba[seg] as i32) - 4) << 7 |
| 649 | }; |
| 650 | if band + self.deltlen[seg] > MAX_BANDS { break; } |
| 651 | for _ in 0..self.deltlen[seg] { |
| 652 | mask[band] += delta; |
| 653 | band += 1; |
| 654 | } |
| 655 | } |
| 656 | } |
| 657 | } |
| 658 | fn calc_snr_offset(&mut self, csnroffst: u8) { |
| 659 | self.snroffset = ((((csnroffst as i32) - 15) << 4) + (self.fsnroffst as i32)) << 2; |
| 660 | } |
| 661 | fn compute_bap(&mut self, mask: &mut [i32; MAX_BANDS], floor: u16) { |
| 662 | let end = self.endmant; |
| 663 | let mut band = TS102366_BIN_TO_BAND[self.startmant] as usize; |
| 664 | let mut bin = self.startmant; |
| 665 | let mut lastbin; |
| 666 | loop { |
| 667 | lastbin = ((TS102366_BAND_START[band] as usize) + (TS102366_BAND_SIZE[band] as usize)).min(end); |
| 668 | mask[band] = (mask[band] - self.snroffset - (floor as i32)).max(0) & 0x1FE0; |
| 669 | mask[band] += floor as i32; |
| 670 | while bin < lastbin { |
| 671 | let addr = (((self.psd[bin] as i32) - mask[band]) >> 5).min(63).max(0) as usize; |
| 672 | self.bap[bin] = TS102366_BAPTAB[addr]; |
| 673 | bin += 1; |
| 674 | } |
| 675 | if lastbin == end { break; } |
| 676 | band += 1; |
| 677 | } |
| 678 | } |
| 679 | fn read_mant(&mut self, br: &mut BitReader, bap_buf: &mut [[i32; 2]; 3], bap_buf_fill: &mut [usize; 3]) -> DecoderResult<()> { |
| 680 | self.mant = [0; BLOCK_LEN]; |
| 681 | for bin in self.startmant..self.endmant { |
| 682 | self.mant[bin] = match self.bap[bin] { |
| 683 | 0 => { |
| 684 | if self.dithflag { |
| 685 | 42 // todo dither |
| 686 | } else { |
| 687 | 0 |
| 688 | } |
| 689 | }, |
| 690 | 1 => { read_bap!(br, TS102366_QUANT3_MAP, 5, 0, bap_buf, bap_buf_fill) }, |
| 691 | 2 => { read_bap!(br, TS102366_QUANT5_MAP, 7, 1, bap_buf, bap_buf_fill) }, |
| 692 | 3 => { read_bap!(br, TS102366_QUANT7_MAP, 3) }, |
| 693 | 4 => { read_bap!(br, TS102366_QUANT11_MAP, 7, 2, bap_buf, bap_buf_fill) }, |
| 694 | 5 => { read_bap!(br, TS102366_QUANT15_MAP, 4) }, |
| 695 | _ => { |
| 696 | validate!(self.bap[bin] < 15); |
| 697 | let nbits = TS102366_BAP_BITS[(self.bap[bin] as usize) - 6]; |
| 698 | let val = br.read(nbits)? as i16; |
| 699 | ((val << (16 - nbits)) as i32) << 9 |
| 700 | }, |
| 701 | }; |
| 702 | self.mant[bin] >>= self.exps[bin]; |
| 703 | } |
| 704 | Ok(()) |
| 705 | } |
| 706 | |
| 707 | fn synth(&mut self, imdct512: &mut IMDCTContext, imdct256: &mut IMDCTContext, tmp: &mut IMDCTWorkspace, delay: &mut [f32; BLOCK_LEN], dst: &mut [f32]) { |
| 708 | if !self.blksw { |
| 709 | imdct512.do_imdct(&self.mant, tmp); |
| 710 | } else { |
| 711 | imdct256.do_imdct_ileave(&self.mant, tmp); |
| 712 | } |
| 713 | overlap(delay, &tmp.out, dst); |
| 714 | } |
| 715 | } |
| 716 | |
| 717 | fn logadd(acc: i32, add: i32) -> i32 { |
| 718 | let c = acc - add; |
| 719 | let addr = (c.abs() >> 1).min(255); |
| 720 | if c >= 0 { |
| 721 | acc + (TS102366_LATAB[addr as usize] as i32) |
| 722 | } else { |
| 723 | add + (TS102366_LATAB[addr as usize] as i32) |
| 724 | } |
| 725 | } |
| 726 | |
| 727 | fn calc_lowcomp(a: i32, b0: i32, b1: i32, band: usize) -> i32 { |
| 728 | if band < 7 { |
| 729 | if (b0 + 256) == b1 { |
| 730 | 384 |
| 731 | } else if b0 > b1 { |
| 732 | 0.max(a - 64) |
| 733 | } else { |
| 734 | a |
| 735 | } |
| 736 | } else if band < 20 { |
| 737 | if (b0 + 256) == b1 { |
| 738 | 320 |
| 739 | } else if b0 > b1 { |
| 740 | 0.max(a - 64) |
| 741 | } else { |
| 742 | a |
| 743 | } |
| 744 | } else { |
| 745 | 0.max(a - 128) |
| 746 | } |
| 747 | } |
| 748 | |
| 749 | fn overlap(delay: &mut [f32; BLOCK_LEN], src: &[f32; BLOCK_LEN * 2], out: &mut [f32]) { |
| 750 | { |
| 751 | let dly = &delay; |
| 752 | for ((d, s), o) in dly.into_iter().zip(src.into_iter()).zip(out.iter_mut()) { |
| 753 | *o = (*d + *s) * 2.0; |
| 754 | } |
| 755 | } |
| 756 | delay.copy_from_slice(&src[BLOCK_LEN..]); |
| 757 | } |
| 758 | |
| 759 | #[derive(Clone)] |
| 760 | struct AudioBlock { |
| 761 | dynrng: Option<u8>, |
| 762 | dynrng2: Option<u8>, |
| 763 | |
| 764 | cplstre: bool, |
| 765 | cplinu: bool, |
| 766 | phsflginu: bool, |
| 767 | cplbegf: usize, |
| 768 | cplendf: usize, |
| 769 | ncplsubnd: usize, |
| 770 | ncplbnd: usize, |
| 771 | cplbndstrc: [bool; MAX_CPLBANDS], |
| 772 | |
| 773 | phsflg: [bool; MAX_CPLBANDS], |
| 774 | rematstr: bool, |
| 775 | rematflg: [bool; 4], |
| 776 | |
| 777 | chdata: [ChannelData; MAX_CHANNELS + 2], |
| 778 | |
| 779 | baie: bool, |
| 780 | fdcycod: usize, |
| 781 | sdcycod: usize, |
| 782 | sgaincod: usize, |
| 783 | dbpbcod: usize, |
| 784 | floorcod: usize, |
| 785 | snroffste: bool, |
| 786 | csnroffst: u8, |
| 787 | cplleake: bool, |
| 788 | cplfleak: u8, |
| 789 | cplsleak: u8, |
| 790 | |
| 791 | deltbaie: bool, |
| 792 | |
| 793 | bap_buf: [[i32; 2]; 3], |
| 794 | bap_buf_fill: [usize; 3], |
| 795 | } |
| 796 | |
| 797 | impl AudioBlock { |
| 798 | fn new() -> Self { |
| 799 | AudioBlock { |
| 800 | chdata: [ChannelData::new(); MAX_CHANNELS + 2], |
| 801 | |
| 802 | dynrng: None, |
| 803 | dynrng2: None, |
| 804 | |
| 805 | cplstre: false, |
| 806 | cplinu: false, |
| 807 | phsflginu: false, |
| 808 | cplbegf: 0, |
| 809 | cplendf: 0, |
| 810 | ncplsubnd: 0, |
| 811 | ncplbnd: 0, |
| 812 | cplbndstrc: [false; MAX_CPLBANDS], |
| 813 | |
| 814 | phsflg: [false; MAX_CPLBANDS], |
| 815 | rematstr: false, |
| 816 | rematflg: [false; 4], |
| 817 | |
| 818 | baie: false, |
| 819 | sdcycod: 0, |
| 820 | fdcycod: 0, |
| 821 | sgaincod: 0, |
| 822 | dbpbcod: 0, |
| 823 | floorcod: 0, |
| 824 | snroffste: false, |
| 825 | csnroffst: 0, |
| 826 | cplleake: false, |
| 827 | cplfleak: 0, |
| 828 | cplsleak: 0, |
| 829 | |
| 830 | deltbaie: false, |
| 831 | |
| 832 | bap_buf: [[0; 2]; 3], |
| 833 | bap_buf_fill: [0; 3], |
| 834 | } |
| 835 | } |
| 836 | fn read(&mut self, br: &mut BitReader, bsi: &BSI, fscod: usize, blk_no: usize) -> DecoderResult<bool> { |
| 837 | let channels = bsi.acmod.get_num_channels(); |
| 838 | let is_stereo = bsi.acmod == ACMode::Stereo; |
| 839 | |
| 840 | for ch in 0..channels { |
| 841 | self.chdata[ch].blksw = br.read_bool()?; |
| 842 | } |
| 843 | // dynamic range information |
| 844 | for ch in 0..channels { |
| 845 | self.chdata[ch].dithflag = br.read_bool()?; |
| 846 | } |
| 847 | self.dynrng = br.read_optional8()?; |
| 848 | if bsi.acmod == ACMode::DualMono { |
| 849 | self.dynrng2 = br.read_optional8()?; |
| 850 | } |
| 851 | // coupling strategy information |
| 852 | self.cplstre = br.read_bool()?; |
| 853 | validate!((blk_no != 0) || self.cplstre); |
| 854 | if self.cplstre { |
| 855 | self.cplinu = br.read_bool()?; |
| 856 | if self.cplinu { |
| 857 | for ch in 0..channels { |
| 858 | self.chdata[ch].chincpl = br.read_bool()?; |
| 859 | } |
| 860 | if is_stereo { |
| 861 | self.phsflginu = br.read_bool()?; |
| 862 | } |
| 863 | self.cplbegf = br.read(4)? as usize; |
| 864 | self.cplendf = (br.read(4)? as usize) + 3; |
| 865 | validate!(self.cplendf >= self.cplbegf); |
| 866 | self.ncplsubnd = self.cplendf - self.cplbegf; |
| 867 | self.ncplbnd = self.ncplsubnd; |
| 868 | self.chdata[CPL_CHANNEL].startmant = self.cplbegf * 12 + 37; |
| 869 | self.chdata[CPL_CHANNEL].endmant = self.cplendf * 12 + 37; |
| 870 | for bnd in 1..self.ncplsubnd { |
| 871 | self.cplbndstrc[bnd] = br.read_bool()?; |
| 872 | if self.cplbndstrc[bnd] { |
| 873 | self.ncplbnd -= 1; |
| 874 | } |
| 875 | } |
| 876 | } |
| 877 | } |
| 878 | // coupling coordinates |
| 879 | if self.cplinu { |
| 880 | for c in 0..channels { |
| 881 | let ch = &mut self.chdata[c]; |
| 882 | if ch.chincpl { |
| 883 | ch.cplcoe = br.read_bool()?; |
| 884 | if ch.cplcoe { |
| 885 | ch.mstrcplco = br.read(2)? as u8; |
| 886 | for bnd in 0..self.ncplbnd { |
| 887 | ch.cplcoexp [bnd] = br.read(4)? as u8; |
| 888 | ch.cplcomant[bnd] = br.read(4)? as u8; |
| 889 | } |
| 890 | } |
| 891 | } |
| 892 | } |
| 893 | if is_stereo && self.phsflginu && (self.chdata[0].cplcoe || self.chdata[1].cplcoe) { |
| 894 | for bnd in 0..self.ncplbnd { |
| 895 | self.phsflg[bnd] = br.read_bool()?; |
| 896 | } |
| 897 | } |
| 898 | } else { |
| 899 | for ch in 0..channels { |
| 900 | self.chdata[ch].chincpl = false; |
| 901 | } |
| 902 | } |
| 903 | // stereo rematrixing |
| 904 | if is_stereo { |
| 905 | self.rematstr = br.read_bool()?; |
| 906 | if self.rematstr { |
| 907 | if self.cplbegf > 2 || !self.cplinu { |
| 908 | for rbnd in 0..4 { |
| 909 | self.rematflg[rbnd] = br.read_bool()?; |
| 910 | } |
| 911 | } |
| 912 | if self.cplbegf > 0 && self.cplbegf <= 2 && self.cplinu { |
| 913 | for rbnd in 0..3 { |
| 914 | self.rematflg[rbnd] = br.read_bool()?; |
| 915 | } |
| 916 | } |
| 917 | if self.cplbegf == 0 && self.cplinu { |
| 918 | for rbnd in 0..2 { |
| 919 | self.rematflg[rbnd] = br.read_bool()?; |
| 920 | } |
| 921 | } |
| 922 | } |
| 923 | } |
| 924 | // exponent strategy |
| 925 | if self.cplinu { |
| 926 | self.chdata[CPL_CHANNEL].read_strategy(br, blk_no)?; |
| 927 | } |
| 928 | for ch in 0..channels { |
| 929 | self.chdata[ch].read_strategy(br, blk_no)?; |
| 930 | } |
| 931 | if bsi.lfeon { |
| 932 | self.chdata[LFE_CHANNEL].expstr = br.read(1)? as u8; |
| 933 | validate!(blk_no != 0 || self.chdata[LFE_CHANNEL].expstr != STRATEGY_REUSE); |
| 934 | self.chdata[LFE_CHANNEL].groups = 2; |
| 935 | self.chdata[LFE_CHANNEL].startmant = 0; |
| 936 | self.chdata[LFE_CHANNEL].endmant = 7; |
| 937 | } |
| 938 | let cpl_startmant = self.chdata[CPL_CHANNEL].startmant; |
| 939 | for c in 0..channels { |
| 940 | let ch = &mut self.chdata[c]; |
| 941 | if ch.expstr != STRATEGY_REUSE && !ch.chincpl { |
| 942 | ch.chbwcod = br.read(6)? as u8; |
| 943 | } |
| 944 | if !ch.chincpl { |
| 945 | ch.startmant = 0; |
| 946 | ch.endmant = ((ch.chbwcod as usize) + 12) * 3 + 37; |
| 947 | } else { |
| 948 | ch.startmant = 0; |
| 949 | ch.endmant = cpl_startmant; |
| 950 | } |
| 951 | } |
| 952 | // set number of mantissas |
| 953 | if self.cplinu { |
| 954 | self.chdata[CPL_CHANNEL].read_exps(br, true, false)?; |
| 955 | } |
| 956 | for ch in 0..channels { |
| 957 | self.chdata[ch].read_exps(br, false, false)?; |
| 958 | } |
| 959 | if bsi.lfeon { |
| 960 | self.chdata[LFE_CHANNEL].read_exps(br, false, true)?; |
| 961 | } |
| 962 | // bit allocation parameters |
| 963 | self.baie = br.read_bool()?; |
| 964 | if self.baie { |
| 965 | self.sdcycod = br.read(2)? as usize; |
| 966 | self.fdcycod = br.read(2)? as usize; |
| 967 | self.sgaincod = br.read(2)? as usize; |
| 968 | self.dbpbcod = br.read(2)? as usize; |
| 969 | self.floorcod = br.read(3)? as usize; |
| 970 | } |
| 971 | self.snroffste = br.read_bool()?; |
| 972 | if self.snroffste { |
| 973 | self.csnroffst = br.read(6)? as u8; |
| 974 | if self.cplinu { |
| 975 | self.chdata[CPL_CHANNEL].read_snr(br)?; |
| 976 | } |
| 977 | for ch in 0..channels { |
| 978 | self.chdata[ch].read_snr(br)?; |
| 979 | } |
| 980 | if bsi.lfeon { |
| 981 | self.chdata[LFE_CHANNEL].read_snr(br)?; |
| 982 | } |
| 983 | } |
| 984 | if self.cplinu { |
| 985 | self.cplleake = br.read_bool()?; |
| 986 | if self.cplleake { |
| 987 | self.cplfleak = br.read(3)? as u8; |
| 988 | self.cplsleak = br.read(3)? as u8; |
| 989 | } |
| 990 | } |
| 991 | // delta bit allocation information |
| 992 | self.deltbaie = br.read_bool()?; |
| 993 | if self.deltbaie { |
| 994 | if self.cplinu { |
| 995 | self.chdata[CPL_CHANNEL].deltbae = br.read(2)? as u8; |
| 996 | validate!(blk_no != 0 || self.chdata[CPL_CHANNEL].deltbae != 0); |
| 997 | validate!(self.chdata[CPL_CHANNEL].deltbae != 3); |
| 998 | } |
| 999 | for ch in 0..channels { |
| 1000 | self.chdata[ch].deltbae = br.read(2)? as u8; |
| 1001 | validate!(blk_no != 0 || self.chdata[ch].deltbae != 0); |
| 1002 | validate!(self.chdata[ch].deltbae != 3); |
| 1003 | } |
| 1004 | if self.cplinu { |
| 1005 | self.chdata[CPL_CHANNEL].read_deltbai(br)?; |
| 1006 | } |
| 1007 | for ch in 0..channels { |
| 1008 | self.chdata[ch].read_deltbai(br)?; |
| 1009 | } |
| 1010 | } |
| 1011 | // dummy data |
| 1012 | if br.read_bool()? { |
| 1013 | let skipl = br.read(9)?; |
| 1014 | br.skip(skipl * 8)?; |
| 1015 | } |
| 1016 | |
| 1017 | let all_zero = self.calc_bitalloc(bsi, channels, fscod); |
| 1018 | if all_zero { return Ok(true); } |
| 1019 | |
| 1020 | // quantised mantissa values |
| 1021 | let mut got_cplchan = false; |
| 1022 | for i in 0..self.bap_buf_fill.len() { self.bap_buf_fill[i] = 0; } |
| 1023 | for c in 0..channels { |
| 1024 | { |
| 1025 | let ch = &mut self.chdata[c]; |
| 1026 | ch.read_mant(br, &mut self.bap_buf, &mut self.bap_buf_fill)?; |
| 1027 | } |
| 1028 | if self.cplinu && self.chdata[c].chincpl && !got_cplchan { |
| 1029 | let cplch = &mut self.chdata[CPL_CHANNEL]; |
| 1030 | cplch.read_mant(br, &mut self.bap_buf, &mut self.bap_buf_fill)?; |
| 1031 | got_cplchan = true; |
| 1032 | } |
| 1033 | } |
| 1034 | if bsi.lfeon { |
| 1035 | let lfech = &mut self.chdata[LFE_CHANNEL]; |
| 1036 | lfech.read_mant(br, &mut self.bap_buf, &mut self.bap_buf_fill)?; |
| 1037 | } |
| 1038 | Ok(false) |
| 1039 | } |
| 1040 | fn calc_bitalloc(&mut self, bsi: &BSI, channels: usize, fscod: usize) -> bool { |
| 1041 | let sdecay1 = TS102366_SLOW_DECAY[self.sdcycod]; |
| 1042 | let fdecay1 = TS102366_FAST_DECAY[self.fdcycod]; |
| 1043 | |
| 1044 | let sdecay = sdecay1 >> bsi.shift; |
| 1045 | let fdecay = fdecay1 >> bsi.shift; |
| 1046 | let sgain = TS102366_SLOW_GAIN[self.sgaincod]; |
| 1047 | let dbknee = TS102366_DBP_TAB[self.dbpbcod]; |
| 1048 | let floor = TS102366_FLOOR_TAB[self.floorcod]; |
| 1049 | |
| 1050 | let mut all_zero = self.csnroffst == 0; |
| 1051 | if !all_zero && self.chdata[LFE_CHANNEL].fsnroffst == 0 { |
| 1052 | for ch in 0..channels { |
| 1053 | if self.chdata[ch].fsnroffst != 0 { |
| 1054 | all_zero = false; |
| 1055 | break; |
| 1056 | } |
| 1057 | } |
| 1058 | } |
| 1059 | if all_zero { return true; } |
| 1060 | |
| 1061 | let mut mask: [i32; MAX_BANDS] = [0; MAX_BANDS]; |
| 1062 | |
| 1063 | if self.cplinu { |
| 1064 | self.chdata[CPL_CHANNEL].compute_bndpsd(); |
| 1065 | self.chdata[CPL_CHANNEL].compute_mask(&mut mask, fscod, sgain, fdecay, sdecay, dbknee, |
| 1066 | ((self.cplfleak as u16) << 8) + 768, ((self.cplsleak as u16) << 8) + 768, bsi.shift); |
| 1067 | self.chdata[CPL_CHANNEL].apply_delta_info(&mut mask); |
| 1068 | self.chdata[CPL_CHANNEL].calc_snr_offset(self.csnroffst); |
| 1069 | self.chdata[CPL_CHANNEL].compute_bap(&mut mask, floor); |
| 1070 | } |
| 1071 | for ch in 0..channels { |
| 1072 | self.chdata[ch].compute_bndpsd(); |
| 1073 | self.chdata[ch].compute_mask(&mut mask, fscod, sgain, fdecay, sdecay, dbknee, 0, 0, bsi.shift); |
| 1074 | self.chdata[ch].apply_delta_info(&mut mask); |
| 1075 | self.chdata[ch].calc_snr_offset(self.csnroffst); |
| 1076 | self.chdata[ch].compute_bap(&mut mask, floor); |
| 1077 | } |
| 1078 | if bsi.lfeon { |
| 1079 | self.chdata[LFE_CHANNEL].compute_bndpsd(); |
| 1080 | self.chdata[LFE_CHANNEL].compute_mask(&mut mask, fscod, sgain, fdecay, sdecay, dbknee, |
| 1081 | 0, 0, bsi.shift); |
| 1082 | self.chdata[LFE_CHANNEL].calc_snr_offset(self.csnroffst); |
| 1083 | self.chdata[LFE_CHANNEL].compute_bap(&mut mask, floor); |
| 1084 | } |
| 1085 | |
| 1086 | false |
| 1087 | } |
| 1088 | fn couple_channels(&mut self, acmod: ACMode) { |
| 1089 | if !self.cplinu { return; } |
| 1090 | for ch in 0..acmod.get_num_channels() { |
| 1091 | if !self.chdata[ch].chincpl { continue; } |
| 1092 | let mut pband = 0; |
| 1093 | for band in self.cplbegf..self.cplendf { |
| 1094 | let cband = band - self.cplbegf; |
| 1095 | let comant = self.chdata[ch].cplcomant[cband]; |
| 1096 | let mut cotemp = (if self.chdata[ch].cplcoexp[cband] == 15 { comant << 1 } else { comant + 16 }) as i32; |
| 1097 | if (acmod == ACMode::Stereo) && (ch == 1) && self.phsflginu && self.phsflg[pband] { |
| 1098 | cotemp = -cotemp; |
| 1099 | } |
| 1100 | if !self.cplbndstrc[cband] { |
| 1101 | pband += 1; |
| 1102 | } |
| 1103 | let exp = self.chdata[ch].cplcoexp[cband] + 3 * self.chdata[ch].mstrcplco + 5 - 3; |
| 1104 | let start = band * 12 + 37; |
| 1105 | for bin in 0..12 { |
| 1106 | self.chdata[ch].mant[start + bin] = self.chdata[CPL_CHANNEL].mant[start + bin] * cotemp >> exp; |
| 1107 | } |
| 1108 | //todo dither |
| 1109 | } |
| 1110 | } |
| 1111 | } |
| 1112 | fn rematrix(&mut self) { |
| 1113 | let maxbin = self.chdata[0].endmant.min(self.chdata[1].endmant); |
| 1114 | if self.rematflg[0] { |
| 1115 | let end = maxbin.min(25); |
| 1116 | for bin in 13..end { |
| 1117 | let s = self.chdata[0].mant[bin] + self.chdata[1].mant[bin]; |
| 1118 | let d = self.chdata[0].mant[bin] - self.chdata[1].mant[bin]; |
| 1119 | self.chdata[0].mant[bin] = d; |
| 1120 | self.chdata[1].mant[bin] = s; |
| 1121 | } |
| 1122 | if maxbin <= 25 { return; } |
| 1123 | } |
| 1124 | if self.rematflg[1] { |
| 1125 | let end = maxbin.min(37); |
| 1126 | for bin in 25..end { |
| 1127 | let s = self.chdata[0].mant[bin] + self.chdata[1].mant[bin]; |
| 1128 | let d = self.chdata[0].mant[bin] - self.chdata[1].mant[bin]; |
| 1129 | self.chdata[0].mant[bin] = d; |
| 1130 | self.chdata[1].mant[bin] = s; |
| 1131 | } |
| 1132 | if maxbin <= 37 { return; } |
| 1133 | } |
| 1134 | if self.rematflg[2] { |
| 1135 | let end = maxbin.min(61); |
| 1136 | for bin in 37..end { |
| 1137 | let s = self.chdata[0].mant[bin] + self.chdata[1].mant[bin]; |
| 1138 | let d = self.chdata[0].mant[bin] - self.chdata[1].mant[bin]; |
| 1139 | self.chdata[0].mant[bin] = d; |
| 1140 | self.chdata[1].mant[bin] = s; |
| 1141 | } |
| 1142 | if maxbin <= 61 { return; } |
| 1143 | } |
| 1144 | if self.rematflg[3] { |
| 1145 | let end = maxbin; |
| 1146 | for bin in 61..end { |
| 1147 | let s = self.chdata[0].mant[bin] + self.chdata[1].mant[bin]; |
| 1148 | let d = self.chdata[0].mant[bin] - self.chdata[1].mant[bin]; |
| 1149 | self.chdata[0].mant[bin] = d; |
| 1150 | self.chdata[1].mant[bin] = s; |
| 1151 | } |
| 1152 | } |
| 1153 | } |
| 1154 | fn synth_audio_block(&mut self, imdct512: &mut IMDCTContext, imdct256: &mut IMDCTContext, tmp: &mut IMDCTWorkspace, channel: usize, delay: &mut [f32; BLOCK_LEN], dst: &mut [f32]) { |
| 1155 | self.chdata[channel].synth(imdct512, imdct256, tmp, delay, dst); |
| 1156 | } |
| 1157 | } |
| 1158 | |
| 1159 | impl NADecoder for AudioDecoder { |
| 1160 | fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> { |
| 1161 | if let NACodecTypeInfo::Audio(_) = info.get_properties() { |
| 1162 | self.info = info.clone(); |
| 1163 | Ok(()) |
| 1164 | } else { |
| 1165 | Err(DecoderError::InvalidData) |
| 1166 | } |
| 1167 | } |
| 1168 | fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> { |
| 1169 | let info = pkt.get_stream().get_info(); |
| 1170 | validate!(info.get_properties().is_audio()); |
| 1171 | let pktbuf = pkt.get_buffer(); |
| 1172 | validate!(pktbuf.len() > 5); |
| 1173 | |
| 1174 | let mut br; |
| 1175 | if (pktbuf[0] == MAGIC_BYTE0) && (pktbuf[1] == MAGIC_BYTE1) { |
| 1176 | br = BitReader::new(pktbuf.as_slice(), pktbuf.len(), BitReaderMode::BE); |
| 1177 | } else if (pktbuf[0] == MAGIC_BYTE1) && (pktbuf[1] == MAGIC_BYTE0) { |
| 1178 | br = BitReader::new(pktbuf.as_slice(), pktbuf.len(), BitReaderMode::LE16MSB); |
| 1179 | } else { |
| 1180 | return Err(DecoderError::InvalidData); |
| 1181 | } |
| 1182 | |
| 1183 | let sinfo = Syncinfo::read(&mut br)?; |
| 1184 | validate!(sinfo.is_valid()); |
| 1185 | |
| 1186 | let bsi = BSI::read(&mut br)?; |
| 1187 | if bsi.has_addb { |
| 1188 | let len = br.read(6)? as u32; |
| 1189 | br.skip((len + 1) * 8)?; |
| 1190 | } |
| 1191 | |
| 1192 | let duration = BLOCK_LEN * NBLOCKS; |
| 1193 | |
| 1194 | let core_channels = bsi.acmod.get_num_channels(); |
| 1195 | let channels = core_channels + if bsi.lfeon { 1 } else { 0 }; |
| 1196 | |
| 1197 | let ainfo = NAAudioInfo::new(sinfo.samplerate >> bsi.shift, channels as u8, |
| 1198 | SND_F32P_FORMAT, BLOCK_LEN); |
| 1199 | |
| 1200 | let abuf = alloc_audio_buffer(ainfo, duration, bsi.acmod.get_channel_map(bsi.lfeon))?; |
| 1201 | let mut adata = abuf.get_abuf_f32().unwrap(); |
| 1202 | let output = adata.get_data_mut().unwrap(); |
| 1203 | |
| 1204 | self.ablk = AudioBlock::new(); |
| 1205 | for blk in 0..NBLOCKS { |
| 1206 | let all_zero = self.ablk.read(&mut br, &bsi, sinfo.fscod as usize, blk)?; |
| 1207 | let off = blk * BLOCK_LEN; |
| 1208 | self.ablk.couple_channels(bsi.acmod); |
| 1209 | if bsi.acmod == ACMode::Stereo { |
| 1210 | self.ablk.rematrix(); |
| 1211 | } |
| 1212 | for ch in 0..core_channels { |
| 1213 | let dpos = abuf.get_offset(ch) + off; |
| 1214 | let dst = &mut output[dpos..][..BLOCK_LEN]; |
| 1215 | if !all_zero { |
| 1216 | self.ablk.synth_audio_block(&mut self.imdct512, &mut self.imdct256, &mut self.tmp, ch, &mut self.delay[ch], dst); |
| 1217 | } else { |
| 1218 | self.delay[ch] = [0.0; BLOCK_LEN]; |
| 1219 | for i in 0..BLOCK_LEN { dst[i] = 0.0; } |
| 1220 | } |
| 1221 | } |
| 1222 | if bsi.lfeon { |
| 1223 | let dpos = abuf.get_offset(core_channels) + off; |
| 1224 | let dst = &mut output[dpos..][..BLOCK_LEN]; |
| 1225 | if !all_zero { |
| 1226 | self.ablk.synth_audio_block(&mut self.imdct512, &mut self.imdct256, &mut self.tmp, LFE_CHANNEL, &mut self.delay[LFE_CHANNEL], dst); |
| 1227 | } else { |
| 1228 | self.delay[LFE_CHANNEL] = [0.0; BLOCK_LEN]; |
| 1229 | for i in 0..BLOCK_LEN { dst[i] = 0.0; } |
| 1230 | } |
| 1231 | } |
| 1232 | } |
| 1233 | //todo skip auxdata |
| 1234 | //todo do errorcheck |
| 1235 | |
| 1236 | let mut frm = NAFrame::new_from_pkt(pkt, self.info.replace_info(NACodecTypeInfo::Audio(ainfo)), abuf); |
| 1237 | frm.set_keyframe(true); |
| 1238 | Ok(Rc::new(RefCell::new(frm))) |
| 1239 | } |
| 1240 | } |
| 1241 | |
| 1242 | pub fn get_decoder() -> Box<NADecoder> { |
| 1243 | Box::new(AudioDecoder::new()) |
| 1244 | } |
| 1245 | |
| 1246 | #[cfg(test)] |
| 1247 | mod test { |
| 1248 | use nihav_core::codecs::RegisteredDecoders; |
| 1249 | use nihav_core::demuxers::RegisteredDemuxers; |
| 1250 | use nihav_core::test::dec_video::test_decode_audio; |
| 1251 | use crate::codecs::generic_register_all_codecs; |
| 1252 | use nihav_realmedia::demuxers::realmedia_register_all_demuxers; |
| 1253 | #[test] |
| 1254 | fn test_ts102366() { |
| 1255 | let mut dmx_reg = RegisteredDemuxers::new(); |
| 1256 | realmedia_register_all_demuxers(&mut dmx_reg); |
| 1257 | let mut dec_reg = RegisteredDecoders::new(); |
| 1258 | generic_register_all_codecs(&mut dec_reg); |
| 1259 | |
| 1260 | let file = "assets/RV/sp_sample1.rm"; |
| 1261 | test_decode_audio("realmedia", file, Some(12000), "ac3", &dmx_reg, &dec_reg); |
| 1262 | } |
| 1263 | } |
| 1264 | |
| 1265 | const TS102366_SLOW_DECAY: [u8; 4] = [ 0x0F, 0x11, 0x13, 0x15 ]; |
| 1266 | const TS102366_FAST_DECAY: [u8; 4] = [ 0x3F, 0x53, 0x67, 0x7B ]; |
| 1267 | const TS102366_SLOW_GAIN: [u16; 4] = [ 0x540, 0x4D8, 0x478, 0x410 ]; |
| 1268 | const TS102366_FAST_GAIN: [u16; 8] = [ 0x080, 0x100, 0x180, 0x200, 0x280, 0x300, 0x380, 0x400 ]; |
| 1269 | const TS102366_DBP_TAB: [u16; 4] = [ 0x000, 0x700, 0x900, 0xB00 ]; |
| 1270 | const TS102366_FLOOR_TAB: [u16; 8] = [ 0x02F0, 0x02B0, 0x0270, 0x0230, 0x01F0, 0x0170, 0x00F0, 0xF800 ]; |
| 1271 | |
| 1272 | const TS102366_BIN_TO_BAND: [u8; 256] = [ |
| 1273 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, |
| 1274 | 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, |
| 1275 | 20, 21, 22, 23, 24, 25, 26, 27, 28, 28, |
| 1276 | 28, 29, 29, 29, 30, 30, 30, 31, 31, 31, |
| 1277 | 32, 32, 32, 33, 33, 33, 34, 34, 34, 35, |
| 1278 | 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, |
| 1279 | 36, 37, 37, 37, 37, 37, 37, 38, 38, 38, |
| 1280 | 38, 38, 38, 39, 39, 39, 39, 39, 39, 40, |
| 1281 | 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, |
| 1282 | 41, 41, 41, 41, 41, 41, 41, 42, 42, 42, |
| 1283 | 42, 42, 42, 42, 42, 42, 42, 42, 42, 43, |
| 1284 | 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, |
| 1285 | 43, 44, 44, 44, 44, 44, 44, 44, 44, 44, |
| 1286 | 44, 44, 44, 45, 45, 45, 45, 45, 45, 45, |
| 1287 | 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, |
| 1288 | 45, 45, 45, 45, 45, 45, 45, 46, 46, 46, |
| 1289 | 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, |
| 1290 | 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, |
| 1291 | 46, 47, 47, 47, 47, 47, 47, 47, 47, 47, |
| 1292 | 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, |
| 1293 | 47, 47, 47, 47, 47, 48, 48, 48, 48, 48, |
| 1294 | 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, |
| 1295 | 48, 48, 48, 48, 48, 48, 48, 48, 48, 49, |
| 1296 | 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, |
| 1297 | 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, |
| 1298 | 49, 49, 49, 0, 0, 0 |
| 1299 | ]; |
| 1300 | const TS102366_BAND_SIZE: [u8; MAX_BANDS] = [ |
| 1301 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1302 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1303 | 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, |
| 1304 | 3, 3, 3, 3, 3, 6, 6, 6, 6, 6, |
| 1305 | 6, 12, 12, 12, 12, 24, 24, 24, 24, 24 |
| 1306 | ]; |
| 1307 | const TS102366_BAND_START: [u8; MAX_BANDS] = [ |
| 1308 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, |
| 1309 | 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, |
| 1310 | 20, 21, 22, 23, 24, 25, 26, 27, 28, 31, |
| 1311 | 34, 37, 40, 43, 46, 49, 55, 61, 67, 73, |
| 1312 | 79, 85, 97, 109, 121, 133, 157, 181, 205, 229 |
| 1313 | ]; |
| 1314 | |
| 1315 | const TS102366_LATAB: [u16; 256] = [ |
| 1316 | 0x0040, 0x003f, 0x003e, 0x003d, 0x003c, 0x003b, 0x003a, 0x0039, |
| 1317 | 0x0038, 0x0037, 0x0036, 0x0035, 0x0034, 0x0034, 0x0033, 0x0032, |
| 1318 | 0x0031, 0x0030, 0x002f, 0x002f, 0x002e, 0x002d, 0x002c, 0x002c, |
| 1319 | 0x002b, 0x002a, 0x0029, 0x0029, 0x0028, 0x0027, 0x0026, 0x0026, |
| 1320 | 0x0025, 0x0024, 0x0024, 0x0023, 0x0023, 0x0022, 0x0021, 0x0021, |
| 1321 | 0x0020, 0x0020, 0x001f, 0x001e, 0x001e, 0x001d, 0x001d, 0x001c, |
| 1322 | 0x001c, 0x001b, 0x001b, 0x001a, 0x001a, 0x0019, 0x0019, 0x0018, |
| 1323 | 0x0018, 0x0017, 0x0017, 0x0016, 0x0016, 0x0015, 0x0015, 0x0015, |
| 1324 | 0x0014, 0x0014, 0x0013, 0x0013, 0x0013, 0x0012, 0x0012, 0x0012, |
| 1325 | 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x000f, 0x000f, |
| 1326 | 0x000f, 0x000e, 0x000e, 0x000e, 0x000d, 0x000d, 0x000d, 0x000d, |
| 1327 | 0x000c, 0x000c, 0x000c, 0x000c, 0x000b, 0x000b, 0x000b, 0x000b, |
| 1328 | 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x0009, 0x0009, 0x0009, |
| 1329 | 0x0009, 0x0009, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, |
| 1330 | 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0006, 0x0006, |
| 1331 | 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0005, 0x0005, |
| 1332 | 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0004, 0x0004, |
| 1333 | 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, |
| 1334 | 0x0004, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, |
| 1335 | 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0002, |
| 1336 | 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, |
| 1337 | 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, |
| 1338 | 0x0002, 0x0002, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, |
| 1339 | 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, |
| 1340 | 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, |
| 1341 | 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, |
| 1342 | 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, |
| 1343 | 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, |
| 1344 | 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, |
| 1345 | 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, |
| 1346 | 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, |
| 1347 | 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 |
| 1348 | ]; |
| 1349 | const TS102366_HTH: [[u16; MAX_BANDS]; 3] = [ |
| 1350 | [ |
| 1351 | 0x04D0, 0x04D0, 0x0440, 0x0400, 0x03E0, 0x03C0, 0x03B0, 0x03B0, 0x03A0, 0x03A0, |
| 1352 | 0x03A0, 0x03A0, 0x03A0, 0x0390, 0x0390, 0x0390, 0x0380, 0x0380, 0x0370, 0x0370, |
| 1353 | 0x0360, 0x0360, 0x0350, 0x0350, 0x0340, 0x0340, 0x0330, 0x0320, 0x0310, 0x0300, |
| 1354 | 0x02F0, 0x02F0, 0x02F0, 0x02F0, 0x0300, 0x0310, 0x0340, 0x0390, 0x03E0, 0x0420, |
| 1355 | 0x0460, 0x0490, 0x04A0, 0x0460, 0x0440, 0x0440, 0x0520, 0x0800, 0x0840, 0x0840, |
| 1356 | ], [ |
| 1357 | 0x04F0, 0x04F0, 0x0460, 0x0410, 0x03E0, 0x03D0, 0x03C0, 0x03B0, 0x03B0, 0x03A0, |
| 1358 | 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x0390, 0x0390, 0x0390, 0x0380, 0x0380, 0x0380, |
| 1359 | 0x0370, 0x0370, 0x0360, 0x0360, 0x0350, 0x0350, 0x0340, 0x0340, 0x0320, 0x0310, |
| 1360 | 0x0300, 0x02F0, 0x02F0, 0x02F0, 0x02F0, 0x0300, 0x0320, 0x0350, 0x0390, 0x03E0, |
| 1361 | 0x0420, 0x0450, 0x04A0, 0x0490, 0x0460, 0x0440, 0x0480, 0x0630, 0x0840, 0x0840, |
| 1362 | ], [ |
| 1363 | 0x0580, 0x0580, 0x04B0, 0x0450, 0x0420, 0x03F0, 0x03E0, 0x03D0, 0x03C0, 0x03B0, |
| 1364 | 0x03B0, 0x03B0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, |
| 1365 | 0x0390, 0x0390, 0x0390, 0x0390, 0x0380, 0x0380, 0x0380, 0x0370, 0x0360, 0x0350, |
| 1366 | 0x0340, 0x0330, 0x0320, 0x0310, 0x0300, 0x02F0, 0x02F0, 0x02F0, 0x0300, 0x0310, |
| 1367 | 0x0330, 0x0350, 0x03C0, 0x0410, 0x0470, 0x04A0, 0x0460, 0x0440, 0x0450, 0x04E0, |
| 1368 | ] |
| 1369 | ]; |
| 1370 | const TS102366_BAPTAB: [u8; 64] = [ |
| 1371 | 0, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, |
| 1372 | 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 10, |
| 1373 | 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14, |
| 1374 | 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15 |
| 1375 | ]; |
| 1376 | |
| 1377 | const TS102366_QUANT3_MAP: [[i32; 3]; 27] = [ |
| 1378 | [ -0x0AAAAAA, -0x0AAAAAA, -0x0AAAAAA ], |
| 1379 | [ -0x0AAAAAA, -0x0AAAAAA, 0x00000000 ], |
| 1380 | [ -0x0AAAAAA, -0x0AAAAAA, 0x00AAAAAA ], |
| 1381 | [ -0x0AAAAAA, 0x00000000, -0x0AAAAAA ], |
| 1382 | [ -0x0AAAAAA, 0x00000000, 0x00000000 ], |
| 1383 | [ -0x0AAAAAA, 0x00000000, 0x00AAAAAA ], |
| 1384 | [ -0x0AAAAAA, 0x00AAAAAA, -0x0AAAAAA ], |
| 1385 | [ -0x0AAAAAA, 0x00AAAAAA, 0x00000000 ], |
| 1386 | [ -0x0AAAAAA, 0x00AAAAAA, 0x00AAAAAA ], |
| 1387 | [ 0x00000000, -0x0AAAAAA, -0x0AAAAAA ], |
| 1388 | [ 0x00000000, -0x0AAAAAA, 0x00000000 ], |
| 1389 | [ 0x00000000, -0x0AAAAAA, 0x00AAAAAA ], |
| 1390 | [ 0x00000000, 0x00000000, -0x0AAAAAA ], |
| 1391 | [ 0x00000000, 0x00000000, 0x00000000 ], |
| 1392 | [ 0x00000000, 0x00000000, 0x00AAAAAA ], |
| 1393 | [ 0x00000000, 0x00AAAAAA, -0x0AAAAAA ], |
| 1394 | [ 0x00000000, 0x00AAAAAA, 0x00000000 ], |
| 1395 | [ 0x00000000, 0x00AAAAAA, 0x00AAAAAA ], |
| 1396 | [ 0x00AAAAAA, -0x0AAAAAA, -0x0AAAAAA ], |
| 1397 | [ 0x00AAAAAA, -0x0AAAAAA, 0x00000000 ], |
| 1398 | [ 0x00AAAAAA, -0x0AAAAAA, 0x00AAAAAA ], |
| 1399 | [ 0x00AAAAAA, 0x00000000, -0x0AAAAAA ], |
| 1400 | [ 0x00AAAAAA, 0x00000000, 0x00000000 ], |
| 1401 | [ 0x00AAAAAA, 0x00000000, 0x00AAAAAA ], |
| 1402 | [ 0x00AAAAAA, 0x00AAAAAA, -0x0AAAAAA ], |
| 1403 | [ 0x00AAAAAA, 0x00AAAAAA, 0x00000000 ], |
| 1404 | [ 0x00AAAAAA, 0x00AAAAAA, 0x00AAAAAA ] |
| 1405 | ]; |
| 1406 | const TS102366_QUANT5_MAP: [[i32; 3]; 125] = [ |
| 1407 | [ -0x0CCCCCC, -0x0CCCCCC, -0x0CCCCCC ], [ -0x0CCCCCC, -0x0CCCCCC, -0x0666666 ], [ -0x0CCCCCC, -0x0CCCCCC, 0x00000000 ], |
| 1408 | [ -0x0CCCCCC, -0x0CCCCCC, 0x00666666 ], [ -0x0CCCCCC, -0x0CCCCCC, 0x00CCCCCC ], |
| 1409 | [ -0x0CCCCCC, -0x0666666, -0x0CCCCCC ], [ -0x0CCCCCC, -0x0666666, -0x0666666 ], [ -0x0CCCCCC, -0x0666666, 0x00000000 ], |
| 1410 | [ -0x0CCCCCC, -0x0666666, 0x00666666 ], [ -0x0CCCCCC, -0x0666666, 0x00CCCCCC ], |
| 1411 | [ -0x0CCCCCC, 0x00000000, -0x0CCCCCC ], [ -0x0CCCCCC, 0x00000000, -0x0666666 ], [ -0x0CCCCCC, 0x00000000, 0x00000000 ], |
| 1412 | [ -0x0CCCCCC, 0x00000000, 0x00666666 ], [ -0x0CCCCCC, 0x00000000, 0x00CCCCCC ], |
| 1413 | [ -0x0CCCCCC, 0x00666666, -0x0CCCCCC ], [ -0x0CCCCCC, 0x00666666, -0x0666666 ], [ -0x0CCCCCC, 0x00666666, 0x00000000 ], |
| 1414 | [ -0x0CCCCCC, 0x00666666, 0x00666666 ], [ -0x0CCCCCC, 0x00666666, 0x00CCCCCC ], |
| 1415 | [ -0x0CCCCCC, 0x00CCCCCC, -0x0CCCCCC ], [ -0x0CCCCCC, 0x00CCCCCC, -0x0666666 ], [ -0x0CCCCCC, 0x00CCCCCC, 0x00000000 ], |
| 1416 | [ -0x0CCCCCC, 0x00CCCCCC, 0x00666666 ], [ -0x0CCCCCC, 0x00CCCCCC, 0x00CCCCCC ], |
| 1417 | [ -0x0666666, -0x0CCCCCC, -0x0CCCCCC ], [ -0x0666666, -0x0CCCCCC, -0x0666666 ], [ -0x0666666, -0x0CCCCCC, 0x00000000 ], |
| 1418 | [ -0x0666666, -0x0CCCCCC, 0x00666666 ], [ -0x0666666, -0x0CCCCCC, 0x00CCCCCC ], |
| 1419 | [ -0x0666666, -0x0666666, -0x0CCCCCC ], [ -0x0666666, -0x0666666, -0x0666666 ], [ -0x0666666, -0x0666666, 0x00000000 ], |
| 1420 | [ -0x0666666, -0x0666666, 0x00666666 ], [ -0x0666666, -0x0666666, 0x00CCCCCC ], |
| 1421 | [ -0x0666666, 0x00000000, -0x0CCCCCC ], [ -0x0666666, 0x00000000, -0x0666666 ], [ -0x0666666, 0x00000000, 0x00000000 ], |
| 1422 | [ -0x0666666, 0x00000000, 0x00666666 ], [ -0x0666666, 0x00000000, 0x00CCCCCC ], |
| 1423 | [ -0x0666666, 0x00666666, -0x0CCCCCC ], [ -0x0666666, 0x00666666, -0x0666666 ], [ -0x0666666, 0x00666666, 0x00000000 ], |
| 1424 | [ -0x0666666, 0x00666666, 0x00666666 ], [ -0x0666666, 0x00666666, 0x00CCCCCC ], |
| 1425 | [ -0x0666666, 0x00CCCCCC, -0x0CCCCCC ], [ -0x0666666, 0x00CCCCCC, -0x0666666 ], [ -0x0666666, 0x00CCCCCC, 0x00000000 ], |
| 1426 | [ -0x0666666, 0x00CCCCCC, 0x00666666 ], [ -0x0666666, 0x00CCCCCC, 0x00CCCCCC ], |
| 1427 | [ 0x00000000, -0x0CCCCCC, -0x0CCCCCC ], [ 0x00000000, -0x0CCCCCC, -0x0666666 ], [ 0x00000000, -0x0CCCCCC, 0x00000000 ], |
| 1428 | [ 0x00000000, -0x0CCCCCC, 0x00666666 ], [ 0x00000000, -0x0CCCCCC, 0x00CCCCCC ], |
| 1429 | [ 0x00000000, -0x0666666, -0x0CCCCCC ], [ 0x00000000, -0x0666666, -0x0666666 ], [ 0x00000000, -0x0666666, 0x00000000 ], |
| 1430 | [ 0x00000000, -0x0666666, 0x00666666 ], [ 0x00000000, -0x0666666, 0x00CCCCCC ], |
| 1431 | [ 0x00000000, 0x00000000, -0x0CCCCCC ], [ 0x00000000, 0x00000000, -0x0666666 ], [ 0x00000000, 0x00000000, 0x00000000 ], |
| 1432 | [ 0x00000000, 0x00000000, 0x00666666 ], [ 0x00000000, 0x00000000, 0x00CCCCCC ], |
| 1433 | [ 0x00000000, 0x00666666, -0x0CCCCCC ], [ 0x00000000, 0x00666666, -0x0666666 ], [ 0x00000000, 0x00666666, 0x00000000 ], |
| 1434 | [ 0x00000000, 0x00666666, 0x00666666 ], [ 0x00000000, 0x00666666, 0x00CCCCCC ], |
| 1435 | [ 0x00000000, 0x00CCCCCC, -0x0CCCCCC ], [ 0x00000000, 0x00CCCCCC, -0x0666666 ], [ 0x00000000, 0x00CCCCCC, 0x00000000 ], |
| 1436 | [ 0x00000000, 0x00CCCCCC, 0x00666666 ], [ 0x00000000, 0x00CCCCCC, 0x00CCCCCC ], |
| 1437 | [ 0x00666666, -0x0CCCCCC, -0x0CCCCCC ], [ 0x00666666, -0x0CCCCCC, -0x0666666 ], [ 0x00666666, -0x0CCCCCC, 0x00000000 ], |
| 1438 | [ 0x00666666, -0x0CCCCCC, 0x00666666 ], [ 0x00666666, -0x0CCCCCC, 0x00CCCCCC ], |
| 1439 | [ 0x00666666, -0x0666666, -0x0CCCCCC ], [ 0x00666666, -0x0666666, -0x0666666 ], [ 0x00666666, -0x0666666, 0x00000000 ], |
| 1440 | [ 0x00666666, -0x0666666, 0x00666666 ], [ 0x00666666, -0x0666666, 0x00CCCCCC ], |
| 1441 | [ 0x00666666, 0x00000000, -0x0CCCCCC ], [ 0x00666666, 0x00000000, -0x0666666 ], [ 0x00666666, 0x00000000, 0x00000000 ], |
| 1442 | [ 0x00666666, 0x00000000, 0x00666666 ], [ 0x00666666, 0x00000000, 0x00CCCCCC ], |
| 1443 | [ 0x00666666, 0x00666666, -0x0CCCCCC ], [ 0x00666666, 0x00666666, -0x0666666 ], [ 0x00666666, 0x00666666, 0x00000000 ], |
| 1444 | [ 0x00666666, 0x00666666, 0x00666666 ], [ 0x00666666, 0x00666666, 0x00CCCCCC ], |
| 1445 | [ 0x00666666, 0x00CCCCCC, -0x0CCCCCC ], [ 0x00666666, 0x00CCCCCC, -0x0666666 ], [ 0x00666666, 0x00CCCCCC, 0x00000000 ], |
| 1446 | [ 0x00666666, 0x00CCCCCC, 0x00666666 ], [ 0x00666666, 0x00CCCCCC, 0x00CCCCCC ], |
| 1447 | [ 0x00CCCCCC, -0x0CCCCCC, -0x0CCCCCC ], [ 0x00CCCCCC, -0x0CCCCCC, -0x0666666 ], [ 0x00CCCCCC, -0x0CCCCCC, 0x00000000 ], |
| 1448 | [ 0x00CCCCCC, -0x0CCCCCC, 0x00666666 ], [ 0x00CCCCCC, -0x0CCCCCC, 0x00CCCCCC ], |
| 1449 | [ 0x00CCCCCC, -0x0666666, -0x0CCCCCC ], [ 0x00CCCCCC, -0x0666666, -0x0666666 ], [ 0x00CCCCCC, -0x0666666, 0x00000000 ], |
| 1450 | [ 0x00CCCCCC, -0x0666666, 0x00666666 ], [ 0x00CCCCCC, -0x0666666, 0x00CCCCCC ], |
| 1451 | [ 0x00CCCCCC, 0x00000000, -0x0CCCCCC ], [ 0x00CCCCCC, 0x00000000, -0x0666666 ], [ 0x00CCCCCC, 0x00000000, 0x00000000 ], |
| 1452 | [ 0x00CCCCCC, 0x00000000, 0x00666666 ], [ 0x00CCCCCC, 0x00000000, 0x00CCCCCC ], |
| 1453 | [ 0x00CCCCCC, 0x00666666, -0x0CCCCCC ], [ 0x00CCCCCC, 0x00666666, -0x0666666 ], [ 0x00CCCCCC, 0x00666666, 0x00000000 ], |
| 1454 | [ 0x00CCCCCC, 0x00666666, 0x00666666 ], [ 0x00CCCCCC, 0x00666666, 0x00CCCCCC ], |
| 1455 | [ 0x00CCCCCC, 0x00CCCCCC, -0x0CCCCCC ], [ 0x00CCCCCC, 0x00CCCCCC, -0x0666666 ], [ 0x00CCCCCC, 0x00CCCCCC, 0x00000000 ], |
| 1456 | [ 0x00CCCCCC, 0x00CCCCCC, 0x00666666 ], [ 0x00CCCCCC, 0x00CCCCCC, 0x00CCCCCC ], |
| 1457 | ]; |
| 1458 | const TS102366_QUANT7_MAP: [i32; 7] = [ |
| 1459 | -0xDB6DB6, -0x924924, -0x492492, 0x000000, 0x492492, 0x924924, 0xDB6DB6 |
| 1460 | ]; |
| 1461 | const TS102366_QUANT11_MAP: [[i32; 2]; 121] = [ |
| 1462 | [ -0x0E8BA2E, -0x0E8BA2E ], [ -0x0E8BA2E, -0x0BA2E8B ], [ -0x0E8BA2E, -0x08BA2E8 ], |
| 1463 | [ -0x0E8BA2E, -0x05D1745 ], [ -0x0E8BA2E, -0x02E8BA2 ], [ -0x0E8BA2E, 0x00000000 ], |
| 1464 | [ -0x0E8BA2E, 0x002E8BA2 ], [ -0x0E8BA2E, 0x005D1745 ], [ -0x0E8BA2E, 0x008BA2E8 ], |
| 1465 | [ -0x0E8BA2E, 0x00BA2E8B ], [ -0x0E8BA2E, 0x00E8BA2E ], [ -0x0BA2E8B, -0x0E8BA2E ], |
| 1466 | [ -0x0BA2E8B, -0x0BA2E8B ], [ -0x0BA2E8B, -0x08BA2E8 ], [ -0x0BA2E8B, -0x05D1745 ], |
| 1467 | [ -0x0BA2E8B, -0x02E8BA2 ], [ -0x0BA2E8B, 0x00000000 ], [ -0x0BA2E8B, 0x002E8BA2 ], |
| 1468 | [ -0x0BA2E8B, 0x005D1745 ], [ -0x0BA2E8B, 0x008BA2E8 ], [ -0x0BA2E8B, 0x00BA2E8B ], |
| 1469 | [ -0x0BA2E8B, 0x00E8BA2E ], [ -0x08BA2E8, -0x0E8BA2E ], [ -0x08BA2E8, -0x0BA2E8B ], |
| 1470 | [ -0x08BA2E8, -0x08BA2E8 ], [ -0x08BA2E8, -0x05D1745 ], [ -0x08BA2E8, -0x02E8BA2 ], |
| 1471 | [ -0x08BA2E8, 0x00000000 ], [ -0x08BA2E8, 0x002E8BA2 ], [ -0x08BA2E8, 0x005D1745 ], |
| 1472 | [ -0x08BA2E8, 0x008BA2E8 ], [ -0x08BA2E8, 0x00BA2E8B ], [ -0x08BA2E8, 0x00E8BA2E ], |
| 1473 | [ -0x05D1745, -0x0E8BA2E ], [ -0x05D1745, -0x0BA2E8B ], [ -0x05D1745, -0x08BA2E8 ], |
| 1474 | [ -0x05D1745, -0x05D1745 ], [ -0x05D1745, -0x02E8BA2 ], [ -0x05D1745, 0x00000000 ], |
| 1475 | [ -0x05D1745, 0x002E8BA2 ], [ -0x05D1745, 0x005D1745 ], [ -0x05D1745, 0x008BA2E8 ], |
| 1476 | [ -0x05D1745, 0x00BA2E8B ], [ -0x05D1745, 0x00E8BA2E ], [ -0x02E8BA2, -0x0E8BA2E ], |
| 1477 | [ -0x02E8BA2, -0x0BA2E8B ], [ -0x02E8BA2, -0x08BA2E8 ], [ -0x02E8BA2, -0x05D1745 ], |
| 1478 | [ -0x02E8BA2, -0x02E8BA2 ], [ -0x02E8BA2, 0x00000000 ], [ -0x02E8BA2, 0x002E8BA2 ], |
| 1479 | [ -0x02E8BA2, 0x005D1745 ], [ -0x02E8BA2, 0x008BA2E8 ], [ -0x02E8BA2, 0x00BA2E8B ], |
| 1480 | [ -0x02E8BA2, 0x00E8BA2E ], [ 0x00000000, -0x0E8BA2E ], [ 0x00000000, -0x0BA2E8B ], |
| 1481 | [ 0x00000000, -0x08BA2E8 ], [ 0x00000000, -0x05D1745 ], [ 0x00000000, -0x02E8BA2 ], |
| 1482 | [ 0x00000000, 0x00000000 ], [ 0x00000000, 0x002E8BA2 ], [ 0x00000000, 0x005D1745 ], |
| 1483 | [ 0x00000000, 0x008BA2E8 ], [ 0x00000000, 0x00BA2E8B ], [ 0x00000000, 0x00E8BA2E ], |
| 1484 | [ 0x002E8BA2, -0x0E8BA2E ], [ 0x002E8BA2, -0x0BA2E8B ], [ 0x002E8BA2, -0x08BA2E8 ], |
| 1485 | [ 0x002E8BA2, -0x05D1745 ], [ 0x002E8BA2, -0x02E8BA2 ], [ 0x002E8BA2, 0x00000000 ], |
| 1486 | [ 0x002E8BA2, 0x002E8BA2 ], [ 0x002E8BA2, 0x005D1745 ], [ 0x002E8BA2, 0x008BA2E8 ], |
| 1487 | [ 0x002E8BA2, 0x00BA2E8B ], [ 0x002E8BA2, 0x00E8BA2E ], [ 0x005D1745, -0x0E8BA2E ], |
| 1488 | [ 0x005D1745, -0x0BA2E8B ], [ 0x005D1745, -0x08BA2E8 ], [ 0x005D1745, -0x05D1745 ], |
| 1489 | [ 0x005D1745, -0x02E8BA2 ], [ 0x005D1745, 0x00000000 ], [ 0x005D1745, 0x002E8BA2 ], |
| 1490 | [ 0x005D1745, 0x005D1745 ], [ 0x005D1745, 0x008BA2E8 ], [ 0x005D1745, 0x00BA2E8B ], |
| 1491 | [ 0x005D1745, 0x00E8BA2E ], [ 0x008BA2E8, -0x0E8BA2E ], [ 0x008BA2E8, -0x0BA2E8B ], |
| 1492 | [ 0x008BA2E8, -0x08BA2E8 ], [ 0x008BA2E8, -0x05D1745 ], [ 0x008BA2E8, -0x02E8BA2 ], |
| 1493 | [ 0x008BA2E8, 0x00000000 ], [ 0x008BA2E8, 0x002E8BA2 ], [ 0x008BA2E8, 0x005D1745 ], |
| 1494 | [ 0x008BA2E8, 0x008BA2E8 ], [ 0x008BA2E8, 0x00BA2E8B ], [ 0x008BA2E8, 0x00E8BA2E ], |
| 1495 | [ 0x00BA2E8B, -0x0E8BA2E ], [ 0x00BA2E8B, -0x0BA2E8B ], [ 0x00BA2E8B, -0x08BA2E8 ], |
| 1496 | [ 0x00BA2E8B, -0x05D1745 ], [ 0x00BA2E8B, -0x02E8BA2 ], [ 0x00BA2E8B, 0x00000000 ], |
| 1497 | [ 0x00BA2E8B, 0x002E8BA2 ], [ 0x00BA2E8B, 0x005D1745 ], [ 0x00BA2E8B, 0x008BA2E8 ], |
| 1498 | [ 0x00BA2E8B, 0x00BA2E8B ], [ 0x00BA2E8B, 0x00E8BA2E ], [ 0x00E8BA2E, -0x0E8BA2E ], |
| 1499 | [ 0x00E8BA2E, -0x0BA2E8B ], [ 0x00E8BA2E, -0x08BA2E8 ], [ 0x00E8BA2E, -0x05D1745 ], |
| 1500 | [ 0x00E8BA2E, -0x02E8BA2 ], [ 0x00E8BA2E, 0x00000000 ], [ 0x00E8BA2E, 0x002E8BA2 ], |
| 1501 | [ 0x00E8BA2E, 0x005D1745 ], [ 0x00E8BA2E, 0x008BA2E8 ], [ 0x00E8BA2E, 0x00BA2E8B ], |
| 1502 | [ 0x00E8BA2E, 0x00E8BA2E ], |
| 1503 | ]; |
| 1504 | const TS102366_QUANT15_MAP: [i32; 15] = [ |
| 1505 | -0x0EEEEEE, -0x0CCCCCC, -0x0AAAAAA, -0x0888888, -0x0666666, -0x0444444, -0x0222222, 0x00000000, |
| 1506 | 0x00222222, 0x00444444, 0x00666666, 0x00888888, 0x00AAAAAA, 0x00CCCCCC, 0x00EEEEEE, |
| 1507 | ]; |
| 1508 | const TS102366_BAP_BITS: [u8; 10] = [ 5, 6, 7, 8, 9, 10, 11, 12, 14, 16 ]; |
| 1509 | |
| 1510 | const TS102366_WINDOW: [f32; 256] = [ |
| 1511 | 0.00014, 0.00024, 0.00037, 0.00051, 0.00067, 0.00086, 0.00107, 0.00130, |
| 1512 | 0.00157, 0.00187, 0.00220, 0.00256, 0.00297, 0.00341, 0.00390, 0.00443, |
| 1513 | 0.00501, 0.00564, 0.00632, 0.00706, 0.00785, 0.00871, 0.00962, 0.01061, |
| 1514 | 0.01166, 0.01279, 0.01399, 0.01526, 0.01662, 0.01806, 0.01959, 0.02121, |
| 1515 | 0.02292, 0.02472, 0.02662, 0.02863, 0.03073, 0.03294, 0.03527, 0.03770, |
| 1516 | 0.04025, 0.04292, 0.04571, 0.04862, 0.05165, 0.05481, 0.05810, 0.06153, |
| 1517 | 0.06508, 0.06878, 0.07261, 0.07658, 0.08069, 0.08495, 0.08935, 0.09389, |
| 1518 | 0.09859, 0.10343, 0.10842, 0.11356, 0.11885, 0.12429, 0.12988, 0.13563, |
| 1519 | 0.14152, 0.14757, 0.15376, 0.16011, 0.16661, 0.17325, 0.18005, 0.18699, |
| 1520 | 0.19407, 0.20130, 0.20867, 0.21618, 0.22382, 0.23161, 0.23952, 0.24757, |
| 1521 | 0.25574, 0.26404, 0.27246, 0.28100, 0.28965, 0.29841, 0.30729, 0.31626, |
| 1522 | 0.32533, 0.33450, 0.34376, 0.35311, 0.36253, 0.37204, 0.38161, 0.39126, |
| 1523 | 0.40096, 0.41072, 0.42054, 0.43040, 0.44030, 0.45023, 0.46020, 0.47019, |
| 1524 | 0.48020, 0.49022, 0.50025, 0.51028, 0.52031, 0.53033, 0.54033, 0.55031, |
| 1525 | 0.56026, 0.57019, 0.58007, 0.58991, 0.59970, 0.60944, 0.61912, 0.62873, |
| 1526 | 0.63827, 0.64774, 0.65713, 0.66643, 0.67564, 0.68476, 0.69377, 0.70269, |
| 1527 | 0.71150, 0.72019, 0.72877, 0.73723, 0.74557, 0.75378, 0.76186, 0.76981, |
| 1528 | 0.77762, 0.78530, 0.79283, 0.80022, 0.80747, 0.81457, 0.82151, 0.82831, |
| 1529 | 0.83496, 0.84145, 0.84779, 0.85398, 0.86001, 0.86588, 0.87160, 0.87716, |
| 1530 | 0.88257, 0.88782, 0.89291, 0.89785, 0.90264, 0.90728, 0.91176, 0.91610, |
| 1531 | 0.92028, 0.92432, 0.92822, 0.93197, 0.93558, 0.93906, 0.94240, 0.94560, |
| 1532 | 0.94867, 0.95162, 0.95444, 0.95713, 0.95971, 0.96217, 0.96451, 0.96674, |
| 1533 | 0.96887, 0.97089, 0.97281, 0.97463, 0.97635, 0.97799, 0.97953, 0.98099, |
| 1534 | 0.98236, 0.98366, 0.98488, 0.98602, 0.98710, 0.98811, 0.98905, 0.98994, |
| 1535 | 0.99076, 0.99153, 0.99225, 0.99291, 0.99353, 0.99411, 0.99464, 0.99513, |
| 1536 | 0.99558, 0.99600, 0.99639, 0.99674, 0.99706, 0.99736, 0.99763, 0.99788, |
| 1537 | 0.99811, 0.99831, 0.99850, 0.99867, 0.99882, 0.99895, 0.99908, 0.99919, |
| 1538 | 0.99929, 0.99938, 0.99946, 0.99953, 0.99959, 0.99965, 0.99969, 0.99974, |
| 1539 | 0.99978, 0.99981, 0.99984, 0.99986, 0.99988, 0.99990, 0.99992, 0.99993, |
| 1540 | 0.99994, 0.99995, 0.99996, 0.99997, 0.99998, 0.99998, 0.99998, 0.99999, |
| 1541 | 0.99999, 0.99999, 0.99999, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, |
| 1542 | 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, |
| 1543 | ]; |