GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/ac3enc_template.c Lines: 193 217 88.9 %
Date: 2019-11-22 03:34:36 Branches: 122 154 79.2 %

Line Branch Exec Source
1
/*
2
 * AC-3 encoder float/fixed template
3
 * Copyright (c) 2000 Fabrice Bellard
4
 * Copyright (c) 2006-2011 Justin Ruggles <justin.ruggles@gmail.com>
5
 * Copyright (c) 2006-2010 Prakash Punnoor <prakash@punnoor.de>
6
 *
7
 * This file is part of FFmpeg.
8
 *
9
 * FFmpeg is free software; you can redistribute it and/or
10
 * modify it under the terms of the GNU Lesser General Public
11
 * License as published by the Free Software Foundation; either
12
 * version 2.1 of the License, or (at your option) any later version.
13
 *
14
 * FFmpeg is distributed in the hope that it will be useful,
15
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17
 * Lesser General Public License for more details.
18
 *
19
 * You should have received a copy of the GNU Lesser General Public
20
 * License along with FFmpeg; if not, write to the Free Software
21
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22
 */
23
24
/**
25
 * @file
26
 * AC-3 encoder float/fixed template
27
 */
28
29
#include <stdint.h>
30
31
#include "libavutil/attributes.h"
32
#include "libavutil/internal.h"
33
34
#include "audiodsp.h"
35
#include "internal.h"
36
#include "ac3enc.h"
37
#include "eac3enc.h"
38
39
40
6
int AC3_NAME(allocate_sample_buffers)(AC3EncodeContext *s)
41
{
42
    int ch;
43
44
6
    FF_ALLOC_OR_GOTO(s->avctx, s->windowed_samples, AC3_WINDOW_SIZE *
45
                     sizeof(*s->windowed_samples), alloc_fail);
46
6
    FF_ALLOC_ARRAY_OR_GOTO(s->avctx, s->planar_samples, s->channels, sizeof(*s->planar_samples),
47
                     alloc_fail);
48
15
    for (ch = 0; ch < s->channels; ch++) {
49
9
        FF_ALLOCZ_OR_GOTO(s->avctx, s->planar_samples[ch],
50
                          (AC3_FRAME_SIZE+AC3_BLOCK_SIZE) * sizeof(**s->planar_samples),
51
                          alloc_fail);
52
    }
53
54
6
    return 0;
55
alloc_fail:
56
    return AVERROR(ENOMEM);
57
}
58
59
60
/*
61
 * Copy input samples.
62
 * Channels are reordered from FFmpeg's default order to AC-3 order.
63
 */
64
1097
static void copy_input_samples(AC3EncodeContext *s, SampleType **samples)
65
{
66
    int ch;
67
68
    /* copy and remap input samples */
69
2913
    for (ch = 0; ch < s->channels; ch++) {
70
        /* copy last 256 samples of previous frame to the start of the current frame */
71
1816
        memcpy(&s->planar_samples[ch][0], &s->planar_samples[ch][AC3_BLOCK_SIZE * s->num_blocks],
72
               AC3_BLOCK_SIZE * sizeof(s->planar_samples[0][0]));
73
74
        /* copy new samples for current frame */
75
1816
        memcpy(&s->planar_samples[ch][AC3_BLOCK_SIZE],
76
1816
               samples[s->channel_map[ch]],
77
1816
               AC3_BLOCK_SIZE * s->num_blocks * sizeof(s->planar_samples[0][0]));
78
    }
79
1097
}
80
81
82
/*
83
 * Apply the MDCT to input samples to generate frequency coefficients.
84
 * This applies the KBD window and normalizes the input to reduce precision
85
 * loss due to fixed-point calculations.
86
 */
