FFmpeg
ac3.c
Go to the documentation of this file.
1 /*
2  * Common code between the AC-3 encoder and decoder
3  * Copyright (c) 2000 Fabrice Bellard
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 /**
23  * @file
24  * Common code between the AC-3 encoder and decoder.
25  */
26 
27 #include "libavutil/error.h"
28 #include "libavutil/macros.h"
29 
30 #include "ac3.h"
31 #include "ac3defs.h"
32 
33 /**
34  * Starting frequency coefficient bin for each critical band.
35  */
36 const uint8_t ff_ac3_band_start_tab[AC3_CRITICAL_BANDS+1] = {
37  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
38  10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
39  20, 21, 22, 23, 24, 25, 26, 27, 28, 31,
40  34, 37, 40, 43, 46, 49, 55, 61, 67, 73,
41  79, 85, 97, 109, 121, 133, 157, 181, 205, 229, 253
42 };
43 
44 /**
45  * Map each frequency coefficient bin to the critical band that contains it.
46  */
47 const uint8_t ff_ac3_bin_to_band_tab[253] = {
48  0,
49  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
50  13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
51  25, 26, 27, 28, 28, 28, 29, 29, 29, 30, 30, 30,
52  31, 31, 31, 32, 32, 32, 33, 33, 33, 34, 34, 34,
53  35, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 36,
54  37, 37, 37, 37, 37, 37, 38, 38, 38, 38, 38, 38,
55  39, 39, 39, 39, 39, 39, 40, 40, 40, 40, 40, 40,
56  41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
57  42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
58  43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
59  44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
60  45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
61  45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
62  46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
63  46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
64  47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
65  47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
66  48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
67  48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
68  49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
69  49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49
70 };
71 
72 static const uint8_t ac3_log_add_tab[260]= {
73 0x40,0x3f,0x3e,0x3d,0x3c,0x3b,0x3a,0x39,0x38,0x37,
74 0x36,0x35,0x34,0x34,0x33,0x32,0x31,0x30,0x2f,0x2f,
75 0x2e,0x2d,0x2c,0x2c,0x2b,0x2a,0x29,0x29,0x28,0x27,
76 0x26,0x26,0x25,0x24,0x24,0x23,0x23,0x22,0x21,0x21,
77 0x20,0x20,0x1f,0x1e,0x1e,0x1d,0x1d,0x1c,0x1c,0x1b,
78 0x1b,0x1a,0x1a,0x19,0x19,0x18,0x18,0x17,0x17,0x16,
79 0x16,0x15,0x15,0x15,0x14,0x14,0x13,0x13,0x13,0x12,
80 0x12,0x12,0x11,0x11,0x11,0x10,0x10,0x10,0x0f,0x0f,
81 0x0f,0x0e,0x0e,0x0e,0x0d,0x0d,0x0d,0x0d,0x0c,0x0c,
82 0x0c,0x0c,0x0b,0x0b,0x0b,0x0b,0x0a,0x0a,0x0a,0x0a,
83 0x0a,0x09,0x09,0x09,0x09,0x09,0x08,0x08,0x08,0x08,
84 0x08,0x08,0x07,0x07,0x07,0x07,0x07,0x07,0x06,0x06,
85 0x06,0x06,0x06,0x06,0x06,0x06,0x05,0x05,0x05,0x05,
86 0x05,0x05,0x05,0x05,0x04,0x04,0x04,0x04,0x04,0x04,
87 0x04,0x04,0x04,0x04,0x04,0x03,0x03,0x03,0x03,0x03,
88 0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x02,
89 0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,
90 0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x01,0x01,
91 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
92 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
93 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
94 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
95 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
96 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
97 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
98 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
99 };
100 
101 static const uint16_t ac3_hearing_threshold_tab[AC3_CRITICAL_BANDS][3]= {
102 { 0x04d0,0x04f0,0x0580 },
103 { 0x04d0,0x04f0,0x0580 },
104 { 0x0440,0x0460,0x04b0 },
105 { 0x0400,0x0410,0x0450 },
106 { 0x03e0,0x03e0,0x0420 },
107 { 0x03c0,0x03d0,0x03f0 },
108 { 0x03b0,0x03c0,0x03e0 },
109 { 0x03b0,0x03b0,0x03d0 },
110 { 0x03a0,0x03b0,0x03c0 },
111 { 0x03a0,0x03a0,0x03b0 },
112 { 0x03a0,0x03a0,0x03b0 },
113 { 0x03a0,0x03a0,0x03b0 },
114 { 0x03a0,0x03a0,0x03a0 },
115 { 0x0390,0x03a0,0x03a0 },
116 { 0x0390,0x0390,0x03a0 },
117 { 0x0390,0x0390,0x03a0 },
118 { 0x0380,0x0390,0x03a0 },
119 { 0x0380,0x0380,0x03a0 },
120 { 0x0370,0x0380,0x03a0 },
121 { 0x0370,0x0380,0x03a0 },
122 { 0x0360,0x0370,0x0390 },
123 { 0x0360,0x0370,0x0390 },
124 { 0x0350,0x0360,0x0390 },
125 { 0x0350,0x0360,0x0390 },
126 { 0x0340,0x0350,0x0380 },
127 { 0x0340,0x0350,0x0380 },
128 { 0x0330,0x0340,0x0380 },
129 { 0x0320,0x0340,0x0370 },
130 { 0x0310,0x0320,0x0360 },
131 { 0x0300,0x0310,0x0350 },
132 { 0x02f0,0x0300,0x0340 },
133 { 0x02f0,0x02f0,0x0330 },
134 { 0x02f0,0x02f0,0x0320 },
135 { 0x02f0,0x02f0,0x0310 },
136 { 0x0300,0x02f0,0x0300 },
137 { 0x0310,0x0300,0x02f0 },
138 { 0x0340,0x0320,0x02f0 },
139 { 0x0390,0x0350,0x02f0 },
140 { 0x03e0,0x0390,0x0300 },
141 { 0x0420,0x03e0,0x0310 },
142 { 0x0460,0x0420,0x0330 },
143 { 0x0490,0x0450,0x0350 },
144 { 0x04a0,0x04a0,0x03c0 },
145 { 0x0460,0x0490,0x0410 },
146 { 0x0440,0x0460,0x0470 },
147 { 0x0440,0x0440,0x04a0 },
148 { 0x0520,0x0480,0x0460 },
149 { 0x0800,0x0630,0x0440 },
150 { 0x0840,0x0840,0x0450 },
151 { 0x0840,0x0840,0x04e0 },
152 };
153 
154 static inline int calc_lowcomp1(int a, int b0, int b1, int c)
155 {
156  if ((b0 + 256) == b1) {
157  a = c;
158  } else if (b0 > b1) {
159  a = FFMAX(a - 64, 0);
160  }
161  return a;
162 }
163 
164 static inline int calc_lowcomp(int a, int b0, int b1, int bin)
165 {
166  if (bin < 7) {
167  return calc_lowcomp1(a, b0, b1, 384);
168  } else if (bin < 20) {
169  return calc_lowcomp1(a, b0, b1, 320);
170  } else {
171  return FFMAX(a - 128, 0);
172  }
173 }
174 
175 void ff_ac3_bit_alloc_calc_psd(int8_t *exp, int start, int end, int16_t *psd,
176  int16_t *band_psd)
177 {
178  int bin, band;
179 
180  /* exponent mapping to PSD */
181  for (bin = start; bin < end; bin++) {
182  psd[bin]=(3072 - (exp[bin] << 7));
183  }
184 
185  /* PSD integration */
186  bin = start;
187  band = ff_ac3_bin_to_band_tab[start];
188  do {
189  int v = psd[bin++];
190  int band_end = FFMIN(ff_ac3_band_start_tab[band+1], end);
191  for (; bin < band_end; bin++) {
192  int max = FFMAX(v, psd[bin]);
193  /* logadd */
194  int adr = FFMIN(max - ((v + psd[bin] + 1) >> 1), 255);
195  v = max + ac3_log_add_tab[adr];
196  }
197  band_psd[band++] = v;
198  } while (end > ff_ac3_band_start_tab[band]);
199 }
200 
201 int ff_ac3_bit_alloc_calc_mask(AC3BitAllocParameters *s, int16_t *band_psd,
202  int start, int end, int fast_gain, int is_lfe,
203  int dba_mode, int dba_nsegs, uint8_t *dba_offsets,
204  uint8_t *dba_lengths, uint8_t *dba_values,
205  int16_t *mask)
206 {
207  int16_t excite[AC3_CRITICAL_BANDS]; /* excitation */
208  int band;
209  int band_start, band_end, begin, end1;
210  int lowcomp, fastleak, slowleak;
211 
212  if (end <= 0)
213  return AVERROR_INVALIDDATA;
214 
215  /* excitation function */
216  band_start = ff_ac3_bin_to_band_tab[start];
217  band_end = ff_ac3_bin_to_band_tab[end-1] + 1;
218 
219  if (band_start == 0) {
220  lowcomp = 0;
221  lowcomp = calc_lowcomp1(lowcomp, band_psd[0], band_psd[1], 384);
222  excite[0] = band_psd[0] - fast_gain - lowcomp;
223  lowcomp = calc_lowcomp1(lowcomp, band_psd[1], band_psd[2], 384);
224  excite[1] = band_psd[1] - fast_gain - lowcomp;
225  begin = 7;
226  for (band = 2; band < 7; band++) {
227  if (!(is_lfe && band == 6))
228  lowcomp = calc_lowcomp1(lowcomp, band_psd[band], band_psd[band+1], 384);
229  fastleak = band_psd[band] - fast_gain;
230  slowleak = band_psd[band] - s->slow_gain;
231  excite[band] = fastleak - lowcomp;
232  if (!(is_lfe && band == 6)) {
233  if (band_psd[band] <= band_psd[band+1]) {
234  begin = band + 1;
235  break;
236  }
237  }
238  }
239 
240  end1 = FFMIN(band_end, 22);
241  for (band = begin; band < end1; band++) {
242  if (!(is_lfe && band == 6))
243  lowcomp = calc_lowcomp(lowcomp, band_psd[band], band_psd[band+1], band);
244  fastleak = FFMAX(fastleak - s->fast_decay, band_psd[band] - fast_gain);
245  slowleak = FFMAX(slowleak - s->slow_decay, band_psd[band] - s->slow_gain);
246  excite[band] = FFMAX(fastleak - lowcomp, slowleak);
247  }
248  begin = 22;
249  } else {
250  /* coupling channel */
251  begin = band_start;
252  fastleak = (s->cpl_fast_leak << 8) + 768;
253  slowleak = (s->cpl_slow_leak << 8) + 768;
254  }
255 
256  for (band = begin; band < band_end; band++) {
257  fastleak = FFMAX(fastleak - s->fast_decay, band_psd[band] - fast_gain);
258  slowleak = FFMAX(slowleak - s->slow_decay, band_psd[band] - s->slow_gain);
259  excite[band] = FFMAX(fastleak, slowleak);
260  }
261 
262  /* compute masking curve */
263 
264  for (band = band_start; band < band_end; band++) {
265  int tmp = s->db_per_bit - band_psd[band];
266  if (tmp > 0) {
267  excite[band] += tmp >> 2;
268  }
269  mask[band] = FFMAX(ac3_hearing_threshold_tab[band >> s->sr_shift][s->sr_code], excite[band]);
270  }
271 
272  /* delta bit allocation */
273 
274  if (dba_mode == DBA_REUSE || dba_mode == DBA_NEW) {
275  int i, seg, delta;
276  if (dba_nsegs > 8)
277  return -1;
278  band = band_start;
279  for (seg = 0; seg < dba_nsegs; seg++) {
280  band += dba_offsets[seg];
281  if (band >= AC3_CRITICAL_BANDS || dba_lengths[seg] > AC3_CRITICAL_BANDS-band)
282  return -1;
283  if (dba_values[seg] >= 4) {
284  delta = (dba_values[seg] - 3) * 128;
285  } else {
286  delta = (dba_values[seg] - 4) * 128;
287  }
288  for (i = 0; i < dba_lengths[seg]; i++) {
289  mask[band++] += delta;
290  }
291  }
292  }
293  return 0;
294 }
ff_ac3_bin_to_band_tab
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:47
calc_lowcomp
static int calc_lowcomp(int a, int b0, int b1, int bin)
Definition: ac3.c:164
AC3_CRITICAL_BANDS
#define AC3_CRITICAL_BANDS
Definition: ac3defs.h:34
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
max
#define max(a, b)
Definition: cuda_runtime.h:33
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
b1
static double b1(void *priv, double x, double y)
Definition: vf_xfade.c:1771
macros.h
mask
static const uint16_t mask[17]
Definition: lzw.c:38
s
#define s(width, name)
Definition: cbs_vp9.c:256
ff_ac3_band_start_tab
const uint8_t ff_ac3_band_start_tab[AC3_CRITICAL_BANDS+1]
Starting frequency coefficient bin for each critical band.
Definition: ac3.c:36
ac3defs.h
exp
int8_t exp
Definition: eval.c:72
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
error.h
ac3_log_add_tab
static const uint8_t ac3_log_add_tab[260]
Definition: ac3.c:72
calc_lowcomp1
static int calc_lowcomp1(int a, int b0, int b1, int c)
Definition: ac3.c:154
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
ac3_hearing_threshold_tab
static const uint16_t ac3_hearing_threshold_tab[AC3_CRITICAL_BANDS][3]
Definition: ac3.c:101
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
DBA_NEW
@ DBA_NEW
Definition: ac3defs.h:48
delta
float delta
Definition: vorbis_enc_data.h:430
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
DBA_REUSE
@ DBA_REUSE
Definition: ac3defs.h:47
AC3BitAllocParameters
Definition: ac3.h:95
ff_ac3_bit_alloc_calc_mask
int ff_ac3_bit_alloc_calc_mask(AC3BitAllocParameters *s, int16_t *band_psd, int start, int end, int fast_gain, int is_lfe, int dba_mode, int dba_nsegs, uint8_t *dba_offsets, uint8_t *dba_lengths, uint8_t *dba_values, int16_t *mask)
Calculate the masking curve.
Definition: ac3.c:201
ac3.h
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
b0
static double b0(void *priv, double x, double y)
Definition: vf_xfade.c:1770
ff_ac3_bit_alloc_calc_psd
void ff_ac3_bit_alloc_calc_psd(int8_t *exp, int start, int end, int16_t *psd, int16_t *band_psd)
Calculate the log power-spectral density of the input signal.
Definition: ac3.c:175
Generated on Tue Feb 28 2023 21:33:06 for FFmpeg by   doxygen 1.8.17