git.sesse.net Git - ffmpeg/blob - libavcodec/aptxdec.c

   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 synthesis filter realized with a polyphase FIR filter.
  27  * Join 2 subbands and upsample by 2.
  28  * So for each 2 subbands sample that goes in, a pair of samples goes out.
  29  */
  30 av_always_inline
  31 static void aptx_qmf_polyphase_synthesis(FilterSignal signal[NB_FILTERS],
  32                                          const int32_t coeffs[NB_FILTERS][FILTER_TAPS],
  33                                          int shift,
  34                                          int32_t low_subband_input,
  35                                          int32_t high_subband_input,
  36                                          int32_t samples[NB_FILTERS])
  37 {
  38     int32_t subbands[NB_FILTERS];
  39     int i;
  40
  41     subbands[0] = low_subband_input + high_subband_input;
  42     subbands[1] = low_subband_input - high_subband_input;
  43
  44     for (i = 0; i < NB_FILTERS; i++) {
  45         aptx_qmf_filter_signal_push(&signal[i], subbands[1-i]);
  46         samples[i] = aptx_qmf_convolution(&signal[i], coeffs[i], shift);
  47     }
  48 }
  49
  50 /*
  51  * Two stage QMF synthesis tree.
  52  * Join 4 subbands and upsample by 4.
  53  * So for each 4 subbands sample that goes in, a group of 4 samples goes out.
  54  */
  55 static void aptx_qmf_tree_synthesis(QMFAnalysis *qmf,
  56                                     int32_t subband_samples[4],
  57                                     int32_t samples[4])
  58 {
  59     int32_t intermediate_samples[4];
  60     int i;
  61
  62     /* Join 4 subbands into 2 intermediate subbands upsampled to 2 samples. */
  63     for (i = 0; i < 2; i++)
  64         aptx_qmf_polyphase_synthesis(qmf->inner_filter_signal[i],
  65                                      aptx_qmf_inner_coeffs, 22,
  66                                      subband_samples[2*i+0],
  67                                      subband_samples[2*i+1],
  68                                      &intermediate_samples[2*i]);
  69
  70     /* Join 2 samples from intermediate subbands upsampled to 4 samples. */
  71     for (i = 0; i < 2; i++)
  72         aptx_qmf_polyphase_synthesis(qmf->outer_filter_signal,
  73                                      aptx_qmf_outer_coeffs, 21,
  74                                      intermediate_samples[0+i],
  75                                      intermediate_samples[2+i],
  76                                      &samples[2*i]);
  77 }
  78
  79
  80 static void aptx_decode_channel(Channel *channel, int32_t samples[4])
  81 {
  82     int32_t subband_samples[4];
  83     int subband;
  84     for (subband = 0; subband < NB_SUBBANDS; subband++)
  85         subband_samples[subband] = channel->prediction[subband].previous_reconstructed_sample;
  86     aptx_qmf_tree_synthesis(&channel->qmf, subband_samples, samples);
  87 }
  88
  89 static void aptx_unpack_codeword(Channel *channel, uint16_t codeword)
  90 {
  91     channel->quantize[0].quantized_sample = sign_extend(codeword >>  0, 7);
  92     channel->quantize[1].quantized_sample = sign_extend(codeword >>  7, 4);
  93     channel->quantize[2].quantized_sample = sign_extend(codeword >> 11, 2);
  94     channel->quantize[3].quantized_sample = sign_extend(codeword >> 13, 3);
  95     channel->quantize[3].quantized_sample = (channel->quantize[3].quantized_sample & ~1)
  96                                           | aptx_quantized_parity(channel);
  97 }
  98
  99 static void aptxhd_unpack_codeword(Channel *channel, uint32_t codeword)
 100 {
 101     channel->quantize[0].quantized_sample = sign_extend(codeword >>  0, 9);
 102     channel->quantize[1].quantized_sample = sign_extend(codeword >>  9, 6);
 103     channel->quantize[2].quantized_sample = sign_extend(codeword >> 15, 4);
 104     channel->quantize[3].quantized_sample = sign_extend(codeword >> 19, 5);
 105     channel->quantize[3].quantized_sample = (channel->quantize[3].quantized_sample & ~1)
 106                                           | aptx_quantized_parity(channel);
 107 }
 108
 109 static int aptx_decode_samples(AptXContext *ctx,
 110                                 const uint8_t *input,
 111                                 int32_t samples[NB_CHANNELS][4])
 112 {
 113     int channel, ret;
 114
 115     for (channel = 0; channel < NB_CHANNELS; channel++) {
 116         ff_aptx_generate_dither(&ctx->channels[channel]);
 117
 118         if (ctx->hd)
 119             aptxhd_unpack_codeword(&ctx->channels[channel],
 120                                    AV_RB24(input + 3*channel));
 121         else
 122             aptx_unpack_codeword(&ctx->channels[channel],
 123                                  AV_RB16(input + 2*channel));
 124         ff_aptx_invert_quantize_and_prediction(&ctx->channels[channel], ctx->hd);
 125     }
 126
 127     ret = aptx_check_parity(ctx->channels, &ctx->sync_idx);
 128
 129     for (channel = 0; channel < NB_CHANNELS; channel++)
 130         aptx_decode_channel(&ctx->channels[channel], samples[channel]);
 131
 132     return ret;
 133 }
 134
 135 static int aptx_decode_frame(AVCodecContext *avctx, void *data,
 136                              int *got_frame_ptr, AVPacket *avpkt)
 137 {
 138     AptXContext *s = avctx->priv_data;
 139     AVFrame *frame = data;
 140     int pos, opos, channel, sample, ret;
 141
 142     if (avpkt->size < s->block_size) {
 143         av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
 144         return AVERROR_INVALIDDATA;
 145     }
 146
 147     /* get output buffer */
 148     frame->channels = NB_CHANNELS;
 149     frame->format = AV_SAMPLE_FMT_S32P;
 150     frame->nb_samples = 4 * avpkt->size / s->block_size;
 151     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
 152         return ret;
 153
 154     for (pos = 0, opos = 0; opos < frame->nb_samples; pos += s->block_size, opos += 4) {
 155         int32_t samples[NB_CHANNELS][4];
 156
 157         if (aptx_decode_samples(s, &avpkt->data[pos], samples)) {
 158             av_log(avctx, AV_LOG_ERROR, "Synchronization error\n");
 159             return AVERROR_INVALIDDATA;
 160         }
 161
 162         for (channel = 0; channel < NB_CHANNELS; channel++)
 163             for (sample = 0; sample < 4; sample++)
 164                 AV_WN32A(&frame->data[channel][4*(opos+sample)],
 165                          samples[channel][sample] * 256);
 166     }
 167
 168     *got_frame_ptr = 1;
 169     return s->block_size * frame->nb_samples / 4;
 170 }
 171
 172 #if CONFIG_APTX_DECODER
 173 const AVCodec ff_aptx_decoder = {
 174     .name                  = "aptx",
 175     .long_name             = NULL_IF_CONFIG_SMALL("aptX (Audio Processing Technology for Bluetooth)"),
 176     .type                  = AVMEDIA_TYPE_AUDIO,
 177     .id                    = AV_CODEC_ID_APTX,
 178     .priv_data_size        = sizeof(AptXContext),
 179     .init                  = ff_aptx_init,
 180     .decode                = aptx_decode_frame,
 181     .capabilities          = AV_CODEC_CAP_DR1,
 182     .caps_internal         = FF_CODEC_CAP_INIT_THREADSAFE,
 183     .channel_layouts       = (const uint64_t[]) { AV_CH_LAYOUT_STEREO, 0},
 184     .sample_fmts           = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P,
 185                                                              AV_SAMPLE_FMT_NONE },
 186 };
 187 #endif
 188
 189 #if CONFIG_APTX_HD_DECODER
 190 const AVCodec ff_aptx_hd_decoder = {
 191     .name                  = "aptx_hd",
 192     .long_name             = NULL_IF_CONFIG_SMALL("aptX HD (Audio Processing Technology for Bluetooth)"),
 193     .type                  = AVMEDIA_TYPE_AUDIO,
 194     .id                    = AV_CODEC_ID_APTX_HD,
 195     .priv_data_size        = sizeof(AptXContext),
 196     .init                  = ff_aptx_init,
 197     .decode                = aptx_decode_frame,
 198     .capabilities          = AV_CODEC_CAP_DR1,
 199     .caps_internal         = FF_CODEC_CAP_INIT_THREADSAFE,
 200     .channel_layouts       = (const uint64_t[]) { AV_CH_LAYOUT_STEREO, 0},
 201     .sample_fmts           = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P,
 202                                                              AV_SAMPLE_FMT_NONE },
 203 };
 204 #endif