FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 ssign = scale < 0 ? -1 : 1;
199  int s = FFABS(scale);
200  unsigned int round;
201  int i, out, c = exp2tab[s & 3];
202  int nlz = 0;
203 
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) * ssign;
220  }
221  }
222  else {
223  s = s + 32;
224  round = 1 << (s-1);
225  for (i=0; i<len; i++) {
226  out = (int)((int64_t)((int64_t)coefs[i] * c + round) >> s);
227  coefs[i] = out * ssign;
228  }
229  }
230 }
231 
233 {
234  SoftFloat tmp;
235  int s;
236 
237  tmp.exp = pf.exp;
238  s = pf.mant >> 31;
239  tmp.mant = (pf.mant ^ s) - s;
240  tmp.mant = (tmp.mant + 0x00200000U) & 0xFFC00000U;
241  tmp.mant = (tmp.mant ^ s) - s;
242 
243  return tmp;
244 }
245 
247 {
248  SoftFloat tmp;
249  int s;
250 
251  tmp.exp = pf.exp;
252  s = pf.mant >> 31;
253  tmp.mant = (pf.mant ^ s) - s;
254  tmp.mant = (tmp.mant + 0x001FFFFFU + (tmp.mant & 0x00400000U >> 16)) & 0xFFC00000U;
255  tmp.mant = (tmp.mant ^ s) - s;
256 
257  return tmp;
258 }
259 
261 {
262  SoftFloat pun;
263  int s;
264 
265  pun.exp = pf.exp;
266  s = pf.mant >> 31;
267  pun.mant = (pf.mant ^ s) - s;
268  pun.mant = pun.mant & 0xFFC00000U;
269  pun.mant = (pun.mant ^ s) - s;
270 
271  return pun;
272 }
273 
274 static av_always_inline void predict(PredictorState *ps, int *coef,
275  int output_enable)
276 {
277  const SoftFloat a = { 1023410176, 0 }; // 61.0 / 64
278  const SoftFloat alpha = { 973078528, 0 }; // 29.0 / 32
279  SoftFloat e0, e1;
280  SoftFloat pv;
281  SoftFloat k1, k2;
282  SoftFloat r0 = ps->r0, r1 = ps->r1;
283  SoftFloat cor0 = ps->cor0, cor1 = ps->cor1;
284  SoftFloat var0 = ps->var0, var1 = ps->var1;
285  SoftFloat tmp;
286 
287  if (var0.exp > 1 || (var0.exp == 1 && var0.mant > 0x20000000)) {
288  k1 = av_mul_sf(cor0, flt16_even(av_div_sf(a, var0)));
289  }
290  else {
291  k1.mant = 0;
292  k1.exp = 0;
293  }
294 
295  if (var1.exp > 1 || (var1.exp == 1 && var1.mant > 0x20000000)) {
296  k2 = av_mul_sf(cor1, flt16_even(av_div_sf(a, var1)));
297  }
298  else {
299  k2.mant = 0;
300  k2.exp = 0;
301  }
302 
303  tmp = av_mul_sf(k1, r0);
304  pv = flt16_round(av_add_sf(tmp, av_mul_sf(k2, r1)));
305  if (output_enable) {
306  int shift = 28 - pv.exp;
307 
308  if (shift < 31) {
309  if (shift > 0) {
310  *coef += (unsigned)((pv.mant + (1 << (shift - 1))) >> shift);
311  } else
312  *coef += (unsigned)pv.mant << -shift;
313  }
314  }
315 
316  e0 = av_int2sf(*coef, 2);
317  e1 = av_sub_sf(e0, tmp);
318 
319  ps->cor1 = flt16_trunc(av_add_sf(av_mul_sf(alpha, cor1), av_mul_sf(r1, e1)));
320  tmp = av_add_sf(av_mul_sf(r1, r1), av_mul_sf(e1, e1));
321  tmp.exp--;
322  ps->var1 = flt16_trunc(av_add_sf(av_mul_sf(alpha, var1), tmp));
323  ps->cor0 = flt16_trunc(av_add_sf(av_mul_sf(alpha, cor0), av_mul_sf(r0, e0)));
324  tmp = av_add_sf(av_mul_sf(r0, r0), av_mul_sf(e0, e0));
325  tmp.exp--;
326  ps->var0 = flt16_trunc(av_add_sf(av_mul_sf(alpha, var0), tmp));
327 
328  ps->r1 = flt16_trunc(av_mul_sf(a, av_sub_sf(r0, av_mul_sf(k1, e0))));
329  ps->r0 = flt16_trunc(av_mul_sf(a, e0));
330 }
331 
332 
333 static const int cce_scale_fixed[8] = {
334  Q30(1.0), //2^(0/8)
335  Q30(1.0905077327), //2^(1/8)
336  Q30(1.1892071150), //2^(2/8)
337  Q30(1.2968395547), //2^(3/8)
338  Q30(1.4142135624), //2^(4/8)
339  Q30(1.5422108254), //2^(5/8)
340  Q30(1.6817928305), //2^(6/8)
341  Q30(1.8340080864), //2^(7/8)
342 };
343 
344 /**
345  * Apply dependent channel coupling (applied before IMDCT).
346  *
347  * @param index index into coupling gain array
348  */
350  SingleChannelElement *target,
351  ChannelElement *cce, int index)
352 {
353  IndividualChannelStream *ics = &cce->ch[0].ics;
354  const uint16_t *offsets = ics->swb_offset;
355  int *dest = target->coeffs;
356  const int *src = cce->ch[0].coeffs;
357  int g, i, group, k, idx = 0;
358  if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP) {
360  "Dependent coupling is not supported together with LTP\n");
361  return;
362  }
363  for (g = 0; g < ics->num_window_groups; g++) {
364  for (i = 0; i < ics->max_sfb; i++, idx++) {
365  if (cce->ch[0].band_type[idx] != ZERO_BT) {
366  const int gain = cce->coup.gain[index][idx];
367  int shift, round, c, tmp;
368 
369  if (gain < 0) {
370  c = -cce_scale_fixed[-gain & 7];
371  shift = (-gain-1024) >> 3;
372  }
373  else {
374  c = cce_scale_fixed[gain & 7];
375  shift = (gain-1024) >> 3;
376  }
377 
378  if (shift < -31) {
379  // Nothing to do
380  } else if (shift < 0) {
381  shift = -shift;
382  round = 1 << (shift - 1);
383 
384  for (group = 0; group < ics->group_len[g]; group++) {
385  for (k = offsets[i]; k < offsets[i + 1]; k++) {
386  tmp = (int)(((int64_t)src[group * 128 + k] * c + \
387  (int64_t)0x1000000000) >> 37);
388  dest[group * 128 + k] += (tmp + round) >> shift;
389  }
390  }
391  }
392  else {
393  for (group = 0; group < ics->group_len[g]; group++) {
394  for (k = offsets[i]; k < offsets[i + 1]; k++) {
395  tmp = (int)(((int64_t)src[group * 128 + k] * c + \
396  (int64_t)0x1000000000) >> 37);
397  dest[group * 128 + k] += tmp * (1U << shift);
398  }
399  }
400  }
401  }
402  }
403  dest += ics->group_len[g] * 128;
404  src += ics->group_len[g] * 128;
405  }
406 }
407 
408 /**
409  * Apply independent channel coupling (applied after IMDCT).
410  *
411  * @param index index into coupling gain array
412  */
414  SingleChannelElement *target,
415  ChannelElement *cce, int index)
416 {
417  int i, c, shift, round, tmp;
418  const int gain = cce->coup.gain[index][0];
419  const int *src = cce->ch[0].ret;
420  int *dest = target->ret;
421  const int len = 1024 << (ac->oc[1].m4ac.sbr == 1);
422 
423  c = cce_scale_fixed[gain & 7];
424  shift = (gain-1024) >> 3;
425  if (shift < -31) {
426  return;
427  } else if (shift < 0) {
428  shift = -shift;
429  round = 1 << (shift - 1);
430 
431  for (i = 0; i < len; i++) {
432  tmp = (int)(((int64_t)src[i] * c + (int64_t)0x1000000000) >> 37);
433  dest[i] += (tmp + round) >> shift;
434  }
435  }
436  else {
437  for (i = 0; i < len; i++) {
438  tmp = (int)(((int64_t)src[i] * c + (int64_t)0x1000000000) >> 37);
439  dest[i] += tmp * (1 << shift);
440  }
441  }
442 }
443 
444 #include "aacdec_template.c"
445 
447  .name = "aac_fixed",
448  .long_name = NULL_IF_CONFIG_SMALL("AAC (Advanced Audio Coding)"),
449  .type = AVMEDIA_TYPE_AUDIO,
450  .id = AV_CODEC_ID_AAC,
451  .priv_data_size = sizeof(AACContext),
453  .close = aac_decode_close,
455  .sample_fmts = (const enum AVSampleFormat[]) {
457  },
459  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
460  .channel_layouts = aac_channel_layout,
462  .flush = flush,
463 };
AAC decoder data.
#define NULL
Definition: coverity.c:32
const char * s
Definition: avisynth_c.h:768
static int shift(int a, int b)
Definition: sonic.c:82
static float alpha(float a)
static void flush(AVCodecContext *avctx)
AVCodecContext * avctx
Definition: aac.h:295
static av_always_inline SoftFloat flt16_round(SoftFloat pf)
Definition: aacdec_fixed.c:232
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:349
const char * g
Definition: vf_curves.c:112
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:1008
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:3351
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 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:413
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:274
#define av_log(a,...)
#define U(x)
Definition: vp56_arith.h:37
MPEG4AudioConfig m4ac
Definition: aac.h:124
#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:3358
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
AAC definitions and structures.
static const int cce_scale_fixed[8]
Definition: aacdec_fixed.c:333
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
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:260
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:446
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:246
AAC data declarations.
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:956
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