Mercurial > libavcodec.hg
comparison ps.c @ 11886:2d81202be6e2 libavcodec
Add HE-AAC v2 support to the AAC decoder.
author | alexc |
---|---|
date | Sat, 19 Jun 2010 14:14:51 +0000 |
parents | |
children | c432b63b345e |
comparison
equal
deleted
inserted
replaced
11885:0e777af9160a | 11886:2d81202be6e2 |
---|---|
1 /* | |
2 * MPEG-4 Parametric Stereo decoding functions | |
3 * Copyright (c) 2010 Alex Converse <alex.converse@gmail.com> | |
4 * | |
5 * This file is part of FFmpeg. | |
6 * | |
7 * FFmpeg is free software; you can redistribute it and/or | |
8 * modify it under the terms of the GNU Lesser General Public | |
9 * License as published by the Free Software Foundation; either | |
10 * version 2.1 of the License, or (at your option) any later version. | |
11 * | |
12 * FFmpeg is distributed in the hope that it will be useful, | |
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Lesser General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Lesser General Public | |
18 * License along with FFmpeg; if not, write to the Free Software | |
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
20 */ | |
21 | |
22 #include <stdint.h> | |
23 #include "libavutil/mathematics.h" | |
24 #include "avcodec.h" | |
25 #include "get_bits.h" | |
26 #include "ps.h" | |
27 #include "ps_tablegen.h" | |
28 #include "psdata.c" | |
29 | |
30 #define PS_BASELINE 0 | |
31 | |
32 #define numQMFSlots 32 //numTimeSlots * RATE | |
33 | |
34 static const int8_t num_env_tab[2][4] = { | |
35 { 0, 1, 2, 4, }, | |
36 { 1, 2, 3, 4, }, | |
37 }; | |
38 | |
39 static const int8_t nr_iidicc_par_tab[] = { | |
40 10, 20, 34, 10, 20, 34, | |
41 }; | |
42 | |
43 static const int8_t nr_iidopd_par_tab[] = { | |
44 5, 11, 17, 5, 11, 17, | |
45 }; | |
46 | |
47 enum { | |
48 huff_iid_df1, | |
49 huff_iid_dt1, | |
50 huff_iid_df0, | |
51 huff_iid_dt0, | |
52 huff_icc_df, | |
53 huff_icc_dt, | |
54 huff_ipd_df, | |
55 huff_ipd_dt, | |
56 huff_opd_df, | |
57 huff_opd_dt, | |
58 }; | |
59 | |
60 static const int huff_iid[] = { | |
61 huff_iid_df0, | |
62 huff_iid_df1, | |
63 huff_iid_dt0, | |
64 huff_iid_dt1, | |
65 }; | |
66 | |
67 static VLC vlc_ps[10]; | |
68 | |
69 /** | |
70 * Read Inter-channel Intensity Difference parameters from the bitstream. | |
71 * | |
72 * @param avctx contains the current codec context | |
73 * @param gb pointer to the input bitstream | |
74 * @param ps pointer to the Parametric Stereo context | |
75 * @param e envelope to decode | |
76 * @param dt 1: time delta-coded, 0: frequency delta-coded | |
77 */ | |
78 static int iid_data(AVCodecContext *avctx, GetBitContext *gb, PSContext *ps, int e, int dt) | |
79 { | |
80 int b; | |
81 int table_idx = huff_iid[2*dt+ps->iid_quant]; | |
82 VLC_TYPE (*vlc_table)[2] = vlc_ps[table_idx].table; | |
83 if (dt) { | |
84 int e_prev = e ? e - 1 : ps->num_env_old - 1; | |
85 e_prev = FFMAX(e_prev, 0); | |
86 for (b = 0; b < ps->nr_iid_par; b++) { | |
87 ps->iid_par[e][b] = ps->iid_par[e_prev][b] + | |
88 get_vlc2(gb, vlc_table, 9, 3) - | |
89 huff_offset[table_idx]; | |
90 if (FFABS(ps->iid_par[e][b]) > 7 + 8 * ps->iid_quant) | |
91 goto err; | |
92 } | |
93 } else { | |
94 int prev = 0; | |
95 for (b = 0; b < ps->nr_iid_par; b++) { | |
96 prev += get_vlc2(gb, vlc_table, 9, 3) - | |
97 huff_offset[table_idx]; | |
98 ps->iid_par[e][b] = prev; | |
99 if (FFABS(ps->iid_par[e][b]) > 7 + 8 * ps->iid_quant) | |
100 goto err; | |
101 } | |
102 } | |
103 return 0; | |
104 err: | |
105 av_log(avctx, AV_LOG_ERROR, "illegal iid\n"); | |
106 return -1; | |
107 } | |
108 | |
109 /** | |
110 * Read Inter-Channel Coherence parameters from the bitstream. | |
111 * | |
112 * @param avctx contains the current codec context | |
113 * @param gb pointer to the input bitstream | |
114 * @param ps pointer to the Parametric Stereo context | |
115 * @param e envelope to decode | |
116 * @param dt 1: time delta-coded, 0: frequency delta-coded | |
117 */ | |
118 static int icc_data(AVCodecContext *avctx, GetBitContext *gb, PSContext *ps, int e, int dt) | |
119 { | |
120 int b; | |
121 int table_idx = dt ? huff_icc_dt : huff_icc_df; | |
122 VLC_TYPE (*vlc_table)[2] = vlc_ps[table_idx].table; | |
123 if (dt) { | |
124 int e_prev = e ? e - 1 : ps->num_env_old - 1; | |
125 e_prev = FFMAX(e_prev, 0); | |
126 for (b = 0; b < ps->nr_icc_par; b++) { | |
127 ps->icc_par[e][b] = ps->icc_par[e_prev][b] + get_vlc2(gb, vlc_table, 9, 3) - huff_offset[table_idx]; | |
128 if (ps->icc_par[e][b] > 7U) | |
129 goto err; | |
130 } | |
131 } else { | |
132 int prev = 0; | |
133 for (b = 0; b < ps->nr_icc_par; b++) { | |
134 prev += get_vlc2(gb, vlc_table, 9, 3) - huff_offset[table_idx]; | |
135 ps->icc_par[e][b] = prev; | |
136 if (ps->icc_par[e][b] > 7U) | |
137 goto err; | |
138 } | |
139 } | |
140 return 0; | |
141 err: | |
142 av_log(avctx, AV_LOG_ERROR, "illegal icc\n"); | |
143 return -1; | |
144 } | |
145 | |
146 /** | |
147 * Read Inter-channel Phase Difference parameters from the bitstream. | |
148 * | |
149 * @param gb pointer to the input bitstream | |
150 * @param ps pointer to the Parametric Stereo context | |
151 * @param e envelope to decode | |
152 * @param dt 1: time delta-coded, 0: frequency delta-coded | |
153 */ | |
154 static void ipd_data(GetBitContext *gb, PSContext *ps, int e, int dt) | |
155 { | |
156 int b; | |
157 int table_idx = dt ? huff_ipd_dt : huff_ipd_df; | |
158 VLC_TYPE (*vlc_table)[2] = vlc_ps[table_idx].table; | |
159 if (dt) { | |
160 int e_prev = e ? e - 1 : ps->num_env_old - 1; | |
161 e_prev = FFMAX(e_prev, 0); | |
162 for (b = 0; b < ps->nr_ipdopd_par; b++) { | |
163 ps->ipd_par[e][b] = (ps->ipd_par[e_prev][b] + get_vlc2(gb, vlc_table, 9, 1)) & 0x07; | |
164 } | |
165 } else { | |
166 int prev = 0; | |
167 for (b = 0; b < ps->nr_ipdopd_par; b++) { | |
168 prev += get_vlc2(gb, vlc_table, 9, 3); | |
169 prev &= 0x07; | |
170 ps->ipd_par[e][b] = prev; | |
171 } | |
172 } | |
173 } | |
174 | |
175 /** | |
176 * Read Overall Phase Difference parameters from the bitstream. | |
177 * | |
178 * @param gb pointer to the input bitstream | |
179 * @param ps pointer to the Parametric Stereo context | |
180 * @param e envelope to decode | |
181 * @param dt 1: time delta-coded, 0: frequency delta-coded | |
182 */ | |
183 static void opd_data(GetBitContext *gb, PSContext *ps, int e, int dt) | |
184 { | |
185 int b; | |
186 int table_idx = dt ? huff_opd_dt : huff_opd_df; | |
187 VLC_TYPE (*vlc_table)[2] = vlc_ps[table_idx].table; | |
188 if (dt) { | |
189 int e_prev = e ? e - 1 : ps->num_env_old - 1; | |
190 e_prev = FFMAX(e_prev, 0); | |
191 for (b = 0; b < ps->nr_ipdopd_par; b++) { | |
192 ps->opd_par[e][b] = (ps->opd_par[e_prev][b] + get_vlc2(gb, vlc_table, 9, 1)) & 0x07; | |
193 } | |
194 } else { | |
195 int prev = 0; | |
196 for (b = 0; b < ps->nr_ipdopd_par; b++) { | |
197 prev += get_vlc2(gb, vlc_table, 9, 3); | |
198 prev &= 0x07; | |
199 ps->opd_par[e][b] = prev; | |
200 } | |
201 } | |
202 } | |
203 | |
204 static int ps_extension(GetBitContext *gb, PSContext *ps, int ps_extension_id) | |
205 { | |
206 int e; | |
207 int count = get_bits_count(gb); | |
208 | |
209 if (ps_extension_id) | |
210 return 0; | |
211 | |
212 ps->enable_ipdopd = get_bits1(gb); | |
213 if (ps->enable_ipdopd) { | |
214 for (e = 0; e < ps->num_env; e++) { | |
215 int dt = get_bits1(gb); | |
216 ipd_data(gb, ps, e, dt); | |
217 dt = get_bits1(gb); | |
218 opd_data(gb, ps, e, dt); | |
219 } | |
220 } | |
221 skip_bits1(gb); //reserved_ps | |
222 return get_bits_count(gb) - count; | |
223 } | |
224 | |
225 static void ipdopd_reset(int8_t *opd_hist, int8_t *ipd_hist) | |
226 { | |
227 int i; | |
228 for (i = 0; i < PS_MAX_NR_IPDOPD; i++) { | |
229 opd_hist[i] = 0; | |
230 ipd_hist[i] = 0; | |
231 } | |
232 } | |
233 | |
234 int ff_ps_read_data(AVCodecContext *avctx, GetBitContext *gb_host, PSContext *ps, int bits_left) | |
235 { | |
236 int e; | |
237 int bit_count_start = get_bits_count(gb_host); | |
238 int header; | |
239 int bits_consumed; | |
240 GetBitContext gbc = *gb_host, *gb = &gbc; | |
241 | |
242 header = get_bits1(gb); | |
243 if (header) { //enable_ps_header | |
244 ps->enable_iid = get_bits1(gb); | |
245 if (ps->enable_iid) { | |
246 ps->iid_mode = get_bits(gb, 3); | |
247 if (ps->iid_mode > 5) { | |
248 av_log(avctx, AV_LOG_ERROR, "iid_mode %d is reserved.\n", | |
249 ps->iid_mode); | |
250 goto err; | |
251 } | |
252 ps->nr_iid_par = nr_iidicc_par_tab[ps->iid_mode]; | |
253 ps->iid_quant = ps->iid_mode > 2; | |
254 ps->nr_ipdopd_par = nr_iidopd_par_tab[ps->iid_mode]; | |
255 } | |
256 ps->enable_icc = get_bits1(gb); | |
257 if (ps->enable_icc) { | |
258 ps->icc_mode = get_bits(gb, 3); | |
259 if (ps->icc_mode > 5) { | |
260 av_log(avctx, AV_LOG_ERROR, "icc_mode %d is reserved.\n", | |
261 ps->icc_mode); | |
262 goto err; | |
263 } | |
264 ps->nr_icc_par = nr_iidicc_par_tab[ps->icc_mode]; | |
265 } | |
266 ps->enable_ext = get_bits1(gb); | |
267 } | |
268 | |
269 ps->frame_class = get_bits1(gb); | |
270 ps->num_env_old = ps->num_env; | |
271 ps->num_env = num_env_tab[ps->frame_class][get_bits(gb, 2)]; | |
272 | |
273 ps->border_position[0] = -1; | |
274 if (ps->frame_class) { | |
275 for (e = 1; e <= ps->num_env; e++) | |
276 ps->border_position[e] = get_bits(gb, 5); | |
277 } else | |
278 for (e = 1; e <= ps->num_env; e++) | |
279 ps->border_position[e] = e * numQMFSlots / ps->num_env - 1; | |
280 | |
281 if (ps->enable_iid) { | |
282 for (e = 0; e < ps->num_env; e++) { | |
283 int dt = get_bits1(gb); | |
284 if (iid_data(avctx, gb, ps, e, dt)) | |
285 goto err; | |
286 } | |
287 } else | |
288 memset(ps->iid_par, 0, sizeof(ps->iid_par)); | |
289 | |
290 if (ps->enable_icc) | |
291 for (e = 0; e < ps->num_env; e++) { | |
292 int dt = get_bits1(gb); | |
293 if (icc_data(avctx, gb, ps, e, dt)) | |
294 goto err; | |
295 } | |
296 else | |
297 memset(ps->icc_par, 0, sizeof(ps->icc_par)); | |
298 | |
299 if (ps->enable_ext) { | |
300 int cnt = get_bits(gb, 4); | |
301 if (cnt == 15) { | |
302 cnt += get_bits(gb, 8); | |
303 } | |
304 cnt *= 8; | |
305 while (cnt > 7) { | |
306 int ps_extension_id = get_bits(gb, 2); | |
307 cnt -= 2 + ps_extension(gb, ps, ps_extension_id); | |
308 } | |
309 if (cnt < 0) { | |
310 av_log(avctx, AV_LOG_ERROR, "ps extension overflow %d", cnt); | |
311 goto err; | |
312 } | |
313 skip_bits(gb, cnt); | |
314 } | |
315 | |
316 ps->enable_ipdopd &= !PS_BASELINE; | |
317 | |
318 //Fix up envelopes | |
319 if (!ps->num_env || ps->border_position[ps->num_env] < numQMFSlots - 1) { | |
320 //Create a fake envelope | |
321 int source = ps->num_env ? ps->num_env - 1 : ps->num_env_old - 1; | |
322 if (source >= 0 && source != ps->num_env) { | |
323 if (ps->enable_iid && ps->num_env_old > 1) { | |
324 memcpy(ps->iid_par+ps->num_env, ps->iid_par+source, sizeof(ps->iid_par[0])); | |
325 } | |
326 if (ps->enable_icc && ps->num_env_old > 1) { | |
327 memcpy(ps->icc_par+ps->num_env, ps->icc_par+source, sizeof(ps->icc_par[0])); | |
328 } | |
329 if (ps->enable_ipdopd && ps->num_env_old > 1) { | |
330 memcpy(ps->ipd_par+ps->num_env, ps->ipd_par+source, sizeof(ps->ipd_par[0])); | |
331 memcpy(ps->opd_par+ps->num_env, ps->opd_par+source, sizeof(ps->opd_par[0])); | |
332 } | |
333 } | |
334 ps->num_env++; | |
335 ps->border_position[ps->num_env] = numQMFSlots - 1; | |
336 } | |
337 | |
338 | |
339 ps->is34bands_old = ps->is34bands; | |
340 if (!PS_BASELINE && (ps->enable_iid || ps->enable_icc)) | |
341 ps->is34bands = (ps->enable_iid && ps->nr_iid_par == 34) || | |
342 (ps->enable_icc && ps->nr_icc_par == 34); | |
343 | |
344 //Baseline | |
345 if (!ps->enable_ipdopd) { | |
346 memset(ps->ipd_par, 0, sizeof(ps->ipd_par)); | |
347 memset(ps->opd_par, 0, sizeof(ps->opd_par)); | |
348 } | |
349 | |
350 if (header) | |
351 ps->start = 1; | |
352 | |
353 bits_consumed = get_bits_count(gb) - bit_count_start; | |
354 if (bits_consumed <= bits_left) { | |
355 skip_bits_long(gb_host, bits_consumed); | |
356 return bits_consumed; | |
357 } | |
358 av_log(avctx, AV_LOG_ERROR, "Expected to read %d PS bits actually read %d.\n", bits_left, bits_consumed); | |
359 err: | |
360 ps->start = 0; | |
361 skip_bits_long(gb_host, bits_left); | |
362 return bits_left; | |
363 } | |
364 | |
365 /** Split one subband into 2 subsubbands with a symmetric real filter. | |
366 * The filter must have its non-center even coefficients equal to zero. */ | |
367 static void hybrid2_re(float (*in)[2], float (*out)[32][2], const float filter[7], int len, int reverse) | |
368 { | |
369 int i, j; | |
370 for (i = 0; i < len; i++) { | |
371 float re_in = filter[6] * in[6+i][0]; //real inphase | |
372 float re_op = 0.0f; //real out of phase | |
373 float im_in = filter[6] * in[6+i][1]; //imag inphase | |
374 float im_op = 0.0f; //imag out of phase | |
375 for (j = 0; j < 6; j += 2) { | |
376 re_op += filter[j+1] * (in[i+j+1][0] + in[12-j-1+i][0]); | |
377 im_op += filter[j+1] * (in[i+j+1][1] + in[12-j-1+i][1]); | |
378 } | |
379 out[ reverse][i][0] = re_in + re_op; | |
380 out[ reverse][i][1] = im_in + im_op; | |
381 out[!reverse][i][0] = re_in - re_op; | |
382 out[!reverse][i][1] = im_in - im_op; | |
383 } | |
384 } | |
385 | |
386 /** Split one subband into 6 subsubbands with a complex filter */ | |
387 static void hybrid6_cx(float (*in)[2], float (*out)[32][2], const float (*filter)[7][2], int len) | |
388 { | |
389 int i, j, ssb; | |
390 int N = 8; | |
391 float temp[8][2]; | |
392 | |
393 for (i = 0; i < len; i++) { | |
394 for (ssb = 0; ssb < N; ssb++) { | |
395 float sum_re = filter[ssb][6][0] * in[i+6][0], sum_im = filter[ssb][6][0] * in[i+6][1]; | |
396 for (j = 0; j < 6; j++) { | |
397 float in0_re = in[i+j][0]; | |
398 float in0_im = in[i+j][1]; | |
399 float in1_re = in[i+12-j][0]; | |
400 float in1_im = in[i+12-j][1]; | |
401 sum_re += filter[ssb][j][0] * (in0_re + in1_re) - filter[ssb][j][1] * (in0_im - in1_im); | |
402 sum_im += filter[ssb][j][0] * (in0_im + in1_im) + filter[ssb][j][1] * (in0_re - in1_re); | |
403 } | |
404 temp[ssb][0] = sum_re; | |
405 temp[ssb][1] = sum_im; | |
406 } | |
407 out[0][i][0] = temp[6][0]; | |
408 out[0][i][1] = temp[6][1]; | |
409 out[1][i][0] = temp[7][0]; | |
410 out[1][i][1] = temp[7][1]; | |
411 out[2][i][0] = temp[0][0]; | |
412 out[2][i][1] = temp[0][1]; | |
413 out[3][i][0] = temp[1][0]; | |
414 out[3][i][1] = temp[1][1]; | |
415 out[4][i][0] = temp[2][0] + temp[5][0]; | |
416 out[4][i][1] = temp[2][1] + temp[5][1]; | |
417 out[5][i][0] = temp[3][0] + temp[4][0]; | |
418 out[5][i][1] = temp[3][1] + temp[4][1]; | |
419 } | |
420 } | |
421 | |
422 static void hybrid4_8_12_cx(float (*in)[2], float (*out)[32][2], const float (*filter)[7][2], int N, int len) | |
423 { | |
424 int i, j, ssb; | |
425 | |
426 for (i = 0; i < len; i++) { | |
427 for (ssb = 0; ssb < N; ssb++) { | |
428 float sum_re = filter[ssb][6][0] * in[i+6][0], sum_im = filter[ssb][6][0] * in[i+6][1]; | |
429 for (j = 0; j < 6; j++) { | |
430 float in0_re = in[i+j][0]; | |
431 float in0_im = in[i+j][1]; | |
432 float in1_re = in[i+12-j][0]; | |
433 float in1_im = in[i+12-j][1]; | |
434 sum_re += filter[ssb][j][0] * (in0_re + in1_re) - filter[ssb][j][1] * (in0_im - in1_im); | |
435 sum_im += filter[ssb][j][0] * (in0_im + in1_im) + filter[ssb][j][1] * (in0_re - in1_re); | |
436 } | |
437 out[ssb][i][0] = sum_re; | |
438 out[ssb][i][1] = sum_im; | |
439 } | |
440 } | |
441 } | |
442 | |
443 static void hybrid_analysis(float out[91][32][2], float in[5][44][2], float L[2][38][64], int is34, int len) | |
444 { | |
445 int i, j; | |
446 for (i = 0; i < 5; i++) { | |
447 for (j = 0; j < 38; j++) { | |
448 in[i][j+6][0] = L[0][j][i]; | |
449 in[i][j+6][1] = L[1][j][i]; | |
450 } | |
451 } | |
452 if(is34) { | |
453 hybrid4_8_12_cx(in[0], out, f34_0_12, 12, len); | |
454 hybrid4_8_12_cx(in[1], out+12, f34_1_8, 8, len); | |
455 hybrid4_8_12_cx(in[2], out+20, f34_2_4, 4, len); | |
456 hybrid4_8_12_cx(in[3], out+24, f34_2_4, 4, len); | |
457 hybrid4_8_12_cx(in[4], out+28, f34_2_4, 4, len); | |
458 for (i = 0; i < 59; i++) { | |
459 for (j = 0; j < len; j++) { | |
460 out[i+32][j][0] = L[0][j][i+5]; | |
461 out[i+32][j][1] = L[1][j][i+5]; | |
462 } | |
463 } | |
464 } else { | |
465 hybrid6_cx(in[0], out, f20_0_8, len); | |
466 hybrid2_re(in[1], out+6, g1_Q2, len, 1); | |
467 hybrid2_re(in[2], out+8, g1_Q2, len, 0); | |
468 for (i = 0; i < 61; i++) { | |
469 for (j = 0; j < len; j++) { | |
470 out[i+10][j][0] = L[0][j][i+3]; | |
471 out[i+10][j][1] = L[1][j][i+3]; | |
472 } | |
473 } | |
474 } | |
475 //update in_buf | |
476 for (i = 0; i < 5; i++) { | |
477 memcpy(in[i], in[i]+32, 6 * sizeof(in[i][0])); | |
478 } | |
479 } | |
480 | |
481 static void hybrid_synthesis(float out[2][38][64], float in[91][32][2], int is34, int len) | |
482 { | |
483 int i, n; | |
484 if(is34) { | |
485 for (n = 0; n < len; n++) { | |
486 memset(out[0][n], 0, 5*sizeof(out[0][n][0])); | |
487 memset(out[1][n], 0, 5*sizeof(out[1][n][0])); | |
488 for(i = 0; i < 12; i++) { | |
489 out[0][n][0] += in[ i][n][0]; | |
490 out[1][n][0] += in[ i][n][1]; | |
491 } | |
492 for(i = 0; i < 8; i++) { | |
493 out[0][n][1] += in[12+i][n][0]; | |
494 out[1][n][1] += in[12+i][n][1]; | |
495 } | |
496 for(i = 0; i < 4; i++) { | |
497 out[0][n][2] += in[20+i][n][0]; | |
498 out[1][n][2] += in[20+i][n][1]; | |
499 out[0][n][3] += in[24+i][n][0]; | |
500 out[1][n][3] += in[24+i][n][1]; | |
501 out[0][n][4] += in[28+i][n][0]; | |
502 out[1][n][4] += in[28+i][n][1]; | |
503 } | |
504 } | |
505 for (i = 0; i < 59; i++) { | |
506 for (n = 0; n < len; n++) { | |
507 out[0][n][i+5] = in[i+32][n][0]; | |
508 out[1][n][i+5] = in[i+32][n][1]; | |
509 } | |
510 } | |
511 } else { | |
512 for (n = 0; n < len; n++) { | |
513 out[0][n][0] = in[0][n][0] + in[1][n][0] + in[2][n][0] + | |
514 in[3][n][0] + in[4][n][0] + in[5][n][0]; | |
515 out[1][n][0] = in[0][n][1] + in[1][n][1] + in[2][n][1] + | |
516 in[3][n][1] + in[4][n][1] + in[5][n][1]; | |
517 out[0][n][1] = in[6][n][0] + in[7][n][0]; | |
518 out[1][n][1] = in[6][n][1] + in[7][n][1]; | |
519 out[0][n][2] = in[8][n][0] + in[9][n][0]; | |
520 out[1][n][2] = in[8][n][1] + in[9][n][1]; | |
521 } | |
522 for (i = 0; i < 61; i++) { | |
523 for (n = 0; n < len; n++) { | |
524 out[0][n][i+3] = in[i+10][n][0]; | |
525 out[1][n][i+3] = in[i+10][n][1]; | |
526 } | |
527 } | |
528 } | |
529 } | |
530 | |
531 /// All-pass filter decay slope | |
532 #define DECAY_SLOPE 0.05f | |
533 /// Number of frequency bands that can be addressed by the parameter index, b(k) | |
534 static const int NR_PAR_BANDS[] = { 20, 34 }; | |
535 /// Number of frequency bands that can be addressed by the sub subband index, k | |
536 static const int NR_BANDS[] = { 71, 91 }; | |
537 /// Start frequency band for the all-pass filter decay slope | |
538 static const int DECAY_CUTOFF[] = { 10, 32 }; | |
539 /// Number of all-pass filer bands | |
540 static const int NR_ALLPASS_BANDS[] = { 30, 50 }; | |
541 /// First stereo band using the short one sample delay | |
542 static const int SHORT_DELAY_BAND[] = { 42, 62 }; | |
543 | |
544 /** Table 8.46 */ | |
545 static void map_idx_10_to_20(int8_t *par_mapped, const int8_t *par, int full) | |
546 { | |
547 int b; | |
548 if (full) | |
549 b = 9; | |
550 else { | |
551 b = 4; | |
552 par_mapped[10] = 0; | |
553 } | |
554 for (; b >= 0; b--) { | |
555 par_mapped[2*b+1] = par_mapped[2*b] = par[b]; | |
556 } | |
557 } | |
558 | |
559 static void map_idx_34_to_20(int8_t *par_mapped, const int8_t *par, int full) | |
560 { | |
561 par_mapped[ 0] = (2*par[ 0] + par[ 1]) / 3; | |
562 par_mapped[ 1] = ( par[ 1] + 2*par[ 2]) / 3; | |
563 par_mapped[ 2] = (2*par[ 3] + par[ 4]) / 3; | |
564 par_mapped[ 3] = ( par[ 4] + 2*par[ 5]) / 3; | |
565 par_mapped[ 4] = ( par[ 6] + par[ 7]) / 2; | |
566 par_mapped[ 5] = ( par[ 8] + par[ 9]) / 2; | |
567 par_mapped[ 6] = par[10]; | |
568 par_mapped[ 7] = par[11]; | |
569 par_mapped[ 8] = ( par[12] + par[13]) / 2; | |
570 par_mapped[ 9] = ( par[14] + par[15]) / 2; | |
571 par_mapped[10] = par[16]; | |
572 if (full) { | |
573 par_mapped[11] = par[17]; | |
574 par_mapped[12] = par[18]; | |
575 par_mapped[13] = par[19]; | |
576 par_mapped[14] = ( par[20] + par[21]) / 2; | |
577 par_mapped[15] = ( par[22] + par[23]) / 2; | |
578 par_mapped[16] = ( par[24] + par[25]) / 2; | |
579 par_mapped[17] = ( par[26] + par[27]) / 2; | |
580 par_mapped[18] = ( par[28] + par[29] + par[30] + par[31]) / 4; | |
581 par_mapped[19] = ( par[32] + par[33]) / 2; | |
582 } | |
583 } | |
584 | |
585 static void map_val_34_to_20(float par[PS_MAX_NR_IIDICC]) | |
586 { | |
587 par[ 0] = (2*par[ 0] + par[ 1]) * 0.33333333f; | |
588 par[ 1] = ( par[ 1] + 2*par[ 2]) * 0.33333333f; | |
589 par[ 2] = (2*par[ 3] + par[ 4]) * 0.33333333f; | |
590 par[ 3] = ( par[ 4] + 2*par[ 5]) * 0.33333333f; | |
591 par[ 4] = ( par[ 6] + par[ 7]) * 0.5f; | |
592 par[ 5] = ( par[ 8] + par[ 9]) * 0.5f; | |
593 par[ 6] = par[10]; | |
594 par[ 7] = par[11]; | |
595 par[ 8] = ( par[12] + par[13]) * 0.5f; | |
596 par[ 9] = ( par[14] + par[15]) * 0.5f; | |
597 par[10] = par[16]; | |
598 par[11] = par[17]; | |
599 par[12] = par[18]; | |
600 par[13] = par[19]; | |
601 par[14] = ( par[20] + par[21]) * 0.5f; | |
602 par[15] = ( par[22] + par[23]) * 0.5f; | |
603 par[16] = ( par[24] + par[25]) * 0.5f; | |
604 par[17] = ( par[26] + par[27]) * 0.5f; | |
605 par[18] = ( par[28] + par[29] + par[30] + par[31]) * 0.25f; | |
606 par[19] = ( par[32] + par[33]) * 0.5f; | |
607 } | |
608 | |
609 static void map_idx_10_to_34(int8_t *par_mapped, const int8_t *par, int full) | |
610 { | |
611 if (full) { | |
612 par_mapped[33] = par[9]; | |
613 par_mapped[32] = par[9]; | |
614 par_mapped[31] = par[9]; | |
615 par_mapped[30] = par[9]; | |
616 par_mapped[29] = par[9]; | |
617 par_mapped[28] = par[9]; | |
618 par_mapped[27] = par[8]; | |
619 par_mapped[26] = par[8]; | |
620 par_mapped[25] = par[8]; | |
621 par_mapped[24] = par[8]; | |
622 par_mapped[23] = par[7]; | |
623 par_mapped[22] = par[7]; | |
624 par_mapped[21] = par[7]; | |
625 par_mapped[20] = par[7]; | |
626 par_mapped[19] = par[6]; | |
627 par_mapped[18] = par[6]; | |
628 par_mapped[17] = par[5]; | |
629 par_mapped[16] = par[5]; | |
630 } else { | |
631 par_mapped[16] = 0; | |
632 } | |
633 par_mapped[15] = par[4]; | |
634 par_mapped[14] = par[4]; | |
635 par_mapped[13] = par[4]; | |
636 par_mapped[12] = par[4]; | |
637 par_mapped[11] = par[3]; | |
638 par_mapped[10] = par[3]; | |
639 par_mapped[ 9] = par[2]; | |
640 par_mapped[ 8] = par[2]; | |
641 par_mapped[ 7] = par[2]; | |
642 par_mapped[ 6] = par[2]; | |
643 par_mapped[ 5] = par[1]; | |
644 par_mapped[ 4] = par[1]; | |
645 par_mapped[ 3] = par[1]; | |
646 par_mapped[ 2] = par[0]; | |
647 par_mapped[ 1] = par[0]; | |
648 par_mapped[ 0] = par[0]; | |
649 } | |
650 | |
651 static void map_idx_20_to_34(int8_t *par_mapped, const int8_t *par, int full) | |
652 { | |
653 if (full) { | |
654 par_mapped[33] = par[19]; | |
655 par_mapped[32] = par[19]; | |
656 par_mapped[31] = par[18]; | |
657 par_mapped[30] = par[18]; | |
658 par_mapped[29] = par[18]; | |
659 par_mapped[28] = par[18]; | |
660 par_mapped[27] = par[17]; | |
661 par_mapped[26] = par[17]; | |
662 par_mapped[25] = par[16]; | |
663 par_mapped[24] = par[16]; | |
664 par_mapped[23] = par[15]; | |
665 par_mapped[22] = par[15]; | |
666 par_mapped[21] = par[14]; | |
667 par_mapped[20] = par[14]; | |
668 par_mapped[19] = par[13]; | |
669 par_mapped[18] = par[12]; | |
670 par_mapped[17] = par[11]; | |
671 } | |
672 par_mapped[16] = par[10]; | |
673 par_mapped[15] = par[ 9]; | |
674 par_mapped[14] = par[ 9]; | |
675 par_mapped[13] = par[ 8]; | |
676 par_mapped[12] = par[ 8]; | |
677 par_mapped[11] = par[ 7]; | |
678 par_mapped[10] = par[ 6]; | |
679 par_mapped[ 9] = par[ 5]; | |
680 par_mapped[ 8] = par[ 5]; | |
681 par_mapped[ 7] = par[ 4]; | |
682 par_mapped[ 6] = par[ 4]; | |
683 par_mapped[ 5] = par[ 3]; | |
684 par_mapped[ 4] = (par[ 2] + par[ 3]) / 2; | |
685 par_mapped[ 3] = par[ 2]; | |
686 par_mapped[ 2] = par[ 1]; | |
687 par_mapped[ 1] = (par[ 0] + par[ 1]) / 2; | |
688 par_mapped[ 0] = par[ 0]; | |
689 } | |
690 | |
691 static void map_val_20_to_34(float par[PS_MAX_NR_IIDICC]) | |
692 { | |
693 par[33] = par[19]; | |
694 par[32] = par[19]; | |
695 par[31] = par[18]; | |
696 par[30] = par[18]; | |
697 par[29] = par[18]; | |
698 par[28] = par[18]; | |
699 par[27] = par[17]; | |
700 par[26] = par[17]; | |
701 par[25] = par[16]; | |
702 par[24] = par[16]; | |
703 par[23] = par[15]; | |
704 par[22] = par[15]; | |
705 par[21] = par[14]; | |
706 par[20] = par[14]; | |
707 par[19] = par[13]; | |
708 par[18] = par[12]; | |
709 par[17] = par[11]; | |
710 par[16] = par[10]; | |
711 par[15] = par[ 9]; | |
712 par[14] = par[ 9]; | |
713 par[13] = par[ 8]; | |
714 par[12] = par[ 8]; | |
715 par[11] = par[ 7]; | |
716 par[10] = par[ 6]; | |
717 par[ 9] = par[ 5]; | |
718 par[ 8] = par[ 5]; | |
719 par[ 7] = par[ 4]; | |
720 par[ 6] = par[ 4]; | |
721 par[ 5] = par[ 3]; | |
722 par[ 4] = (par[ 2] + par[ 3]) * 0.5f; | |
723 par[ 3] = par[ 2]; | |
724 par[ 2] = par[ 1]; | |
725 par[ 1] = (par[ 0] + par[ 1]) * 0.5f; | |
726 par[ 0] = par[ 0]; | |
727 } | |
728 | |
729 static void decorrelation(PSContext *ps, float (*out)[32][2], const float (*s)[32][2], int is34) | |
730 { | |
731 float power[34][PS_QMF_TIME_SLOTS] = {{0}}; | |
732 float transient_gain[34][PS_QMF_TIME_SLOTS]; | |
733 float *peak_decay_nrg = ps->peak_decay_nrg; | |
734 float *power_smooth = ps->power_smooth; | |
735 float *peak_decay_diff_smooth = ps->peak_decay_diff_smooth; | |
736 float (*delay)[PS_QMF_TIME_SLOTS + PS_MAX_DELAY][2] = ps->delay; | |
737 float (*ap_delay)[PS_AP_LINKS][PS_QMF_TIME_SLOTS + PS_MAX_AP_DELAY][2] = ps->ap_delay; | |
738 const int8_t *k_to_i = is34 ? k_to_i_34 : k_to_i_20; | |
739 const float peak_decay_factor = 0.76592833836465f; | |
740 const float transient_impact = 1.5f; | |
741 const float a_smooth = 0.25f; //< Smoothing coefficient | |
742 int i, k, m, n; | |
743 int n0 = 0, nL = 32; | |
744 static const int link_delay[] = { 3, 4, 5 }; | |
745 static const float a[] = { 0.65143905753106f, | |
746 0.56471812200776f, | |
747 0.48954165955695f }; | |
748 | |
749 if (is34 != ps->is34bands_old) { | |
750 memset(ps->peak_decay_nrg, 0, sizeof(ps->peak_decay_nrg)); | |
751 memset(ps->power_smooth, 0, sizeof(ps->power_smooth)); | |
752 memset(ps->peak_decay_diff_smooth, 0, sizeof(ps->peak_decay_diff_smooth)); | |
753 memset(ps->delay, 0, sizeof(ps->delay)); | |
754 memset(ps->ap_delay, 0, sizeof(ps->ap_delay)); | |
755 } | |
756 | |
757 for (n = n0; n < nL; n++) { | |
758 for (k = 0; k < NR_BANDS[is34]; k++) { | |
759 int i = k_to_i[k]; | |
760 power[i][n] += s[k][n][0] * s[k][n][0] + s[k][n][1] * s[k][n][1]; | |
761 } | |
762 } | |
763 | |
764 //Transient detection | |
765 for (i = 0; i < NR_PAR_BANDS[is34]; i++) { | |
766 for (n = n0; n < nL; n++) { | |
767 float decayed_peak = peak_decay_factor * peak_decay_nrg[i]; | |
768 float denom; | |
769 peak_decay_nrg[i] = FFMAX(decayed_peak, power[i][n]); | |
770 power_smooth[i] += a_smooth * (power[i][n] - power_smooth[i]); | |
771 peak_decay_diff_smooth[i] += a_smooth * (peak_decay_nrg[i] - power[i][n] - peak_decay_diff_smooth[i]); | |
772 denom = transient_impact * peak_decay_diff_smooth[i]; | |
773 transient_gain[i][n] = (denom > power_smooth[i]) ? | |
774 power_smooth[i] / denom : 1.0f; | |
775 } | |
776 } | |
777 | |
778 //Decorrelation and transient reduction | |
779 // PS_AP_LINKS - 1 | |
780 // ----- | |
781 // | | Q_fract_allpass[k][m]*z^-link_delay[m] - a[m]*g_decay_slope[k] | |
782 //H[k][z] = z^-2 * phi_fract[k] * | | ---------------------------------------------------------------- | |
783 // | | 1 - a[m]*g_decay_slope[k]*Q_fract_allpass[k][m]*z^-link_delay[m] | |
784 // m = 0 | |
785 //d[k][z] (out) = transient_gain_mapped[k][z] * H[k][z] * s[k][z] | |
786 for (k = 0; k < NR_ALLPASS_BANDS[is34]; k++) { | |
787 int b = k_to_i[k]; | |
788 float g_decay_slope = 1.f - DECAY_SLOPE * (k - DECAY_CUTOFF[is34]); | |
789 float ag[PS_AP_LINKS]; | |
790 g_decay_slope = av_clipf(g_decay_slope, 0.f, 1.f); | |
791 memcpy(delay[k], delay[k]+nL, PS_MAX_DELAY*sizeof(delay[k][0])); | |
792 memcpy(delay[k]+PS_MAX_DELAY, s[k], numQMFSlots*sizeof(delay[k][0])); | |
793 for (m = 0; m < PS_AP_LINKS; m++) { | |
794 memcpy(ap_delay[k][m], ap_delay[k][m]+numQMFSlots, 5*sizeof(ap_delay[k][m][0])); | |
795 ag[m] = a[m] * g_decay_slope; | |
796 } | |
797 for (n = n0; n < nL; n++) { | |
798 float in_re = delay[k][n+PS_MAX_DELAY-2][0] * phi_fract[is34][k][0] - | |
799 delay[k][n+PS_MAX_DELAY-2][1] * phi_fract[is34][k][1]; | |
800 float in_im = delay[k][n+PS_MAX_DELAY-2][0] * phi_fract[is34][k][1] + | |
801 delay[k][n+PS_MAX_DELAY-2][1] * phi_fract[is34][k][0]; | |
802 for (m = 0; m < PS_AP_LINKS; m++) { | |
803 float a_re = ag[m] * in_re; | |
804 float a_im = ag[m] * in_im; | |
805 float link_delay_re = ap_delay[k][m][n+5-link_delay[m]][0]; | |
806 float link_delay_im = ap_delay[k][m][n+5-link_delay[m]][1]; | |
807 float fractional_delay_re = Q_fract_allpass[is34][k][m][0]; | |
808 float fractional_delay_im = Q_fract_allpass[is34][k][m][1]; | |
809 ap_delay[k][m][n+5][0] = in_re; | |
810 ap_delay[k][m][n+5][1] = in_im; | |
811 in_re = link_delay_re * fractional_delay_re - link_delay_im * fractional_delay_im - a_re; | |
812 in_im = link_delay_re * fractional_delay_im + link_delay_im * fractional_delay_re - a_im; | |
813 ap_delay[k][m][n+5][0] += ag[m] * in_re; | |
814 ap_delay[k][m][n+5][1] += ag[m] * in_im; | |
815 } | |
816 out[k][n][0] = transient_gain[b][n] * in_re; | |
817 out[k][n][1] = transient_gain[b][n] * in_im; | |
818 } | |
819 } | |
820 for (; k < SHORT_DELAY_BAND[is34]; k++) { | |
821 memcpy(delay[k], delay[k]+nL, PS_MAX_DELAY*sizeof(delay[k][0])); | |
822 memcpy(delay[k]+PS_MAX_DELAY, s[k], numQMFSlots*sizeof(delay[k][0])); | |
823 for (n = n0; n < nL; n++) { | |
824 //H = delay 14 | |
825 out[k][n][0] = transient_gain[k_to_i[k]][n] * delay[k][n+PS_MAX_DELAY-14][0]; | |
826 out[k][n][1] = transient_gain[k_to_i[k]][n] * delay[k][n+PS_MAX_DELAY-14][1]; | |
827 } | |
828 } | |
829 for (; k < NR_BANDS[is34]; k++) { | |
830 memcpy(delay[k], delay[k]+nL, PS_MAX_DELAY*sizeof(delay[k][0])); | |
831 memcpy(delay[k]+PS_MAX_DELAY, s[k], numQMFSlots*sizeof(delay[k][0])); | |
832 for (n = n0; n < nL; n++) { | |
833 //H = delay 1 | |
834 out[k][n][0] = transient_gain[k_to_i[k]][n] * delay[k][n+PS_MAX_DELAY-1][0]; | |
835 out[k][n][1] = transient_gain[k_to_i[k]][n] * delay[k][n+PS_MAX_DELAY-1][1]; | |
836 } | |
837 } | |
838 } | |
839 | |
840 static void remap34(int8_t (**p_par_mapped)[PS_MAX_NR_IIDICC], | |
841 int8_t (*par)[PS_MAX_NR_IIDICC], | |
842 int num_par, int num_env, int full) | |
843 { | |
844 int8_t (*par_mapped)[PS_MAX_NR_IIDICC] = *p_par_mapped; | |
845 int e; | |
846 if (num_par == 20 || num_par == 11) { | |
847 for (e = 0; e < num_env; e++) { | |
848 map_idx_20_to_34(par_mapped[e], par[e], full); | |
849 } | |
850 } else if (num_par == 10 || num_par == 5) { | |
851 for (e = 0; e < num_env; e++) { | |
852 map_idx_10_to_34(par_mapped[e], par[e], full); | |
853 } | |
854 } else { | |
855 *p_par_mapped = par; | |
856 } | |
857 } | |
858 | |
859 static void remap20(int8_t (**p_par_mapped)[PS_MAX_NR_IIDICC], | |
860 int8_t (*par)[PS_MAX_NR_IIDICC], | |
861 int num_par, int num_env, int full) | |
862 { | |
863 int8_t (*par_mapped)[PS_MAX_NR_IIDICC] = *p_par_mapped; | |
864 int e; | |
865 if (num_par == 34 || num_par == 17) { | |
866 for (e = 0; e < num_env; e++) { | |
867 map_idx_34_to_20(par_mapped[e], par[e], full); | |
868 } | |
869 } else if (num_par == 10 || num_par == 5) { | |
870 for (e = 0; e < num_env; e++) { | |
871 map_idx_10_to_20(par_mapped[e], par[e], full); | |
872 } | |
873 } else { | |
874 *p_par_mapped = par; | |
875 } | |
876 } | |
877 | |
878 static void stereo_processing(PSContext *ps, float (*l)[32][2], float (*r)[32][2], int is34) | |
879 { | |
880 int e, b, k, n; | |
881 | |
882 float (*H11)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H11; | |
883 float (*H12)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H12; | |
884 float (*H21)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H21; | |
885 float (*H22)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H22; | |
886 int8_t *opd_hist = ps->opd_hist; | |
887 int8_t *ipd_hist = ps->ipd_hist; | |
888 int8_t iid_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC]; | |
889 int8_t icc_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC]; | |
890 int8_t ipd_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC]; | |
891 int8_t opd_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC]; | |
892 int8_t (*iid_mapped)[PS_MAX_NR_IIDICC] = iid_mapped_buf; | |
893 int8_t (*icc_mapped)[PS_MAX_NR_IIDICC] = icc_mapped_buf; | |
894 int8_t (*ipd_mapped)[PS_MAX_NR_IIDICC] = ipd_mapped_buf; | |
895 int8_t (*opd_mapped)[PS_MAX_NR_IIDICC] = opd_mapped_buf; | |
896 const int8_t *k_to_i = is34 ? k_to_i_34 : k_to_i_20; | |
897 const float (*H_LUT)[8][4] = (PS_BASELINE || ps->icc_mode < 3) ? HA : HB; | |
898 | |
899 //Remapping | |
900 for (b = 0; b < PS_MAX_NR_IIDICC; b++) { | |
901 H11[0][0][b] = H11[0][ps->num_env_old][b]; | |
902 H12[0][0][b] = H12[0][ps->num_env_old][b]; | |
903 H21[0][0][b] = H21[0][ps->num_env_old][b]; | |
904 H22[0][0][b] = H22[0][ps->num_env_old][b]; | |
905 H11[1][0][b] = H11[1][ps->num_env_old][b]; | |
906 H12[1][0][b] = H12[1][ps->num_env_old][b]; | |
907 H21[1][0][b] = H21[1][ps->num_env_old][b]; | |
908 H22[1][0][b] = H22[1][ps->num_env_old][b]; | |
909 } | |
910 if (is34) { | |
911 remap34(&iid_mapped, ps->iid_par, ps->nr_iid_par, ps->num_env, 1); | |
912 remap34(&icc_mapped, ps->icc_par, ps->nr_icc_par, ps->num_env, 1); | |
913 if (ps->enable_ipdopd) { | |
914 remap34(&ipd_mapped, ps->ipd_par, ps->nr_ipdopd_par, ps->num_env, 0); | |
915 remap34(&opd_mapped, ps->opd_par, ps->nr_ipdopd_par, ps->num_env, 0); | |
916 } | |
917 if (!ps->is34bands_old) { | |
918 map_val_20_to_34(H11[0][0]); | |
919 map_val_20_to_34(H11[1][0]); | |
920 map_val_20_to_34(H12[0][0]); | |
921 map_val_20_to_34(H12[1][0]); | |
922 map_val_20_to_34(H21[0][0]); | |
923 map_val_20_to_34(H21[1][0]); | |
924 map_val_20_to_34(H22[0][0]); | |
925 map_val_20_to_34(H22[1][0]); | |
926 ipdopd_reset(ipd_hist, opd_hist); | |
927 } | |
928 } else { | |
929 remap20(&iid_mapped, ps->iid_par, ps->nr_iid_par, ps->num_env, 1); | |
930 remap20(&icc_mapped, ps->icc_par, ps->nr_icc_par, ps->num_env, 1); | |
931 if (ps->enable_ipdopd) { | |
932 remap20(&ipd_mapped, ps->ipd_par, ps->nr_ipdopd_par, ps->num_env, 0); | |
933 remap20(&opd_mapped, ps->opd_par, ps->nr_ipdopd_par, ps->num_env, 0); | |
934 } | |
935 if (ps->is34bands_old) { | |
936 map_val_34_to_20(H11[0][0]); | |
937 map_val_34_to_20(H11[1][0]); | |
938 map_val_34_to_20(H12[0][0]); | |
939 map_val_34_to_20(H12[1][0]); | |
940 map_val_34_to_20(H21[0][0]); | |
941 map_val_34_to_20(H21[1][0]); | |
942 map_val_34_to_20(H22[0][0]); | |
943 map_val_34_to_20(H22[1][0]); | |
944 ipdopd_reset(ipd_hist, opd_hist); | |
945 } | |
946 } | |
947 | |
948 //Mixing | |
949 for (e = 0; e < ps->num_env; e++) { | |
950 for (b = 0; b < NR_PAR_BANDS[is34]; b++) { | |
951 float h11, h12, h21, h22; | |
952 h11 = H_LUT[iid_mapped[e][b] + 7 + 23 * ps->iid_quant][icc_mapped[e][b]][0]; | |
953 h12 = H_LUT[iid_mapped[e][b] + 7 + 23 * ps->iid_quant][icc_mapped[e][b]][1]; | |
954 h21 = H_LUT[iid_mapped[e][b] + 7 + 23 * ps->iid_quant][icc_mapped[e][b]][2]; | |
955 h22 = H_LUT[iid_mapped[e][b] + 7 + 23 * ps->iid_quant][icc_mapped[e][b]][3]; | |
956 if (!PS_BASELINE && ps->enable_ipdopd && b < ps->nr_ipdopd_par) { | |
957 //The spec say says to only run this smoother when enable_ipdopd | |
958 //is set but the reference decoder appears to run it constantly | |
959 float h11i, h12i, h21i, h22i; | |
960 float ipd_adj_re, ipd_adj_im; | |
961 int opd_idx = opd_hist[b] * 8 + opd_mapped[e][b]; | |
962 int ipd_idx = ipd_hist[b] * 8 + ipd_mapped[e][b]; | |
963 float opd_re = pd_re_smooth[opd_idx]; | |
964 float opd_im = pd_im_smooth[opd_idx]; | |
965 float ipd_re = pd_re_smooth[ipd_idx]; | |
966 float ipd_im = pd_im_smooth[ipd_idx]; | |
967 opd_hist[b] = opd_idx & 0x3F; | |
968 ipd_hist[b] = ipd_idx & 0x3F; | |
969 | |
970 ipd_adj_re = opd_re*ipd_re + opd_im*ipd_im; | |
971 ipd_adj_im = opd_im*ipd_re - opd_re*ipd_im; | |
972 h11i = h11 * opd_im; | |
973 h11 = h11 * opd_re; | |
974 h12i = h12 * ipd_adj_im; | |
975 h12 = h12 * ipd_adj_re; | |
976 h21i = h21 * opd_im; | |
977 h21 = h21 * opd_re; | |
978 h22i = h22 * ipd_adj_im; | |
979 h22 = h22 * ipd_adj_re; | |
980 H11[1][e+1][b] = h11i; | |
981 H12[1][e+1][b] = h12i; | |
982 H21[1][e+1][b] = h21i; | |
983 H22[1][e+1][b] = h22i; | |
984 } | |
985 H11[0][e+1][b] = h11; | |
986 H12[0][e+1][b] = h12; | |
987 H21[0][e+1][b] = h21; | |
988 H22[0][e+1][b] = h22; | |
989 } | |
990 for (k = 0; k < NR_BANDS[is34]; k++) { | |
991 float h11r, h12r, h21r, h22r; | |
992 float h11i, h12i, h21i, h22i; | |
993 float h11r_step, h12r_step, h21r_step, h22r_step; | |
994 float h11i_step, h12i_step, h21i_step, h22i_step; | |
995 int start = ps->border_position[e]; | |
996 int stop = ps->border_position[e+1]; | |
997 float width = 1.f / (stop - start); | |
998 b = k_to_i[k]; | |
999 h11r = H11[0][e][b]; | |
1000 h12r = H12[0][e][b]; | |
1001 h21r = H21[0][e][b]; | |
1002 h22r = H22[0][e][b]; | |
1003 if (!PS_BASELINE && ps->enable_ipdopd) { | |
1004 //Is this necessary? ps_04_new seems unchanged | |
1005 if ((is34 && k <= 13 && k >= 9) || (!is34 && k <= 1)) { | |
1006 h11i = -H11[1][e][b]; | |
1007 h12i = -H12[1][e][b]; | |
1008 h21i = -H21[1][e][b]; | |
1009 h22i = -H22[1][e][b]; | |
1010 } else { | |
1011 h11i = H11[1][e][b]; | |
1012 h12i = H12[1][e][b]; | |
1013 h21i = H21[1][e][b]; | |
1014 h22i = H22[1][e][b]; | |
1015 } | |
1016 } | |
1017 //Interpolation | |
1018 h11r_step = (H11[0][e+1][b] - h11r) * width; | |
1019 h12r_step = (H12[0][e+1][b] - h12r) * width; | |
1020 h21r_step = (H21[0][e+1][b] - h21r) * width; | |
1021 h22r_step = (H22[0][e+1][b] - h22r) * width; | |
1022 if (!PS_BASELINE && ps->enable_ipdopd) { | |
1023 h11i_step = (H11[1][e+1][b] - h11i) * width; | |
1024 h12i_step = (H12[1][e+1][b] - h12i) * width; | |
1025 h21i_step = (H21[1][e+1][b] - h21i) * width; | |
1026 h22i_step = (H22[1][e+1][b] - h22i) * width; | |
1027 } | |
1028 for (n = start + 1; n <= stop; n++) { | |
1029 //l is s, r is d | |
1030 float l_re = l[k][n][0]; | |
1031 float l_im = l[k][n][1]; | |
1032 float r_re = r[k][n][0]; | |
1033 float r_im = r[k][n][1]; | |
1034 h11r += h11r_step; | |
1035 h12r += h12r_step; | |
1036 h21r += h21r_step; | |
1037 h22r += h22r_step; | |
1038 if (!PS_BASELINE && ps->enable_ipdopd) { | |
1039 h11i += h11i_step; | |
1040 h12i += h12i_step; | |
1041 h21i += h21i_step; | |
1042 h22i += h22i_step; | |
1043 | |
1044 l[k][n][0] = h11r*l_re + h21r*r_re - h11i*l_im - h21i*r_im; | |
1045 l[k][n][1] = h11r*l_im + h21r*r_im + h11i*l_re + h21i*r_re; | |
1046 r[k][n][0] = h12r*l_re + h22r*r_re - h12i*l_im - h22i*r_im; | |
1047 r[k][n][1] = h12r*l_im + h22r*r_im + h12i*l_re + h22i*r_re; | |
1048 } else { | |
1049 l[k][n][0] = h11r*l_re + h21r*r_re; | |
1050 l[k][n][1] = h11r*l_im + h21r*r_im; | |
1051 r[k][n][0] = h12r*l_re + h22r*r_re; | |
1052 r[k][n][1] = h12r*l_im + h22r*r_im; | |
1053 } | |
1054 } | |
1055 } | |
1056 } | |
1057 } | |
1058 | |
1059 int ff_ps_apply(AVCodecContext *avctx, PSContext *ps, float L[2][38][64], float R[2][38][64], int top) | |
1060 { | |
1061 float Lbuf[91][32][2]; | |
1062 float Rbuf[91][32][2]; | |
1063 const int len = 32; | |
1064 int is34 = ps->is34bands; | |
1065 | |
1066 top += NR_BANDS[is34] - 64; | |
1067 memset(ps->delay+top, 0, (NR_BANDS[is34] - top)*sizeof(ps->delay[0])); | |
1068 if (top < NR_ALLPASS_BANDS[is34]) | |
1069 memset(ps->ap_delay + top, 0, (NR_ALLPASS_BANDS[is34] - top)*sizeof(ps->ap_delay[0])); | |
1070 | |
1071 hybrid_analysis(Lbuf, ps->in_buf, L, is34, len); | |
1072 decorrelation(ps, Rbuf, Lbuf, is34); | |
1073 stereo_processing(ps, Lbuf, Rbuf, is34); | |
1074 hybrid_synthesis(L, Lbuf, is34, len); | |
1075 hybrid_synthesis(R, Rbuf, is34, len); | |
1076 | |
1077 return 0; | |
1078 } | |
1079 | |
1080 #define PS_INIT_VLC_STATIC(num, size) \ | |
1081 INIT_VLC_STATIC(&vlc_ps[num], 9, ps_tmp[num].table_size / ps_tmp[num].elem_size, \ | |
1082 ps_tmp[num].ps_bits, 1, 1, \ | |
1083 ps_tmp[num].ps_codes, ps_tmp[num].elem_size, ps_tmp[num].elem_size, \ | |
1084 size); | |
1085 | |
1086 #define PS_VLC_ROW(name) \ | |
1087 { name ## _codes, name ## _bits, sizeof(name ## _codes), sizeof(name ## _codes[0]) } | |
1088 | |
1089 av_cold void ff_ps_init(void) { | |
1090 // Syntax initialization | |
1091 static const struct { | |
1092 const void *ps_codes, *ps_bits; | |
1093 const unsigned int table_size, elem_size; | |
1094 } ps_tmp[] = { | |
1095 PS_VLC_ROW(huff_iid_df1), | |
1096 PS_VLC_ROW(huff_iid_dt1), | |
1097 PS_VLC_ROW(huff_iid_df0), | |
1098 PS_VLC_ROW(huff_iid_dt0), | |
1099 PS_VLC_ROW(huff_icc_df), | |
1100 PS_VLC_ROW(huff_icc_dt), | |
1101 PS_VLC_ROW(huff_ipd_df), | |
1102 PS_VLC_ROW(huff_ipd_dt), | |
1103 PS_VLC_ROW(huff_opd_df), | |
1104 PS_VLC_ROW(huff_opd_dt), | |
1105 }; | |
1106 | |
1107 PS_INIT_VLC_STATIC(0, 1544); | |
1108 PS_INIT_VLC_STATIC(1, 832); | |
1109 PS_INIT_VLC_STATIC(2, 1024); | |
1110 PS_INIT_VLC_STATIC(3, 1036); | |
1111 PS_INIT_VLC_STATIC(4, 544); | |
1112 PS_INIT_VLC_STATIC(5, 544); | |
1113 PS_INIT_VLC_STATIC(6, 512); | |
1114 PS_INIT_VLC_STATIC(7, 512); | |
1115 PS_INIT_VLC_STATIC(8, 512); | |
1116 PS_INIT_VLC_STATIC(9, 512); | |
1117 | |
1118 ps_tableinit(); | |
1119 } | |
1120 | |
1121 av_cold void ff_ps_ctx_init(PSContext *ps) | |
1122 { | |
1123 ipdopd_reset(ps->ipd_hist, ps->opd_hist); | |
1124 } |