GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/atrac3plusdec.c Lines: 122 195 62.6 %
Date: 2019-11-22 03:34:36 Branches: 50 90 55.6 %

Line Branch Exec Source
1
/*
2
 * ATRAC3+ compatible decoder
3
 *
4
 * Copyright (c) 2010-2013 Maxim Poliakovski
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22
23
/**
24
 * @file
25
 * Sony ATRAC3+ compatible decoder.
26
 *
27
 * Container formats used to store its data:
28
 * RIFF WAV (.at3) and Sony OpenMG (.oma, .aa3).
29
 *
30
 * Technical description of this codec can be found here:
31
 * http://wiki.multimedia.cx/index.php?title=ATRAC3plus
32
 *
33
 * Kudos to Benjamin Larsson and Michael Karcher
34
 * for their precious technical help!
35
 */
36
37
#include <stdint.h>
38
#include <string.h>
39
40
#include "libavutil/channel_layout.h"
41
#include "libavutil/float_dsp.h"
42
#include "avcodec.h"
43
#include "get_bits.h"
44
#include "internal.h"
45
#include "atrac.h"
46
#include "atrac3plus.h"
47
48
typedef struct ATRAC3PContext {
49
    GetBitContext gb;
50
    AVFloatDSPContext *fdsp;
51
52
    DECLARE_ALIGNED(32, float, samples)[2][ATRAC3P_FRAME_SAMPLES];  ///< quantized MDCT spectrum
53
    DECLARE_ALIGNED(32, float, mdct_buf)[2][ATRAC3P_FRAME_SAMPLES]; ///< output of the IMDCT
54
    DECLARE_ALIGNED(32, float, time_buf)[2][ATRAC3P_FRAME_SAMPLES]; ///< output of the gain compensation
55
    DECLARE_ALIGNED(32, float, outp_buf)[2][ATRAC3P_FRAME_SAMPLES];
56
57
    AtracGCContext gainc_ctx;   ///< gain compensation context
58
    FFTContext mdct_ctx;
59
    FFTContext ipqf_dct_ctx;    ///< IDCT context used by IPQF
60
61
    Atrac3pChanUnitCtx *ch_units;   ///< global channel units
62
63
    int num_channel_blocks;     ///< number of channel blocks
64
    uint8_t channel_blocks[5];  ///< channel configuration descriptor
65
    uint64_t my_channel_layout; ///< current channel layout
66
} ATRAC3PContext;
67
68
4
static av_cold int atrac3p_decode_close(AVCodecContext *avctx)
69
{
70
4
    ATRAC3PContext *ctx = avctx->priv_data;
71
72
4
    av_freep(&ctx->ch_units);
73
4
    av_freep(&ctx->fdsp);
74
75
4
    ff_mdct_end(&ctx->mdct_ctx);
76
4
    ff_mdct_end(&ctx->ipqf_dct_ctx);
77
78
4
    return 0;
79
}
80
81
4
static av_cold int set_channel_params(ATRAC3PContext *ctx,
82
                                      AVCodecContext *avctx)
