]>
Commit | Line | Data |
---|---|---|
1 | use formats::*; | |
2 | use frame::*; | |
3 | use super::*; | |
4 | use io::bitreader::*; | |
5 | use 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: Rc<NACodecInfo>, | |
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: Rc<NACodecInfo>) -> 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 mut abuf = alloc_audio_buffer(ainfo, duration, bsi.acmod.get_channel_map(bsi.lfeon))?; | |
1201 | let mut adata = abuf.get_abuf_f32().unwrap(); | |
1202 | let mut output = adata.get_data_mut(); | |
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 test::dec_video::*; | |
1249 | #[test] | |
1250 | fn test_ts102366() { | |
1251 | let file = "assets/RV/sp_sample1.rm"; | |
1252 | test_decode_audio("realmedia", file, Some(12000), "ac3"); | |
1253 | } | |
1254 | } | |
1255 | ||
1256 | const TS102366_SLOW_DECAY: [u8; 4] = [ 0x0F, 0x11, 0x13, 0x15 ]; | |
1257 | const TS102366_FAST_DECAY: [u8; 4] = [ 0x3F, 0x53, 0x67, 0x7B ]; | |
1258 | const TS102366_SLOW_GAIN: [u16; 4] = [ 0x540, 0x4D8, 0x478, 0x410 ]; | |
1259 | const TS102366_FAST_GAIN: [u16; 8] = [ 0x080, 0x100, 0x180, 0x200, 0x280, 0x300, 0x380, 0x400 ]; | |
1260 | const TS102366_DBP_TAB: [u16; 4] = [ 0x000, 0x700, 0x900, 0xB00 ]; | |
1261 | const TS102366_FLOOR_TAB: [u16; 8] = [ 0x02F0, 0x02B0, 0x0270, 0x0230, 0x01F0, 0x0170, 0x00F0, 0xF800 ]; | |
1262 | ||
1263 | const TS102366_BIN_TO_BAND: [u8; 256] = [ | |
1264 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, | |
1265 | 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, | |
1266 | 20, 21, 22, 23, 24, 25, 26, 27, 28, 28, | |
1267 | 28, 29, 29, 29, 30, 30, 30, 31, 31, 31, | |
1268 | 32, 32, 32, 33, 33, 33, 34, 34, 34, 35, | |
1269 | 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, | |
1270 | 36, 37, 37, 37, 37, 37, 37, 38, 38, 38, | |
1271 | 38, 38, 38, 39, 39, 39, 39, 39, 39, 40, | |
1272 | 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, | |
1273 | 41, 41, 41, 41, 41, 41, 41, 42, 42, 42, | |
1274 | 42, 42, 42, 42, 42, 42, 42, 42, 42, 43, | |
1275 | 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, | |
1276 | 43, 44, 44, 44, 44, 44, 44, 44, 44, 44, | |
1277 | 44, 44, 44, 45, 45, 45, 45, 45, 45, 45, | |
1278 | 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, | |
1279 | 45, 45, 45, 45, 45, 45, 45, 46, 46, 46, | |
1280 | 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, | |
1281 | 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, | |
1282 | 46, 47, 47, 47, 47, 47, 47, 47, 47, 47, | |
1283 | 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, | |
1284 | 47, 47, 47, 47, 47, 48, 48, 48, 48, 48, | |
1285 | 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, | |
1286 | 48, 48, 48, 48, 48, 48, 48, 48, 48, 49, | |
1287 | 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, | |
1288 | 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, | |
1289 | 49, 49, 49, 0, 0, 0 | |
1290 | ]; | |
1291 | const TS102366_BAND_SIZE: [u8; MAX_BANDS] = [ | |
1292 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
1293 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
1294 | 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, | |
1295 | 3, 3, 3, 3, 3, 6, 6, 6, 6, 6, | |
1296 | 6, 12, 12, 12, 12, 24, 24, 24, 24, 24 | |
1297 | ]; | |
1298 | const TS102366_BAND_START: [u8; MAX_BANDS] = [ | |
1299 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, | |
1300 | 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, | |
1301 | 20, 21, 22, 23, 24, 25, 26, 27, 28, 31, | |
1302 | 34, 37, 40, 43, 46, 49, 55, 61, 67, 73, | |
1303 | 79, 85, 97, 109, 121, 133, 157, 181, 205, 229 | |
1304 | ]; | |
1305 | ||
1306 | const TS102366_LATAB: [u16; 256] = [ | |
1307 | 0x0040, 0x003f, 0x003e, 0x003d, 0x003c, 0x003b, 0x003a, 0x0039, | |
1308 | 0x0038, 0x0037, 0x0036, 0x0035, 0x0034, 0x0034, 0x0033, 0x0032, | |
1309 | 0x0031, 0x0030, 0x002f, 0x002f, 0x002e, 0x002d, 0x002c, 0x002c, | |
1310 | 0x002b, 0x002a, 0x0029, 0x0029, 0x0028, 0x0027, 0x0026, 0x0026, | |
1311 | 0x0025, 0x0024, 0x0024, 0x0023, 0x0023, 0x0022, 0x0021, 0x0021, | |
1312 | 0x0020, 0x0020, 0x001f, 0x001e, 0x001e, 0x001d, 0x001d, 0x001c, | |
1313 | 0x001c, 0x001b, 0x001b, 0x001a, 0x001a, 0x0019, 0x0019, 0x0018, | |
1314 | 0x0018, 0x0017, 0x0017, 0x0016, 0x0016, 0x0015, 0x0015, 0x0015, | |
1315 | 0x0014, 0x0014, 0x0013, 0x0013, 0x0013, 0x0012, 0x0012, 0x0012, | |
1316 | 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x000f, 0x000f, | |
1317 | 0x000f, 0x000e, 0x000e, 0x000e, 0x000d, 0x000d, 0x000d, 0x000d, | |
1318 | 0x000c, 0x000c, 0x000c, 0x000c, 0x000b, 0x000b, 0x000b, 0x000b, | |
1319 | 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x0009, 0x0009, 0x0009, | |
1320 | 0x0009, 0x0009, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, | |
1321 | 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0006, 0x0006, | |
1322 | 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0005, 0x0005, | |
1323 | 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0004, 0x0004, | |
1324 | 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, | |
1325 | 0x0004, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, | |
1326 | 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0002, | |
1327 | 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, | |
1328 | 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, | |
1329 | 0x0002, 0x0002, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, | |
1330 | 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, | |
1331 | 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, | |
1332 | 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, | |
1333 | 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, | |
1334 | 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, | |
1335 | 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, | |
1336 | 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, | |
1337 | 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, | |
1338 | 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 | |
1339 | ]; | |
1340 | const TS102366_HTH: [[u16; MAX_BANDS]; 3] = [ | |
1341 | [ | |
1342 | 0x04D0, 0x04D0, 0x0440, 0x0400, 0x03E0, 0x03C0, 0x03B0, 0x03B0, 0x03A0, 0x03A0, | |
1343 | 0x03A0, 0x03A0, 0x03A0, 0x0390, 0x0390, 0x0390, 0x0380, 0x0380, 0x0370, 0x0370, | |
1344 | 0x0360, 0x0360, 0x0350, 0x0350, 0x0340, 0x0340, 0x0330, 0x0320, 0x0310, 0x0300, | |
1345 | 0x02F0, 0x02F0, 0x02F0, 0x02F0, 0x0300, 0x0310, 0x0340, 0x0390, 0x03E0, 0x0420, | |
1346 | 0x0460, 0x0490, 0x04A0, 0x0460, 0x0440, 0x0440, 0x0520, 0x0800, 0x0840, 0x0840, | |
1347 | ], [ | |
1348 | 0x04F0, 0x04F0, 0x0460, 0x0410, 0x03E0, 0x03D0, 0x03C0, 0x03B0, 0x03B0, 0x03A0, | |
1349 | 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x0390, 0x0390, 0x0390, 0x0380, 0x0380, 0x0380, | |
1350 | 0x0370, 0x0370, 0x0360, 0x0360, 0x0350, 0x0350, 0x0340, 0x0340, 0x0320, 0x0310, | |
1351 | 0x0300, 0x02F0, 0x02F0, 0x02F0, 0x02F0, 0x0300, 0x0320, 0x0350, 0x0390, 0x03E0, | |
1352 | 0x0420, 0x0450, 0x04A0, 0x0490, 0x0460, 0x0440, 0x0480, 0x0630, 0x0840, 0x0840, | |
1353 | ], [ | |
1354 | 0x0580, 0x0580, 0x04B0, 0x0450, 0x0420, 0x03F0, 0x03E0, 0x03D0, 0x03C0, 0x03B0, | |
1355 | 0x03B0, 0x03B0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, | |
1356 | 0x0390, 0x0390, 0x0390, 0x0390, 0x0380, 0x0380, 0x0380, 0x0370, 0x0360, 0x0350, | |
1357 | 0x0340, 0x0330, 0x0320, 0x0310, 0x0300, 0x02F0, 0x02F0, 0x02F0, 0x0300, 0x0310, | |
1358 | 0x0330, 0x0350, 0x03C0, 0x0410, 0x0470, 0x04A0, 0x0460, 0x0440, 0x0450, 0x04E0, | |
1359 | ] | |
1360 | ]; | |
1361 | const TS102366_BAPTAB: [u8; 64] = [ | |
1362 | 0, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, | |
1363 | 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 10, | |
1364 | 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14, | |
1365 | 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15 | |
1366 | ]; | |
1367 | ||
1368 | const TS102366_QUANT3_MAP: [[i32; 3]; 27] = [ | |
1369 | [ -0x0AAAAAA, -0x0AAAAAA, -0x0AAAAAA ], | |
1370 | [ -0x0AAAAAA, -0x0AAAAAA, 0x00000000 ], | |
1371 | [ -0x0AAAAAA, -0x0AAAAAA, 0x00AAAAAA ], | |
1372 | [ -0x0AAAAAA, 0x00000000, -0x0AAAAAA ], | |
1373 | [ -0x0AAAAAA, 0x00000000, 0x00000000 ], | |
1374 | [ -0x0AAAAAA, 0x00000000, 0x00AAAAAA ], | |
1375 | [ -0x0AAAAAA, 0x00AAAAAA, -0x0AAAAAA ], | |
1376 | [ -0x0AAAAAA, 0x00AAAAAA, 0x00000000 ], | |
1377 | [ -0x0AAAAAA, 0x00AAAAAA, 0x00AAAAAA ], | |
1378 | [ 0x00000000, -0x0AAAAAA, -0x0AAAAAA ], | |
1379 | [ 0x00000000, -0x0AAAAAA, 0x00000000 ], | |
1380 | [ 0x00000000, -0x0AAAAAA, 0x00AAAAAA ], | |
1381 | [ 0x00000000, 0x00000000, -0x0AAAAAA ], | |
1382 | [ 0x00000000, 0x00000000, 0x00000000 ], | |
1383 | [ 0x00000000, 0x00000000, 0x00AAAAAA ], | |
1384 | [ 0x00000000, 0x00AAAAAA, -0x0AAAAAA ], | |
1385 | [ 0x00000000, 0x00AAAAAA, 0x00000000 ], | |
1386 | [ 0x00000000, 0x00AAAAAA, 0x00AAAAAA ], | |
1387 | [ 0x00AAAAAA, -0x0AAAAAA, -0x0AAAAAA ], | |
1388 | [ 0x00AAAAAA, -0x0AAAAAA, 0x00000000 ], | |
1389 | [ 0x00AAAAAA, -0x0AAAAAA, 0x00AAAAAA ], | |
1390 | [ 0x00AAAAAA, 0x00000000, -0x0AAAAAA ], | |
1391 | [ 0x00AAAAAA, 0x00000000, 0x00000000 ], | |
1392 | [ 0x00AAAAAA, 0x00000000, 0x00AAAAAA ], | |
1393 | [ 0x00AAAAAA, 0x00AAAAAA, -0x0AAAAAA ], | |
1394 | [ 0x00AAAAAA, 0x00AAAAAA, 0x00000000 ], | |
1395 | [ 0x00AAAAAA, 0x00AAAAAA, 0x00AAAAAA ] | |
1396 | ]; | |
1397 | const TS102366_QUANT5_MAP: [[i32; 3]; 125] = [ | |
1398 | [ -0x0CCCCCC, -0x0CCCCCC, -0x0CCCCCC ], [ -0x0CCCCCC, -0x0CCCCCC, -0x0666666 ], [ -0x0CCCCCC, -0x0CCCCCC, 0x00000000 ], | |
1399 | [ -0x0CCCCCC, -0x0CCCCCC, 0x00666666 ], [ -0x0CCCCCC, -0x0CCCCCC, 0x00CCCCCC ], | |
1400 | [ -0x0CCCCCC, -0x0666666, -0x0CCCCCC ], [ -0x0CCCCCC, -0x0666666, -0x0666666 ], [ -0x0CCCCCC, -0x0666666, 0x00000000 ], | |
1401 | [ -0x0CCCCCC, -0x0666666, 0x00666666 ], [ -0x0CCCCCC, -0x0666666, 0x00CCCCCC ], | |
1402 | [ -0x0CCCCCC, 0x00000000, -0x0CCCCCC ], [ -0x0CCCCCC, 0x00000000, -0x0666666 ], [ -0x0CCCCCC, 0x00000000, 0x00000000 ], | |
1403 | [ -0x0CCCCCC, 0x00000000, 0x00666666 ], [ -0x0CCCCCC, 0x00000000, 0x00CCCCCC ], | |
1404 | [ -0x0CCCCCC, 0x00666666, -0x0CCCCCC ], [ -0x0CCCCCC, 0x00666666, -0x0666666 ], [ -0x0CCCCCC, 0x00666666, 0x00000000 ], | |
1405 | [ -0x0CCCCCC, 0x00666666, 0x00666666 ], [ -0x0CCCCCC, 0x00666666, 0x00CCCCCC ], | |
1406 | [ -0x0CCCCCC, 0x00CCCCCC, -0x0CCCCCC ], [ -0x0CCCCCC, 0x00CCCCCC, -0x0666666 ], [ -0x0CCCCCC, 0x00CCCCCC, 0x00000000 ], | |
1407 | [ -0x0CCCCCC, 0x00CCCCCC, 0x00666666 ], [ -0x0CCCCCC, 0x00CCCCCC, 0x00CCCCCC ], | |
1408 | [ -0x0666666, -0x0CCCCCC, -0x0CCCCCC ], [ -0x0666666, -0x0CCCCCC, -0x0666666 ], [ -0x0666666, -0x0CCCCCC, 0x00000000 ], | |
1409 | [ -0x0666666, -0x0CCCCCC, 0x00666666 ], [ -0x0666666, -0x0CCCCCC, 0x00CCCCCC ], | |
1410 | [ -0x0666666, -0x0666666, -0x0CCCCCC ], [ -0x0666666, -0x0666666, -0x0666666 ], [ -0x0666666, -0x0666666, 0x00000000 ], | |
1411 | [ -0x0666666, -0x0666666, 0x00666666 ], [ -0x0666666, -0x0666666, 0x00CCCCCC ], | |
1412 | [ -0x0666666, 0x00000000, -0x0CCCCCC ], [ -0x0666666, 0x00000000, -0x0666666 ], [ -0x0666666, 0x00000000, 0x00000000 ], | |
1413 | [ -0x0666666, 0x00000000, 0x00666666 ], [ -0x0666666, 0x00000000, 0x00CCCCCC ], | |
1414 | [ -0x0666666, 0x00666666, -0x0CCCCCC ], [ -0x0666666, 0x00666666, -0x0666666 ], [ -0x0666666, 0x00666666, 0x00000000 ], | |
1415 | [ -0x0666666, 0x00666666, 0x00666666 ], [ -0x0666666, 0x00666666, 0x00CCCCCC ], | |
1416 | [ -0x0666666, 0x00CCCCCC, -0x0CCCCCC ], [ -0x0666666, 0x00CCCCCC, -0x0666666 ], [ -0x0666666, 0x00CCCCCC, 0x00000000 ], | |
1417 | [ -0x0666666, 0x00CCCCCC, 0x00666666 ], [ -0x0666666, 0x00CCCCCC, 0x00CCCCCC ], | |
1418 | [ 0x00000000, -0x0CCCCCC, -0x0CCCCCC ], [ 0x00000000, -0x0CCCCCC, -0x0666666 ], [ 0x00000000, -0x0CCCCCC, 0x00000000 ], | |
1419 | [ 0x00000000, -0x0CCCCCC, 0x00666666 ], [ 0x00000000, -0x0CCCCCC, 0x00CCCCCC ], | |
1420 | [ 0x00000000, -0x0666666, -0x0CCCCCC ], [ 0x00000000, -0x0666666, -0x0666666 ], [ 0x00000000, -0x0666666, 0x00000000 ], | |
1421 | [ 0x00000000, -0x0666666, 0x00666666 ], [ 0x00000000, -0x0666666, 0x00CCCCCC ], | |
1422 | [ 0x00000000, 0x00000000, -0x0CCCCCC ], [ 0x00000000, 0x00000000, -0x0666666 ], [ 0x00000000, 0x00000000, 0x00000000 ], | |
1423 | [ 0x00000000, 0x00000000, 0x00666666 ], [ 0x00000000, 0x00000000, 0x00CCCCCC ], | |
1424 | [ 0x00000000, 0x00666666, -0x0CCCCCC ], [ 0x00000000, 0x00666666, -0x0666666 ], [ 0x00000000, 0x00666666, 0x00000000 ], | |
1425 | [ 0x00000000, 0x00666666, 0x00666666 ], [ 0x00000000, 0x00666666, 0x00CCCCCC ], | |
1426 | [ 0x00000000, 0x00CCCCCC, -0x0CCCCCC ], [ 0x00000000, 0x00CCCCCC, -0x0666666 ], [ 0x00000000, 0x00CCCCCC, 0x00000000 ], | |
1427 | [ 0x00000000, 0x00CCCCCC, 0x00666666 ], [ 0x00000000, 0x00CCCCCC, 0x00CCCCCC ], | |
1428 | [ 0x00666666, -0x0CCCCCC, -0x0CCCCCC ], [ 0x00666666, -0x0CCCCCC, -0x0666666 ], [ 0x00666666, -0x0CCCCCC, 0x00000000 ], | |
1429 | [ 0x00666666, -0x0CCCCCC, 0x00666666 ], [ 0x00666666, -0x0CCCCCC, 0x00CCCCCC ], | |
1430 | [ 0x00666666, -0x0666666, -0x0CCCCCC ], [ 0x00666666, -0x0666666, -0x0666666 ], [ 0x00666666, -0x0666666, 0x00000000 ], | |
1431 | [ 0x00666666, -0x0666666, 0x00666666 ], [ 0x00666666, -0x0666666, 0x00CCCCCC ], | |
1432 | [ 0x00666666, 0x00000000, -0x0CCCCCC ], [ 0x00666666, 0x00000000, -0x0666666 ], [ 0x00666666, 0x00000000, 0x00000000 ], | |
1433 | [ 0x00666666, 0x00000000, 0x00666666 ], [ 0x00666666, 0x00000000, 0x00CCCCCC ], | |
1434 | [ 0x00666666, 0x00666666, -0x0CCCCCC ], [ 0x00666666, 0x00666666, -0x0666666 ], [ 0x00666666, 0x00666666, 0x00000000 ], | |
1435 | [ 0x00666666, 0x00666666, 0x00666666 ], [ 0x00666666, 0x00666666, 0x00CCCCCC ], | |
1436 | [ 0x00666666, 0x00CCCCCC, -0x0CCCCCC ], [ 0x00666666, 0x00CCCCCC, -0x0666666 ], [ 0x00666666, 0x00CCCCCC, 0x00000000 ], | |
1437 | [ 0x00666666, 0x00CCCCCC, 0x00666666 ], [ 0x00666666, 0x00CCCCCC, 0x00CCCCCC ], | |
1438 | [ 0x00CCCCCC, -0x0CCCCCC, -0x0CCCCCC ], [ 0x00CCCCCC, -0x0CCCCCC, -0x0666666 ], [ 0x00CCCCCC, -0x0CCCCCC, 0x00000000 ], | |
1439 | [ 0x00CCCCCC, -0x0CCCCCC, 0x00666666 ], [ 0x00CCCCCC, -0x0CCCCCC, 0x00CCCCCC ], | |
1440 | [ 0x00CCCCCC, -0x0666666, -0x0CCCCCC ], [ 0x00CCCCCC, -0x0666666, -0x0666666 ], [ 0x00CCCCCC, -0x0666666, 0x00000000 ], | |
1441 | [ 0x00CCCCCC, -0x0666666, 0x00666666 ], [ 0x00CCCCCC, -0x0666666, 0x00CCCCCC ], | |
1442 | [ 0x00CCCCCC, 0x00000000, -0x0CCCCCC ], [ 0x00CCCCCC, 0x00000000, -0x0666666 ], [ 0x00CCCCCC, 0x00000000, 0x00000000 ], | |
1443 | [ 0x00CCCCCC, 0x00000000, 0x00666666 ], [ 0x00CCCCCC, 0x00000000, 0x00CCCCCC ], | |
1444 | [ 0x00CCCCCC, 0x00666666, -0x0CCCCCC ], [ 0x00CCCCCC, 0x00666666, -0x0666666 ], [ 0x00CCCCCC, 0x00666666, 0x00000000 ], | |
1445 | [ 0x00CCCCCC, 0x00666666, 0x00666666 ], [ 0x00CCCCCC, 0x00666666, 0x00CCCCCC ], | |
1446 | [ 0x00CCCCCC, 0x00CCCCCC, -0x0CCCCCC ], [ 0x00CCCCCC, 0x00CCCCCC, -0x0666666 ], [ 0x00CCCCCC, 0x00CCCCCC, 0x00000000 ], | |
1447 | [ 0x00CCCCCC, 0x00CCCCCC, 0x00666666 ], [ 0x00CCCCCC, 0x00CCCCCC, 0x00CCCCCC ], | |
1448 | ]; | |
1449 | const TS102366_QUANT7_MAP: [i32; 7] = [ | |
1450 | -0xDB6DB6, -0x924924, -0x492492, 0x000000, 0x492492, 0x924924, 0xDB6DB6 | |
1451 | ]; | |
1452 | const TS102366_QUANT11_MAP: [[i32; 2]; 121] = [ | |
1453 | [ -0x0E8BA2E, -0x0E8BA2E ], [ -0x0E8BA2E, -0x0BA2E8B ], [ -0x0E8BA2E, -0x08BA2E8 ], | |
1454 | [ -0x0E8BA2E, -0x05D1745 ], [ -0x0E8BA2E, -0x02E8BA2 ], [ -0x0E8BA2E, 0x00000000 ], | |
1455 | [ -0x0E8BA2E, 0x002E8BA2 ], [ -0x0E8BA2E, 0x005D1745 ], [ -0x0E8BA2E, 0x008BA2E8 ], | |
1456 | [ -0x0E8BA2E, 0x00BA2E8B ], [ -0x0E8BA2E, 0x00E8BA2E ], [ -0x0BA2E8B, -0x0E8BA2E ], | |
1457 | [ -0x0BA2E8B, -0x0BA2E8B ], [ -0x0BA2E8B, -0x08BA2E8 ], [ -0x0BA2E8B, -0x05D1745 ], | |
1458 | [ -0x0BA2E8B, -0x02E8BA2 ], [ -0x0BA2E8B, 0x00000000 ], [ -0x0BA2E8B, 0x002E8BA2 ], | |
1459 | [ -0x0BA2E8B, 0x005D1745 ], [ -0x0BA2E8B, 0x008BA2E8 ], [ -0x0BA2E8B, 0x00BA2E8B ], | |
1460 | [ -0x0BA2E8B, 0x00E8BA2E ], [ -0x08BA2E8, -0x0E8BA2E ], [ -0x08BA2E8, -0x0BA2E8B ], | |
1461 | [ -0x08BA2E8, -0x08BA2E8 ], [ -0x08BA2E8, -0x05D1745 ], [ -0x08BA2E8, -0x02E8BA2 ], | |
1462 | [ -0x08BA2E8, 0x00000000 ], [ -0x08BA2E8, 0x002E8BA2 ], [ -0x08BA2E8, 0x005D1745 ], | |
1463 | [ -0x08BA2E8, 0x008BA2E8 ], [ -0x08BA2E8, 0x00BA2E8B ], [ -0x08BA2E8, 0x00E8BA2E ], | |
1464 | [ -0x05D1745, -0x0E8BA2E ], [ -0x05D1745, -0x0BA2E8B ], [ -0x05D1745, -0x08BA2E8 ], | |
1465 | [ -0x05D1745, -0x05D1745 ], [ -0x05D1745, -0x02E8BA2 ], [ -0x05D1745, 0x00000000 ], | |
1466 | [ -0x05D1745, 0x002E8BA2 ], [ -0x05D1745, 0x005D1745 ], [ -0x05D1745, 0x008BA2E8 ], | |
1467 | [ -0x05D1745, 0x00BA2E8B ], [ -0x05D1745, 0x00E8BA2E ], [ -0x02E8BA2, -0x0E8BA2E ], | |
1468 | [ -0x02E8BA2, -0x0BA2E8B ], [ -0x02E8BA2, -0x08BA2E8 ], [ -0x02E8BA2, -0x05D1745 ], | |
1469 | [ -0x02E8BA2, -0x02E8BA2 ], [ -0x02E8BA2, 0x00000000 ], [ -0x02E8BA2, 0x002E8BA2 ], | |
1470 | [ -0x02E8BA2, 0x005D1745 ], [ -0x02E8BA2, 0x008BA2E8 ], [ -0x02E8BA2, 0x00BA2E8B ], | |
1471 | [ -0x02E8BA2, 0x00E8BA2E ], [ 0x00000000, -0x0E8BA2E ], [ 0x00000000, -0x0BA2E8B ], | |
1472 | [ 0x00000000, -0x08BA2E8 ], [ 0x00000000, -0x05D1745 ], [ 0x00000000, -0x02E8BA2 ], | |
1473 | [ 0x00000000, 0x00000000 ], [ 0x00000000, 0x002E8BA2 ], [ 0x00000000, 0x005D1745 ], | |
1474 | [ 0x00000000, 0x008BA2E8 ], [ 0x00000000, 0x00BA2E8B ], [ 0x00000000, 0x00E8BA2E ], | |
1475 | [ 0x002E8BA2, -0x0E8BA2E ], [ 0x002E8BA2, -0x0BA2E8B ], [ 0x002E8BA2, -0x08BA2E8 ], | |
1476 | [ 0x002E8BA2, -0x05D1745 ], [ 0x002E8BA2, -0x02E8BA2 ], [ 0x002E8BA2, 0x00000000 ], | |
1477 | [ 0x002E8BA2, 0x002E8BA2 ], [ 0x002E8BA2, 0x005D1745 ], [ 0x002E8BA2, 0x008BA2E8 ], | |
1478 | [ 0x002E8BA2, 0x00BA2E8B ], [ 0x002E8BA2, 0x00E8BA2E ], [ 0x005D1745, -0x0E8BA2E ], | |
1479 | [ 0x005D1745, -0x0BA2E8B ], [ 0x005D1745, -0x08BA2E8 ], [ 0x005D1745, -0x05D1745 ], | |
1480 | [ 0x005D1745, -0x02E8BA2 ], [ 0x005D1745, 0x00000000 ], [ 0x005D1745, 0x002E8BA2 ], | |
1481 | [ 0x005D1745, 0x005D1745 ], [ 0x005D1745, 0x008BA2E8 ], [ 0x005D1745, 0x00BA2E8B ], | |
1482 | [ 0x005D1745, 0x00E8BA2E ], [ 0x008BA2E8, -0x0E8BA2E ], [ 0x008BA2E8, -0x0BA2E8B ], | |
1483 | [ 0x008BA2E8, -0x08BA2E8 ], [ 0x008BA2E8, -0x05D1745 ], [ 0x008BA2E8, -0x02E8BA2 ], | |
1484 | [ 0x008BA2E8, 0x00000000 ], [ 0x008BA2E8, 0x002E8BA2 ], [ 0x008BA2E8, 0x005D1745 ], | |
1485 | [ 0x008BA2E8, 0x008BA2E8 ], [ 0x008BA2E8, 0x00BA2E8B ], [ 0x008BA2E8, 0x00E8BA2E ], | |
1486 | [ 0x00BA2E8B, -0x0E8BA2E ], [ 0x00BA2E8B, -0x0BA2E8B ], [ 0x00BA2E8B, -0x08BA2E8 ], | |
1487 | [ 0x00BA2E8B, -0x05D1745 ], [ 0x00BA2E8B, -0x02E8BA2 ], [ 0x00BA2E8B, 0x00000000 ], | |
1488 | [ 0x00BA2E8B, 0x002E8BA2 ], [ 0x00BA2E8B, 0x005D1745 ], [ 0x00BA2E8B, 0x008BA2E8 ], | |
1489 | [ 0x00BA2E8B, 0x00BA2E8B ], [ 0x00BA2E8B, 0x00E8BA2E ], [ 0x00E8BA2E, -0x0E8BA2E ], | |
1490 | [ 0x00E8BA2E, -0x0BA2E8B ], [ 0x00E8BA2E, -0x08BA2E8 ], [ 0x00E8BA2E, -0x05D1745 ], | |
1491 | [ 0x00E8BA2E, -0x02E8BA2 ], [ 0x00E8BA2E, 0x00000000 ], [ 0x00E8BA2E, 0x002E8BA2 ], | |
1492 | [ 0x00E8BA2E, 0x005D1745 ], [ 0x00E8BA2E, 0x008BA2E8 ], [ 0x00E8BA2E, 0x00BA2E8B ], | |
1493 | [ 0x00E8BA2E, 0x00E8BA2E ], | |
1494 | ]; | |
1495 | const TS102366_QUANT15_MAP: [i32; 15] = [ | |
1496 | -0x0EEEEEE, -0x0CCCCCC, -0x0AAAAAA, -0x0888888, -0x0666666, -0x0444444, -0x0222222, 0x00000000, | |
1497 | 0x00222222, 0x00444444, 0x00666666, 0x00888888, 0x00AAAAAA, 0x00CCCCCC, 0x00EEEEEE, | |
1498 | ]; | |
1499 | const TS102366_BAP_BITS: [u8; 10] = [ 5, 6, 7, 8, 9, 10, 11, 12, 14, 16 ]; | |
1500 | ||
1501 | const TS102366_WINDOW: [f32; 256] = [ | |
1502 | 0.00014, 0.00024, 0.00037, 0.00051, 0.00067, 0.00086, 0.00107, 0.00130, | |
1503 | 0.00157, 0.00187, 0.00220, 0.00256, 0.00297, 0.00341, 0.00390, 0.00443, | |
1504 | 0.00501, 0.00564, 0.00632, 0.00706, 0.00785, 0.00871, 0.00962, 0.01061, | |
1505 | 0.01166, 0.01279, 0.01399, 0.01526, 0.01662, 0.01806, 0.01959, 0.02121, | |
1506 | 0.02292, 0.02472, 0.02662, 0.02863, 0.03073, 0.03294, 0.03527, 0.03770, | |
1507 | 0.04025, 0.04292, 0.04571, 0.04862, 0.05165, 0.05481, 0.05810, 0.06153, | |
1508 | 0.06508, 0.06878, 0.07261, 0.07658, 0.08069, 0.08495, 0.08935, 0.09389, | |
1509 | 0.09859, 0.10343, 0.10842, 0.11356, 0.11885, 0.12429, 0.12988, 0.13563, | |
1510 | 0.14152, 0.14757, 0.15376, 0.16011, 0.16661, 0.17325, 0.18005, 0.18699, | |
1511 | 0.19407, 0.20130, 0.20867, 0.21618, 0.22382, 0.23161, 0.23952, 0.24757, | |
1512 | 0.25574, 0.26404, 0.27246, 0.28100, 0.28965, 0.29841, 0.30729, 0.31626, | |
1513 | 0.32533, 0.33450, 0.34376, 0.35311, 0.36253, 0.37204, 0.38161, 0.39126, | |
1514 | 0.40096, 0.41072, 0.42054, 0.43040, 0.44030, 0.45023, 0.46020, 0.47019, | |
1515 | 0.48020, 0.49022, 0.50025, 0.51028, 0.52031, 0.53033, 0.54033, 0.55031, | |
1516 | 0.56026, 0.57019, 0.58007, 0.58991, 0.59970, 0.60944, 0.61912, 0.62873, | |
1517 | 0.63827, 0.64774, 0.65713, 0.66643, 0.67564, 0.68476, 0.69377, 0.70269, | |
1518 | 0.71150, 0.72019, 0.72877, 0.73723, 0.74557, 0.75378, 0.76186, 0.76981, | |
1519 | 0.77762, 0.78530, 0.79283, 0.80022, 0.80747, 0.81457, 0.82151, 0.82831, | |
1520 | 0.83496, 0.84145, 0.84779, 0.85398, 0.86001, 0.86588, 0.87160, 0.87716, | |
1521 | 0.88257, 0.88782, 0.89291, 0.89785, 0.90264, 0.90728, 0.91176, 0.91610, | |
1522 | 0.92028, 0.92432, 0.92822, 0.93197, 0.93558, 0.93906, 0.94240, 0.94560, | |
1523 | 0.94867, 0.95162, 0.95444, 0.95713, 0.95971, 0.96217, 0.96451, 0.96674, | |
1524 | 0.96887, 0.97089, 0.97281, 0.97463, 0.97635, 0.97799, 0.97953, 0.98099, | |
1525 | 0.98236, 0.98366, 0.98488, 0.98602, 0.98710, 0.98811, 0.98905, 0.98994, | |
1526 | 0.99076, 0.99153, 0.99225, 0.99291, 0.99353, 0.99411, 0.99464, 0.99513, | |
1527 | 0.99558, 0.99600, 0.99639, 0.99674, 0.99706, 0.99736, 0.99763, 0.99788, | |
1528 | 0.99811, 0.99831, 0.99850, 0.99867, 0.99882, 0.99895, 0.99908, 0.99919, | |
1529 | 0.99929, 0.99938, 0.99946, 0.99953, 0.99959, 0.99965, 0.99969, 0.99974, | |
1530 | 0.99978, 0.99981, 0.99984, 0.99986, 0.99988, 0.99990, 0.99992, 0.99993, | |
1531 | 0.99994, 0.99995, 0.99996, 0.99997, 0.99998, 0.99998, 0.99998, 0.99999, | |
1532 | 0.99999, 0.99999, 0.99999, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, | |
1533 | 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, | |
1534 | ]; |