GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/aptxenc.c Lines: 0 96 0.0 %
Date: 2020-02-25 19:56:21 Branches: 0 40 0.0 %

Line Branch Exec Source
1
/*
2
 * Audio Processing Technology codec for Bluetooth (aptX)
3
 *
4
 * Copyright (C) 2017  Aurelien Jacobs <aurel@gnuage.org>
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
#include "aptx.h"
24
25
/*
26
 * Half-band QMF analysis filter realized with a polyphase FIR filter.
27
 * Split into 2 subbands and downsample by 2.
28
 * So for each pair of samples that goes in, one sample goes out,
29
 * split into 2 separate subbands.
30
 */
31
av_always_inline
32
static void aptx_qmf_polyphase_analysis(FilterSignal signal[NB_FILTERS],
33
                                        const int32_t coeffs[NB_FILTERS][FILTER_TAPS],
34
                                        int shift,
35
                                        int32_t samples[NB_FILTERS],
36
                                        int32_t *low_subband_output,
37
                                        int32_t *high_subband_output)
38
{
39
    int32_t subbands[NB_FILTERS];
40
    int i;
41
42
    for (i = 0; i < NB_FILTERS; i++) {
43
        aptx_qmf_filter_signal_push(&signal[i], samples[NB_FILTERS-1-i]);
44
        subbands[i] = aptx_qmf_convolution(&signal[i], coeffs[i], shift);
45
    }
46
47
    *low_subband_output  = av_clip_intp2(subbands[0] + subbands[1], 23);
48
    *high_subband_output = av_clip_intp2(subbands[0] - subbands[1], 23);
49
}
50
51
/*
52
 * Two stage QMF analysis tree.
53
 * Split 4 input samples into 4 subbands and downsample by 4.
54
 * So for each group of 4 samples that goes in, one sample goes out,
55
 * split into 4 separate subbands.
56
 */
57
static void aptx_qmf_tree_analysis(QMFAnalysis *qmf,
58
                                   int32_t samples[4],
59
                                   int32_t subband_samples[4])
60
{
61
    int32_t intermediate_samples[4];
62
    int i;
63
64
    /* Split 4 input samples into 2 intermediate subbands downsampled to 2 samples */
65
    for (i = 0; i < 2; i++)
66
        aptx_qmf_polyphase_analysis(qmf->outer_filter_signal,
67
                                    aptx_qmf_outer_coeffs, 23,
68
                                    &samples[2*i],
69
                                    &intermediate_samples[0+i],
70
                                    &intermediate_samples[2+i]);
71
72
    /* Split 2 intermediate subband samples into 4 final subbands downsampled to 1 sample */
73
    for (i = 0; i < 2; i++)
74
        aptx_qmf_polyphase_analysis(qmf->inner_filter_signal[i],
75
                                    aptx_qmf_inner_coeffs, 23,
76
                                    &intermediate_samples[2*i],
77
                                    &subband_samples[2*i+0],
78
                                    &subband_samples[2*i+1]);
79
}
80
81
av_always_inline
82
static int32_t aptx_bin_search(int32_t value, int32_t factor,
83
                               const int32_t *intervals, int32_t nb_intervals)
84
{
85
    int32_t idx = 0;
86
    int i;
87
88
    for (i = nb_intervals >> 1; i > 0; i >>= 1)
89
        if (MUL64(factor, intervals[idx + i]) <= ((int64_t)value << 24))
90
            idx += i;
91
92
    return idx;
93
}
94
95
static void aptx_quantize_difference(Quantize *quantize,
96
                                     int32_t sample_difference,
97
                                     int32_t dither,
98
                                     int32_t quantization_factor,
99
                                     ConstTables *tables)
