/* * 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 */ #ifndef AVCODEC_APTX_H#define AVCODEC_APTX_H #include "libavutil/intreadwrite.h"#include "avcodec.h"#include "mathops.h"  enum channels {    LEFT,    RIGHT,    NB_CHANNELS}; enum subbands {    LF,  // Low Frequency (0-5.5 kHz)    MLF, // Medium-Low Frequency (5.5-11kHz)    MHF, // Medium-High Frequency (11-16.5kHz)    HF,  // High Frequency (16.5-22kHz)    NB_SUBBANDS}; #define NB_FILTERS 2#define FILTER_TAPS 16 typedef struct {    int pos;    int32_t buffer[2*FILTER_TAPS];} FilterSignal; typedef struct {    FilterSignal outer_filter_signal[NB_FILTERS];    FilterSignal inner_filter_signal[NB_FILTERS][NB_FILTERS];} QMFAnalysis; typedef struct {    int32_t quantized_sample;    int32_t quantized_sample_parity_change;    int32_t error;} Quantize; typedef struct {    int32_t quantization_factor;    int32_t factor_select;    int32_t reconstructed_difference;} InvertQuantize; typedef struct {    int32_t prev_sign[2];    int32_t s_weight[2];    int32_t d_weight[24];    int32_t pos;    int32_t reconstructed_differences[48];    int32_t previous_reconstructed_sample;    int32_t predicted_difference;    int32_t predicted_sample;} Prediction; typedef struct {    int32_t codeword_history;    int32_t dither_parity;    int32_t dither[NB_SUBBANDS];     QMFAnalysis qmf;    Quantize quantize[NB_SUBBANDS];    InvertQuantize invert_quantize[NB_SUBBANDS];    Prediction prediction[NB_SUBBANDS];} Channel; typedef struct {    int hd;    int block_size;    int32_t sync_idx;    Channel channels[NB_CHANNELS];} AptXContext; typedef const struct {    const int32_t *quantize_intervals;    const int32_t *invert_quantize_dither_factors;    const int32_t *quantize_dither_factors;    const int16_t *quantize_factor_select_offset;    int tables_size;    int32_t factor_max;    int32_t prediction_order;} ConstTables; extern ConstTables ff_aptx_quant_tables[2][NB_SUBBANDS]; /* Rounded right shift with optionnal clipping */#define RSHIFT_SIZE(size)                                                     \av_always_inline                                                              \static int##size##_t rshift##size(int##size##_t value, int shift)             \{                                                                             \    int##size##_t rounding = (int##size##_t)1 << (shift - 1);                 \    int##size##_t mask = ((int##size##_t)1 << (shift + 1)) - 1;               \    return ((value + rounding) >> shift) - ((value & mask) == rounding);      \}                                                                             \av_always_inline                                                              \static int##size##_t rshift##size##_clip24(int##size##_t value, int shift)    \{                                                                             \    return av_clip_intp2(rshift##size(value, shift), 23);                     \}RSHIFT_SIZE(32)RSHIFT_SIZE(64) /* * Convolution filter coefficients for the outer QMF of the QMF tree. * The 2 sets are a mirror of each other. */static const int32_t aptx_qmf_outer_coeffs[NB_FILTERS][FILTER_TAPS] = {    {        730, -413, -9611, 43626, -121026, 269973, -585547, 2801966,        697128, -160481, 27611, 8478, -10043, 3511, 688, -897,    },    {        -897, 688, 3511, -10043, 8478, 27611, -160481, 697128,        2801966, -585547, 269973, -121026, 43626, -9611, -413, 730,    },}; /* * Convolution filter coefficients for the inner QMF of the QMF tree. * The 2 sets are a mirror of each other. */static const int32_t aptx_qmf_inner_coeffs[NB_FILTERS][FILTER_TAPS] = {    {       1033, -584, -13592, 61697, -171156, 381799, -828088, 3962579,       985888, -226954, 39048, 11990, -14203, 4966, 973, -1268,    },    {      -1268, 973, 4966, -14203, 11990, 39048, -226954, 985888,      3962579, -828088, 381799, -171156, 61697, -13592, -584, 1033,    },}; /* * Push one sample into a circular signal buffer. */av_always_inlinestatic void aptx_qmf_filter_signal_push(FilterSignal *signal, int32_t sample){    signal->buffer[signal->pos            ] = sample;    signal->buffer[signal->pos+FILTER_TAPS] = sample;    signal->pos = (signal->pos + 1) & (FILTER_TAPS - 1);} /* * Compute the convolution of the signal with the coefficients, and reduce * to 24 bits by applying the specified right shifting. */av_always_inlinestatic int32_t aptx_qmf_convolution(FilterSignal *signal,                                    const int32_t coeffs[FILTER_TAPS],                                    int shift){    int32_t *sig = &signal->buffer[signal->pos];    int64_t e = 0;    int i;     for (i = 0; i < FILTER_TAPS; i++)        e += MUL64(sig[i], coeffs[i]);     return rshift64_clip24(e, shift);} static inline int32_t aptx_quantized_parity(Channel *channel){    int32_t parity = channel->dither_parity;    int subband;     for (subband = 0; subband < NB_SUBBANDS; subband++)        parity ^= channel->quantize[subband].quantized_sample;     return parity & 1;} /* For each sample, ensure that the parity of all subbands of all channels * is 0 except once every 8 samples where the parity is forced to 1. */static inline int aptx_check_parity(Channel channels[NB_CHANNELS], int32_t *idx){    int32_t parity = aptx_quantized_parity(&channels[LEFT])                   ^ aptx_quantized_parity(&channels[RIGHT]);     int eighth = *idx == 7;    *idx = (*idx + 1) & 7;     return parity ^ eighth;} void ff_aptx_invert_quantize_and_prediction(Channel *channel, int hd);void ff_aptx_generate_dither(Channel *channel); int ff_aptx_init(AVCodecContext *avctx); #endif /* AVCODEC_APTX_H */