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