87
1097
static void apply_mdct(AC3EncodeContext *s)
88
{
89
    int blk, ch;
90
91
2913
    for (ch = 0; ch < s->channels; ch++) {
92
12712
        for (blk = 0; blk < s->num_blocks; blk++) {
93
10896
            AC3Block *block = &s->blocks[blk];
94
10896
            const SampleType *input_samples = &s->planar_samples[ch][blk * AC3_BLOCK_SIZE];
95
96
#if CONFIG_AC3ENC_FLOAT
97
6552
            s->fdsp->vector_fmul(s->windowed_samples, input_samples,
98
6552
                                s->mdct_window, AC3_WINDOW_SIZE);
99
#else
100
4344
            s->ac3dsp.apply_window_int16(s->windowed_samples, input_samples,
101
4344
                                         s->mdct_window, AC3_WINDOW_SIZE);
102
103
4344
            if (s->fixed_point)
104
4344
                block->coeff_shift[ch+1] = normalize_samples(s);
105
#endif
106
107
10896
            s->mdct.mdct_calcw(&s->mdct, block->mdct_coef[ch+1],
108
10896
                               s->windowed_samples);
109
        }
110
    }
111
1097
}
112
113
114
/*
115
 * Calculate coupling channel and coupling coordinates.
116
 */
117
719
static void apply_channel_coupling(AC3EncodeContext *s)
118
{
119
719
    LOCAL_ALIGNED_16(CoefType, cpl_coords,      [AC3_MAX_BLOCKS], [AC3_MAX_CHANNELS][16]);
120
#if CONFIG_AC3ENC_FLOAT
121
546
    LOCAL_ALIGNED_16(int32_t, fixed_cpl_coords, [AC3_MAX_BLOCKS], [AC3_MAX_CHANNELS][16]);
122
#else
123
173
    int32_t (*fixed_cpl_coords)[AC3_MAX_CHANNELS][16] = cpl_coords;
124
#endif
125
719
    int av_uninit(blk), ch, bnd, i, j;
126
719
    CoefSumType energy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][16] = {{{0}}};
127
    int cpl_start, num_cpl_coefs;
128
129
719
    memset(cpl_coords,       0, AC3_MAX_BLOCKS * sizeof(*cpl_coords));
130
#if CONFIG_AC3ENC_FLOAT
131
546
    memset(fixed_cpl_coords, 0, AC3_MAX_BLOCKS * sizeof(*cpl_coords));
132
#endif
133
134
    /* align start to 16-byte boundary. align length to multiple of 32.
135
        note: coupling start bin % 4 will always be 1 */
136
719
    cpl_start     = s->start_freq[CPL_CH] - 1;
137
719
    num_cpl_coefs = FFALIGN(s->num_cpl_subbands * 12 + 1, 32);
138
719
    cpl_start     = FFMIN(256, cpl_start + num_cpl_coefs) - num_cpl_coefs;
139
140
    /* calculate coupling channel from fbw channels */
141
5033
    for (blk = 0; blk < s->num_blocks; blk++) {
142
4314
        AC3Block *block = &s->blocks[blk];
143
4314
        CoefType *cpl_coef = &block->mdct_coef[CPL_CH][cpl_start];
144
4314
        if (!block->cpl_in_use)
145
            continue;
146
4314
        memset(cpl_coef, 0, num_cpl_coefs * sizeof(*cpl_coef));
147
12942
        for (ch = 1; ch <= s->fbw_channels; ch++) {
148
8628
            CoefType *ch_coef = &block->mdct_coef[ch][cpl_start];
149
8628
            if (!block->channel_in_cpl[ch])
150
                continue;
151
560820
            for (i = 0; i < num_cpl_coefs; i++)
152
552192
                cpl_coef[i] += ch_coef[i];
153
        }
154
155
        /* coefficients must be clipped in order to be encoded */
156
4314
        clip_coefficients(&s->adsp, cpl_coef, num_cpl_coefs);
157
    }
158
159
    /* calculate energy in each band in coupling channel and each fbw channel */
160
    /* TODO: possibly use SIMD to speed up energy calculation */
161
719
    bnd = 0;
162
719
    i = s->start_freq[CPL_CH];
