← Back to branch summary

~ubuntu-branches/debian/sid/ffmpeg/sid

« back to all changes in this revision

Viewing changes to libavcodec/aacdec_fixed.c

  • Committer: Package Import Robot
  • Author(s): Andreas Cadhalpun, Fabian Greffrath, Andreas Cadhalpun
  • Date: 2015-09-22 15:15:20 UTC
  • mfrom: (0.1.29)
  • Revision ID: package-import@ubuntu.com-20150922151520-hhmd3in9ykigjvs9
Tags: 7:2.8-1
http://bugs.debian.org/786670
http://bugs.debian.org/798189
[ Fabian Greffrath ]
* Pass the --dbg-package=ffmpeg-dbg parameter only to dh_strip.
* Add alternative Depends: libavcodec-ffmpeg-extra56 to libavcodec-dev and
  ffmpeg-dbg to allow for building and debugging with this library installed.

[ Andreas Cadhalpun ]
* Import new major upstream release 2.8.
* Remove the transitional lib*-ffmpeg-dev packages.
* Drop old Breaks on kodi-bin.
* Drop workaround for sparc, which is no Debian architecture anymore.
* Re-enable x265 on alpha, as it's available again.
* Disable unavailable frei0r, opencv and x264 on mips64el.
* Disable libopenjpeg (#787275) and libschroedinger (#787957) decoders.
  (Closes: #786670)
* Disable libdc1394 on sparc64, because it links against the broken due to
  #790560 libudev1.
* Enable libsnappy support.
* Add new symbols.
* Update debian/copyright.
* Update debian/tests/encdec_list.txt.
* Add hls-only-seek-if-there-is-an-offset.patch. (Closes: #798189)
* Add 'Breaks: libavutil-ffmpeg54 (>= 8:0)' to the libraries.

Show diffs side-by-side

added added

removed removed

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