GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/wmaenc.c Lines: 203 233 87.1 %
Date: 2020-10-23 17:01:47 Branches: 98 142 69.0 %

Line Branch Exec Source
1
/*
2
 * WMA compatible encoder
3
 * Copyright (c) 2007 Michael Niedermayer
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
#include "libavutil/attributes.h"
23
#include "libavutil/ffmath.h"
24
25
#include "avcodec.h"
26
#include "internal.h"
27
#include "wma.h"
28
#include "libavutil/avassert.h"
29
30
31
2
static av_cold int encode_init(AVCodecContext *avctx)
32
{
33
2
    WMACodecContext *s = avctx->priv_data;
34
    int i, flags1, flags2, block_align;
35
    uint8_t *extradata;
36
    int ret;
37
38
2
    s->avctx = avctx;
39
40
2
    if (avctx->channels > MAX_CHANNELS) {
41
        av_log(avctx, AV_LOG_ERROR,
42
               "too many channels: got %i, need %i or fewer\n",
43
               avctx->channels, MAX_CHANNELS);
44
        return AVERROR(EINVAL);
45
    }
46
47
2
    if (avctx->sample_rate > 48000) {
48
        av_log(avctx, AV_LOG_ERROR, "sample rate is too high: %d > 48kHz\n",
49
               avctx->sample_rate);
50
        return AVERROR(EINVAL);
51
    }
52
53
2
    if (avctx->bit_rate < 24 * 1000) {
54
        av_log(avctx, AV_LOG_ERROR,
55
               "bitrate too low: got %"PRId64", need 24000 or higher\n",
56
               avctx->bit_rate);
57
        return AVERROR(EINVAL);
58
    }
59
60
    /* extract flag info */
61
2
    flags1 = 0;
62
2
    flags2 = 1;
63
2
    if (avctx->codec->id == AV_CODEC_ID_WMAV1) {
64
1
        extradata             = av_malloc(4);
65
1
        if (!extradata)
66
            return AVERROR(ENOMEM);
67
1
        avctx->extradata_size = 4;
68
1
        AV_WL16(extradata, flags1);
69
1
        AV_WL16(extradata + 2, flags2);
70
1
    } else if (avctx->codec->id == AV_CODEC_ID_WMAV2) {
71
1
        extradata             = av_mallocz(10);
72
1
        if (!extradata)
73
            return AVERROR(ENOMEM);
74
1
        avctx->extradata_size = 10;
75
1
        AV_WL32(extradata, flags1);
76
1
        AV_WL16(extradata + 4, flags2);
77
    } else {
78
        av_assert0(0);
79
    }
80
2
    avctx->extradata          = extradata;
81
2
    s->use_exp_vlc            = flags2 & 0x0001;
82
2
    s->use_bit_reservoir      = flags2 & 0x0002;
83
2
    s->use_variable_block_len = flags2 & 0x0004;
84
2
    if (avctx->channels == 2)
85
2
        s->ms_stereo = 1;
86
87
2
    if ((ret = ff_wma_init(avctx, flags2)) < 0)
88
        return ret;
89
90
    /* init MDCT */
91
4
    for (i = 0; i < s->nb_block_sizes; i++)
92
2
        ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 0, 1.0);
93
94
2
    block_align        = avctx->bit_rate * (int64_t) s->frame_len /
95
2
                         (avctx->sample_rate * 8);
96
2
    block_align        = FFMIN(block_align, MAX_CODED_SUPERFRAME_SIZE);
97
2
    avctx->block_align = block_align;
98
2
    avctx->frame_size = avctx->initial_padding = s->frame_len;
99
100
2
    return 0;
