GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/aacenc_quantization.h Lines: 99 105 94.3 %
Date: 2019-11-22 03:34:36 Branches: 68 76 89.5 %

Line Branch Exec Source
1
/*
2
 * AAC encoder quantizer
3
 * Copyright (C) 2015 Rostislav Pehlivanov
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
22
/**
23
 * @file
24
 * AAC encoder quantizer
25
 * @author Rostislav Pehlivanov ( atomnuker gmail com )
26
 */
27
28
#ifndef AVCODEC_AACENC_QUANTIZATION_H
29
#define AVCODEC_AACENC_QUANTIZATION_H
30
31
#include "aactab.h"
32
#include "aacenc.h"
33
#include "aacenctab.h"
34
#include "aacenc_utils.h"
35
36
/**
37
 * Calculate rate distortion cost for quantizing with given codebook
38
 *
39
 * @return quantization distortion
40
 */
41
9664386
static av_always_inline float quantize_and_encode_band_cost_template(
42
                                struct AACEncContext *s,
43
                                PutBitContext *pb, const float *in, float *out,
44
                                const float *scaled, int size, int scale_idx,
45
                                int cb, const float lambda, const float uplim,
46
                                int *bits, float *energy, int BT_ZERO, int BT_UNSIGNED,
47
                                int BT_PAIR, int BT_ESC, int BT_NOISE, int BT_STEREO,
48
                                const float ROUNDING)
49
{
50
9664386
    const int q_idx = POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512;
51
9664386
    const float Q   = ff_aac_pow2sf_tab [q_idx];
52
9664386
    const float Q34 = ff_aac_pow34sf_tab[q_idx];
53
9664386
    const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
54
9664386
    const float CLIPPED_ESCAPE = 165140.0f*IQ;
55
    int i, j;
56
9664386
    float cost = 0;
57
9664386
    float qenergy = 0;
58
9664386
    const int dim = BT_PAIR ? 2 : 4;
59
9664386
    int resbits = 0;
60
    int off;
61
62

9664386
    if (BT_ZERO || BT_NOISE || BT_STEREO) {
63
46456801
        for (i = 0; i < size; i++)
64
44504028
            cost += in[i]*in[i];
65
1952773
        if (bits)
66
1908616
            *bits = 0;
67
1952773
        if (energy)
68
1835760
            *energy = qenergy;
69
1952773
        if (out) {
70
            for (i = 0; i < size; i += dim)
71
                for (j = 0; j < dim; j++)
72
                    out[i+j] = 0.0f;
73
        }
74
1952773
        return cost * lambda;
75
    }
76
7711613
    if (!scaled) {
77
504146
        s->abs_pow34(s->scoefs, in, size);
78
504146
        scaled = s->scoefs;
79
    }
80
7711613
    s->quant_bands(s->qcoefs, in, scaled, size, !BT_UNSIGNED, aac_cb_maxval[cb], Q34, ROUNDING);
81
7711613
    if (BT_UNSIGNED) {
82
4722575
        off = 0;
83
    } else {
84
2989038
        off = aac_cb_maxval[cb];
85
    }
86
69643636
    for (i = 0; i < size; i += dim) {
87
        const float *vec;
88
61939511
        int *quants = s->qcoefs + i;
89
61939511
        int curidx = 0;
90
        int curbits;
91
61939511
        float quantized, rd = 0.0f;
92
221643851
        for (j = 0; j < dim; j++) {
93
159704340
            curidx *= aac_cb_range[cb];
94
159704340
            curidx += quants[j] + off;
95
        }
96
61939511
        curbits =  ff_aac_spectral_bits[cb-1][curidx];
97
61939511
        vec     = &ff_aac_codebook_vectors[cb-1][curidx*dim];
98
61939511
        if (BT_UNSIGNED) {
99
131457421
            for (j = 0; j < dim; j++) {
100
92564718
                float t = fabsf(in[i+j]);
101
                float di;
102

92564718
                if (BT_ESC && vec[j] == 64.0f) { //FIXME: slow
103
1796894
                    if (t >= CLIPPED_ESCAPE) {
104
2698
                        quantized = CLIPPED_ESCAPE;
105
2698
                        curbits += 21;
106
                    } else {
107
1794196
                        int c = av_clip_uintp2(quant(t, Q, ROUNDING), 13);
108
1794196
                        quantized = c*cbrtf(c)*IQ;
109
1794196
                        curbits += av_log2(c)*2 - 4 + 1;
110
                    }
111
                } else {
112
90767824
                    quantized = vec[j]*IQ;
113
                }
114
92564718
                di = t - quantized;
115
92564718
                if (out)
116
53900
                    out[i+j] = in[i+j] >= 0 ? quantized : -quantized;
117
92564718
                if (vec[j] != 0.0f)
118
51752360
                    curbits++;
119
92564718
                qenergy += quantized*quantized;
120
92564718
                rd += di*di;
121
            }
122
        } else {
123
90186430
            for (j = 0; j < dim; j++) {
124
67139622
                quantized = vec[j]*IQ;
125
67139622
                qenergy += quantized*quantized;
126
67139622
                if (out)
127
445132
                    out[i+j] = quantized;
128
67139622
                rd += (in[i+j] - quantized)*(in[i+j] - quantized);
129
            }
130
        }
131
61939511
        cost    += rd * lambda + curbits;
132
61939511
        resbits += curbits;
133
61939511
        if (cost >= uplim)
134
7488
            return uplim;
135
61932023
        if (pb) {
136
3608102
            put_bits(pb, ff_aac_spectral_bits[cb-1][curidx], ff_aac_spectral_codes[cb-1][curidx]);
137
3608102
            if (BT_UNSIGNED)
138
6645719
                for (j = 0; j < dim; j++)
139
4836936
                    if (ff_aac_codebook_vectors[cb-1][curidx*dim+j] != 0.0f)
140
3351858
                        put_bits(pb, 1, in[i+j] < 0.0f);
141
3608102
            if (BT_ESC) {
142
1393374
                for (j = 0; j < 2; j++) {
143
928916
                    if (ff_aac_codebook_vectors[cb-1][curidx*2+j] == 64.0f) {
144
148480
                        int coef = av_clip_uintp2(quant(fabsf(in[i+j]), Q, ROUNDING), 13);
145
148480
                        int len = av_log2(coef);
146
147
148480
                        put_bits(pb, len - 4 + 1, (1 << (len - 4 + 1)) - 2);
148
148480
                        put_sbits(pb, len, coef);
149
                    }
150
                }
151
            }
152
        }
153
    }
154
155
7704125
    if (bits)
156
7103069
        *bits = resbits;
157
7704125
    if (energy)
158
3040243
        *energy = qenergy;
159
7704125
    return cost;
160
}
161
162
static inline float quantize_and_encode_band_cost_NONE(struct AACEncContext *s, PutBitContext *pb,
163
                                                const float *in, float *quant, const float *scaled,
164
                                                int size, int scale_idx, int cb,
165
                                                const float lambda, const float uplim,
166
                                                int *bits, float *energy) {
167
    av_assert0(0);
168
    return 0.0f;
169
}
170
171
#define QUANTIZE_AND_ENCODE_BAND_COST_FUNC(NAME, BT_ZERO, BT_UNSIGNED, BT_PAIR, BT_ESC, BT_NOISE, BT_STEREO, ROUNDING) \
172
static float quantize_and_encode_band_cost_ ## NAME(                                         \
173
                                struct AACEncContext *s,                                     \
