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