101
}
102
103
410
static int apply_window_and_mdct(AVCodecContext *avctx, const AVFrame *frame)
104
{
105
410
    WMACodecContext *s = avctx->priv_data;
106
410
    float **audio      = (float **) frame->extended_data;
107
410
    int len            = frame->nb_samples;
108
410
    int window_index   = s->frame_len_bits - s->block_len_bits;
109
410
    FFTContext *mdct   = &s->mdct_ctx[window_index];
110
    int ch;
111
410
    const float *win   = s->windows[window_index];
112
410
    int window_len     = 1 << s->block_len_bits;
113
410
    float n            = 2.0 * 32768.0 / window_len;
114
115
1230
    for (ch = 0; ch < avctx->channels; ch++) {
116
820
        memcpy(s->output, s->frame_out[ch], window_len * sizeof(*s->output));
117
820
        s->fdsp->vector_fmul_scalar(s->frame_out[ch], audio[ch], n, len);
118
820
        s->fdsp->vector_fmul_reverse(&s->output[window_len], s->frame_out[ch],
119
                                    win, len);
120
820
        s->fdsp->vector_fmul(s->frame_out[ch], s->frame_out[ch], win, len);
121
820
        mdct->mdct_calc(mdct, s->coefs[ch], s->output);
122
820
        if (!isfinite(s->coefs[ch][0])) {
123
            av_log(avctx, AV_LOG_ERROR, "Input contains NaN/+-Inf\n");
124
            return AVERROR(EINVAL);
125
        }
126
    }
127
128
410
    return 0;
129
}
130
131
// FIXME use for decoding too
132
6128
static void init_exp(WMACodecContext *s, int ch, const int *exp_param)
133
{
134
    int n;
135
    const uint16_t *ptr;
136
    float v, *q, max_scale, *q_end;
137
138
6128
    ptr       = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
139
6128
    q         = s->exponents[ch];
140
6128
    q_end     = q + s->block_len;
141
6128
    max_scale = 0;
142
159328
    while (q < q_end) {
143
        /* XXX: use a table */
144
153200
        v         = ff_exp10(*exp_param++ *(1.0 / 16.0));
145
153200
        max_scale = FFMAX(max_scale, v);
146
153200
        n         = *ptr++;
147
        do {
148
12550144
            *q++ = v;
149
12550144
        } while (--n);
150
    }
151
6128
    s->max_exponent[ch] = max_scale;
152
6128
}
153
154
6128
static void encode_exp_vlc(WMACodecContext *s, int ch, const int *exp_param)
155
{
156
    int last_exp;
157
    const uint16_t *ptr;
158
    float *q, *q_end;
159
160
6128
    ptr   = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
161
6128
    q     = s->exponents[ch];
162
6128
    q_end = q + s->block_len;
163
6128
    if (s->version == 1) {
164
3064
        last_exp = *exp_param++;
165

3064
        av_assert0(last_exp - 10 >= 0 && last_exp - 10 < 32);
166
3064
        put_bits(&s->pb, 5, last_exp - 10);
167
3064
        q += *ptr++;
168
    } else
169
3064
        last_exp = 36;
170
156264
    while (q < q_end) {
171
150136
        int exp  = *exp_param++;
172
150136
        int code = exp - last_exp + 60;
173
        av_assert1(code >= 0 && code < 120);
174
150136
        put_bits(&s->pb, ff_aac_scalefactor_bits[code],
175
150136
                 ff_aac_scalefactor_code[code]);
176
        /* XXX: use a table */
177
150136
        q       += *ptr++;
178
150136
        last_exp = exp;
179
    }
180
6128
}
181
182
3064
static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
183
                        int total_gain)