83
{
84
4
    memset(ctx->channel_blocks, 0, sizeof(ctx->channel_blocks));
85
86


4
    switch (avctx->channels) {
87
    case 1:
88
        if (avctx->channel_layout != AV_CH_FRONT_LEFT)
89
            avctx->channel_layout = AV_CH_LAYOUT_MONO;
90
91
        ctx->num_channel_blocks = 1;
92
        ctx->channel_blocks[0]  = CH_UNIT_MONO;
93
        break;
94
4
    case 2:
95
4
        avctx->channel_layout   = AV_CH_LAYOUT_STEREO;
96
4
        ctx->num_channel_blocks = 1;
97
4
        ctx->channel_blocks[0]  = CH_UNIT_STEREO;
98
4
        break;
99
    case 3:
100
        avctx->channel_layout   = AV_CH_LAYOUT_SURROUND;
101
        ctx->num_channel_blocks = 2;
102
        ctx->channel_blocks[0]  = CH_UNIT_STEREO;
103
        ctx->channel_blocks[1]  = CH_UNIT_MONO;
104
        break;
105
    case 4:
106
        avctx->channel_layout   = AV_CH_LAYOUT_4POINT0;
107
        ctx->num_channel_blocks = 3;
108
        ctx->channel_blocks[0]  = CH_UNIT_STEREO;
109
        ctx->channel_blocks[1]  = CH_UNIT_MONO;
110
        ctx->channel_blocks[2]  = CH_UNIT_MONO;
111
        break;
112
    case 6:
113
        avctx->channel_layout   = AV_CH_LAYOUT_5POINT1_BACK;
114
        ctx->num_channel_blocks = 4;
115
        ctx->channel_blocks[0]  = CH_UNIT_STEREO;
116
        ctx->channel_blocks[1]  = CH_UNIT_MONO;
117
        ctx->channel_blocks[2]  = CH_UNIT_STEREO;
118
        ctx->channel_blocks[3]  = CH_UNIT_MONO;
119
        break;
120
    case 7:
121
        avctx->channel_layout   = AV_CH_LAYOUT_6POINT1_BACK;
122
        ctx->num_channel_blocks = 5;
123
        ctx->channel_blocks[0]  = CH_UNIT_STEREO;
124
        ctx->channel_blocks[1]  = CH_UNIT_MONO;
125
        ctx->channel_blocks[2]  = CH_UNIT_STEREO;
126
        ctx->channel_blocks[3]  = CH_UNIT_MONO;
127
        ctx->channel_blocks[4]  = CH_UNIT_MONO;
128
        break;
129
    case 8:
130
        avctx->channel_layout   = AV_CH_LAYOUT_7POINT1;
131
        ctx->num_channel_blocks = 5;
132
        ctx->channel_blocks[0]  = CH_UNIT_STEREO;
133
        ctx->channel_blocks[1]  = CH_UNIT_MONO;
134
        ctx->channel_blocks[2]  = CH_UNIT_STEREO;
135
        ctx->channel_blocks[3]  = CH_UNIT_STEREO;
136
        ctx->channel_blocks[4]  = CH_UNIT_MONO;
137
        break;
138
    default:
139
        av_log(avctx, AV_LOG_ERROR,
140
               "Unsupported channel count: %d!\n", avctx->channels);
141
        return AVERROR_INVALIDDATA;
142
    }
143
144
4
    return 0;
145
}
146
147
4
static av_cold int atrac3p_decode_init(AVCodecContext *avctx)
148
{
149
4
    ATRAC3PContext *ctx = avctx->priv_data;
150
    int i, ch, ret;
151
152
4
    if (!avctx->block_align) {
153
        av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");
154
        return AVERROR(EINVAL);
155
    }
156
157
4
    ff_atrac3p_init_vlcs();
158
159
    /* initialize IPQF */
160
4
    ff_mdct_init(&ctx->ipqf_dct_ctx, 5, 1, 32.0 / 32768.0);
161
162
4
    ff_atrac3p_init_imdct(avctx, &ctx->mdct_ctx);
163
164
4
    ff_atrac_init_gain_compensation(&ctx->gainc_ctx, 6, 2);
165
166
4
    ff_atrac3p_init_wave_synth();
167
168
4
    if ((ret = set_channel_params(ctx, avctx)) < 0)
169
        return ret;
170
171
4
    ctx->my_channel_layout = avctx->channel_layout;
172
173
4
    ctx->ch_units = av_mallocz_array(ctx->num_channel_blocks, sizeof(*ctx->ch_units));
174
4
    ctx->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
175
176

4
    if (!ctx->ch_units || !ctx->fdsp) {
177
        return AVERROR(ENOMEM);
178
    }
179
180
8
    for (i = 0; i < ctx->num_channel_blocks; i++) {
181
12
        for (ch = 0; ch < 2; ch++) {
182
8
            ctx->ch_units[i].channels[ch].ch_num          = ch;
183
8
            ctx->ch_units[i].channels[ch].wnd_shape       = &ctx->ch_units[i].channels[ch].wnd_shape_hist[0][0];
184
8
            ctx->ch_units[i].channels[ch].wnd_shape_prev  = &ctx->ch_units[i].channels[ch].wnd_shape_hist[1][0];
185
8
            ctx->ch_units[i].channels[ch].gain_data       = &ctx->ch_units[i].channels[ch].gain_data_hist[0][0];
186
8
            ctx->ch_units[i].channels[ch].gain_data_prev  = &ctx->ch_units[i].channels[ch].gain_data_hist[1][0];
187
8
            ctx->ch_units[i].channels[ch].tones_info      = &ctx->ch_units[i].channels[ch].tones_info_hist[0][0];
188
8
            ctx->ch_units[i].channels[ch].tones_info_prev = &ctx->ch_units[i].channels[ch].tones_info_hist[1][0];
189
        }
190
191
4
        ctx->ch_units[i].waves_info      = &ctx->ch_units[i].wave_synth_hist[0];
192
4
        ctx->ch_units[i].waves_info_prev = &ctx->ch_units[i].wave_synth_hist[1];
193
    }
194
195
4
    avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
196
197
4
    return 0;
198
}
199
200
813
static void decode_residual_spectrum(ATRAC3PContext *ctx, Atrac3pChanUnitCtx *ch_unit,
201
                                     float out[2][ATRAC3P_FRAME_SAMPLES],
202
                                     int num_channels,
203
                                     AVCodecContext *avctx)
