/* * Audio Processing Technology codec for Bluetooth (aptX) * * Copyright (C) 2017  Aurelien Jacobs <aurel@gnuage.org> * * This file is part of FFmpeg. * * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "aptx.h" /* * Half-band QMF synthesis filter realized with a polyphase FIR filter. * Join 2 subbands and upsample by 2. * So for each 2 subbands sample that goes in, a pair of samples goes out. */av_always_inlinestatic void aptx_qmf_polyphase_synthesis(FilterSignal signal[NB_FILTERS],                                         const int32_t coeffs[NB_FILTERS][FILTER_TAPS],                                         int shift,                                         int32_t low_subband_input,                                         int32_t high_subband_input,                                         int32_t samples[NB_FILTERS]){    int32_t subbands[NB_FILTERS];    int i;     subbands[0] = low_subband_input + high_subband_input;    subbands[1] = low_subband_input - high_subband_input;     for (i = 0; i < NB_FILTERS; i++) {        aptx_qmf_filter_signal_push(&signal[i], subbands[1-i]);        samples[i] = aptx_qmf_convolution(&signal[i], coeffs[i], shift);    }} /* * Two stage QMF synthesis tree. * Join 4 subbands and upsample by 4. * So for each 4 subbands sample that goes in, a group of 4 samples goes out. */static void aptx_qmf_tree_synthesis(QMFAnalysis *qmf,                                    int32_t subband_samples[4],                                    int32_t samples[4]){    int32_t intermediate_samples[4];    int i;     /* Join 4 subbands into 2 intermediate subbands upsampled to 2 samples. */    for (i = 0; i < 2; i++)        aptx_qmf_polyphase_synthesis(qmf->inner_filter_signal[i],                                     aptx_qmf_inner_coeffs, 22,                                     subband_samples[2*i+0],                                     subband_samples[2*i+1],                                     &intermediate_samples[2*i]);     /* Join 2 samples from intermediate subbands upsampled to 4 samples. */    for (i = 0; i < 2; i++)        aptx_qmf_polyphase_synthesis(qmf->outer_filter_signal,                                     aptx_qmf_outer_coeffs, 21,                                     intermediate_samples[0+i],                                     intermediate_samples[2+i],                                     &samples[2*i]);}  static void aptx_decode_channel(Channel *channel, int32_t samples[4]){    int32_t subband_samples[4];    int subband;    for (subband = 0; subband < NB_SUBBANDS; subband++)        subband_samples[subband] = channel->prediction[subband].previous_reconstructed_sample;    aptx_qmf_tree_synthesis(&channel->qmf, subband_samples, samples);} static void aptx_unpack_codeword(Channel *channel, uint16_t codeword){    channel->quantize[0].quantized_sample = sign_extend(codeword >>  0, 7);    channel->quantize[1].quantized_sample = sign_extend(codeword >>  7, 4);    channel->quantize[2].quantized_sample = sign_extend(codeword >> 11, 2);    channel->quantize[3].quantized_sample = sign_extend(codeword >> 13, 3);    channel->quantize[3].quantized_sample = (channel->quantize[3].quantized_sample & ~1)                                          | aptx_quantized_parity(channel);} static void aptxhd_unpack_codeword(Channel *channel, uint32_t codeword){    channel->quantize[0].quantized_sample = sign_extend(codeword >>  0, 9);    channel->quantize[1].quantized_sample = sign_extend(codeword >>  9, 6);    channel->quantize[2].quantized_sample = sign_extend(codeword >> 15, 4);    channel->quantize[3].quantized_sample = sign_extend(codeword >> 19, 5);    channel->quantize[3].quantized_sample = (channel->quantize[3].quantized_sample & ~1)                                          | aptx_quantized_parity(channel);} static int aptx_decode_samples(AptXContext *ctx,                                const uint8_t *input,                                int32_t samples[NB_CHANNELS][4]){    int channel, ret;     for (channel = 0; channel < NB_CHANNELS; channel++) {        ff_aptx_generate_dither(&ctx->channels[channel]);         if (ctx->hd)            aptxhd_unpack_codeword(&ctx->channels[channel],                                   AV_RB24(input + 3*channel));        else            aptx_unpack_codeword(&ctx->channels[channel],                                 AV_RB16(input + 2*channel));        ff_aptx_invert_quantize_and_prediction(&ctx->channels[channel], ctx->hd);    }     ret = aptx_check_parity(ctx->channels, &ctx->sync_idx);     for (channel = 0; channel < NB_CHANNELS; channel++)        aptx_decode_channel(&ctx->channels[channel], samples[channel]);     return ret;} static int aptx_decode_frame(AVCodecContext *avctx, void *data,                             int *got_frame_ptr, AVPacket *avpkt){    AptXContext *s = avctx->priv_data;    AVFrame *frame = data;    int pos, opos, channel, sample, ret;     if (avpkt->size < s->block_size) {        av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");        return AVERROR_INVALIDDATA;    }     /* get output buffer */    frame->channels = NB_CHANNELS;    frame->format = AV_SAMPLE_FMT_S32P;    frame->nb_samples = 4 * avpkt->size / s->block_size;    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)        return ret;     for (pos = 0, opos = 0; opos < frame->nb_samples; pos += s->block_size, opos += 4) {        int32_t samples[NB_CHANNELS][4];         if (aptx_decode_samples(s, &avpkt->data[pos], samples)) {            av_log(avctx, AV_LOG_ERROR, "Synchronization error\n");            return AVERROR_INVALIDDATA;        }         for (channel = 0; channel < NB_CHANNELS; channel++)            for (sample = 0; sample < 4; sample++)                AV_WN32A(&frame->data[channel][4*(opos+sample)],                         samples[channel][sample] * 256);    }     *got_frame_ptr = 1;    return s->block_size * frame->nb_samples / 4;} #if CONFIG_APTX_DECODERAVCodec ff_aptx_decoder = {    .name                  = "aptx",    .long_name             = NULL_IF_CONFIG_SMALL("aptX (Audio Processing Technology for Bluetooth)"),    .type                  = AVMEDIA_TYPE_AUDIO,    .id                    = AV_CODEC_ID_APTX,    .priv_data_size        = sizeof(AptXContext),    .init                  = ff_aptx_init,    .decode                = aptx_decode_frame,    .capabilities          = AV_CODEC_CAP_DR1,    .caps_internal         = FF_CODEC_CAP_INIT_THREADSAFE,    .channel_layouts       = (const uint64_t[]) { AV_CH_LAYOUT_STEREO, 0},    .sample_fmts           = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P,                                                             AV_SAMPLE_FMT_NONE },};#endif #if CONFIG_APTX_HD_DECODERAVCodec ff_aptx_hd_decoder = {    .name                  = "aptx_hd",    .long_name             = NULL_IF_CONFIG_SMALL("aptX HD (Audio Processing Technology for Bluetooth)"),    .type                  = AVMEDIA_TYPE_AUDIO,    .id                    = AV_CODEC_ID_APTX_HD,    .priv_data_size        = sizeof(AptXContext),    .init                  = ff_aptx_init,    .decode                = aptx_decode_frame,    .capabilities          = AV_CODEC_CAP_DR1,    .caps_internal         = FF_CODEC_CAP_INIT_THREADSAFE,    .channel_layouts       = (const uint64_t[]) { AV_CH_LAYOUT_STEREO, 0},    .sample_fmts           = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P,                                                             AV_SAMPLE_FMT_NONE },};#endif