174
                                PutBitContext *pb, const float *in, float *quant,            \
175
                                const float *scaled, int size, int scale_idx,                \
176
                                int cb, const float lambda, const float uplim,               \
177
                                int *bits, float *energy) {                                  \
178
    return quantize_and_encode_band_cost_template(                                           \
179
                                s, pb, in, quant, scaled, size, scale_idx,                   \
180
                                BT_ESC ? ESC_BT : cb, lambda, uplim, bits, energy,           \
181
                                BT_ZERO, BT_UNSIGNED, BT_PAIR, BT_ESC, BT_NOISE, BT_STEREO,  \
182
                                ROUNDING);                                                   \
183
}
184
185
1891151
QUANTIZE_AND_ENCODE_BAND_COST_FUNC(ZERO,  1, 0, 0, 0, 0, 0, ROUND_STANDARD)
186
1727146
QUANTIZE_AND_ENCODE_BAND_COST_FUNC(SQUAD, 0, 0, 0, 0, 0, 0, ROUND_STANDARD)
187
1304638
QUANTIZE_AND_ENCODE_BAND_COST_FUNC(UQUAD, 0, 1, 0, 0, 0, 0, ROUND_STANDARD)
188
1261892
QUANTIZE_AND_ENCODE_BAND_COST_FUNC(SPAIR, 0, 0, 1, 0, 0, 0, ROUND_STANDARD)
189
2363118
QUANTIZE_AND_ENCODE_BAND_COST_FUNC(UPAIR, 0, 1, 1, 0, 0, 0, ROUND_STANDARD)
190
1049734
QUANTIZE_AND_ENCODE_BAND_COST_FUNC(ESC,   0, 1, 1, 1, 0, 0, ROUND_STANDARD)
191
5085
QUANTIZE_AND_ENCODE_BAND_COST_FUNC(ESC_RTZ, 0, 1, 1, 1, 0, 0, ROUND_TO_ZERO)
192
45176
QUANTIZE_AND_ENCODE_BAND_COST_FUNC(NOISE, 0, 0, 0, 0, 1, 0, ROUND_STANDARD)
193
16446
QUANTIZE_AND_ENCODE_BAND_COST_FUNC(STEREO,0, 0, 0, 0, 0, 1, ROUND_STANDARD)
194
195
static float (*const quantize_and_encode_band_cost_arr[])(
196
                                struct AACEncContext *s,
197
                                PutBitContext *pb, const float *in, float *quant,
198
                                const float *scaled, int size, int scale_idx,
199
                                int cb, const float lambda, const float uplim,
200
                                int *bits, float *energy) = {
201
    quantize_and_encode_band_cost_ZERO,
202
    quantize_and_encode_band_cost_SQUAD,
203
    quantize_and_encode_band_cost_SQUAD,
204
    quantize_and_encode_band_cost_UQUAD,
205
    quantize_and_encode_band_cost_UQUAD,
206
    quantize_and_encode_band_cost_SPAIR,
207
    quantize_and_encode_band_cost_SPAIR,
208
    quantize_and_encode_band_cost_UPAIR,
209
    quantize_and_encode_band_cost_UPAIR,
210
    quantize_and_encode_band_cost_UPAIR,
211
    quantize_and_encode_band_cost_UPAIR,
212
    quantize_and_encode_band_cost_ESC,
213
    quantize_and_encode_band_cost_NONE,     /* CB 12 doesn't exist */
214
    quantize_and_encode_band_cost_NOISE,
215
    quantize_and_encode_band_cost_STEREO,
216
    quantize_and_encode_band_cost_STEREO,
217
};
218
219
static float (*const quantize_and_encode_band_cost_rtz_arr[])(
220
                                struct AACEncContext *s,
221
                                PutBitContext *pb, const float *in, float *quant,
222
                                const float *scaled, int size, int scale_idx,
223
                                int cb, const float lambda, const float uplim,
224
                                int *bits, float *energy) = {
225
    quantize_and_encode_band_cost_ZERO,
226
    quantize_and_encode_band_cost_SQUAD,
227
    quantize_and_encode_band_cost_SQUAD,
228
    quantize_and_encode_band_cost_UQUAD,
229
    quantize_and_encode_band_cost_UQUAD,
230
    quantize_and_encode_band_cost_SPAIR,
231
    quantize_and_encode_band_cost_SPAIR,
232
    quantize_and_encode_band_cost_UPAIR,
233
    quantize_and_encode_band_cost_UPAIR,
234
    quantize_and_encode_band_cost_UPAIR,
235
    quantize_and_encode_band_cost_UPAIR,
236
    quantize_and_encode_band_cost_ESC_RTZ,
237
    quantize_and_encode_band_cost_NONE,     /* CB 12 doesn't exist */
238
    quantize_and_encode_band_cost_NOISE,
239
    quantize_and_encode_band_cost_STEREO,
240
    quantize_and_encode_band_cost_STEREO,
241
};
242
243
#define quantize_and_encode_band_cost(                                  \
244
                                s, pb, in, quant, scaled, size, scale_idx, cb, \