204
{
205
    int i, sb, ch, qu, nspeclines, RNG_index;
206
    float *dst, q;
207
    int16_t *src;
208
    /* calculate RNG table index for each subband */
209
813
    int sb_RNG_index[ATRAC3P_SUBBANDS] = { 0 };
210
211
813
    if (ch_unit->mute_flag) {
212
        for (ch = 0; ch < num_channels; ch++)
213
            memset(out[ch], 0, ATRAC3P_FRAME_SAMPLES * sizeof(*out[ch]));
214
        return;
215
    }
216
217
22793
    for (qu = 0, RNG_index = 0; qu < ch_unit->used_quant_units; qu++)
218
21980
        RNG_index += ch_unit->channels[0].qu_sf_idx[qu] +
219
21980
                     ch_unit->channels[1].qu_sf_idx[qu];
220
221
10377
    for (sb = 0; sb < ch_unit->num_coded_subbands; sb++, RNG_index += 128)
222
9564
        sb_RNG_index[sb] = RNG_index & 0x3FC;
223
224
    /* inverse quant and power compensation */
225
2439
    for (ch = 0; ch < num_channels; ch++) {
226
        /* clear channel's residual spectrum */
227
1626
        memset(out[ch], 0, ATRAC3P_FRAME_SAMPLES * sizeof(*out[ch]));
228
229
45586
        for (qu = 0; qu < ch_unit->used_quant_units; qu++) {
230
43960
            src        = &ch_unit->channels[ch].spectrum[ff_atrac3p_qu_to_spec_pos[qu]];
231
43960
            dst        = &out[ch][ff_atrac3p_qu_to_spec_pos[qu]];
232
43960
            nspeclines = ff_atrac3p_qu_to_spec_pos[qu + 1] -
233
43960
                         ff_atrac3p_qu_to_spec_pos[qu];
234
235
43960
            if (ch_unit->channels[ch].qu_wordlen[qu] > 0) {
236
43960
                q = ff_atrac3p_sf_tab[ch_unit->channels[ch].qu_sf_idx[qu]] *
237
43960
                    ff_atrac3p_mant_tab[ch_unit->channels[ch].qu_wordlen[qu]];
238
2492344
                for (i = 0; i < nspeclines; i++)
239
2448384
                    dst[i] = src[i] * q;
240
            }
241
        }
242
243
20754
        for (sb = 0; sb < ch_unit->num_coded_subbands; sb++)
244
19128
            ff_atrac3p_power_compensation(ch_unit, ctx->fdsp, ch, &out[ch][0],
245
                                          sb_RNG_index[sb], sb);
246
    }
247
248
813
    if (ch_unit->unit_type == CH_UNIT_STEREO) {
249
10377
        for (sb = 0; sb < ch_unit->num_coded_subbands; sb++) {
250
9564
            if (ch_unit->swap_channels[sb]) {
251
                for (i = 0; i < ATRAC3P_SUBBAND_SAMPLES; i++)
252
                    FFSWAP(float, out[0][sb * ATRAC3P_SUBBAND_SAMPLES + i],
253
                                  out[1][sb * ATRAC3P_SUBBAND_SAMPLES + i]);
254
            }
255
256
            /* flip coefficients' sign if requested */
257
9564
            if (ch_unit->negate_coeffs[sb])
258
                for (i = 0; i < ATRAC3P_SUBBAND_SAMPLES; i++)
259
                    out[1][sb * ATRAC3P_SUBBAND_SAMPLES + i] = -(out[1][sb * ATRAC3P_SUBBAND_SAMPLES + i]);
260
        }
261
    }
262
}
263
264
813
static void reconstruct_frame(ATRAC3PContext *ctx, Atrac3pChanUnitCtx *ch_unit,
265
                              int num_channels, AVCodecContext *avctx)