163
3595
    while (i < s->cpl_end_freq) {
164
2876
        int band_size = s->cpl_band_sizes[bnd];
165
11504
        for (ch = CPL_CH; ch <= s->fbw_channels; ch++) {
166
60396
            for (blk = 0; blk < s->num_blocks; blk++) {
167
51768
                AC3Block *block = &s->blocks[blk];
168

51768
                if (!block->cpl_in_use || (ch > CPL_CH && !block->channel_in_cpl[ch]))
169
                    continue;
170
828288
                for (j = 0; j < band_size; j++) {
171
776520
                    CoefType v = block->mdct_coef[ch][i+j];
172
776520
                    MAC_COEF(energy[blk][ch][bnd], v, v);
173
                }
174
            }
175
        }
176
2876
        i += band_size;
177
2876
        bnd++;
178
    }
179
180
    /* calculate coupling coordinates for all blocks for all channels */
181
5033
    for (blk = 0; blk < s->num_blocks; blk++) {
182
4314
        AC3Block *block  = &s->blocks[blk];
183
4314
        if (!block->cpl_in_use)
184
            continue;
185
12942
        for (ch = 1; ch <= s->fbw_channels; ch++) {
186
8628
            if (!block->channel_in_cpl[ch])
187
                continue;
188
43140
            for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
189
34512
                cpl_coords[blk][ch][bnd] = calc_cpl_coord(energy[blk][ch][bnd],
190
                                                          energy[blk][CPL_CH][bnd]);
191
            }
192
        }
193
    }
194
195
    /* determine which blocks to send new coupling coordinates for */
196
5033
    for (blk = 0; blk < s->num_blocks; blk++) {
197
4314
        AC3Block *block  = &s->blocks[blk];
198
4314
        AC3Block *block0 = blk ? &s->blocks[blk-1] : NULL;
199
200
4314
        memset(block->new_cpl_coords, 0, sizeof(block->new_cpl_coords));
201
202
4314
        if (block->cpl_in_use) {
203
            /* send new coordinates if this is the first block, if previous
204
             * block did not use coupling but this block does, the channels
205
             * using coupling has changed from the previous block, or the
206
             * coordinate difference from the last block for any channel is
207
             * greater than a threshold value. */
208

4314
            if (blk == 0 || !block0->cpl_in_use) {
209
2157
                for (ch = 1; ch <= s->fbw_channels; ch++)
210
1438
                    block->new_cpl_coords[ch] = 1;
211
            } else {
212
10785
                for (ch = 1; ch <= s->fbw_channels; ch++) {
213
7190
                    if (!block->channel_in_cpl[ch])
214
                        continue;
215
7190
                    if (!block0->channel_in_cpl[ch]) {
216
                        block->new_cpl_coords[ch] = 1;
217
                    } else {
218
7190
                        CoefSumType coord_diff = 0;
219
35950
                        for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
220
28760
                            coord_diff += FFABS(cpl_coords[blk-1][ch][bnd] -
221
                                                cpl_coords[blk  ][ch][bnd]);
222
                        }
223
7190
                        coord_diff /= s->num_cpl_bands;
224
7190
                        if (coord_diff > NEW_CPL_COORD_THRESHOLD)
225
32
                            block->new_cpl_coords[ch] = 1;
226
                    }
227
                }
228
            }
229
        }
230
    }
231
232
    /* calculate final coupling coordinates, taking into account reusing of
233
       coordinates in successive blocks */
234
3595
    for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
235
2876
        blk = 0;
236
5840
        while (blk < s->num_blocks) {
237
2964
            int av_uninit(blk1);
238
2964
            AC3Block *block  = &s->blocks[blk];
239
240
2964
            if (!block->cpl_in_use) {
241
                blk++;
242
                continue;
243
            }
244
245
8892
            for (ch = 1; ch <= s->fbw_channels; ch++) {
246
                CoefSumType energy_ch, energy_cpl;
247
5928
                if (!block->channel_in_cpl[ch])
248
                    continue;
249
5928
                energy_cpl = energy[blk][CPL_CH][bnd];
250
5928
                energy_ch = energy[blk][ch][bnd];
251
5928
                blk1 = blk+1;
252

34696
                while (blk1 < s->num_blocks && !s->blocks[blk1].new_cpl_coords[ch]) {
253
28768
                    if (s->blocks[blk1].cpl_in_use) {
254
28768
                        energy_cpl += energy[blk1][CPL_CH][bnd];
255
28768
                        energy_ch += energy[blk1][ch][bnd];
256
                    }
257
28768
                    blk1++;
258
                }
259
5928
                cpl_coords[blk][ch][bnd] = calc_cpl_coord(energy_ch, energy_cpl);
260
            }
261
2964
            blk = blk1;
262
        }
