GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/dca_core.h Lines: 20 20 100.0 %
Date: 2019-11-22 03:34:36 Branches: 16 18 88.9 %

Line Branch Exec Source
1
/*
2
 * Copyright (C) 2016 foo86
3
 *
4
 * This file is part of FFmpeg.
5
 *
6
 * FFmpeg is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2.1 of the License, or (at your option) any later version.
10
 *
11
 * FFmpeg is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with FFmpeg; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 */
20
21
#ifndef AVCODEC_DCA_CORE_H
22
#define AVCODEC_DCA_CORE_H
23
24
#include "libavutil/common.h"
25
#include "libavutil/float_dsp.h"
26
#include "libavutil/fixed_dsp.h"
27
#include "libavutil/mem.h"
28
29
#include "avcodec.h"
30
#include "internal.h"
31
#include "get_bits.h"
32
#include "dca.h"
33
#include "dca_exss.h"
34
#include "dcadsp.h"
35
#include "dcadct.h"
36
#include "dcamath.h"
37
#include "dcahuff.h"
38
#include "fft.h"
39
#include "synth_filter.h"
40
41
#define DCA_CHANNELS            7
42
#define DCA_SUBBANDS            32
43
#define DCA_SUBBANDS_X96        64
44
#define DCA_SUBFRAMES           16
45
#define DCA_SUBBAND_SAMPLES     8
46
#define DCA_PCMBLOCK_SAMPLES    32
47
#define DCA_LFE_HISTORY         8
48
#define DCA_ABITS_MAX           26
49
50
#define DCA_CORE_CHANNELS_MAX       6
51
#define DCA_DMIX_CHANNELS_MAX       4
52
#define DCA_XXCH_CHANNELS_MAX       2
53
#define DCA_EXSS_CHANNELS_MAX       8
54
#define DCA_EXSS_CHSETS_MAX         4
55
56
#define DCA_FILTER_MODE_X96     0x01
57
#define DCA_FILTER_MODE_FIXED   0x02
58
59
enum DCACoreAudioMode {
60
    DCA_AMODE_MONO,             // Mode 0: A (mono)
61
    DCA_AMODE_MONO_DUAL,        // Mode 1: A + B (dual mono)
62
    DCA_AMODE_STEREO,           // Mode 2: L + R (stereo)
63
    DCA_AMODE_STEREO_SUMDIFF,   // Mode 3: (L+R) + (L-R) (sum-diff)
64
    DCA_AMODE_STEREO_TOTAL,     // Mode 4: LT + RT (left and right total)
65
    DCA_AMODE_3F,               // Mode 5: C + L + R
66
    DCA_AMODE_2F1R,             // Mode 6: L + R + S
67
    DCA_AMODE_3F1R,             // Mode 7: C + L + R + S
68
    DCA_AMODE_2F2R,             // Mode 8: L + R + SL + SR
69
    DCA_AMODE_3F2R,             // Mode 9: C + L + R + SL + SR
70
71
    DCA_AMODE_COUNT
72
};
73
74
enum DCACoreExtAudioType {
75
    DCA_EXT_AUDIO_XCH   = 0,
76
    DCA_EXT_AUDIO_X96   = 2,
77
    DCA_EXT_AUDIO_XXCH  = 6
78
};
79
80
enum DCACoreLFEFlag {
81
    DCA_LFE_FLAG_NONE,
82
    DCA_LFE_FLAG_128,
83
    DCA_LFE_FLAG_64,
84
    DCA_LFE_FLAG_INVALID
85
};
86
87
typedef struct DCADSPData {
88
    union {
89
        struct {
90
            DECLARE_ALIGNED(32, float, hist1)[1024];
91
            DECLARE_ALIGNED(32, float, hist2)[64];
92
        } flt;
93
        struct {
94
            DECLARE_ALIGNED(32, int32_t, hist1)[1024];
95
            DECLARE_ALIGNED(32, int32_t, hist2)[64];
96
        } fix;
97
    } u;
98
    int offset;
99
} DCADSPData;
100
101
typedef struct DCACoreDecoder {
102
    AVCodecContext  *avctx;
103
    GetBitContext   gb;
104
    GetBitContext   gb_in;
105
106
    // Bit stream header
107
    int     crc_present;        ///< CRC present flag
108
    int     npcmblocks;         ///< Number of PCM sample blocks
109
    int     frame_size;         ///< Primary frame byte size
110
    int     audio_mode;         ///< Audio channel arrangement
111
    int     sample_rate;        ///< Core audio sampling frequency
112
    int     bit_rate;           ///< Transmission bit rate
113
    int     drc_present;        ///< Embedded dynamic range flag
114
    int     ts_present;         ///< Embedded time stamp flag
115
    int     aux_present;        ///< Auxiliary data flag
116
    int     ext_audio_type;     ///< Extension audio descriptor flag
117
    int     ext_audio_present;  ///< Extended coding flag
118
    int     sync_ssf;           ///< Audio sync word insertion flag
119
    int     lfe_present;        ///< Low frequency effects flag
120
    int     predictor_history;  ///< Predictor history flag switch
121
    int     filter_perfect;     ///< Multirate interpolator switch
122
    int     source_pcm_res;     ///< Source PCM resolution
123
    int     es_format;          ///< Extended surround (ES) mastering flag
124
    int     sumdiff_front;      ///< Front sum/difference flag
125
    int     sumdiff_surround;   ///< Surround sum/difference flag
126
127
    // Primary audio coding header
128
    int         nsubframes;     ///< Number of subframes
129
    int         nchannels;      ///< Number of primary audio channels (incl. extension channels)
130
    int         ch_mask;        ///< Speaker layout mask (incl. LFE and extension channels)
131
    int8_t      nsubbands[DCA_CHANNELS];                ///< Subband activity count
132
    int8_t      subband_vq_start[DCA_CHANNELS];         ///< High frequency VQ start subband
133
    int8_t      joint_intensity_index[DCA_CHANNELS];    ///< Joint intensity coding index
134
    int8_t      transition_mode_sel[DCA_CHANNELS];      ///< Transient mode code book
135
    int8_t      scale_factor_sel[DCA_CHANNELS];         ///< Scale factor code book
136
    int8_t      bit_allocation_sel[DCA_CHANNELS];       ///< Bit allocation quantizer select
137
    int8_t      quant_index_sel[DCA_CHANNELS][DCA_CODE_BOOKS];  ///< Quantization index codebook select
138
    int32_t     scale_factor_adj[DCA_CHANNELS][DCA_CODE_BOOKS]; ///< Scale factor adjustment
139
140
    // Primary audio coding side information
141
    int8_t      nsubsubframes[DCA_SUBFRAMES];   ///< Subsubframe count for each subframe
142
    int8_t      prediction_mode[DCA_CHANNELS][DCA_SUBBANDS_X96];            ///< Prediction mode
143
    int16_t     prediction_vq_index[DCA_CHANNELS][DCA_SUBBANDS_X96];        ///< Prediction coefficients VQ address
144
    int8_t      bit_allocation[DCA_CHANNELS][DCA_SUBBANDS_X96];             ///< Bit allocation index
145
    int8_t      transition_mode[DCA_SUBFRAMES][DCA_CHANNELS][DCA_SUBBANDS]; ///< Transition mode
146
    int32_t     scale_factors[DCA_CHANNELS][DCA_SUBBANDS][2];               ///< Scale factors (2x for transients and X96)
147
    int8_t      joint_scale_sel[DCA_CHANNELS];                              ///< Joint subband codebook select
148
    int32_t     joint_scale_factors[DCA_CHANNELS][DCA_SUBBANDS_X96];        ///< Scale factors for joint subband coding
149
150
    // Auxiliary data
151
    int     prim_dmix_embedded; ///< Auxiliary dynamic downmix flag
152
    int     prim_dmix_type;     ///< Auxiliary primary channel downmix type
153
    int     prim_dmix_coeff[DCA_DMIX_CHANNELS_MAX * DCA_CORE_CHANNELS_MAX]; ///< Dynamic downmix code coefficients
154
155
    // Core extensions
156
    int     ext_audio_mask;     ///< Bit mask of fully decoded core extensions
157
158
    // XCH extension data
159
    int     xch_pos;    ///< Bit position of XCH frame in core substream
160
161
    // XXCH extension data
162
    int     xxch_crc_present;       ///< CRC presence flag for XXCH channel set header
163
    int     xxch_mask_nbits;        ///< Number of bits for loudspeaker mask
164
    int     xxch_core_mask;         ///< Core loudspeaker activity mask
165
    int     xxch_spkr_mask;         ///< Loudspeaker layout mask
166
    int     xxch_dmix_embedded;     ///< Downmix already performed by encoder
167
    int     xxch_dmix_scale_inv;    ///< Downmix scale factor
168
    int     xxch_dmix_mask[DCA_XXCH_CHANNELS_MAX];  ///< Downmix channel mapping mask
169
    int     xxch_dmix_coeff[DCA_XXCH_CHANNELS_MAX * DCA_CORE_CHANNELS_MAX];     ///< Downmix coefficients
170
    int     xxch_pos;   ///< Bit position of XXCH frame in core substream
171
172
    // X96 extension data
173
    int     x96_rev_no;         ///< X96 revision number
174
    int     x96_crc_present;    ///< CRC presence flag for X96 channel set header
175
    int     x96_nchannels;      ///< Number of primary channels in X96 extension
176
    int     x96_high_res;       ///< X96 high resolution flag
177
    int     x96_subband_start;  ///< First encoded subband in X96 extension
178
    int     x96_rand;           ///< Random seed for generating samples for unallocated X96 subbands
179
    int     x96_pos;            ///< Bit position of X96 frame in core substream
180
181
    // Sample buffers
182
    unsigned int    x96_subband_size;
183
    int32_t         *x96_subband_buffer;    ///< X96 subband sample buffer base
184
    int32_t         *x96_subband_samples[DCA_CHANNELS][DCA_SUBBANDS_X96];   ///< X96 subband samples
185
186
    unsigned int    subband_size;
187
    int32_t         *subband_buffer;    ///< Subband sample buffer base
188
    int32_t         *subband_samples[DCA_CHANNELS][DCA_SUBBANDS];   ///< Subband samples
189
    int32_t         *lfe_samples;    ///< Decimated LFE samples
190
191
    // DSP contexts
192
    DCADSPData              dcadsp_data[DCA_CHANNELS];    ///< FIR history buffers
193
    DCADSPContext           *dcadsp;
194
    DCADCTContext           dcadct;
195
    FFTContext              imdct[2];
196
    SynthFilterContext      synth;
197
    AVFloatDSPContext       *float_dsp;
198
    AVFixedDSPContext       *fixed_dsp;
199
200
    // PCM output data
201
    unsigned int    output_size;
202
    void            *output_buffer;                         ///< PCM output buffer base
203
    int32_t         *output_samples[DCA_SPEAKER_COUNT];     ///< PCM output for fixed point mode
204
    int32_t         output_history_lfe_fixed;               ///< LFE PCM history for X96 filter
205
    float           output_history_lfe_float;               ///< LFE PCM history for X96 filter
206
207
    int     ch_remap[DCA_SPEAKER_COUNT];   ///< Channel to speaker map
208
    int     request_mask;   ///< Requested channel layout (for stereo downmix)
209
210
    int     npcmsamples;    ///< Number of PCM samples per channel
211
    int     output_rate;    ///< Output sample rate (1x or 2x header rate)
212
213
    int     filter_mode;    ///< Previous filtering mode for detecting changes
214
} DCACoreDecoder;
215
216
7751
static inline int ff_dca_core_map_spkr(DCACoreDecoder *core, int spkr)
217
{
218
7751
    if (core->ch_mask & (1U << spkr))
219
7637
        return spkr;
220

114
    if (spkr == DCA_SPEAKER_Lss && (core->ch_mask & DCA_SPEAKER_MASK_Ls))
221
48
        return DCA_SPEAKER_Ls;
222

66
    if (spkr == DCA_SPEAKER_Rss && (core->ch_mask & DCA_SPEAKER_MASK_Rs))
223
48
        return DCA_SPEAKER_Rs;
224
18
    return -1;
225
}
226
227
680132
static inline void ff_dca_core_dequantize(int32_t *output, const int32_t *input,
228
                                          int32_t step_size, int32_t scale, int residual, int len)