266
{
267
    int ch, sb;
268
269
2439
    for (ch = 0; ch < num_channels; ch++) {
270
23298
        for (sb = 0; sb < ch_unit->num_subbands; sb++) {
271
            /* inverse transform and windowing */
272
21672
            ff_atrac3p_imdct(ctx->fdsp, &ctx->mdct_ctx,
273
21672
                             &ctx->samples[ch][sb * ATRAC3P_SUBBAND_SAMPLES],
274
21672
                             &ctx->mdct_buf[ch][sb * ATRAC3P_SUBBAND_SAMPLES],
275
21672
                             (ch_unit->channels[ch].wnd_shape_prev[sb] << 1) +
276
21672
                             ch_unit->channels[ch].wnd_shape[sb], sb);
277
278
            /* gain compensation and overlapping */
279
21672
            ff_atrac_gain_compensation(&ctx->gainc_ctx,
280
21672
                                       &ctx->mdct_buf[ch][sb * ATRAC3P_SUBBAND_SAMPLES],
281
21672
                                       &ch_unit->prev_buf[ch][sb * ATRAC3P_SUBBAND_SAMPLES],
282
21672
                                       &ch_unit->channels[ch].gain_data_prev[sb],
283
21672
                                       &ch_unit->channels[ch].gain_data[sb],
284
                                       ATRAC3P_SUBBAND_SAMPLES,
285
21672
                                       &ctx->time_buf[ch][sb * ATRAC3P_SUBBAND_SAMPLES]);
286
        }
287
288
        /* zero unused subbands in both output and overlapping buffers */
289
1626
        memset(&ch_unit->prev_buf[ch][ch_unit->num_subbands * ATRAC3P_SUBBAND_SAMPLES],
290
               0,
291
1626
               (ATRAC3P_SUBBANDS - ch_unit->num_subbands) *
292
               ATRAC3P_SUBBAND_SAMPLES *
293
               sizeof(ch_unit->prev_buf[ch][ch_unit->num_subbands * ATRAC3P_SUBBAND_SAMPLES]));
294
1626
        memset(&ctx->time_buf[ch][ch_unit->num_subbands * ATRAC3P_SUBBAND_SAMPLES],
295
               0,
296
1626
               (ATRAC3P_SUBBANDS - ch_unit->num_subbands) *
297
               ATRAC3P_SUBBAND_SAMPLES *
298
               sizeof(ctx->time_buf[ch][ch_unit->num_subbands * ATRAC3P_SUBBAND_SAMPLES]));
299
300
        /* resynthesize and add tonal signal */
301
1626
        if (ch_unit->waves_info->tones_present ||
302
1626
            ch_unit->waves_info_prev->tones_present) {
303
            for (sb = 0; sb < ch_unit->num_subbands; sb++)
304
                if (ch_unit->channels[ch].tones_info[sb].num_wavs ||
305
                    ch_unit->channels[ch].tones_info_prev[sb].num_wavs) {
306
                    ff_atrac3p_generate_tones(ch_unit, ctx->fdsp, ch, sb,
307
                                              &ctx->time_buf[ch][sb * 128]);
308
                }
309
        }
310
311
        /* subband synthesis and acoustic signal output */
312
1626
        ff_atrac3p_ipqf(&ctx->ipqf_dct_ctx, &ch_unit->ipqf_ctx[ch],
313
1626
                        &ctx->time_buf[ch][0], &ctx->outp_buf[ch][0]);
314
    }
315
316
    /* swap window shape and gain control buffers. */
317
2439
    for (ch = 0; ch < num_channels; ch++) {
318
1626
        FFSWAP(uint8_t *, ch_unit->channels[ch].wnd_shape,
319
               ch_unit->channels[ch].wnd_shape_prev);
320
1626
        FFSWAP(AtracGainInfo *, ch_unit->channels[ch].gain_data,
321
               ch_unit->channels[ch].gain_data_prev);
322
1626
        FFSWAP(Atrac3pWavesData *, ch_unit->channels[ch].tones_info,
323
               ch_unit->channels[ch].tones_info_prev);
324
    }
325
326
813
    FFSWAP(Atrac3pWaveSynthParams *, ch_unit->waves_info, ch_unit->waves_info_prev);
327
813
}
328
329
813
static int atrac3p_decode_frame(AVCodecContext *avctx, void *data,
330
                                int *got_frame_ptr, AVPacket *avpkt)
