Merge commit 'a1a143adb0fd11c474221431417cff25db7d920f'
[ffmpeg.git] / libavcodec / ac3dsp.c
1 /*
2  * AC-3 DSP functions
3  * Copyright (c) 2011 Justin Ruggles
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 "avcodec.h"
23 #include "ac3.h"
24 #include "ac3dsp.h"
25 #include "mathops.h"
26
27 static void ac3_exponent_min_c(uint8_t *exp, int num_reuse_blocks, int nb_coefs)
28 {
29     int blk, i;
30
31     if (!num_reuse_blocks)
32         return;
33
34     for (i = 0; i < nb_coefs; i++) {
35         uint8_t min_exp = *exp;
36         uint8_t *exp1 = exp + 256;
37         for (blk = 0; blk < num_reuse_blocks; blk++) {
38             uint8_t next_exp = *exp1;
39             if (next_exp < min_exp)
40                 min_exp = next_exp;
41             exp1 += 256;
42         }
43         *exp++ = min_exp;
44     }
45 }
46
47 static int ac3_max_msb_abs_int16_c(const int16_t *src, int len)
48 {
49     int i, v = 0;
50     for (i = 0; i < len; i++)
51         v |= abs(src[i]);
52     return v;
53 }
54
55 static void ac3_lshift_int16_c(int16_t *src, unsigned int len,
56                                unsigned int shift)
57 {
58     uint32_t *src32 = (uint32_t *)src;
59     const uint32_t mask = ~(((1 << shift) - 1) << 16);
60     int i;
61     len >>= 1;
62     for (i = 0; i < len; i += 8) {
63         src32[i  ] = (src32[i  ] << shift) & mask;
64         src32[i+1] = (src32[i+1] << shift) & mask;
65         src32[i+2] = (src32[i+2] << shift) & mask;
66         src32[i+3] = (src32[i+3] << shift) & mask;
67         src32[i+4] = (src32[i+4] << shift) & mask;
68         src32[i+5] = (src32[i+5] << shift) & mask;
69         src32[i+6] = (src32[i+6] << shift) & mask;
70         src32[i+7] = (src32[i+7] << shift) & mask;
71     }
72 }
73
74 static void ac3_rshift_int32_c(int32_t *src, unsigned int len,
75                                unsigned int shift)
76 {
77     do {
78         *src++ >>= shift;
79         *src++ >>= shift;
80         *src++ >>= shift;
81         *src++ >>= shift;
82         *src++ >>= shift;
83         *src++ >>= shift;
84         *src++ >>= shift;
85         *src++ >>= shift;
86         len -= 8;
87     } while (len > 0);
88 }
89
90 static void float_to_fixed24_c(int32_t *dst, const float *src, unsigned int len)
91 {
92     const float scale = 1 << 24;
93     do {
94         *dst++ = lrintf(*src++ * scale);
95         *dst++ = lrintf(*src++ * scale);
96         *dst++ = lrintf(*src++ * scale);
97         *dst++ = lrintf(*src++ * scale);
98         *dst++ = lrintf(*src++ * scale);
99         *dst++ = lrintf(*src++ * scale);
100         *dst++ = lrintf(*src++ * scale);
101         *dst++ = lrintf(*src++ * scale);
102         len -= 8;
103     } while (len > 0);
104 }
105
106 static void ac3_bit_alloc_calc_bap_c(int16_t *mask, int16_t *psd,
107                                      int start, int end,
108                                      int snr_offset, int floor,
109                                      const uint8_t *bap_tab, uint8_t *bap)
110 {
111     int bin, band, band_end;
112
113     /* special case, if snr offset is -960, set all bap's to zero */
114     if (snr_offset == -960) {
115         memset(bap, 0, AC3_MAX_COEFS);
116         return;
117     }
118
119     bin  = start;
120     band = ff_ac3_bin_to_band_tab[start];
121     do {
122         int m = (FFMAX(mask[band] - snr_offset - floor, 0) & 0x1FE0) + floor;
123         band_end = ff_ac3_band_start_tab[++band];
124         band_end = FFMIN(band_end, end);
125
126         for (; bin < band_end; bin++) {
127             int address = av_clip_uintp2((psd[bin] - m) >> 5, 6);
128             bap[bin] = bap_tab[address];
129         }
130     } while (end > band_end);
131 }
132
133 static void ac3_update_bap_counts_c(uint16_t mant_cnt[16], uint8_t *bap,
134                                     int len)
135 {
136     while (len-- > 0)
137         mant_cnt[bap[len]]++;
138 }
139
140 DECLARE_ALIGNED(16, const uint16_t, ff_ac3_bap_bits)[16] = {
141     0,  0,  0,  3,  0,  4,  5,  6,  7,  8,  9, 10, 11, 12, 14, 16
142 };
143
144 static int ac3_compute_mantissa_size_c(uint16_t mant_cnt[6][16])
145 {
146     int blk, bap;
147     int bits = 0;
148
149     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
150         // bap=1 : 3 mantissas in 5 bits
151         bits += (mant_cnt[blk][1] / 3) * 5;
152         // bap=2 : 3 mantissas in 7 bits
153         // bap=4 : 2 mantissas in 7 bits
154         bits += ((mant_cnt[blk][2] / 3) + (mant_cnt[blk][4] >> 1)) * 7;
155         // bap=3 : 1 mantissa in 3 bits
156         bits += mant_cnt[blk][3] * 3;
157         // bap=5 to 15 : get bits per mantissa from table
158         for (bap = 5; bap < 16; bap++)
159             bits += mant_cnt[blk][bap] * ff_ac3_bap_bits[bap];
160     }
161     return bits;
162 }
163
164 static void ac3_extract_exponents_c(uint8_t *exp, int32_t *coef, int nb_coefs)
165 {
166     int i;
167
168     for (i = 0; i < nb_coefs; i++) {
169         int v = abs(coef[i]);
170         exp[i] = v ? 23 - av_log2(v) : 24;
171     }
172 }
173
174 static void ac3_sum_square_butterfly_int32_c(int64_t sum[4],
175                                              const int32_t *coef0,
176                                              const int32_t *coef1,
177                                              int len)
178 {
179     int i;
180
181     sum[0] = sum[1] = sum[2] = sum[3] = 0;
182
183     for (i = 0; i < len; i++) {
184         int lt = coef0[i];
185         int rt = coef1[i];
186         int md = lt + rt;
187         int sd = lt - rt;
188         MAC64(sum[0], lt, lt);
189         MAC64(sum[1], rt, rt);
190         MAC64(sum[2], md, md);
191         MAC64(sum[3], sd, sd);
192     }
193 }
194
195 static void ac3_sum_square_butterfly_float_c(float sum[4],
196                                              const float *coef0,
197                                              const float *coef1,
198                                              int len)
199 {
200     int i;
201
202     sum[0] = sum[1] = sum[2] = sum[3] = 0;
203
204     for (i = 0; i < len; i++) {
205         float lt = coef0[i];
206         float rt = coef1[i];
207         float md = lt + rt;
208         float sd = lt - rt;
209         sum[0] += lt * lt;
210         sum[1] += rt * rt;
211         sum[2] += md * md;
212         sum[3] += sd * sd;
213     }
214 }
215
216 static void ac3_downmix_5_to_2_symmetric_c(float **samples, float **matrix,
217                                            int len)
218 {
219     int i;
220     float v0, v1;
221     float front_mix    = matrix[0][0];
222     float center_mix   = matrix[0][1];
223     float surround_mix = matrix[0][3];
224
225     for (i = 0; i < len; i++) {
226         v0 = samples[0][i] * front_mix  +
227              samples[1][i] * center_mix +
228              samples[3][i] * surround_mix;
229
230         v1 = samples[1][i] * center_mix +
231              samples[2][i] * front_mix  +
232              samples[4][i] * surround_mix;
233
234         samples[0][i] = v0;
235         samples[1][i] = v1;
236     }
237 }
238
239 static void ac3_downmix_5_to_1_symmetric_c(float **samples, float **matrix,
240                                            int len)
241 {
242     int i;
243     float front_mix    = matrix[0][0];
244     float center_mix   = matrix[0][1];
245     float surround_mix = matrix[0][3];
246
247     for (i = 0; i < len; i++) {
248         samples[0][i] = samples[0][i] * front_mix    +
249                         samples[1][i] * center_mix   +
250                         samples[2][i] * front_mix    +
251                         samples[3][i] * surround_mix +
252                         samples[4][i] * surround_mix;
253     }
254 }
255
256 static void ac3_downmix_c(float **samples, float **matrix,
257                           int out_ch, int in_ch, int len)
258 {
259     int i, j;
260     float v0, v1;
261
262     if (out_ch == 2) {
263         for (i = 0; i < len; i++) {
264             v0 = v1 = 0.0f;
265             for (j = 0; j < in_ch; j++) {
266                 v0 += samples[j][i] * matrix[0][j];
267                 v1 += samples[j][i] * matrix[1][j];
268             }
269             samples[0][i] = v0;
270             samples[1][i] = v1;
271         }
272     } else if (out_ch == 1) {
273         for (i = 0; i < len; i++) {
274             v0 = 0.0f;
275             for (j = 0; j < in_ch; j++)
276                 v0 += samples[j][i] * matrix[0][j];
277             samples[0][i] = v0;
278         }
279     }
280 }
281
282 static void ac3_downmix_5_to_2_symmetric_c_fixed(int32_t **samples, int16_t **matrix,
283                                            int len)
284 {
285     int i;
286     int64_t v0, v1;
287     int16_t front_mix    = matrix[0][0];
288     int16_t center_mix   = matrix[0][1];
289     int16_t surround_mix = matrix[0][3];
290
291     for (i = 0; i < len; i++) {
292         v0 = (int64_t)samples[0][i] * front_mix  +
293              (int64_t)samples[1][i] * center_mix +
294              (int64_t)samples[3][i] * surround_mix;
295
296         v1 = (int64_t)samples[1][i] * center_mix +
297              (int64_t)samples[2][i] * front_mix  +
298              (int64_t)samples[4][i] * surround_mix;
299
300         samples[0][i] = (v0+2048)>>12;
301         samples[1][i] = (v1+2048)>>12;
302     }
303 }
304
305 static void ac3_downmix_5_to_1_symmetric_c_fixed(int32_t **samples, int16_t **matrix,
306                                                  int len)
307 {
308     int i;
309     int64_t v0;
310     int16_t front_mix    = matrix[0][0];
311     int16_t center_mix   = matrix[0][1];
312     int16_t surround_mix = matrix[0][3];
313
314     for (i = 0; i < len; i++) {
315         v0 = (int64_t)samples[0][i] * front_mix    +
316              (int64_t)samples[1][i] * center_mix   +
317              (int64_t)samples[2][i] * front_mix    +
318              (int64_t)samples[3][i] * surround_mix +
319              (int64_t)samples[4][i] * surround_mix;
320
321         samples[0][i] = (v0+2048)>>12;
322     }
323 }
324
325 static void ac3_downmix_c_fixed(int32_t **samples, int16_t **matrix,
326                                 int out_ch, int in_ch, int len)
327 {
328     int i, j;
329     int64_t v0, v1;
330     if (out_ch == 2) {
331         for (i = 0; i < len; i++) {
332             v0 = v1 = 0;
333             for (j = 0; j < in_ch; j++) {
334                 v0 += (int64_t)samples[j][i] * matrix[0][j];
335                 v1 += (int64_t)samples[j][i] * matrix[1][j];
336             }
337             samples[0][i] = (v0+2048)>>12;
338             samples[1][i] = (v1+2048)>>12;
339         }
340     } else if (out_ch == 1) {
341         for (i = 0; i < len; i++) {
342             v0 = 0;
343             for (j = 0; j < in_ch; j++)
344                 v0 += (int64_t)samples[j][i] * matrix[0][j];
345             samples[0][i] = (v0+2048)>>12;
346         }
347     }
348 }
349
350 void ff_ac3dsp_downmix_fixed(AC3DSPContext *c, int32_t **samples, int16_t **matrix,
351                              int out_ch, int in_ch, int len)
352 {
353     if (c->in_channels != in_ch || c->out_channels != out_ch) {
354         c->in_channels  = in_ch;
355         c->out_channels = out_ch;
356         c->downmix_fixed = NULL;
357
358         if (in_ch == 5 && out_ch == 2 &&
359             !(matrix[1][0] | matrix[0][2]  |
360               matrix[1][3] | matrix[0][4]  |
361              (matrix[0][1] ^ matrix[1][1]) |
362              (matrix[0][0] ^ matrix[1][2]))) {
363             c->downmix_fixed = ac3_downmix_5_to_2_symmetric_c_fixed;
364         } else if (in_ch == 5 && out_ch == 1 &&
365                    matrix[0][0] == matrix[0][2] &&
366                    matrix[0][3] == matrix[0][4]) {
367             c->downmix_fixed = ac3_downmix_5_to_1_symmetric_c_fixed;
368         }
369     }
370
371     if (c->downmix_fixed)
372         c->downmix_fixed(samples, matrix, len);
373     else
374         ac3_downmix_c_fixed(samples, matrix, out_ch, in_ch, len);
375 }
376
377 static void apply_window_int16_c(int16_t *output, const int16_t *input,
378                                  const int16_t *window, unsigned int len)
379 {
380     int i;
381     int len2 = len >> 1;
382
383     for (i = 0; i < len2; i++) {
384         int16_t w       = window[i];
385         output[i]       = (MUL16(input[i],       w) + (1 << 14)) >> 15;
386         output[len-i-1] = (MUL16(input[len-i-1], w) + (1 << 14)) >> 15;
387     }
388 }
389
390 void ff_ac3dsp_downmix(AC3DSPContext *c, float **samples, float **matrix,
391                        int out_ch, int in_ch, int len)
392 {
393     if (c->in_channels != in_ch || c->out_channels != out_ch) {
394         int **matrix_cmp = (int **)matrix;
395
396         c->in_channels  = in_ch;
397         c->out_channels = out_ch;
398         c->downmix      = NULL;
399
400         if (in_ch == 5 && out_ch == 2 &&
401             !(matrix_cmp[1][0] | matrix_cmp[0][2]   |
402               matrix_cmp[1][3] | matrix_cmp[0][4]   |
403              (matrix_cmp[0][1] ^ matrix_cmp[1][1]) |
404              (matrix_cmp[0][0] ^ matrix_cmp[1][2]))) {
405             c->downmix = ac3_downmix_5_to_2_symmetric_c;
406         } else if (in_ch == 5 && out_ch == 1 &&
407                    matrix_cmp[0][0] == matrix_cmp[0][2] &&
408                    matrix_cmp[0][3] == matrix_cmp[0][4]) {
409             c->downmix = ac3_downmix_5_to_1_symmetric_c;
410         }
411
412         if (ARCH_X86)
413             ff_ac3dsp_set_downmix_x86(c);
414     }
415
416     if (c->downmix)
417         c->downmix(samples, matrix, len);
418     else
419         ac3_downmix_c(samples, matrix, out_ch, in_ch, len);
420 }
421
422 av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
423 {
424     c->ac3_exponent_min = ac3_exponent_min_c;
425     c->ac3_max_msb_abs_int16 = ac3_max_msb_abs_int16_c;
426     c->ac3_lshift_int16 = ac3_lshift_int16_c;
427     c->ac3_rshift_int32 = ac3_rshift_int32_c;
428     c->float_to_fixed24 = float_to_fixed24_c;
429     c->bit_alloc_calc_bap = ac3_bit_alloc_calc_bap_c;
430     c->update_bap_counts = ac3_update_bap_counts_c;
431     c->compute_mantissa_size = ac3_compute_mantissa_size_c;
432     c->extract_exponents = ac3_extract_exponents_c;
433     c->sum_square_butterfly_int32 = ac3_sum_square_butterfly_int32_c;
434     c->sum_square_butterfly_float = ac3_sum_square_butterfly_float_c;
435     c->in_channels           = 0;
436     c->out_channels          = 0;
437     c->downmix               = NULL;
438     c->downmix_fixed         = NULL;
439     c->apply_window_int16 = apply_window_int16_c;
440
441     if (ARCH_ARM)
442         ff_ac3dsp_init_arm(c, bit_exact);
443     if (ARCH_X86)
444         ff_ac3dsp_init_x86(c, bit_exact);
445     if (ARCH_MIPS)
446         ff_ac3dsp_init_mips(c, bit_exact);
447 }