229
{
230
    // Account for quantizer step size
231
680132
    int64_t step_scale = (int64_t)step_size * scale;
232
680132
    int n, shift = 0;
233
234
    // Limit scale factor resolution to 22 bits
235
680132
    if (step_scale > (1 << 23)) {
236
471989
        shift = av_log2(step_scale >> 23) + 1;
237
471989
        step_scale >>= shift;
238
    }
239
240
    // Scale the samples
241
680132
    if (residual) {
242
41958
        for (n = 0; n < len; n++)
243
37296
            output[n] += clip23(norm__(input[n] * step_scale, 22 - shift));
244
    } else {
245
5814526
        for (n = 0; n < len; n++)
246
5139056
            output[n]  = clip23(norm__(input[n] * step_scale, 22 - shift));
247
    }
248
680132
}
249
250
int ff_dca_core_parse(DCACoreDecoder *s, uint8_t *data, int size);
251
int ff_dca_core_parse_exss(DCACoreDecoder *s, uint8_t *data, DCAExssAsset *asset);
252
int ff_dca_core_filter_fixed(DCACoreDecoder *s, int x96_synth);
253
int ff_dca_core_filter_frame(DCACoreDecoder *s, AVFrame *frame);
254
av_cold void ff_dca_core_flush(DCACoreDecoder *s);
255
av_cold int ff_dca_core_init(DCACoreDecoder *s);
256
av_cold void ff_dca_core_close(DCACoreDecoder *s);
257
258
#endif