331
{
332
813
    ATRAC3PContext *ctx = avctx->priv_data;
333
813
    AVFrame *frame      = data;
334
813
    int i, ret, ch_unit_id, ch_block = 0, out_ch_index = 0, channels_to_process;
335
813
    float **samples_p = (float **)frame->extended_data;
336
337
813
    frame->nb_samples = ATRAC3P_FRAME_SAMPLES;
338
813
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
339
        return ret;
340
341
813
    if ((ret = init_get_bits8(&ctx->gb, avpkt->data, avpkt->size)) < 0)
342
        return ret;
343
344
813
    if (get_bits1(&ctx->gb)) {
345
        av_log(avctx, AV_LOG_ERROR, "Invalid start bit!\n");
346
        return AVERROR_INVALIDDATA;
347
    }
348
349
1626
    while (get_bits_left(&ctx->gb) >= 2 &&
350
1625
           (ch_unit_id = get_bits(&ctx->gb, 2)) != CH_UNIT_TERMINATOR) {
351
813
        if (ch_unit_id == CH_UNIT_EXTENSION) {
352
            avpriv_report_missing_feature(avctx, "Channel unit extension");
353
            return AVERROR_PATCHWELCOME;
354
        }
355
813
        if (ch_block >= ctx->num_channel_blocks ||
356
813
            ctx->channel_blocks[ch_block] != ch_unit_id) {
357
            av_log(avctx, AV_LOG_ERROR,
358
                   "Frame data doesn't match channel configuration!\n");
359
            return AVERROR_INVALIDDATA;
360
        }
361
362
813
        ctx->ch_units[ch_block].unit_type = ch_unit_id;
363
813
        channels_to_process               = ch_unit_id + 1;
364
365
813
        if ((ret = ff_atrac3p_decode_channel_unit(&ctx->gb,
366
813
                                                  &ctx->ch_units[ch_block],
367
                                                  channels_to_process,
368
                                                  avctx)) < 0)
369
            return ret;
370
371
813
        decode_residual_spectrum(ctx, &ctx->ch_units[ch_block], ctx->samples,
372
                                 channels_to_process, avctx);
373
813
        reconstruct_frame(ctx, &ctx->ch_units[ch_block],
374
                          channels_to_process, avctx);
375
376
2439
        for (i = 0; i < channels_to_process; i++)
377
1626
            memcpy(samples_p[out_ch_index + i], ctx->outp_buf[i],
378
                   ATRAC3P_FRAME_SAMPLES * sizeof(**samples_p));
379
380
813
        ch_block++;
381
813
        out_ch_index += channels_to_process;
382
    }
383
384
813
    *got_frame_ptr = 1;
385
386
813
    return avctx->codec_id == AV_CODEC_ID_ATRAC3P ? FFMIN(avctx->block_align, avpkt->size) : avpkt->size;
387
}
388
389
AVCodec ff_atrac3p_decoder = {
390
    .name           = "atrac3plus",
391
    .long_name      = NULL_IF_CONFIG_SMALL("ATRAC3+ (Adaptive TRansform Acoustic Coding 3+)"),
392
    .type           = AVMEDIA_TYPE_AUDIO,
393
    .id             = AV_CODEC_ID_ATRAC3P,
394
    .capabilities   = AV_CODEC_CAP_DR1,
395
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
396
    .priv_data_size = sizeof(ATRAC3PContext),
397
    .init           = atrac3p_decode_init,
398
    .close          = atrac3p_decode_close,
399
    .decode         = atrac3p_decode_frame,
400
};
401
402
AVCodec ff_atrac3pal_decoder = {
403
    .name           = "atrac3plusal",
404
    .long_name      = NULL_IF_CONFIG_SMALL("ATRAC3+ AL (Adaptive TRansform Acoustic Coding 3+ Advanced Lossless)"),
405
    .type           = AVMEDIA_TYPE_AUDIO,
406
    .id             = AV_CODEC_ID_ATRAC3PAL,
407
    .capabilities   = AV_CODEC_CAP_DR1,
408
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
409
    .priv_data_size = sizeof(ATRAC3PContext),
410
    .init           = atrac3p_decode_init,
411
    .close          = atrac3p_decode_close,
412
    .decode         = atrac3p_decode_frame,
413
};