100
{
101
    const int32_t *intervals = tables->quantize_intervals;
102
    int32_t quantized_sample, dithered_sample, parity_change;
103
    int32_t d, mean, interval, inv, sample_difference_abs;
104
    int64_t error;
105
106
    sample_difference_abs = FFABS(sample_difference);
107
    sample_difference_abs = FFMIN(sample_difference_abs, (1 << 23) - 1);
108
109
    quantized_sample = aptx_bin_search(sample_difference_abs >> 4,
110
                                       quantization_factor,
111
                                       intervals, tables->tables_size);
112
113
    d = rshift32_clip24(MULH(dither, dither), 7) - (1 << 23);
114
    d = rshift64(MUL64(d, tables->quantize_dither_factors[quantized_sample]), 23);
115
116
    intervals += quantized_sample;
117
    mean = (intervals[1] + intervals[0]) / 2;
118
    interval = (intervals[1] - intervals[0]) * (-(sample_difference < 0) | 1);
119
120
    dithered_sample = rshift64_clip24(MUL64(dither, interval) + ((int64_t)av_clip_intp2(mean + d, 23) << 32), 32);
121
    error = ((int64_t)sample_difference_abs << 20) - MUL64(dithered_sample, quantization_factor);
122
    quantize->error = FFABS(rshift64(error, 23));
123
124
    parity_change = quantized_sample;
125
    if (error < 0)
126
        quantized_sample--;
127
    else
128
        parity_change--;
129
130
    inv = -(sample_difference < 0);
131
    quantize->quantized_sample               = quantized_sample ^ inv;
132
    quantize->quantized_sample_parity_change = parity_change    ^ inv;
133
}
134
135
static void aptx_encode_channel(Channel *channel, int32_t samples[4], int hd)
136
{
137
    int32_t subband_samples[4];
138
    int subband;
139
    aptx_qmf_tree_analysis(&channel->qmf, samples, subband_samples);
140
    ff_aptx_generate_dither(channel);
141
    for (subband = 0; subband < NB_SUBBANDS; subband++) {
142
        int32_t diff = av_clip_intp2(subband_samples[subband] - channel->prediction[subband].predicted_sample, 23);
143
        aptx_quantize_difference(&channel->quantize[subband], diff,
144
                                 channel->dither[subband],
145
                                 channel->invert_quantize[subband].quantization_factor,
146
                                 &ff_aptx_quant_tables[hd][subband]);
147
    }
148
}
149
150
static void aptx_insert_sync(Channel channels[NB_CHANNELS], int32_t *idx)
151
{
152
    if (aptx_check_parity(channels, idx)) {
153
        int i;
154
        Channel *c;
155
        static const int map[] = { 1, 2, 0, 3 };
156
        Quantize *min = &channels[NB_CHANNELS-1].quantize[map[0]];
157
        for (c = &channels[NB_CHANNELS-1]; c >= channels; c--)
158
            for (i = 0; i < NB_SUBBANDS; i++)
159
                if (c->quantize[map[i]].error < min->error)
160
                    min = &c->quantize[map[i]];
161
162
        /* Forcing the desired parity is done by offsetting by 1 the quantized
163
         * sample from the subband featuring the smallest quantization error. */
164
        min->quantized_sample = min->quantized_sample_parity_change;
165
    }
166
}
167
168
static uint16_t aptx_pack_codeword(Channel *channel)
169
{
170
    int32_t parity = aptx_quantized_parity(channel);
171
    return (((channel->quantize[3].quantized_sample & 0x06) | parity) << 13)
172
         | (((channel->quantize[2].quantized_sample & 0x03)         ) << 11)
173
         | (((channel->quantize[1].quantized_sample & 0x0F)         ) <<  7)
174
         | (((channel->quantize[0].quantized_sample & 0x7F)         ) <<  0);
175
}
176
177
static uint32_t aptxhd_pack_codeword(Channel *channel)
178
{
179
    int32_t parity = aptx_quantized_parity(channel);
180
    return (((channel->quantize[3].quantized_sample & 0x01E) | parity) << 19)
181
         | (((channel->quantize[2].quantized_sample & 0x00F)         ) << 15)
182
         | (((channel->quantize[1].quantized_sample & 0x03F)         ) <<  9)
183
         | (((channel->quantize[0].quantized_sample & 0x1FF)         ) <<  0);
184
}
185
186
static void aptx_encode_samples(AptXContext *ctx,
187
                                int32_t samples[NB_CHANNELS][4],
188
                                uint8_t *output)
