1 const HISTORY_SIZE: usize = 512;
3 fn val2sign(val: i32) -> i32 {
20 filters: [NFilterContext; 3],
21 lfilt: LastFilterContext,
22 rfilt: LastFilterContext,
25 #[allow(clippy::large_enum_variant)]
33 pub fn new(version: u16, compression: u16) -> Self {
35 FilterMode::Old(OldFilt::new(version, compression))
37 FilterMode::New(NewFilt::new(version, compression))
40 pub fn filter_mono(&mut self, l: &mut [i32]) {
42 FilterMode::Old(ref mut ofilt) => ofilt.filter(l),
43 FilterMode::New(ref mut nfilt) => nfilt.filter_mono(l),
44 FilterMode::None => unreachable!(),
47 pub fn filter_stereo(&mut self, l: &mut [i32], r: &mut [i32]) {
49 FilterMode::Old(ref mut ofilt) => {
52 for (l, r) in l.iter_mut().zip(r.iter_mut()) {
53 let new_l = *l - *r / 2;
54 let new_r = *r + new_l;
59 FilterMode::New(ref mut nfilt) => {
60 nfilt.filter_stereo(l, r);
61 for (l, r) in l.iter_mut().zip(r.iter_mut()) {
62 let new_l = *r - *l / 2;
63 let new_r = *l + new_l;
68 FilterMode::None => unreachable!(),
73 const NEW_FILTER_PARAMS: [[(u8, u8); 3]; 5] = [
74 [ (0, 0), ( 0, 0), ( 0, 0) ],
75 [ (1, 11), ( 0, 0), ( 0, 0) ],
76 [ (4, 11), ( 0, 0), ( 0, 0) ],
77 [ (2, 10), (16, 13), ( 0, 0) ],
78 [ (1, 11), (16, 13), (80, 15) ],
81 #[derive(Clone,Default)]
82 struct NFilterContext {
91 fn adapt_loop(filt: &mut [i32], coeffs: &[i32], adapt: &[i32], val: i32) -> i32 {
93 for (coef, (res, adapt)) in filt.iter_mut().zip(coeffs.iter().zip(adapt.iter())) {
100 *coef = *coef << 16 >> 16;
105 impl NFilterContext {
106 fn new(ord16: u8, bits: u8, new: bool) -> Self {
107 let order = ord16 as usize * 16;
109 buf: if order > 0 { vec![0; order * 2 + HISTORY_SIZE] } else { Vec::new() },
110 coeffs: vec![0; order],
117 fn reset(&mut self) {
118 for el in self.buf[..self.order * 2].iter_mut() { *el = 0; }
119 for el in self.coeffs.iter_mut() { *el = 0; }
122 fn apply(&mut self, dst: &mut [i32]) {
123 if self.order == 0 { return; }
124 let mut adapt_pos = self.order;
125 let mut delay_pos = self.order * 2;
126 for el in dst.iter_mut() {
127 let sum = adapt_loop(&mut self.coeffs,
128 &self.buf[delay_pos - self.order..],
129 &self.buf[adapt_pos - self.order..], *el);
130 let pred = (sum + (1 << (self.bits - 1))) >> self.bits;
131 let val = *el + pred;
133 self.buf[delay_pos] = val.min(32767).max(-32768);
135 let aval = val.abs();
136 let sign = val2sign(val);
137 self.buf[adapt_pos] = if aval == 0 {
139 } else if aval <= self.avg * 4 / 3 {
141 } else if aval <= self.avg * 3 {
146 self.avg += (aval - self.avg) / 16;
147 self.buf[adapt_pos - 1] >>= 1;
148 self.buf[adapt_pos - 2] >>= 1;
149 self.buf[adapt_pos - 8] >>= 1;
151 self.buf[adapt_pos] = 4 * val2sign(val);
152 self.buf[adapt_pos - 4] >>= 1;
153 self.buf[adapt_pos - 8] >>= 1;
157 if delay_pos == HISTORY_SIZE + self.order * 2 {
158 delay_pos = self.order * 2;
159 adapt_pos = self.order;
160 for i in 0..self.order * 2 {
161 self.buf[i] = self.buf[HISTORY_SIZE + i];
168 #[derive(Clone,Copy,Default)]
169 struct LastFilterContext {
181 impl LastFilterContext {
183 const COEFFS_A_NEW: [i32; 4] = [360, 317, -109, 98];
187 self.coeffs_a = COEFFS_A_NEW;
188 self.coeffs_b = [0; 5];
190 self.delay_a = [0; 4];
191 self.adapt_a = [0; 4];
192 self.delay_b = [0; 5];
193 self.adapt_b = [0; 5];
195 fn predict_a(&mut self) -> i32 {
196 for i in (0..3).rev() {
197 self.delay_a[i + 1] = self.delay_a[i];
198 self.adapt_a[i + 1] = self.adapt_a[i];
200 self.delay_a[0] = self.last_a;
201 self.delay_a[1] = self.last_a - self.delay_a[1];
202 self.adapt_a[0] = val2sign(self.delay_a[0]);
203 self.adapt_a[1] = val2sign(self.delay_a[1]);
205 self.delay_a[0] * self.coeffs_a[0] +
206 self.delay_a[1] * self.coeffs_a[1] +
207 self.delay_a[2] * self.coeffs_a[2] +
208 self.delay_a[3] * self.coeffs_a[3]
210 fn predict_b(&mut self, other_a: i32) -> i32 {
211 for i in (0..4).rev() {
212 self.delay_b[i + 1] = self.delay_b[i];
213 self.adapt_b[i + 1] = self.adapt_b[i];
215 self.delay_b[0] = other_a - ((self.filter_b * 31) >> 5);
216 self.delay_b[1] = self.delay_b[0] - self.delay_b[1];
217 self.adapt_b[0] = val2sign(self.delay_b[0]);
218 self.adapt_b[1] = val2sign(self.delay_b[1]);
220 self.filter_b = other_a;
222 (self.delay_b[0] * self.coeffs_b[0] +
223 self.delay_b[1] * self.coeffs_b[1] +
224 self.delay_b[2] * self.coeffs_b[2] +
225 self.delay_b[3] * self.coeffs_b[3] +
226 self.delay_b[4] * self.coeffs_b[4]) >> 1
228 fn update_a(&mut self, pred: i32, diff: i32) -> i32 {
229 self.last_a = diff + (pred >> 10);
230 let sign = val2sign(diff);
232 self.coeffs_a[i] += self.adapt_a[i] * sign;
234 self.filter_a = self.last_a + ((self.filter_a * 31) >> 5);
238 fn update_b(&mut self, diff: i32) {
239 let sign = val2sign(diff);
241 self.coeffs_b[i] += self.adapt_b[i] * sign;
244 fn predict_3930(&mut self, diff: i32) -> i32 {
245 for i in (0..3).rev() {
246 self.delay_a[i + 1] = self.delay_a[i];
248 self.delay_a[0] = self.last_a;
249 let d0 = self.delay_a[0];
250 let d1 = self.delay_a[0] - self.delay_a[1];
251 let d2 = self.delay_a[1] - self.delay_a[2];
252 let d3 = self.delay_a[2] - self.delay_a[3];
254 let pred = (self.coeffs_a[0] * d0 +
255 self.coeffs_a[1] * d1 +
256 self.coeffs_a[2] * d2 +
257 self.coeffs_a[3] * d3) >> 9;
258 self.last_a = diff + pred;
259 self.filter_a = self.last_a + ((self.filter_a * 31) >> 5);
261 let sign = val2sign(diff);
262 self.coeffs_a[0] += if d0 < 0 { sign } else { -sign };
263 self.coeffs_a[1] += if d1 < 0 { sign } else { -sign };
264 self.coeffs_a[2] += if d2 < 0 { sign } else { -sign };
265 self.coeffs_a[3] += if d3 < 0 { sign } else { -sign };
272 fn new(version: u16, compression: u16) -> Self {
273 let cidx = (compression / 1000) as usize - 1;
276 filters: [NFilterContext::default(), NFilterContext::default(), NFilterContext::default()],
277 lfilt: LastFilterContext::default(),
278 rfilt: LastFilterContext::default(),
280 obj.version = version;
281 let new = version >= 3980;
283 let (ord16, bits) = NEW_FILTER_PARAMS[cidx][i];
284 obj.filters[i] = NFilterContext::new(ord16, bits, new);
288 fn filter_mono(&mut self, dst: &mut [i32]) {
289 for filt in self.filters.iter_mut() {
294 if self.version >= 3950 {
295 for el in dst.iter_mut() {
296 let pred = self.lfilt.predict_a();
297 *el = self.lfilt.update_a(pred, *el);
300 for el in dst.iter_mut() {
301 *el = self.lfilt.predict_3930(*el);
305 fn filter_stereo(&mut self, l: &mut [i32], r: &mut [i32]) {
306 for filt in self.filters.iter_mut() {
314 if self.version >= 3950 {
315 for (l, r) in l.iter_mut().zip(r.iter_mut()) {
316 let mut pred = self.lfilt.predict_a();
317 pred += self.lfilt.predict_b(self.rfilt.filter_a);
318 let new_l = self.lfilt.update_a(pred, *l);
319 self.lfilt.update_b(*l);
322 let mut pred = self.rfilt.predict_a();
323 pred += self.rfilt.predict_b(self.lfilt.filter_a);
324 let new_r = self.rfilt.update_a(pred, *r);
325 self.rfilt.update_b(*r);
329 for (l, r) in l.iter_mut().zip(r.iter_mut()) {
330 let new_l = self.lfilt.predict_3930(*r);
331 let new_r = self.rfilt.predict_3930(*l);
340 fn new(version: u16, compression: u16) -> Self {
345 fn filter(&mut self, dst: &mut [i32]) {
346 match self.compression {
348 Self::filter_fast(dst);
351 Self::filter_normal(dst, 4, 10);
354 Self::filter_high(dst, 16, 9);
355 Self::filter_normal(dst, 16, 10);
358 if self.version < 3830 {
359 Self::filter_high(dst, 128, 11);
360 Self::filter_normal(dst, 128, 10);
362 Self::filter_extra_high(dst);
363 Self::filter_high(dst, 256, 12);
364 Self::filter_normal(dst, 256, 11);
370 fn filter_fast(dst: &mut [i32]) {
371 const COEFF_A_FAST: i32 = 375;
376 let mut delay = [dst[1], dst[0]];
377 let mut last = dst[2];
378 let mut filter = dst[2];
379 let mut weight = COEFF_A_FAST;
380 for el in dst[3..].iter_mut() {
383 let pred = delay[0] * 2 - delay[1];
384 last = *el + ((pred * weight) >> 9);
385 if (*el ^ pred) > 0 {
394 fn filter_normal(dst: &mut [i32], start: usize, shift: u8) {
395 const COEFFS_A_NORMAL: [i32; 3] = [64, 115, 64];
396 const COEFFS_B_NORMAL: [i32; 2] = [740, 0];
399 let mut coeffs_a = COEFFS_A_NORMAL;
400 let mut coeffs_b = COEFFS_B_NORMAL;
401 let mut filter_a = 0;
402 let mut filter_b = 0;
403 let mut delay_a = [0; 3];
404 let mut delay_b = [0; 2];
406 for (i, el) in dst.iter_mut().enumerate() {
407 delay_a[2] = delay_a[1]; delay_a[1] = delay_a[0]; delay_a[0] = last;
408 delay_b[1] = delay_b[0]; delay_b[0] = filter_b;
410 let val = *el + filter_a;
417 let a0 = delay_a[0] + (delay_a[2] - delay_a[1]) * 8;
418 let a1 = (delay_a[0] - delay_a[1]) * 2;
420 let b0 = delay_b[0] * 2 - delay_b[1];
423 let pred_a = a0 * coeffs_a[0] + a1 * coeffs_a[1] + a2 * coeffs_a[2];
424 let pred_b = b0 * coeffs_b[0] - b1 * coeffs_b[1];
426 let sign = val2sign(*el);
427 coeffs_a[0] += (((a0 >> 30) & 2) - 1) * sign;
428 coeffs_a[1] += (((a1 >> 28) & 8) - 4) * sign;
429 coeffs_a[2] += (((a2 >> 28) & 8) - 4) * sign;
430 last = *el + (pred_a >> 11);
432 let sign = val2sign(last);
433 coeffs_b[0] += (((b0 >> 29) & 4) - 2) * sign;
434 coeffs_b[1] -= (((b1 >> 30) & 2) - 1) * sign;
436 filter_b = last + (pred_b >> shift);
437 filter_a = filter_b + ((filter_a * 31) >> 5);
442 fn filter_high(dst: &mut [i32], order: usize, shift: u8) {
443 let mut coeffs = [0i32; 256];
444 let mut delay = [0i32; 256];
445 if dst.len() <= order {
448 delay[..order].copy_from_slice(&dst[..order]);
449 for el in dst[order..].iter_mut() {
450 let sign = val2sign(*el);
453 sum += delay[i] * coeffs[i];
454 coeffs[i] -= (((delay[i] >> 30) & 2) - 1) * sign;
457 for i in 0..order-1 {
458 delay[i] = delay[i + 1];
460 delay[order - 1] = *el;
463 fn filter_extra_high(dst: &mut [i32]) {
464 let mut coeffs = [0i32; 8];
465 let mut delay = [0i32; 8];
466 for el in dst[256..].iter_mut() {
467 let sign = val2sign(*el);
470 sum += delay[i] * coeffs[i];
471 coeffs[i] -= (((delay[i] >> 30) & 2) - 1) * sign;
473 for i in (0..7).rev() {
474 delay[i + 1] = delay[i];