263
    }
264
265
    /* calculate exponents/mantissas for coupling coordinates */
266
5033
    for (blk = 0; blk < s->num_blocks; blk++) {
267
4314
        AC3Block *block = &s->blocks[blk];
268
4314
        if (!block->cpl_in_use)
269
            continue;
270
271
#if CONFIG_AC3ENC_FLOAT
272
3276
        s->ac3dsp.float_to_fixed24(fixed_cpl_coords[blk][1],
273
3276
                                   cpl_coords[blk][1],
274
3276
                                   s->fbw_channels * 16);
275
#endif
276
4314
        s->ac3dsp.extract_exponents(block->cpl_coord_exp[1],
277
4314
                                    fixed_cpl_coords[blk][1],
278
4314
                                    s->fbw_channels * 16);
279
280
12942
        for (ch = 1; ch <= s->fbw_channels; ch++) {
281
            int bnd, min_exp, max_exp, master_exp;
282
283
8628
            if (!block->new_cpl_coords[ch])
284
7158
                continue;
285
286
            /* determine master exponent */
287
1470
            min_exp = max_exp = block->cpl_coord_exp[ch][0];
288
5880
            for (bnd = 1; bnd < s->num_cpl_bands; bnd++) {
289
4410
                int exp = block->cpl_coord_exp[ch][bnd];
290
4410
                min_exp = FFMIN(exp, min_exp);
291
4410
                max_exp = FFMAX(exp, max_exp);
292
            }
293
1470
            master_exp = ((max_exp - 15) + 2) / 3;
294
1470
            master_exp = FFMAX(master_exp, 0);
295
1470
            while (min_exp < master_exp * 3)
296
                master_exp--;
297
7350
            for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
298
5880
                block->cpl_coord_exp[ch][bnd] = av_clip(block->cpl_coord_exp[ch][bnd] -
299
5880
                                                        master_exp * 3, 0, 15);
300
            }
301
1470
            block->cpl_master_exp[ch] = master_exp;
302
303
            /* quantize mantissas */
304
7350
            for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
305
5880
                int cpl_exp  = block->cpl_coord_exp[ch][bnd];
306
5880
                int cpl_mant = (fixed_cpl_coords[blk][ch][bnd] << (5 + cpl_exp + master_exp * 3)) >> 24;
307
5880
                if (cpl_exp == 15)
308
                    cpl_mant >>= 1;
309
                else
310
5880
                    cpl_mant -= 16;
311
312
5880
                block->cpl_coord_mant[ch][bnd] = cpl_mant;
313
            }
314
        }
315
    }
316
317
719
    if (CONFIG_EAC3_ENCODER && s->eac3)
318
273
        ff_eac3_set_cpl_states(s);
319
719
}
320
321
322
/*
323
 * Determine rematrixing flags for each block and band.
324
 */