189
{
190
    int channel;
191
    for (channel = 0; channel < NB_CHANNELS; channel++)
192
        aptx_encode_channel(&ctx->channels[channel], samples[channel], ctx->hd);
193
194
    aptx_insert_sync(ctx->channels, &ctx->sync_idx);
195
196
    for (channel = 0; channel < NB_CHANNELS; channel++) {
197
        ff_aptx_invert_quantize_and_prediction(&ctx->channels[channel], ctx->hd);
198
        if (ctx->hd)
199
            AV_WB24(output + 3*channel,
200
                    aptxhd_pack_codeword(&ctx->channels[channel]));
201
        else
202
            AV_WB16(output + 2*channel,
203
                    aptx_pack_codeword(&ctx->channels[channel]));
204
    }
205
}
206
207
static int aptx_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
208
                             const AVFrame *frame, int *got_packet_ptr)
209
{
210
    AptXContext *s = avctx->priv_data;
211
    int pos, ipos, channel, sample, output_size, ret;
212
213
    if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
214
        return ret;
215
216
    output_size = s->block_size * frame->nb_samples/4;
217
    if ((ret = ff_alloc_packet2(avctx, avpkt, output_size, 0)) < 0)
218
        return ret;
219
220
    for (pos = 0, ipos = 0; pos < output_size; pos += s->block_size, ipos += 4) {
221
        int32_t samples[NB_CHANNELS][4];
222
223
        for (channel = 0; channel < NB_CHANNELS; channel++)
224
            for (sample = 0; sample < 4; sample++)
225
                samples[channel][sample] = (int32_t)AV_RN32A(&frame->data[channel][4*(ipos+sample)]) >> 8;
226
227
        aptx_encode_samples(s, samples, avpkt->data + pos);
228
    }
229
230
    ff_af_queue_remove(&s->afq, frame->nb_samples, &avpkt->pts, &avpkt->duration);
231
    *got_packet_ptr = 1;
232
    return 0;
233
}
234
235
static av_cold int aptx_close(AVCodecContext *avctx)
236
{
237
    AptXContext *s = avctx->priv_data;
238
    ff_af_queue_close(&s->afq);
239
    return 0;
240
}
241
242
#if CONFIG_APTX_ENCODER
243
AVCodec ff_aptx_encoder = {
244
    .name                  = "aptx",
245
    .long_name             = NULL_IF_CONFIG_SMALL("aptX (Audio Processing Technology for Bluetooth)"),
246
    .type                  = AVMEDIA_TYPE_AUDIO,
247
    .id                    = AV_CODEC_ID_APTX,
248
    .priv_data_size        = sizeof(AptXContext),
249
    .init                  = ff_aptx_init,
250
    .encode2               = aptx_encode_frame,
251
    .close                 = aptx_close,
252
    .capabilities          = AV_CODEC_CAP_SMALL_LAST_FRAME,
253
    .caps_internal         = FF_CODEC_CAP_INIT_THREADSAFE,
254
    .channel_layouts       = (const uint64_t[]) { AV_CH_LAYOUT_STEREO, 0},
255
    .sample_fmts           = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P,
256
                                                             AV_SAMPLE_FMT_NONE },
257
    .supported_samplerates = (const int[]) {8000, 16000, 24000, 32000, 44100, 48000, 0},
258
};
259
#endif
260
261
#if CONFIG_APTX_HD_ENCODER
262
AVCodec ff_aptx_hd_encoder = {
263
    .name                  = "aptx_hd",
264
    .long_name             = NULL_IF_CONFIG_SMALL("aptX HD (Audio Processing Technology for Bluetooth)"),
265
    .type                  = AVMEDIA_TYPE_AUDIO,
266
    .id                    = AV_CODEC_ID_APTX_HD,
267
    .priv_data_size        = sizeof(AptXContext),
268
    .init                  = ff_aptx_init,
269
    .encode2               = aptx_encode_frame,
270
    .close                 = aptx_close,
271
    .capabilities          = AV_CODEC_CAP_SMALL_LAST_FRAME,
272
    .caps_internal         = FF_CODEC_CAP_INIT_THREADSAFE,
273
    .channel_layouts       = (const uint64_t[]) { AV_CH_LAYOUT_STEREO, 0},
274
    .sample_fmts           = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P,
275
                                                             AV_SAMPLE_FMT_NONE },
276
    .supported_samplerates = (const int[]) {8000, 16000, 24000, 32000, 44100, 48000, 0},
277
};
278
#endif