184
{
185
    int v, bsize, ch, coef_nb_bits, parse_exponents;
186
    float mdct_norm;
187
    int nb_coefs[MAX_CHANNELS];
188
    static const int fixed_exp[25] = {
189
        20, 20, 20, 20, 20,
190
        20, 20, 20, 20, 20,
191
        20, 20, 20, 20, 20,
192
        20, 20, 20, 20, 20,
193
        20, 20, 20, 20, 20
194
    };
195
196
    // FIXME remove duplication relative to decoder
197
3064
    if (s->use_variable_block_len) {
198
        av_assert0(0); // FIXME not implemented
199
    } else {
200
        /* fixed block len */
201
3064
        s->next_block_len_bits = s->frame_len_bits;
202
3064
        s->prev_block_len_bits = s->frame_len_bits;
203
3064
        s->block_len_bits      = s->frame_len_bits;
204
    }
205
206
3064
    s->block_len = 1 << s->block_len_bits;
207
//     av_assert0((s->block_pos + s->block_len) <= s->frame_len);
208
3064
    bsize = s->frame_len_bits - s->block_len_bits;
209
210
    // FIXME factor
211
3064
    v = s->coefs_end[bsize] - s->coefs_start;
212
9192
    for (ch = 0; ch < s->avctx->channels; ch++)
213
6128
        nb_coefs[ch] = v;
214
    {
215
3064
        int n4 = s->block_len / 2;
216
3064
        mdct_norm = 1.0 / (float) n4;
217
3064
        if (s->version == 1)
218
1532
            mdct_norm *= sqrt(n4);
219
    }
220
221
3064
    if (s->avctx->channels == 2)
222
3064
        put_bits(&s->pb, 1, !!s->ms_stereo);
223
224
9192
    for (ch = 0; ch < s->avctx->channels; ch++) {
225
        // FIXME only set channel_coded when needed, instead of always
226
6128
        s->channel_coded[ch] = 1;
227
6128
        if (s->channel_coded[ch])
228
6128
            init_exp(s, ch, fixed_exp);
229
    }
230
231
9192
    for (ch = 0; ch < s->avctx->channels; ch++) {
232
6128
        if (s->channel_coded[ch]) {
233
            WMACoef *coefs1;
234
            float *coefs, *exponents, mult;
235
            int i, n;
236
237
6128
            coefs1    = s->coefs1[ch];
238
6128
            exponents = s->exponents[ch];
239
6128
            mult      = ff_exp10(total_gain * 0.05) / s->max_exponent[ch];
240
6128
            mult     *= mdct_norm;
241
6128
            coefs     = src_coefs[ch];
242
            if (s->use_noise_coding && 0) {
243
                av_assert0(0); // FIXME not implemented
244
            } else {
245
6128
                coefs += s->coefs_start;
246
6128
                n      = nb_coefs[ch];
247
11419528
                for (i = 0; i < n; i++) {
248
11413400
                    double t = *coefs++ / (exponents[i] * mult);
249

11413400
                    if (t < -32768 || t > 32767)
250
                        return -1;
251
252
11413400
                    coefs1[i] = lrint(t);
253
                }
254
            }
255
        }
256
    }
257
258
3064
    v = 0;
259
9192
    for (ch = 0; ch < s->avctx->channels; ch++) {
260
6128
        int a = s->channel_coded[ch];
261
6128
        put_bits(&s->pb, 1, a);
262
6128
        v |= a;
263
    }
264
265
3064
    if (!v)
266
        return 1;
267
268
3064
    for (v = total_gain - 1; v >= 127; v -= 127)
269
        put_bits(&s->pb, 7, 127);
270
3064
    put_bits(&s->pb, 7, v);
271
272
3064
    coef_nb_bits = ff_wma_total_gain_to_bits(total_gain);
273
274
3064
    if (s->use_noise_coding) {
275
        for (ch = 0; ch < s->avctx->channels; ch++) {
276
            if (s->channel_coded[ch]) {
277
                int i, n;
278
                n = s->exponent_high_sizes[bsize];
279
                for (i = 0; i < n; i++) {
280
                    put_bits(&s->pb, 1, s->high_band_coded[ch][i] = 0);
281
                    if (0)
282
                        nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
283
                }
284
            }
285
        }
286
    }
287
288
3064
    parse_exponents = 1;
289
3064
    if (s->block_len_bits != s->frame_len_bits)
290
        put_bits(&s->pb, 1, parse_exponents);
291
292
3064
    if (parse_exponents) {
293
9192
        for (ch = 0; ch < s->avctx->channels; ch++) {
294
6128
            if (s->channel_coded[ch]) {
295
6128
                if (s->use_exp_vlc) {
296
6128
                    encode_exp_vlc(s, ch, fixed_exp);
297
                } else {
298
                    av_assert0(0); // FIXME not implemented
299
//                    encode_exp_lsp(s, ch);
300
                }
301
            }
302
        }
303
    } else
304
        av_assert0(0); // FIXME not implemented
305
306
8435
    for (ch = 0; ch < s->avctx->channels; ch++) {
307
5755
        if (s->channel_coded[ch]) {
308
            int run, tindex;
309
            WMACoef *ptr, *eptr;
310

5755
            tindex = (ch == 1 && s->ms_stereo);
311
5755
            ptr    = &s->coefs1[ch][0];
312
5755
            eptr   = ptr + nb_coefs[ch];
313
314
5755
            run = 0;
315
10012817
            for (; ptr < eptr; ptr++) {
316
10007446
                if (*ptr) {
317
2918406
                    int level     = *ptr;
318
2918406
                    int abs_level = FFABS(level);
319
2918406
                    int code      = 0;
320
2918406
                    if (abs_level <= s->coef_vlcs[tindex]->max_level)
321
2889049
                        if (run < s->coef_vlcs[tindex]->levels[abs_level - 1])
322
2884295
                            code = run + s->int_table[tindex][abs_level - 1];
323
324
                    av_assert2(code < s->coef_vlcs[tindex]->n);
325
2918406
                    put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[code],
326
2918406
                             s->coef_vlcs[tindex]->huffcodes[code]);
327
328
2918406
                    if (code == 0) {
329
34111
                        if (1 << coef_nb_bits <= abs_level)
330
384
                            return -1;
331
332
33727
                        put_bits(&s->pb, coef_nb_bits, abs_level);
333
33727
                        put_bits(&s->pb, s->frame_len_bits, run);
334
                    }
335
                    // FIXME the sign is flipped somewhere
336
2918022
                    put_bits(&s->pb, 1, level < 0);
337
2918022
                    run = 0;
338
                } else
339
7089040
                    run++;
340
            }
341
5371
            if (run)
342
5152
                put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[1],
343
5152
                         s->coef_vlcs[tindex]->huffcodes[1]);
344
        }