245
                                lambda, uplim, bits, energy, rtz)               \
246
    ((rtz) ? quantize_and_encode_band_cost_rtz_arr : quantize_and_encode_band_cost_arr)[cb]( \
247
                                s, pb, in, quant, scaled, size, scale_idx, cb, \
248
                                lambda, uplim, bits, energy)
249
250
5051498
static inline float quantize_band_cost(struct AACEncContext *s, const float *in,
251
                                const float *scaled, int size, int scale_idx,
252
                                int cb, const float lambda, const float uplim,
253
                                int *bits, float *energy, int rtz)
254
{
255
5051498
    return quantize_and_encode_band_cost(s, NULL, in, NULL, scaled, size, scale_idx,
256
                                         cb, lambda, uplim, bits, energy, rtz);
257
}
258
259
4012006
static inline int quantize_band_cost_bits(struct AACEncContext *s, const float *in,
260
                                const float *scaled, int size, int scale_idx,
261
                                int cb, const float lambda, const float uplim,
262
                                int *bits, float *energy, int rtz)
263
{
264
    int auxbits;
265
4012006
    quantize_and_encode_band_cost(s, NULL, in, NULL, scaled, size, scale_idx,
266
                                         cb, 0.0f, uplim, &auxbits, energy, rtz);
267
4012006
    if (bits) {
268
        *bits = auxbits;
269
    }
270
4012006
    return auxbits;
271
}
272
273
529728
static inline void quantize_and_encode_band(struct AACEncContext *s, PutBitContext *pb,
274
                                            const float *in, float *out, int size, int scale_idx,
275
                                            int cb, const float lambda, int rtz)
276
{
277
529728
    quantize_and_encode_band_cost(s, pb, in, out, NULL, size, scale_idx, cb, lambda,
278
                                  INFINITY, NULL, NULL, rtz);
279
529728
}
280
281
#include "aacenc_quantization_misc.h"
282
283
#endif /* AVCODEC_AACENC_QUANTIZATION_H */