FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ac3dsp.c
Go to the documentation of this file.
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;
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_c(float **samples, float (*matrix)[2],
217  int out_ch, int in_ch, int len)
218 {
219  int i, j;
220  float v0, v1;
221  if (out_ch == 2) {
222  for (i = 0; i < len; i++) {
223  v0 = v1 = 0.0f;
224  for (j = 0; j < in_ch; j++) {
225  v0 += samples[j][i] * matrix[j][0];
226  v1 += samples[j][i] * matrix[j][1];
227  }
228  samples[0][i] = v0;
229  samples[1][i] = v1;
230  }
231  } else if (out_ch == 1) {
232  for (i = 0; i < len; i++) {
233  v0 = 0.0f;
234  for (j = 0; j < in_ch; j++)
235  v0 += samples[j][i] * matrix[j][0];
236  samples[0][i] = v0;
237  }
238  }
239 }
240 
241 static void ac3_downmix_c_fixed(int32_t **samples, int16_t (*matrix)[2],
242  int out_ch, int in_ch, int len)
243 {
244  int i, j;
245  int64_t v0, v1;
246  if (out_ch == 2) {
247  for (i = 0; i < len; i++) {
248  v0 = v1 = 0;
249  for (j = 0; j < in_ch; j++) {
250  v0 += (int64_t)samples[j][i] * matrix[j][0];
251  v1 += (int64_t)samples[j][i] * matrix[j][1];
252  }
253  samples[0][i] = (v0+2048)>>12;
254  samples[1][i] = (v1+2048)>>12;
255  }
256  } else if (out_ch == 1) {
257  for (i = 0; i < len; i++) {
258  v0 = 0;
259  for (j = 0; j < in_ch; j++)
260  v0 += (int64_t)samples[j][i] * matrix[j][0];
261  samples[0][i] = (v0+2048)>>12;
262  }
263  }
264 }
265 
266 static void apply_window_int16_c(int16_t *output, const int16_t *input,
267  const int16_t *window, unsigned int len)
268 {
269  int i;
270  int len2 = len >> 1;
271 
272  for (i = 0; i < len2; i++) {
273  int16_t w = window[i];
274  output[i] = (MUL16(input[i], w) + (1 << 14)) >> 15;
275  output[len-i-1] = (MUL16(input[len-i-1], w) + (1 << 14)) >> 15;
276  }
277 }
278 
279 av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
280 {
292  c->downmix = ac3_downmix_c;
295 
296  if (ARCH_ARM)
297  ff_ac3dsp_init_arm(c, bit_exact);
298  if (ARCH_X86)
299  ff_ac3dsp_init_x86(c, bit_exact);
300  if (ARCH_MIPS)
301  ff_ac3dsp_init_mips(c, bit_exact);
302 }
void(* ac3_rshift_int32)(int32_t *src, unsigned int len, unsigned int shift)
Right-shift each value in an array of int32_t by a specified amount.
Definition: ac3dsp.h:76
void(* float_to_fixed24)(int32_t *dst, const float *src, unsigned int len)
Convert an array of float in range [-1.0,1.0] to int32_t with range [-(1<<24),(1<<24)].
Definition: ac3dsp.h:89
static int shift(int a, int b)
Definition: sonic.c:82
#define AC3_MAX_COEFS
Definition: ac3.h:34
void ff_ac3dsp_init_mips(AC3DSPContext *c, int bit_exact)
Definition: ac3dsp_mips.c:403
void(* sum_square_butterfly_float)(float sum[4], const float *coef0, const float *coef1, int len)
Definition: ac3dsp.h:132
int av_log2(unsigned v)
Definition: intmath.c:26
GLfloat v0
Definition: opengl_enc.c:107
#define blk(i)
Definition: sha.c:185
const uint8_t ff_ac3_bin_to_band_tab[253]
Map each frequency coefficient bin to the critical band that contains it.
Definition: ac3.c:46
uint8_t bits
Definition: crc.c:296
uint8_t
#define av_cold
Definition: attributes.h:82
static int ac3_max_msb_abs_int16_c(const int16_t *src, int len)
Definition: ac3dsp.c:47
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int(* ac3_max_msb_abs_int16)(const int16_t *src, int len)
Calculate the maximum MSB of the absolute value of each element in an array of int16_t.
Definition: ac3dsp.h:54
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:101
#define lrintf(x)
Definition: libm_mips.h:70
static void ac3_downmix_c_fixed(int32_t **samples, int16_t(*matrix)[2], int out_ch, int in_ch, int len)
Definition: ac3dsp.c:241
void ff_ac3dsp_init_x86(AC3DSPContext *c, int bit_exact)
Definition: ac3dsp_init.c:198
void ff_ac3dsp_init_arm(AC3DSPContext *c, int bit_exact)
static const uint16_t mask[17]
Definition: lzw.c:38
static void ac3_sum_square_butterfly_int32_c(int64_t sum[4], const int32_t *coef0, const int32_t *coef1, int len)
Definition: ac3dsp.c:174
const uint8_t ff_ac3_band_start_tab[AC3_CRITICAL_BANDS+1]
Starting frequency coefficient bin for each critical band.
Definition: ac3.c:35
static int ac3_compute_mantissa_size_c(uint16_t mant_cnt[6][16])
Definition: ac3dsp.c:144
#define FFMAX(a, b)
Definition: common.h:94
#define MUL16(ra, rb)
Definition: mathops.h:87
int8_t exp
Definition: eval.c:64
static SDL_Window * window
Definition: ffplay.c:361
#define md
#define FFMIN(a, b)
Definition: common.h:96
av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
Definition: ac3dsp.c:279
static void ac3_downmix_c(float **samples, float(*matrix)[2], int out_ch, int in_ch, int len)
Definition: ac3dsp.c:216
int32_t
static void apply_window_int16_c(int16_t *output, const int16_t *input, const int16_t *window, unsigned int len)
Definition: ac3dsp.c:266
#define src
Definition: vp9dsp.c:530
void(* extract_exponents)(uint8_t *exp, int32_t *coef, int nb_coefs)
Definition: ac3dsp.h:127
void(* bit_alloc_calc_bap)(int16_t *mask, int16_t *psd, int start, int end, int snr_offset, int floor, const uint8_t *bap_tab, uint8_t *bap)
Calculate bit allocation pointers.
Definition: ac3dsp.h:106
Libavcodec external API header.
static void ac3_update_bap_counts_c(uint16_t mant_cnt[16], uint8_t *bap, int len)
Definition: ac3dsp.c:133
static void ac3_exponent_min_c(uint8_t *exp, int num_reuse_blocks, int nb_coefs)
Definition: ac3dsp.c:27
#define AC3_MAX_BLOCKS
Definition: ac3.h:36
void(* apply_window_int16)(int16_t *output, const int16_t *input, const int16_t *window, unsigned int len)
Apply symmetric window in 16-bit fixed-point.
Definition: ac3dsp.h:152
static void ac3_rshift_int32_c(int32_t *src, unsigned int len, unsigned int shift)
Definition: ac3dsp.c:74
static void ac3_extract_exponents_c(uint8_t *exp, int32_t *coef, int nb_coefs)
Definition: ac3dsp.c:164
int(* compute_mantissa_size)(uint16_t mant_cnt[6][16])
Calculate the number of bits needed to encode a set of mantissas.
Definition: ac3dsp.h:125
void(* update_bap_counts)(uint16_t mant_cnt[16], uint8_t *bap, int len)
Update bap counts using the supplied array of bap.
Definition: ac3dsp.h:117
static double c[64]
const uint16_t ff_ac3_bap_bits[16]
Number of mantissa bits written for each bap value.
Definition: ac3dsp.c:140
void(* ac3_lshift_int16)(int16_t *src, unsigned int len, unsigned int shift)
Left-shift each value in an array of int16_t by a specified amount.
Definition: ac3dsp.h:65
void(* ac3_exponent_min)(uint8_t *exp, int num_reuse_blocks, int nb_coefs)
Set each encoded exponent in a block to the minimum of itself and the exponents in the same frequency...
Definition: ac3dsp.h:43
static void float_to_fixed24_c(int32_t *dst, const float *src, unsigned int len)
Definition: ac3dsp.c:90
int len
void(* downmix_fixed)(int32_t **samples, int16_t(*matrix)[2], int out_ch, int in_ch, int len)
Definition: ac3dsp.h:138
void(* downmix)(float **samples, float(*matrix)[2], int out_ch, int in_ch, int len)
Definition: ac3dsp.h:135
static void ac3_bit_alloc_calc_bap_c(int16_t *mask, int16_t *psd, int start, int end, int snr_offset, int floor, const uint8_t *bap_tab, uint8_t *bap)
Definition: ac3dsp.c:106
#define MAC64(d, a, b)
Definition: mathops.h:73
void(* sum_square_butterfly_int32)(int64_t sum[4], const int32_t *coef0, const int32_t *coef1, int len)
Definition: ac3dsp.h:129
void INT64 start
Definition: avisynth_c.h:690
static void ac3_lshift_int16_c(int16_t *src, unsigned int len, unsigned int shift)
Definition: ac3dsp.c:55
static void ac3_sum_square_butterfly_float_c(float sum[4], const float *coef0, const float *coef1, int len)
Definition: ac3dsp.c:195
Common code between the AC-3 encoder and decoder.