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 USE_FIXED 1
63
64#include "libavutil/fixed_dsp.h"
65#include "libavutil/opt.h"
66#include "avcodec.h"
67#include "codec_internal.h"
68#include "get_bits.h"
69#include "fft.h"
70#include "lpc.h"
71#include "kbdwin.h"
72#include "sinewin_fixed_tablegen.h"
73
74#include "aac.h"
75#include "aactab.h"
76#include "aacdectab.h"
77#include "adts_header.h"
78#include "cbrt_data.h"
79#include "sbr.h"
80#include "aacsbr.h"
81#include "mpeg4audio.h"
82#include "profiles.h"
83#include "libavutil/intfloat.h"
84
85#include <math.h>
86#include <string.h>
87
88DECLARE_ALIGNED(32, static int, AAC_RENAME2(aac_kbd_long_1024))[1024];
89DECLARE_ALIGNED(32, static int, AAC_RENAME2(aac_kbd_short_128))[128];
90
91static av_always_inline void reset_predict_state(PredictorState *ps)
92{
93    ps->r0.mant   = 0;
94    ps->r0.exp   = 0;
95    ps->r1.mant   = 0;
96    ps->r1.exp   = 0;
97    ps->cor0.mant = 0;
98    ps->cor0.exp = 0;
99    ps->cor1.mant = 0;
100    ps->cor1.exp = 0;
101    ps->var0.mant = 0x20000000;
102    ps->var0.exp = 1;
103    ps->var1.mant = 0x20000000;
104    ps->var1.exp = 1;
105}
106
107static 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
108
109static inline int *DEC_SPAIR(int *dst, unsigned idx)
110{
111    dst[0] = (idx & 15) - 4;
112    dst[1] = (idx >> 4 & 15) - 4;
113
114    return dst + 2;
115}
116
117static inline int *DEC_SQUAD(int *dst, unsigned idx)
118{
119    dst[0] = (idx & 3) - 1;
120    dst[1] = (idx >> 2 & 3) - 1;
121    dst[2] = (idx >> 4 & 3) - 1;
122    dst[3] = (idx >> 6 & 3) - 1;
123
124    return dst + 4;
125}
126
127static inline int *DEC_UPAIR(int *dst, unsigned idx, unsigned sign)
128{
129    dst[0] = (idx & 15) * (1 - (sign & 0xFFFFFFFE));
130    dst[1] = (idx >> 4 & 15) * (1 - ((sign & 1) * 2));
131
132    return dst + 2;
133}
134
135static inline int *DEC_UQUAD(int *dst, unsigned idx, unsigned sign)
136{
137    unsigned nz = idx >> 12;
138
139    dst[0] = (idx & 3) * (1 + (((int)sign >> 31) * 2));
140    sign <<= nz & 1;
141    nz >>= 1;
142    dst[1] = (idx >> 2 & 3) * (1 + (((int)sign >> 31) * 2));
143    sign <<= nz & 1;
144    nz >>= 1;
145    dst[2] = (idx >> 4 & 3) * (1 + (((int)sign >> 31) * 2));
146    sign <<= nz & 1;
147    nz >>= 1;
148    dst[3] = (idx >> 6 & 3) * (1 + (((int)sign >> 31) * 2));
149
150    return dst + 4;
151}
152
153static void vector_pow43(int *coefs, int len)
154{
155    int i, coef;
156
157    for (i=0; i<len; i++) {
158        coef = coefs[i];
159        if (coef < 0)
160            coef = -(int)ff_cbrt_tab_fixed[(-coef) & 8191];
161        else
162            coef =  (int)ff_cbrt_tab_fixed[  coef  & 8191];
163        coefs[i] = coef;
164    }
165}
166
167static void subband_scale(int *dst, int *src, int scale, int offset, int len, void *log_context)
168{
169    int ssign = scale < 0 ? -1 : 1;
170    int s = FFABS(scale);
171    unsigned int round;
172    int i, out, c = exp2tab[s & 3];
173
174    s = offset - (s >> 2);
175
176    if (s > 31) {
177        for (i=0; i<len; i++) {
178            dst[i] = 0;
179        }
180    } else if (s > 0) {
181        round = 1 << (s-1);
182        for (i=0; i<len; i++) {
183            out = (int)(((int64_t)src[i] * c) >> 32);
184            dst[i] = ((int)(out+round) >> s) * ssign;
185        }
186    } else if (s > -32) {
187        s = s + 32;
188        round = 1U << (s-1);
189        for (i=0; i<len; i++) {
190            out = (int)((int64_t)((int64_t)src[i] * c + round) >> s);
191            dst[i] = out * (unsigned)ssign;
192        }
193    } else {
194        av_log(log_context, AV_LOG_ERROR, "Overflow in subband_scale()\n");
195    }
196}
197
198static void noise_scale(int *coefs, int scale, int band_energy, int len)
199{
200    int s = -scale;
201    unsigned int round;
202    int i, out, c = exp2tab[s & 3];
203    int nlz = 0;
204
205    av_assert0(s >= 0);
206    while (band_energy > 0x7fff) {
207        band_energy >>= 1;
208        nlz++;
209    }
210    c /= band_energy;
211    s = 21 + nlz - (s >> 2);
212
213    if (s > 31) {
214        for (i=0; i<len; i++) {
215            coefs[i] = 0;
216        }
217    } else if (s >= 0) {
218        round = s ? 1 << (s-1) : 0;
219        for (i=0; i<len; i++) {
220            out = (int)(((int64_t)coefs[i] * c) >> 32);
221            coefs[i] = -((int)(out+round) >> s);
222        }
223    }
224    else {
225        s = s + 32;
226        if (s > 0) {
227            round = 1 << (s-1);
228            for (i=0; i<len; i++) {
229                out = (int)((int64_t)((int64_t)coefs[i] * c + round) >> s);
230                coefs[i] = -out;
231            }
232        } else {
233            for (i=0; i<len; i++)
234                coefs[i] = -(int64_t)coefs[i] * c * (1 << -s);
235        }
236    }
237}
238
239static av_always_inline SoftFloat flt16_round(SoftFloat pf)
240{
241    SoftFloat tmp;
242    int s;
243
244    tmp.exp = pf.exp;
245    s = pf.mant >> 31;
246    tmp.mant = (pf.mant ^ s) - s;
247    tmp.mant = (tmp.mant + 0x00200000U) & 0xFFC00000U;
248    tmp.mant = (tmp.mant ^ s) - s;
249
250    return tmp;
251}
252
253static av_always_inline SoftFloat flt16_even(SoftFloat pf)
254{
255    SoftFloat tmp;
256    int s;
257
258    tmp.exp = pf.exp;
259    s = pf.mant >> 31;
260    tmp.mant = (pf.mant ^ s) - s;
261    tmp.mant = (tmp.mant + 0x001FFFFFU + (tmp.mant & 0x00400000U >> 16)) & 0xFFC00000U;
262    tmp.mant = (tmp.mant ^ s) - s;
263
264    return tmp;
265}
266
267static av_always_inline SoftFloat flt16_trunc(SoftFloat pf)
268{
269    SoftFloat pun;
270    int s;
271
272    pun.exp = pf.exp;
273    s = pf.mant >> 31;
274    pun.mant = (pf.mant ^ s) - s;
275    pun.mant = pun.mant & 0xFFC00000U;
276    pun.mant = (pun.mant ^ s) - s;
277
278    return pun;
279}
280
281static av_always_inline void predict(PredictorState *ps, int *coef,
282                                     int output_enable)
283{
284    const SoftFloat a     = { 1023410176, 0 };  // 61.0 / 64
285    const SoftFloat alpha = {  973078528, 0 };  // 29.0 / 32
286    SoftFloat e0, e1;
287    SoftFloat pv;
288    SoftFloat k1, k2;
289    SoftFloat   r0 = ps->r0,     r1 = ps->r1;
290    SoftFloat cor0 = ps->cor0, cor1 = ps->cor1;
291    SoftFloat var0 = ps->var0, var1 = ps->var1;
292    SoftFloat tmp;
293
294    if (var0.exp > 1 || (var0.exp == 1 && var0.mant > 0x20000000)) {
295        k1 = av_mul_sf(cor0, flt16_even(av_div_sf(a, var0)));
296    }
297    else {
298        k1.mant = 0;
299        k1.exp = 0;
300    }
301
302    if (var1.exp > 1 || (var1.exp == 1 && var1.mant > 0x20000000)) {
303        k2 = av_mul_sf(cor1, flt16_even(av_div_sf(a, var1)));
304    }
305    else {
306        k2.mant = 0;
307        k2.exp = 0;
308    }
309
310    tmp = av_mul_sf(k1, r0);
311    pv = flt16_round(av_add_sf(tmp, av_mul_sf(k2, r1)));
312    if (output_enable) {
313        int shift = 28 - pv.exp;
314
315        if (shift < 31) {
316            if (shift > 0) {
317                *coef += (unsigned)((pv.mant + (1 << (shift - 1))) >> shift);
318            } else
319                *coef += (unsigned)pv.mant << -shift;
320        }
321    }
322
323    e0 = av_int2sf(*coef, 2);
324    e1 = av_sub_sf(e0, tmp);
325
326    ps->cor1 = flt16_trunc(av_add_sf(av_mul_sf(alpha, cor1), av_mul_sf(r1, e1)));
327    tmp = av_add_sf(av_mul_sf(r1, r1), av_mul_sf(e1, e1));
328    tmp.exp--;
329    ps->var1 = flt16_trunc(av_add_sf(av_mul_sf(alpha, var1), tmp));
330    ps->cor0 = flt16_trunc(av_add_sf(av_mul_sf(alpha, cor0), av_mul_sf(r0, e0)));
331    tmp = av_add_sf(av_mul_sf(r0, r0), av_mul_sf(e0, e0));
332    tmp.exp--;
333    ps->var0 = flt16_trunc(av_add_sf(av_mul_sf(alpha, var0), tmp));
334
335    ps->r1 = flt16_trunc(av_mul_sf(a, av_sub_sf(r0, av_mul_sf(k1, e0))));
336    ps->r0 = flt16_trunc(av_mul_sf(a, e0));
337}
338
339
340static const int cce_scale_fixed[8] = {
341    Q30(1.0),          //2^(0/8)
342    Q30(1.0905077327), //2^(1/8)
343    Q30(1.1892071150), //2^(2/8)
344    Q30(1.2968395547), //2^(3/8)
345    Q30(1.4142135624), //2^(4/8)
346    Q30(1.5422108254), //2^(5/8)
347    Q30(1.6817928305), //2^(6/8)
348    Q30(1.8340080864), //2^(7/8)
349};
350
351/**
352 * Apply dependent channel coupling (applied before IMDCT).
353 *
354 * @param   index   index into coupling gain array
355 */
356static void apply_dependent_coupling_fixed(AACContext *ac,
357                                     SingleChannelElement *target,
358                                     ChannelElement *cce, int index)
359{
360    IndividualChannelStream *ics = &cce->ch[0].ics;
361    const uint16_t *offsets = ics->swb_offset;
362    int *dest = target->coeffs;
363    const int *src = cce->ch[0].coeffs;
364    int g, i, group, k, idx = 0;
365    if (ac->oc[1].m4ac.object_type == AOT_AAC_LTP) {
366        av_log(ac->avctx, AV_LOG_ERROR,
367               "Dependent coupling is not supported together with LTP\n");
368        return;
369    }
370    for (g = 0; g < ics->num_window_groups; g++) {
371        for (i = 0; i < ics->max_sfb; i++, idx++) {
372            if (cce->ch[0].band_type[idx] != ZERO_BT) {
373                const int gain = cce->coup.gain[index][idx];
374                int shift, round, c, tmp;
375
376                if (gain < 0) {
377                    c = -cce_scale_fixed[-gain & 7];
378                    shift = (-gain-1024) >> 3;
379                }
380                else {
381                    c = cce_scale_fixed[gain & 7];
382                    shift = (gain-1024) >> 3;
383                }
384
385                if (shift < -31) {
386                    // Nothing to do
387                } else if (shift < 0) {
388                    shift = -shift;
389                    round = 1 << (shift - 1);
390
391                    for (group = 0; group < ics->group_len[g]; group++) {
392                        for (k = offsets[i]; k < offsets[i + 1]; k++) {
393                            tmp = (int)(((int64_t)src[group * 128 + k] * c + \
394                                       (int64_t)0x1000000000) >> 37);
395                            dest[group * 128 + k] += (tmp + (int64_t)round) >> shift;
396                        }
397                    }
398                }
399                else {
400                    for (group = 0; group < ics->group_len[g]; group++) {
401                        for (k = offsets[i]; k < offsets[i + 1]; k++) {
402                            tmp = (int)(((int64_t)src[group * 128 + k] * c + \
403                                        (int64_t)0x1000000000) >> 37);
404                            dest[group * 128 + k] += tmp * (1U << shift);
405                        }
406                    }
407                }
408            }
409        }
410        dest += ics->group_len[g] * 128;
411        src  += ics->group_len[g] * 128;
412    }
413}
414
415/**
416 * Apply independent channel coupling (applied after IMDCT).
417 *
418 * @param   index   index into coupling gain array
419 */
420static void apply_independent_coupling_fixed(AACContext *ac,
421                                       SingleChannelElement *target,
422                                       ChannelElement *cce, int index)
423{
424    int i, c, shift, round, tmp;
425    const int gain = cce->coup.gain[index][0];
426    const int *src = cce->ch[0].ret;
427    unsigned int *dest = target->ret;
428    const int len = 1024 << (ac->oc[1].m4ac.sbr == 1);
429
430    c = cce_scale_fixed[gain & 7];
431    shift = (gain-1024) >> 3;
432    if (shift < -31) {
433        return;
434    } else if (shift < 0) {
435        shift = -shift;
436        round = 1 << (shift - 1);
437
438        for (i = 0; i < len; i++) {
439            tmp = (int)(((int64_t)src[i] * c + (int64_t)0x1000000000) >> 37);
440            dest[i] += (tmp + round) >> shift;
441        }
442    }
443    else {
444      for (i = 0; i < len; i++) {
445          tmp = (int)(((int64_t)src[i] * c + (int64_t)0x1000000000) >> 37);
446          dest[i] += tmp * (1U << shift);
447      }
448    }
449}
450
451#include "aacdec_template.c"
452
453const FFCodec ff_aac_fixed_decoder = {
454    .p.name          = "aac_fixed",
455    .p.long_name     = NULL_IF_CONFIG_SMALL("AAC (Advanced Audio Coding)"),
456    .p.type          = AVMEDIA_TYPE_AUDIO,
457    .p.id            = AV_CODEC_ID_AAC,
458    .priv_data_size  = sizeof(AACContext),
459    .init            = aac_decode_init,
460    .close           = aac_decode_close,
461    FF_CODEC_DECODE_CB(aac_decode_frame),
462    .p.sample_fmts   = (const enum AVSampleFormat[]) {
463        AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_NONE
464    },
465    .p.capabilities  = AV_CODEC_CAP_CHANNEL_CONF | AV_CODEC_CAP_DR1,
466    .caps_internal   = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
467#if FF_API_OLD_CHANNEL_LAYOUT
468    .p.channel_layouts = aac_channel_layout,
469#endif
470    .p.ch_layouts    = aac_ch_layout,
471    .p.profiles      = NULL_IF_CONFIG_SMALL(ff_aac_profiles),
472    .flush = flush,
473};
474