325
1097
static void compute_rematrixing_strategy(AC3EncodeContext *s)
326
{
327
    int nb_coefs;
328
    int blk, bnd;
329
1097
    AC3Block *block, *block0 = NULL;
330
331
1097
    if (s->channel_mode != AC3_CHMODE_STEREO)
332
378
        return;
333
334
5033
    for (blk = 0; blk < s->num_blocks; blk++) {
335
4314
        block = &s->blocks[blk];
336
4314
        block->new_rematrixing_strategy = !blk;
337
338
4314
        block->num_rematrixing_bands = 4;
339
4314
        if (block->cpl_in_use) {
340
4314
            block->num_rematrixing_bands -= (s->start_freq[CPL_CH] <= 61);
341
4314
            block->num_rematrixing_bands -= (s->start_freq[CPL_CH] == 37);
342

4314
            if (blk && block->num_rematrixing_bands != block0->num_rematrixing_bands)
343
                block->new_rematrixing_strategy = 1;
344
        }
345
4314
        nb_coefs = FFMIN(block->end_freq[1], block->end_freq[2]);
346
347
4314
        if (!s->rematrixing_enabled) {
348
            block0 = block;
349
            continue;
350
        }
351
352
21570
        for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) {
353
            /* calculate sum of squared coeffs for one band in one block */
354
17256
            int start = ff_ac3_rematrix_band_tab[bnd];
355
17256
            int end   = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);
356
            CoefSumType sum[4];
357
17256
            sum_square_butterfly(s, sum, block->mdct_coef[1] + start,
358
17256
                                 block->mdct_coef[2] + start, end - start);
359
360
            /* compare sums to determine if rematrixing will be used for this band */
361

17256
            if (FFMIN(sum[2], sum[3]) < FFMIN(sum[0], sum[1]))
362
9589
                block->rematrixing_flags[bnd] = 1;
363
            else
364
7667
                block->rematrixing_flags[bnd] = 0;
365
366
            /* determine if new rematrixing flags will be sent */
367
17256
            if (blk &&
368
14380
                block->rematrixing_flags[bnd] != block0->rematrixing_flags[bnd]) {
369
1932
                block->new_rematrixing_strategy = 1;
370
            }
371
        }
372
4314
        block0 = block;
373
    }
374
}
375
376
377
1097
int AC3_NAME(encode_frame)(AVCodecContext *avctx, AVPacket *avpkt,
378
                           const AVFrame *frame, int *got_packet_ptr)
379
{
380
1097
    AC3EncodeContext *s = avctx->priv_data;
381
    int ret;
382
383
1097
    if (s->options.allow_per_frame_metadata) {
384
        ret = ff_ac3_validate_metadata(s);
385
        if (ret)
386
            return ret;
387
    }
388
389

1097
    if (s->bit_alloc.sr_code == 1 || s->eac3)
390
1097
        ff_ac3_adjust_frame_size(s);
391
392
1097
    copy_input_samples(s, (SampleType **)frame->extended_data);
393
394
1097
    apply_mdct(s);
395
396
1097
    if (s->fixed_point)
397
551
        scale_coefficients(s);
398
399
1097
    clip_coefficients(&s->adsp, s->blocks[0].mdct_coef[1],
400
1097
                      AC3_MAX_COEFS * s->num_blocks * s->channels);
401
402
1097
    s->cpl_on = s->cpl_enabled;
403
1097
    ff_ac3_compute_coupling_strategy(s);
404
405
1097
    if (s->cpl_on)
406
719
        apply_channel_coupling(s);
407
408
1097
    compute_rematrixing_strategy(s);
409
410
1097
    if (!s->fixed_point)
411
546
        scale_coefficients(s);
412
413
1097
    ff_ac3_apply_rematrixing(s);
414
415
1097
    ff_ac3_process_exponents(s);
416
417
1097
    ret = ff_ac3_compute_bit_allocation(s);
418
1097
    if (ret) {
419
        av_log(avctx, AV_LOG_ERROR, "Bit allocation failed. Try increasing the bitrate.\n");
420
        return ret;
421
    }
422
423
1097
    ff_ac3_group_exponents(s);
424
425
1097
    ff_ac3_quantize_mantissas(s);
426
427
1097
    if ((ret = ff_alloc_packet2(avctx, avpkt, s->frame_size, 0)) < 0)
428
        return ret;
429
1097
    ff_ac3_output_frame(s, avpkt->data);
430
431
1097
    if (frame->pts != AV_NOPTS_VALUE)
432
1097
        avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->initial_padding);
433
434
1097
    *got_packet_ptr = 1;
435
1097
    return 0;
436
}