FFmpeg  4.1.5
aacdec_fixed.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2013
3  * MIPS Technologies, Inc., California.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  * notice, this list of conditions and the following disclaimer in the
12  * documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the MIPS Technologies, Inc., nor the names of its
14  * contributors may be used to endorse or promote products derived from
15  * this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE MIPS TECHNOLOGIES, INC. ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED. IN NO EVENT SHALL THE MIPS TECHNOLOGIES, INC. BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  * AAC decoder fixed-point implementation
30  *
31  * Copyright (c) 2005-2006 Oded Shimon ( ods15 ods15 dyndns org )
32  * Copyright (c) 2006-2007 Maxim Gavrilov ( maxim.gavrilov gmail com )
33  *
34  * This file is part of FFmpeg.
35  *
36  * FFmpeg is free software; you can redistribute it and/or
37  * modify it under the terms of the GNU Lesser General Public
38  * License as published by the Free Software Foundation; either
39  * version 2.1 of the License, or (at your option) any later version.
40  *
41  * FFmpeg is distributed in the hope that it will be useful,
42  * but WITHOUT ANY WARRANTY; without even the implied warranty of
43  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
44  * Lesser General Public License for more details.
45  *
46  * You should have received a copy of the GNU Lesser General Public
47  * License along with FFmpeg; if not, write to the Free Software
48  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
49  */
50 
51 /**
52  * @file
53  * AAC decoder
54  * @author Oded Shimon ( ods15 ods15 dyndns org )
55  * @author Maxim Gavrilov ( maxim.gavrilov gmail com )
56  *
57  * Fixed point implementation
58  * @author Stanislav Ocovaj ( stanislav.ocovaj imgtec com )
59  */
60 
61 #define FFT_FLOAT 0
62 #define FFT_FIXED_32 1
63 #define USE_FIXED 1
64 
65 #include "libavutil/fixed_dsp.h"
66 #include "libavutil/opt.h"
67 #include "avcodec.h"
68 #include "internal.h"
69 #include "get_bits.h"
70 #include "fft.h"
71 #include "lpc.h"
72 #include "kbdwin.h"
73 #include "sinewin.h"
74 
75 #include "aac.h"
76 #include "aactab.h"
77 #include "aacdectab.h"
78 #include "adts_header.h"
79 #include "cbrt_data.h"
80 #include "sbr.h"
81 #include "aacsbr.h"
82 #include "mpeg4audio.h"
83 #include "profiles.h"
84 #include "libavutil/intfloat.h"
85 
86 #include <math.h>
87 #include <string.h>
88 
90 {
91  ps->r0.mant = 0;
92  ps->r0.exp = 0;
93  ps->r1.mant = 0;
94  ps->r1.exp = 0;
95  ps->cor0.mant = 0;
96  ps->cor0.exp = 0;
97  ps->cor1.mant = 0;
98  ps->cor1.exp = 0;
99  ps->var0.mant = 0x20000000;
100  ps->var0.exp = 1;
101  ps->var1.mant = 0x20000000;
102  ps->var1.exp = 1;
103 }
104 
105 static const int exp2tab[4] = { Q31(1.0000000000/2), Q31(1.1892071150/2), Q31(1.4142135624/2), Q31(1.6817928305/2) }; // 2^0, 2^0.25, 2^0.5, 2^0.75
106 
107 static inline int *DEC_SPAIR(int *dst, unsigned idx)
108 {
109  dst[0] = (idx & 15) - 4;
110  dst[1] = (idx >> 4 & 15) - 4;
111 
112  return dst + 2;
113 }
114 
115 static inline int *DEC_SQUAD(int *dst, unsigned idx)
116 {
117  dst[0] = (idx & 3) - 1;
118  dst[1] = (idx >> 2 & 3) - 1;
119  dst[2] = (idx >> 4 & 3) - 1;
120  dst[3] = (idx >> 6 & 3) - 1;
121 
122  return dst + 4;
123 }
124 
125 static inline int *DEC_UPAIR(int *dst, unsigned idx, unsigned sign)
126 {
127  dst[0] = (idx & 15) * (1 - (sign & 0xFFFFFFFE));
128  dst[1] = (idx >> 4 & 15) * (1 - ((sign & 1) * 2));
129 
130  return dst + 2;
131 }
132 
133 static inline int *DEC_UQUAD(int *dst, unsigned idx, unsigned sign)
134 {
135  unsigned nz = idx >> 12;
136 
137  dst[0] = (idx & 3) * (1 + (((int)sign >> 31) * 2));
138  sign <<= nz & 1;
139  nz >>= 1;
140  dst[1] = (idx >> 2 & 3) * (1 + (((int)sign >> 31) * 2));
141  sign <<= nz & 1;
142  nz >>= 1;
143  dst[2] = (idx >> 4 & 3) * (1 + (((int)sign >> 31) * 2));
144  sign <<= nz & 1;
145  nz >>= 1;
146  dst[3] = (idx >> 6 & 3) * (1 + (((int)sign >> 31) * 2));
147 
148  return dst + 4;
149 }
150 
151 static void vector_pow43(int *coefs, int len)
152 {
153  int i, coef;
154 
155  for (i=0; i<len; i++) {
156  coef = coefs[i];
157  if (coef < 0)
158  coef = -(int)ff_cbrt_tab_fixed[-coef];
159  else
160  coef = (int)ff_cbrt_tab_fixed[coef];
161  coefs[i] = coef;
162  }
163 }
164 
165 static void subband_scale(int *dst, int *src, int scale, int offset, int len)
166 {
167  int ssign = scale < 0 ? -1 : 1;
168  int s = FFABS(scale);
169  unsigned int round;
170  int i, out, c = exp2tab[s & 3];
171 
172  s = offset - (s >> 2);
173 
174  if (s > 31) {
175  for (i=0; i<len; i++) {
176  dst[i] = 0;
177  }
178  } else if (s > 0) {
179  round = 1 << (s-1);
180  for (i=0; i<len; i++) {
181  out = (int)(((int64_t)src[i] * c) >> 32);
182  dst[i] = ((int)(out+round) >> s) * ssign;
183  }
184  } else if (s > -32) {
185  s = s + 32;
186  round = 1U << (s-1);
187  for (i=0; i<len; i++) {
188  out = (int)((int64_t)((int64_t)src[i] * c + round) >> s);
189  dst[i] = out * (unsigned)ssign;
190  }
191  } else {
192  av_log(NULL, AV_LOG_ERROR, "Overflow in subband_scale()\n");
193  }
194 }
195 
196 static void noise_scale(int *coefs, int scale, int band_energy, int len)
197 {
198  int s = -scale;
199  unsigned int round;
200  int i, out, c = exp2tab[s & 3];
201  int nlz = 0;
202 
203  av_assert0(s >= 0);
204  while (band_energy > 0x7fff) {
205  band_energy >>= 1;
206  nlz++;
207  }
208  c /= band_energy;
209  s = 21 + nlz - (s >> 2);
210 
211  if (s > 31) {
212  for (i=0; i<len; i++) {
213  coefs[i] = 0;
214  }
215  } else if (s >= 0) {
216  round = s ? 1 << (s-1) : 0;
217  for (i=0; i<len; i++) {
218  out = (int)(((int64_t)coefs[i] * c) >> 32);
219  coefs[i] = -((int)(out+round) >> s);
220  }
221  }
222  else {
223  s = s + 32;
224  if (s > 0) {
225  round = 1 << (s-1);
226  for (i=0; i<len; i++) {
227  out = (int)((int64_t)((int64_t)coefs[i] * c + round) >> s);
228  coefs[i] = -out;
229  }
230  } else {
231  for (i=0; i<len; i++)
232  coefs[i] = -(int64_t)coefs[i] * c * (1 << -s);
233  }
234  }
235 }
236 
238 {
239  SoftFloat tmp;
240  int s;
241 
242  tmp.exp = pf.exp;
243  s = pf.mant >> 31;
244  tmp.mant = (pf.mant ^ s) - s;
245  tmp.mant = (tmp.mant + 0x00200000U) & 0xFFC00000U;
246  tmp.mant = (tmp.mant ^ s) - s;
247 
248  return tmp;
249 }
250 
252 {
253  SoftFloat tmp;
254  int s;
255 
256  tmp.exp = pf.exp;
257  s = pf.mant >> 31;
258  tmp.mant = (pf.mant ^ s) - s;
259  tmp.mant = (tmp.mant + 0x001FFFFFU + (tmp.mant & 0x00400000U >> 16)) & 0xFFC00000U;
260  tmp.mant = (tmp.mant ^ s) - s;
261 
262  return tmp;
263 }
264 
266 {
267  SoftFloat pun;
268  int s;
269 
270  pun.exp = pf.exp;
271  s = pf.mant >> 31;
272  pun.mant = (pf.mant ^ s) - s;
273  pun.mant = pun.mant & 0xFFC00000U;
274  pun.mant = (pun.mant ^ s) - s;
275 
276  return pun;
277 }
278 
279 static av_always_inline void predict(PredictorState *ps, int *coef,
280  int output_enable)
281 {
282  const SoftFloat a = { 1023410176, 0 }; // 61.0 / 64
283  const SoftFloat alpha = { 973078528, 0 }; // 29.0 / 32
284  SoftFloat e0, e1;
285  SoftFloat pv;
286  SoftFloat k1, k2;
287  SoftFloat r0 = ps->r0, r1 = ps->r1;
288  SoftFloat cor0 = ps->cor0, cor1 = ps->cor1;
289  SoftFloat var0 = ps->var0, var1 = ps->var1;
290  SoftFloat tmp;
291 
292  if (var0.exp > 1 || (var0.exp == 1 && var0.mant > 0x20000000)) {
293  k1 = av_mul_sf(cor0, flt16_even(av_div_sf(a, var0)));
294  }
295  else {
296  k1.mant = 0;
297  k1.exp = 0;
298  }
299 
300  if (var1.exp > 1 || (var1.exp == 1 && var1.mant > 0x20000000)) {
301  k2 = av_mul_sf(cor1, flt16_even(av_div_sf(a, var1)));
302  }
303  else {
304  k2.mant = 0;
305  k2.exp = 0;
306  }
307 
308  tmp = av_mul_sf(k1, r0);
309  pv = flt16_round(av_add_sf(tmp, av_mul_sf(k2, r1)));
310  if (output_enable) {
311  int shift = 28 - pv.exp;
312 
313  if (shift < 31) {
314  if (shift > 0) {
315  *coef += (unsigned)((pv.mant + (1 << (shift - 1))) >> shift);
316  } else
317  *coef += (unsigned)pv.mant << -shift;
318  }
319  }
320 
321  e0 = av_int2sf(*coef, 2);
322  e1 = av_sub_sf(e0, tmp);
323 
324  ps->cor1 = flt16_trunc(av_add_sf(av_mul_sf(alpha, cor1), av_mul_sf(r1, e1)));
325  tmp = av_add_sf(av_mul_sf(r1, r1), av_mul_sf(e1, e1));
326  tmp.exp--;
327  ps->var1 = flt16_trunc(av_add_sf(av_mul_sf(alpha, var1), tmp));
328  ps->cor0 = flt16_trunc(av_add_sf(av_mul_sf(alpha, cor0), av_mul_sf(r0, e0)));
329  tmp = av_add_sf(av_mul_sf(r0, r0), av_mul_sf(e0, e0));
330  tmp.exp--;
331  ps->var0 = flt16_trunc(av_add_sf(av_mul_sf(alpha, var0), tmp));
332 
333  ps->r1 = flt16_trunc(av_mul_sf(a, av_sub_sf(r0, av_mul_sf(k1, e0))));
334  ps->r0 = flt16_trunc(av_mul_sf(a, e0));
335 }
336 
337 
338 static const int cce_scale_fixed[8] = {
339  Q30(1.0), //2^(0/8)
340  Q30(1.0905077327), //2^(1/8)
341  Q30(1.1892071150), //2^(2/8)
342  Q30(1.2968395547), //2^(3/8)
343  Q30(1.4142135624), //2^(4/8)
344  Q30(1.5422108254), //2^(5/8)
345  Q30(1.6817928305), //2^(6/8)
346  Q30(1.8340080864), //2^(7/8)
347 };
348 
349 /**
350  * Apply dependent channel coupling (applied before IMDCT).
351  *
352  * @param index index into coupling gain array
353  */
355  SingleChannelElement *target,
356  ChannelElement *cce, int index)
357 {
358  IndividualChannelStream *ics = &cce->ch[0].ics;
359  const uint16_t *offsets = ics->swb_offset;
360  int *dest = target->coeffs;
361  const int *src = cce->ch[0].coeffs;
362  int g, i, group, k, idx = 0;
363  if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP) {
365  "Dependent coupling is not supported together with LTP\n");
366  return;
367  }
368  for (g = 0; g < ics->num_window_groups; g++) {
369  for (i = 0; i < ics->max_sfb; i++, idx++) {
370  if (cce->ch[0].band_type[idx] != ZERO_BT) {
371  const int gain = cce->coup.gain[index][idx];
372  int shift, round, c, tmp;
373 
374  if (gain < 0) {
375  c = -cce_scale_fixed[-gain & 7];
376  shift = (-gain-1024) >> 3;
377  }
378  else {
379  c = cce_scale_fixed[gain & 7];
380  shift = (gain-1024) >> 3;
381  }
382 
383  if (shift < -31) {
384  // Nothing to do
385  } else if (shift < 0) {
386  shift = -shift;
387  round = 1 << (shift - 1);
388 
389  for (group = 0; group < ics->group_len[g]; group++) {
390  for (k = offsets[i]; k < offsets[i + 1]; k++) {
391  tmp = (int)(((int64_t)src[group * 128 + k] * c + \
392  (int64_t)0x1000000000) >> 37);
393  dest[group * 128 + k] += (tmp + (int64_t)round) >> shift;
394  }
395  }
396  }
397  else {
398  for (group = 0; group < ics->group_len[g]; group++) {
399  for (k = offsets[i]; k < offsets[i + 1]; k++) {
400  tmp = (int)(((int64_t)src[group * 128 + k] * c + \
401  (int64_t)0x1000000000) >> 37);
402  dest[group * 128 + k] += tmp * (1U << shift);
403  }
404  }
405  }
406  }
407  }
408  dest += ics->group_len[g] * 128;
409  src += ics->group_len[g] * 128;
410  }
411 }
412 
413 /**
414  * Apply independent channel coupling (applied after IMDCT).
415  *
416  * @param index index into coupling gain array
417  */
419  SingleChannelElement *target,
420  ChannelElement *cce, int index)
421 {
422  int i, c, shift, round, tmp;
423  const int gain = cce->coup.gain[index][0];
424  const int *src = cce->ch[0].ret;
425  unsigned int *dest = target->ret;
426  const int len = 1024 << (ac->oc[1].m4ac.sbr == 1);
427 
428  c = cce_scale_fixed[gain & 7];
429  shift = (gain-1024) >> 3;
430  if (shift < -31) {
431  return;
432  } else if (shift < 0) {
433  shift = -shift;
434  round = 1 << (shift - 1);
435 
436  for (i = 0; i < len; i++) {
437  tmp = (int)(((int64_t)src[i] * c + (int64_t)0x1000000000) >> 37);
438  dest[i] += (tmp + round) >> shift;
439  }
440  }
441  else {
442  for (i = 0; i < len; i++) {
443  tmp = (int)(((int64_t)src[i] * c + (int64_t)0x1000000000) >> 37);
444  dest[i] += tmp * (1U << shift);
445  }
446  }
447 }
448 
449 #include "aacdec_template.c"
450 
452  .name = "aac_fixed",
453  .long_name = NULL_IF_CONFIG_SMALL("AAC (Advanced Audio Coding)"),
454  .type = AVMEDIA_TYPE_AUDIO,
455  .id = AV_CODEC_ID_AAC,
456  .priv_data_size = sizeof(AACContext),
458  .close = aac_decode_close,
460  .sample_fmts = (const enum AVSampleFormat[]) {
462  },
464  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
465  .channel_layouts = aac_channel_layout,
467  .flush = flush,
468 };
AAC decoder data.
#define NULL
Definition: coverity.c:32
static int shift(int a, int b)
Definition: sonic.c:82
static void flush(AVCodecContext *avctx)
AVCodecContext * avctx
Definition: aac.h:295
static av_always_inline SoftFloat flt16_round(SoftFloat pf)
Definition: aacdec_fixed.c:237
static int * DEC_UPAIR(int *dst, unsigned idx, unsigned sign)
Definition: aacdec_fixed.c:125
static void apply_dependent_coupling_fixed(AACContext *ac, SingleChannelElement *target, ChannelElement *cce, int index)
Apply dependent channel coupling (applied before IMDCT).
Definition: aacdec_fixed.c:354
const char * g
Definition: vf_curves.c:115
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static av_const SoftFloat av_div_sf(SoftFloat a, SoftFloat b)
b has to be normalized and not zero.
Definition: softfloat.h:116
static int * DEC_SQUAD(int *dst, unsigned idx)
Definition: aacdec_fixed.c:115
const AVProfile ff_aac_profiles[]
Definition: profiles.c:26
INTFLOAT * ret
PCM output.
Definition: aac.h:269
AAC decoder.
static void vector_pow43(int *coefs, int len)
Definition: aacdec_fixed.c:151
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: avcodec.h:1020
static void subband_scale(int *dst, int *src, int scale, int offset, int len)
Definition: aacdec_fixed.c:165
#define src
Definition: vp8dsp.c:254
AVCodec.
Definition: avcodec.h:3424
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
const uint16_t * swb_offset
table of offsets to the lowest spectral coefficient of a scalefactor band, sfb, for a particular wind...
Definition: aac.h:181
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
AAC_FLOAT cor0
Definition: aac.h:136
#define Q30(x)
Definition: aac_defines.h:95
AAC_FLOAT var1
Definition: aac.h:139
AVOptions.
SingleChannelElement ch[2]
Definition: aac.h:284
static av_cold int aac_decode_init(AVCodecContext *avctx)
AAC_FLOAT cor1
Definition: aac.h:137
uint32_t ff_cbrt_tab_fixed[1<< 13]
static void apply_independent_coupling_fixed(AACContext *ac, SingleChannelElement *target, ChannelElement *cce, int index)
Apply independent channel coupling (applied after IMDCT).
Definition: aacdec_fixed.c:418
bitstream reader API header.
int32_t mant
Definition: softfloat.h:35
static av_always_inline void predict(PredictorState *ps, int *coef, int output_enable)
Definition: aacdec_fixed.c:279
#define av_log(a,...)
#define U(x)
Definition: vp56_arith.h:37
MPEG4AudioConfig m4ac
Definition: aac.h:124
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:258
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AAC_FLOAT r1
Definition: aac.h:141
#define pv
Definition: regdef.h:60
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
AAC_FLOAT r0
Definition: aac.h:140
Spectral Band Replication definitions and structures.
const char * name
Name of the codec implementation.
Definition: avcodec.h:3431
static av_always_inline av_const double round(double x)
Definition: libm.h:444
uint8_t max_sfb
number of scalefactor bands per group
Definition: aac.h:175
static av_always_inline void reset_predict_state(PredictorState *ps)
Definition: aacdec_fixed.c:89
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
Predictor State.
Definition: aac.h:135
static const uint64_t aac_channel_layout[16]
Definition: aacdectab.h:57
#define Q31(x)
Definition: aac_defines.h:96
AAC Spectral Band Replication function declarations.
static int aac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
signed 32 bits, planar
Definition: samplefmt.h:68
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
AAC definitions and structures.
static const int cce_scale_fixed[8]
Definition: aacdec_fixed.c:338
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
static const int16_t alpha[]
Definition: ilbcdata.h:55
IndividualChannelStream ics
Definition: aac.h:249
uint8_t group_len[8]
Definition: aac.h:179
static av_cold int aac_decode_close(AVCodecContext *avctx)
int index
Definition: gxfenc.c:89
static void noise_scale(int *coefs, int scale, int band_energy, int len)
Definition: aacdec_fixed.c:196
main AAC context
Definition: aac.h:293
static av_const SoftFloat av_sub_sf(SoftFloat a, SoftFloat b)
Definition: softfloat.h:173
ChannelCoupling coup
Definition: aac.h:286
static av_const SoftFloat av_add_sf(SoftFloat a, SoftFloat b)
Definition: softfloat.h:162
INTFLOAT coeffs[1024]
coefficients for IMDCT, maybe processed
Definition: aac.h:262
INTFLOAT gain[16][120]
Definition: aac.h:242
OutputConfiguration oc[2]
Definition: aac.h:356
int
common internal api header.
Single Channel Element - used for both SCE and LFE elements.
Definition: aac.h:248
static av_const SoftFloat av_mul_sf(SoftFloat a, SoftFloat b)
Definition: softfloat.h:102
static double c[64]
Individual Channel Stream.
Definition: aac.h:174
int32_t exp
Definition: softfloat.h:36
channel element - generic struct for SCE/CPE/CCE/LFE
Definition: aac.h:275
static const int exp2tab[4]
Definition: aacdec_fixed.c:105
int len
Scalefactors and spectral data are all zero.
Definition: aac.h:83
static int * DEC_SPAIR(int *dst, unsigned idx)
Definition: aacdec_fixed.c:107
Y Long Term Prediction.
Definition: mpeg4audio.h:78
static av_always_inline SoftFloat flt16_trunc(SoftFloat pf)
Definition: aacdec_fixed.c:265
enum BandType band_type[128]
band types
Definition: aac.h:252
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
AVCodec ff_aac_fixed_decoder
Definition: aacdec_fixed.c:451
FILE * out
Definition: movenc.c:54
int sbr
-1 implicit, 1 presence
Definition: mpeg4audio.h:38
static av_const SoftFloat av_int2sf(int v, int frac_bits)
Converts a mantisse and exponent to a SoftFloat.
Definition: softfloat.h:185
#define av_always_inline
Definition: attributes.h:39
static av_always_inline SoftFloat flt16_even(SoftFloat pf)
Definition: aacdec_fixed.c:251
AAC data declarations.
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:968
AAC_FLOAT var0
Definition: aac.h:138
static int * DEC_UQUAD(int *dst, unsigned idx, unsigned sign)
Definition: aacdec_fixed.c:133
static uint8_t tmp[11]
Definition: aes_ctr.c:26