345

5371
        if (s->version == 1 && s->avctx->channels >= 2)
346
2803
            avpriv_align_put_bits(&s->pb);
347
    }
348
2680
    return 0;
349
}
350
351
3064
static int encode_frame(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
352
                        uint8_t *buf, int buf_size, int total_gain)
353
{
354
3064
    init_put_bits(&s->pb, buf, buf_size);
355
356
3064
    if (s->use_bit_reservoir)
357
        av_assert0(0); // FIXME not implemented
358
3064
    else if (encode_block(s, src_coefs, total_gain) < 0)
359
384
        return INT_MAX;
360
361
2680
    avpriv_align_put_bits(&s->pb);
362
363
2680
    return put_bits_count(&s->pb) / 8 - s->avctx->block_align;
364
}
365
366
410
static int encode_superframe(AVCodecContext *avctx, AVPacket *avpkt,
367
                             const AVFrame *frame, int *got_packet_ptr)
368
{
369
410
    WMACodecContext *s = avctx->priv_data;
370
    int i, total_gain, ret, error;
371
372
410
    s->block_len_bits = s->frame_len_bits; // required by non variable block len
373
410
    s->block_len      = 1 << s->block_len_bits;
374
375
410
    ret = apply_window_and_mdct(avctx, frame);
376
377
410
    if (ret < 0)
378
        return ret;
379
380
410
    if (s->ms_stereo) {
381
        float a, b;
382
        int i;
383
384
840090
        for (i = 0; i < s->block_len; i++) {
385
839680
            a              = s->coefs[0][i] * 0.5;
386
839680
            b              = s->coefs[1][i] * 0.5;
387
839680
            s->coefs[0][i] = a + b;
388
839680
            s->coefs[1][i] = a - b;
389
        }
390
    }
391
392
410
    if ((ret = ff_alloc_packet2(avctx, avpkt, 2 * MAX_CODED_SUPERFRAME_SIZE, 0)) < 0)
393
        return ret;
394
395
410
    total_gain = 128;
396
3280
    for (i = 64; i; i >>= 1) {
397
2870
        error = encode_frame(s, s->coefs, avpkt->data, avpkt->size,
398
                                 total_gain - i);
399
2870
        if (error <= 0)
400
1331
            total_gain -= i;
401
    }
402
403

604
    while(total_gain <= 128 && error > 0)
404
194
        error = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain++);
405
410
    if (error > 0) {
406
        av_log(avctx, AV_LOG_ERROR, "Invalid input data or requested bitrate too low, cannot encode\n");
407
        avpkt->size = 0;
408
        return AVERROR(EINVAL);
409
    }
410
410
    av_assert0((put_bits_count(&s->pb) & 7) == 0);
411
410
    i= avctx->block_align - (put_bits_count(&s->pb)+7)/8;
412
410
    av_assert0(i>=0);
413
22160
    while(i--)
414
21750
        put_bits(&s->pb, 8, 'N');
415
416
410
    flush_put_bits(&s->pb);
417
410
    av_assert0(put_bits_ptr(&s->pb) - s->pb.buf == avctx->block_align);
418
419
410
    if (frame->pts != AV_NOPTS_VALUE)
420
410
        avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->initial_padding);
421
422
410
    avpkt->size     = avctx->block_align;
423
410
    *got_packet_ptr = 1;
424
410
    return 0;
425
}
426
427
#if CONFIG_WMAV1_ENCODER
428
AVCodec ff_wmav1_encoder = {
429
    .name           = "wmav1",
430
    .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
431
    .type           = AVMEDIA_TYPE_AUDIO,
432
    .id             = AV_CODEC_ID_WMAV1,
433
    .priv_data_size = sizeof(WMACodecContext),
434
    .init           = encode_init,
435
    .encode2        = encode_superframe,
436
    .close          = ff_wma_end,
437
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
438
                                                      AV_SAMPLE_FMT_NONE },
439
};
440
#endif
441
#if CONFIG_WMAV2_ENCODER
442
AVCodec ff_wmav2_encoder = {
443
    .name           = "wmav2",
444
    .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
445
    .type           = AVMEDIA_TYPE_AUDIO,
446
    .id             = AV_CODEC_ID_WMAV2,
447
    .priv_data_size = sizeof(WMACodecContext),
448
    .init           = encode_init,
449
    .encode2        = encode_superframe,
450
    .close          = ff_wma_end,
451
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
452
                                                      AV_SAMPLE_FMT_NONE },
453
};
454
#endif