LCOV - code coverage report
Current view: top level - libavcodec - aptx.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 261 0.0 %
Date: 2017-12-10 21:22:29 Functions: 0 32 0.0 %

          Line data    Source code
       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 "libavutil/intreadwrite.h"
      24             : #include "avcodec.h"
      25             : #include "internal.h"
      26             : #include "mathops.h"
      27             : #include "audio_frame_queue.h"
      28             : 
      29             : 
      30             : enum channels {
      31             :     LEFT,
      32             :     RIGHT,
      33             :     NB_CHANNELS
      34             : };
      35             : 
      36             : enum subbands {
      37             :     LF,  // Low Frequency (0-5.5 kHz)
      38             :     MLF, // Medium-Low Frequency (5.5-11kHz)
      39             :     MHF, // Medium-High Frequency (11-16.5kHz)
      40             :     HF,  // High Frequency (16.5-22kHz)
      41             :     NB_SUBBANDS
      42             : };
      43             : 
      44             : #define NB_FILTERS 2
      45             : #define FILTER_TAPS 16
      46             : 
      47             : typedef struct {
      48             :     int pos;
      49             :     int32_t buffer[2*FILTER_TAPS];
      50             : } FilterSignal;
      51             : 
      52             : typedef struct {
      53             :     FilterSignal outer_filter_signal[NB_FILTERS];
      54             :     FilterSignal inner_filter_signal[NB_FILTERS][NB_FILTERS];
      55             : } QMFAnalysis;
      56             : 
      57             : typedef struct {
      58             :     int32_t quantized_sample;
      59             :     int32_t quantized_sample_parity_change;
      60             :     int32_t error;
      61             : } Quantize;
      62             : 
      63             : typedef struct {
      64             :     int32_t quantization_factor;
      65             :     int32_t factor_select;
      66             :     int32_t reconstructed_difference;
      67             : } InvertQuantize;
      68             : 
      69             : typedef struct {
      70             :     int32_t prev_sign[2];
      71             :     int32_t s_weight[2];
      72             :     int32_t d_weight[24];
      73             :     int32_t pos;
      74             :     int32_t reconstructed_differences[48];
      75             :     int32_t previous_reconstructed_sample;
      76             :     int32_t predicted_difference;
      77             :     int32_t predicted_sample;
      78             : } Prediction;
      79             : 
      80             : typedef struct {
      81             :     int32_t codeword_history;
      82             :     int32_t dither_parity;
      83             :     int32_t dither[NB_SUBBANDS];
      84             : 
      85             :     QMFAnalysis qmf;
      86             :     Quantize quantize[NB_SUBBANDS];
      87             :     InvertQuantize invert_quantize[NB_SUBBANDS];
      88             :     Prediction prediction[NB_SUBBANDS];
      89             : } Channel;
      90             : 
      91             : typedef struct {
      92             :     int32_t sync_idx;
      93             :     Channel channels[NB_CHANNELS];
      94             :     AudioFrameQueue afq;
      95             : } AptXContext;
      96             : 
      97             : 
      98             : static const int32_t quantize_intervals_LF[65] = {
      99             :       -9948,    9948,   29860,   49808,   69822,   89926,  110144,  130502,
     100             :      151026,  171738,  192666,  213832,  235264,  256982,  279014,  301384,
     101             :      324118,  347244,  370790,  394782,  419250,  444226,  469742,  495832,
     102             :      522536,  549890,  577936,  606720,  636290,  666700,  698006,  730270,
     103             :      763562,  797958,  833538,  870398,  908640,  948376,  989740, 1032874,
     104             :     1077948, 1125150, 1174700, 1226850, 1281900, 1340196, 1402156, 1468282,
     105             :     1539182, 1615610, 1698514, 1789098, 1888944, 2000168, 2125700, 2269750,
     106             :     2438670, 2642660, 2899462, 3243240, 3746078, 4535138, 5664098, 7102424,
     107             :     8897462,
     108             : };
     109             : static const int32_t invert_quantize_dither_factors_LF[65] = {
     110             :        9948,   9948,   9962,   9988,  10026,  10078,  10142,  10218,
     111             :       10306,  10408,  10520,  10646,  10784,  10934,  11098,  11274,
     112             :       11462,  11664,  11880,  12112,  12358,  12618,  12898,  13194,
     113             :       13510,  13844,  14202,  14582,  14988,  15422,  15884,  16380,
     114             :       16912,  17484,  18098,  18762,  19480,  20258,  21106,  22030,
     115             :       23044,  24158,  25390,  26760,  28290,  30008,  31954,  34172,
     116             :       36728,  39700,  43202,  47382,  52462,  58762,  66770,  77280,
     117             :       91642, 112348, 144452, 199326, 303512, 485546, 643414, 794914,
     118             :     1000124,
     119             : };
     120             : static const int32_t quantize_dither_factors_LF[65] = {
     121             :         0,     4,     7,    10,    13,    16,    19,    22,
     122             :        26,    28,    32,    35,    38,    41,    44,    47,
     123             :        51,    54,    58,    62,    65,    70,    74,    79,
     124             :        84,    90,    95,   102,   109,   116,   124,   133,
     125             :       143,   154,   166,   180,   195,   212,   231,   254,
     126             :       279,   308,   343,   383,   430,   487,   555,   639,
     127             :       743,   876,  1045,  1270,  1575,  2002,  2628,  3591,
     128             :      5177,  8026, 13719, 26047, 45509, 39467, 37875, 51303,
     129             :         0,
     130             : };
     131             : static const int16_t quantize_factor_select_offset_LF[65] = {
     132             :       0, -21, -19, -17, -15, -12, -10,  -8,
     133             :      -6,  -4,  -1,   1,   3,   6,   8,  10,
     134             :      13,  15,  18,  20,  23,  26,  29,  31,
     135             :      34,  37,  40,  43,  47,  50,  53,  57,
     136             :      60,  64,  68,  72,  76,  80,  85,  89,
     137             :      94,  99, 105, 110, 116, 123, 129, 136,
     138             :     144, 152, 161, 171, 182, 194, 207, 223,
     139             :     241, 263, 291, 328, 382, 467, 522, 522,
     140             :     522,
     141             : };
     142             : 
     143             : 
     144             : static const int32_t quantize_intervals_MLF[9] = {
     145             :     -89806, 89806, 278502, 494338, 759442, 1113112, 1652322, 2720256, 5190186,
     146             : };
     147             : static const int32_t invert_quantize_dither_factors_MLF[9] = {
     148             :     89806, 89806, 98890, 116946, 148158, 205512, 333698, 734236, 1735696,
     149             : };
     150             : static const int32_t quantize_dither_factors_MLF[9] = {
     151             :     0, 2271, 4514, 7803, 14339, 32047, 100135, 250365, 0,
     152             : };
     153             : static const int16_t quantize_factor_select_offset_MLF[9] = {
     154             :     0, -14, 6, 29, 58, 96, 154, 270, 521,
     155             : };
     156             : 
     157             : 
     158             : static const int32_t quantize_intervals_MHF[3] = {
     159             :     -194080, 194080, 890562,
     160             : };
     161             : static const int32_t invert_quantize_dither_factors_MHF[3] = {
     162             :     194080, 194080, 502402,
     163             : };
     164             : static const int32_t quantize_dither_factors_MHF[3] = {
     165             :     0, 77081, 0,
     166             : };
     167             : static const int16_t quantize_factor_select_offset_MHF[3] = {
     168             :     0, -33, 136,
     169             : };
     170             : 
     171             : 
     172             : static const int32_t quantize_intervals_HF[5] = {
     173             :     -163006, 163006, 542708, 1120554, 2669238,
     174             : };
     175             : static const int32_t invert_quantize_dither_factors_HF[5] = {
     176             :     163006, 163006, 216698, 361148, 1187538,
     177             : };
     178             : static const int32_t quantize_dither_factors_HF[5] = {
     179             :     0, 13423, 36113, 206598, 0,
     180             : };
     181             : static const int16_t quantize_factor_select_offset_HF[5] = {
     182             :     0, -8, 33, 95, 262,
     183             : };
     184             : 
     185             : typedef const struct {
     186             :     const int32_t *quantize_intervals;
     187             :     const int32_t *invert_quantize_dither_factors;
     188             :     const int32_t *quantize_dither_factors;
     189             :     const int16_t *quantize_factor_select_offset;
     190             :     int tables_size;
     191             :     int32_t quantized_bits;
     192             :     int32_t prediction_order;
     193             : } ConstTables;
     194             : 
     195             : static ConstTables tables[NB_SUBBANDS] = {
     196             :     [LF]  = { quantize_intervals_LF,
     197             :               invert_quantize_dither_factors_LF,
     198             :               quantize_dither_factors_LF,
     199             :               quantize_factor_select_offset_LF,
     200             :               FF_ARRAY_ELEMS(quantize_intervals_LF),
     201             :               7, 24 },
     202             :     [MLF] = { quantize_intervals_MLF,
     203             :               invert_quantize_dither_factors_MLF,
     204             :               quantize_dither_factors_MLF,
     205             :               quantize_factor_select_offset_MLF,
     206             :               FF_ARRAY_ELEMS(quantize_intervals_MLF),
     207             :               4, 12 },
     208             :     [MHF] = { quantize_intervals_MHF,
     209             :               invert_quantize_dither_factors_MHF,
     210             :               quantize_dither_factors_MHF,
     211             :               quantize_factor_select_offset_MHF,
     212             :               FF_ARRAY_ELEMS(quantize_intervals_MHF),
     213             :               2, 6 },
     214             :     [HF]  = { quantize_intervals_HF,
     215             :               invert_quantize_dither_factors_HF,
     216             :               quantize_dither_factors_HF,
     217             :               quantize_factor_select_offset_HF,
     218             :               FF_ARRAY_ELEMS(quantize_intervals_HF),
     219             :               3, 12 },
     220             : };
     221             : 
     222             : static const int16_t quantization_factors[32] = {
     223             :     2048, 2093, 2139, 2186, 2233, 2282, 2332, 2383,
     224             :     2435, 2489, 2543, 2599, 2656, 2714, 2774, 2834,
     225             :     2896, 2960, 3025, 3091, 3158, 3228, 3298, 3371,
     226             :     3444, 3520, 3597, 3676, 3756, 3838, 3922, 4008,
     227             : };
     228             : 
     229             : 
     230             : /* Rounded right shift with optionnal clipping */
     231             : #define RSHIFT_SIZE(size)                                                     \
     232             : av_always_inline                                                              \
     233             : static int##size##_t rshift##size(int##size##_t value, int shift)             \
     234             : {                                                                             \
     235             :     int##size##_t rounding = (int##size##_t)1 << (shift - 1);                 \
     236             :     int##size##_t mask = ((int##size##_t)1 << (shift + 1)) - 1;               \
     237             :     return ((value + rounding) >> shift) - ((value & mask) == rounding);      \
     238             : }                                                                             \
     239             : av_always_inline                                                              \
     240             : static int##size##_t rshift##size##_clip24(int##size##_t value, int shift)    \
     241             : {                                                                             \
     242             :     return av_clip_intp2(rshift##size(value, shift), 23);                     \
     243             : }
     244           0 : RSHIFT_SIZE(32)
     245           0 : RSHIFT_SIZE(64)
     246             : 
     247             : 
     248             : av_always_inline
     249           0 : static void aptx_update_codeword_history(Channel *channel)
     250             : {
     251           0 :     int32_t cw = ((channel->quantize[0].quantized_sample & 3) << 0) +
     252           0 :                  ((channel->quantize[1].quantized_sample & 2) << 1) +
     253           0 :                  ((channel->quantize[2].quantized_sample & 1) << 3);
     254           0 :     channel->codeword_history = (cw << 8) + (channel->codeword_history << 4);
     255           0 : }
     256             : 
     257           0 : static void aptx_generate_dither(Channel *channel)
     258             : {
     259             :     int subband;
     260             :     int64_t m;
     261             :     int32_t d;
     262             : 
     263           0 :     aptx_update_codeword_history(channel);
     264             : 
     265           0 :     m = (int64_t)5184443 * (channel->codeword_history >> 7);
     266           0 :     d = (m << 2) + (m >> 22);
     267           0 :     for (subband = 0; subband < NB_SUBBANDS; subband++)
     268           0 :         channel->dither[subband] = d << (23 - 5*subband);
     269           0 :     channel->dither_parity = (d >> 25) & 1;
     270           0 : }
     271             : 
     272             : /*
     273             :  * Convolution filter coefficients for the outer QMF of the QMF tree.
     274             :  * The 2 sets are a mirror of each other.
     275             :  */
     276             : static const int32_t aptx_qmf_outer_coeffs[NB_FILTERS][FILTER_TAPS] = {
     277             :     {
     278             :         730, -413, -9611, 43626, -121026, 269973, -585547, 2801966,
     279             :         697128, -160481, 27611, 8478, -10043, 3511, 688, -897,
     280             :     },
     281             :     {
     282             :         -897, 688, 3511, -10043, 8478, 27611, -160481, 697128,
     283             :         2801966, -585547, 269973, -121026, 43626, -9611, -413, 730,
     284             :     },
     285             : };
     286             : 
     287             : /*
     288             :  * Convolution filter coefficients for the inner QMF of the QMF tree.
     289             :  * The 2 sets are a mirror of each other.
     290             :  */
     291             : static const int32_t aptx_qmf_inner_coeffs[NB_FILTERS][FILTER_TAPS] = {
     292             :     {
     293             :        1033, -584, -13592, 61697, -171156, 381799, -828088, 3962579,
     294             :        985888, -226954, 39048, 11990, -14203, 4966, 973, -1268,
     295             :     },
     296             :     {
     297             :       -1268, 973, 4966, -14203, 11990, 39048, -226954, 985888,
     298             :       3962579, -828088, 381799, -171156, 61697, -13592, -584, 1033,
     299             :     },
     300             : };
     301             : 
     302             : /*
     303             :  * Push one sample into a circular signal buffer.
     304             :  */
     305             : av_always_inline
     306           0 : static void aptx_qmf_filter_signal_push(FilterSignal *signal, int32_t sample)
     307             : {
     308           0 :     signal->buffer[signal->pos            ] = sample;
     309           0 :     signal->buffer[signal->pos+FILTER_TAPS] = sample;
     310           0 :     signal->pos = (signal->pos + 1) & (FILTER_TAPS - 1);
     311           0 : }
     312             : 
     313             : /*
     314             :  * Compute the convolution of the signal with the coefficients, and reduce
     315             :  * to 24 bits by applying the specified right shifting.
     316             :  */
     317             : av_always_inline
     318           0 : static int32_t aptx_qmf_convolution(FilterSignal *signal,
     319             :                                     const int32_t coeffs[FILTER_TAPS],
     320             :                                     int shift)
     321             : {
     322           0 :     int32_t *sig = &signal->buffer[signal->pos];
     323           0 :     int64_t e = 0;
     324             :     int i;
     325             : 
     326           0 :     for (i = 0; i < FILTER_TAPS; i++)
     327           0 :         e += MUL64(sig[i], coeffs[i]);
     328             : 
     329           0 :     return rshift64_clip24(e, shift);
     330             : }
     331             : 
     332             : /*
     333             :  * Half-band QMF analysis filter realized with a polyphase FIR filter.
     334             :  * Split into 2 subbands and downsample by 2.
     335             :  * So for each pair of samples that goes in, one sample goes out,
     336             :  * split into 2 separate subbands.
     337             :  */
     338             : av_always_inline
     339           0 : static void aptx_qmf_polyphase_analysis(FilterSignal signal[NB_FILTERS],
     340             :                                         const int32_t coeffs[NB_FILTERS][FILTER_TAPS],
     341             :                                         int shift,
     342             :                                         int32_t samples[NB_FILTERS],
     343             :                                         int32_t *low_subband_output,
     344             :                                         int32_t *high_subband_output)
     345             : {
     346             :     int32_t subbands[NB_FILTERS];
     347             :     int i;
     348             : 
     349           0 :     for (i = 0; i < NB_FILTERS; i++) {
     350           0 :         aptx_qmf_filter_signal_push(&signal[i], samples[NB_FILTERS-1-i]);
     351           0 :         subbands[i] = aptx_qmf_convolution(&signal[i], coeffs[i], shift);
     352             :     }
     353             : 
     354           0 :     *low_subband_output  = av_clip_intp2(subbands[0] + subbands[1], 23);
     355           0 :     *high_subband_output = av_clip_intp2(subbands[0] - subbands[1], 23);
     356           0 : }
     357             : 
     358             : /*
     359             :  * Two stage QMF analysis tree.
     360             :  * Split 4 input samples into 4 subbands and downsample by 4.
     361             :  * So for each group of 4 samples that goes in, one sample goes out,
     362             :  * split into 4 separate subbands.
     363             :  */
     364           0 : static void aptx_qmf_tree_analysis(QMFAnalysis *qmf,
     365             :                                    int32_t samples[4],
     366             :                                    int32_t subband_samples[4])
     367             : {
     368             :     int32_t intermediate_samples[4];
     369             :     int i;
     370             : 
     371             :     /* Split 4 input samples into 2 intermediate subbands downsampled to 2 samples */
     372           0 :     for (i = 0; i < 2; i++)
     373           0 :         aptx_qmf_polyphase_analysis(qmf->outer_filter_signal,
     374             :                                     aptx_qmf_outer_coeffs, 23,
     375             :                                     &samples[2*i],
     376             :                                     &intermediate_samples[0+i],
     377           0 :                                     &intermediate_samples[2+i]);
     378             : 
     379             :     /* Split 2 intermediate subband samples into 4 final subbands downsampled to 1 sample */
     380           0 :     for (i = 0; i < 2; i++)
     381           0 :         aptx_qmf_polyphase_analysis(qmf->inner_filter_signal[i],
     382             :                                     aptx_qmf_inner_coeffs, 23,
     383           0 :                                     &intermediate_samples[2*i],
     384             :                                     &subband_samples[2*i+0],
     385           0 :                                     &subband_samples[2*i+1]);
     386           0 : }
     387             : 
     388             : /*
     389             :  * Half-band QMF synthesis filter realized with a polyphase FIR filter.
     390             :  * Join 2 subbands and upsample by 2.
     391             :  * So for each 2 subbands sample that goes in, a pair of samples goes out.
     392             :  */
     393             : av_always_inline
     394           0 : static void aptx_qmf_polyphase_synthesis(FilterSignal signal[NB_FILTERS],
     395             :                                          const int32_t coeffs[NB_FILTERS][FILTER_TAPS],
     396             :                                          int shift,
     397             :                                          int32_t low_subband_input,
     398             :                                          int32_t high_subband_input,
     399             :                                          int32_t samples[NB_FILTERS])
     400             : {
     401             :     int32_t subbands[NB_FILTERS];
     402             :     int i;
     403             : 
     404           0 :     subbands[0] = low_subband_input + high_subband_input;
     405           0 :     subbands[1] = low_subband_input - high_subband_input;
     406             : 
     407           0 :     for (i = 0; i < NB_FILTERS; i++) {
     408           0 :         aptx_qmf_filter_signal_push(&signal[i], subbands[1-i]);
     409           0 :         samples[i] = aptx_qmf_convolution(&signal[i], coeffs[i], shift);
     410             :     }
     411           0 : }
     412             : 
     413             : /*
     414             :  * Two stage QMF synthesis tree.
     415             :  * Join 4 subbands and upsample by 4.
     416             :  * So for each 4 subbands sample that goes in, a group of 4 samples goes out.
     417             :  */
     418           0 : static void aptx_qmf_tree_synthesis(QMFAnalysis *qmf,
     419             :                                     int32_t subband_samples[4],
     420             :                                     int32_t samples[4])
     421             : {
     422             :     int32_t intermediate_samples[4];
     423             :     int i;
     424             : 
     425             :     /* Join 4 subbands into 2 intermediate subbands upsampled to 2 samples. */
     426           0 :     for (i = 0; i < 2; i++)
     427           0 :         aptx_qmf_polyphase_synthesis(qmf->inner_filter_signal[i],
     428             :                                      aptx_qmf_inner_coeffs, 22,
     429           0 :                                      subband_samples[2*i+0],
     430           0 :                                      subband_samples[2*i+1],
     431           0 :                                      &intermediate_samples[2*i]);
     432             : 
     433             :     /* Join 2 samples from intermediate subbands upsampled to 4 samples. */
     434           0 :     for (i = 0; i < 2; i++)
     435           0 :         aptx_qmf_polyphase_synthesis(qmf->outer_filter_signal,
     436             :                                      aptx_qmf_outer_coeffs, 21,
     437             :                                      intermediate_samples[0+i],
     438           0 :                                      intermediate_samples[2+i],
     439             :                                      &samples[2*i]);
     440           0 : }
     441             : 
     442             : 
     443             : av_always_inline
     444           0 : static int32_t aptx_bin_search(int32_t value, int32_t factor,
     445             :                                const int32_t *intervals, int32_t nb_intervals)
     446             : {
     447           0 :     int32_t idx = 0;
     448             :     int i;
     449             : 
     450           0 :     for (i = nb_intervals >> 1; i > 0; i >>= 1)
     451           0 :         if (MUL64(factor, intervals[idx + i]) <= ((int64_t)value << 24))
     452           0 :             idx += i;
     453             : 
     454           0 :     return idx;
     455             : }
     456             : 
     457           0 : static void aptx_quantize_difference(Quantize *quantize,
     458             :                                      int32_t sample_difference,
     459             :                                      int32_t dither,
     460             :                                      int32_t quantization_factor,
     461             :                                      ConstTables *tables)
     462             : {
     463           0 :     const int32_t *intervals = tables->quantize_intervals;
     464             :     int32_t quantized_sample, dithered_sample, parity_change;
     465             :     int32_t d, mean, interval, inv;
     466             :     int64_t error;
     467             : 
     468           0 :     quantized_sample = aptx_bin_search(FFABS(sample_difference) >> 4,
     469             :                                        quantization_factor,
     470             :                                        intervals, tables->tables_size);
     471             : 
     472           0 :     d = rshift32_clip24(MULH(dither, dither), 7) - (1 << 23);
     473           0 :     d = rshift64(MUL64(d, tables->quantize_dither_factors[quantized_sample]), 23);
     474             : 
     475           0 :     intervals += quantized_sample;
     476           0 :     mean = (intervals[1] + intervals[0]) / 2;
     477           0 :     interval = (intervals[1] - intervals[0]) * (-(sample_difference < 0) | 1);
     478             : 
     479           0 :     dithered_sample = rshift64_clip24(MUL64(dither, interval) + ((int64_t)(mean + d) << 32), 32);
     480           0 :     error = ((int64_t)FFABS(sample_difference) << 20) - MUL64(dithered_sample, quantization_factor);
     481           0 :     quantize->error = FFABS(rshift64(error, 23));
     482             : 
     483           0 :     parity_change = quantized_sample;
     484           0 :     if (error < 0)
     485           0 :         quantized_sample--;
     486             :     else
     487           0 :         parity_change--;
     488             : 
     489           0 :     inv = -(sample_difference < 0);
     490           0 :     quantize->quantized_sample               = quantized_sample ^ inv;
     491           0 :     quantize->quantized_sample_parity_change = parity_change    ^ inv;
     492           0 : }
     493             : 
     494           0 : static void aptx_encode_channel(Channel *channel, int32_t samples[4])
     495             : {
     496             :     int32_t subband_samples[4];
     497             :     int subband;
     498           0 :     aptx_qmf_tree_analysis(&channel->qmf, samples, subband_samples);
     499           0 :     aptx_generate_dither(channel);
     500           0 :     for (subband = 0; subband < NB_SUBBANDS; subband++) {
     501           0 :         int32_t diff = av_clip_intp2(subband_samples[subband] - channel->prediction[subband].predicted_sample, 23);
     502           0 :         aptx_quantize_difference(&channel->quantize[subband], diff,
     503             :                                  channel->dither[subband],
     504             :                                  channel->invert_quantize[subband].quantization_factor,
     505             :                                  &tables[subband]);
     506             :     }
     507           0 : }
     508             : 
     509           0 : static void aptx_decode_channel(Channel *channel, int32_t samples[4])
     510             : {
     511             :     int32_t subband_samples[4];
     512             :     int subband;
     513           0 :     for (subband = 0; subband < NB_SUBBANDS; subband++)
     514           0 :         subband_samples[subband] = channel->prediction[subband].previous_reconstructed_sample;
     515           0 :     aptx_qmf_tree_synthesis(&channel->qmf, subband_samples, samples);
     516           0 : }
     517             : 
     518             : 
     519           0 : static void aptx_invert_quantization(InvertQuantize *invert_quantize,
     520             :                                      int32_t quantized_sample, int32_t dither,
     521             :                                      ConstTables *tables)
     522             : {
     523             :     int32_t qr, idx, shift, factor_select;
     524             : 
     525           0 :     idx = (quantized_sample ^ -(quantized_sample < 0)) + 1;
     526           0 :     qr = tables->quantize_intervals[idx] / 2;
     527           0 :     if (quantized_sample < 0)
     528           0 :         qr = -qr;
     529             : 
     530           0 :     qr = rshift64_clip24(((int64_t)qr<<32) + MUL64(dither, tables->invert_quantize_dither_factors[idx]), 32);
     531           0 :     invert_quantize->reconstructed_difference = MUL64(invert_quantize->quantization_factor, qr) >> 19;
     532             : 
     533           0 :     shift = 24 - tables->quantized_bits;
     534             : 
     535             :     /* update factor_select */
     536           0 :     factor_select = 32620 * invert_quantize->factor_select;
     537           0 :     factor_select = rshift32(factor_select + (tables->quantize_factor_select_offset[idx] << 15), 15);
     538           0 :     invert_quantize->factor_select = av_clip(factor_select, 0, (shift << 8) | 0xFF);
     539             : 
     540             :     /* update quantization factor */
     541           0 :     idx = (invert_quantize->factor_select & 0xFF) >> 3;
     542           0 :     shift -= invert_quantize->factor_select >> 8;
     543           0 :     invert_quantize->quantization_factor = (quantization_factors[idx] << 11) >> shift;
     544           0 : }
     545             : 
     546           0 : static int32_t *aptx_reconstructed_differences_update(Prediction *prediction,
     547             :                                                       int32_t reconstructed_difference,
     548             :                                                       int order)
     549             : {
     550           0 :     int32_t *rd1 = prediction->reconstructed_differences, *rd2 = rd1 + order;
     551           0 :     int p = prediction->pos;
     552             : 
     553           0 :     rd1[p] = rd2[p];
     554           0 :     prediction->pos = p = (p + 1) % order;
     555           0 :     rd2[p] = reconstructed_difference;
     556           0 :     return &rd2[p];
     557             : }
     558             : 
     559           0 : static void aptx_prediction_filtering(Prediction *prediction,
     560             :                                       int32_t reconstructed_difference,
     561             :                                       int order)
     562             : {
     563             :     int32_t reconstructed_sample, predictor, srd0;
     564             :     int32_t *reconstructed_differences;
     565           0 :     int64_t predicted_difference = 0;
     566             :     int i;
     567             : 
     568           0 :     reconstructed_sample = av_clip_intp2(reconstructed_difference + prediction->predicted_sample, 23);
     569           0 :     predictor = av_clip_intp2((MUL64(prediction->s_weight[0], prediction->previous_reconstructed_sample)
     570           0 :                              + MUL64(prediction->s_weight[1], reconstructed_sample)) >> 22, 23);
     571           0 :     prediction->previous_reconstructed_sample = reconstructed_sample;
     572             : 
     573           0 :     reconstructed_differences = aptx_reconstructed_differences_update(prediction, reconstructed_difference, order);
     574           0 :     srd0 = FFDIFFSIGN(reconstructed_difference, 0) << 23;
     575           0 :     for (i = 0; i < order; i++) {
     576           0 :         int32_t srd = FF_SIGNBIT(reconstructed_differences[-i-1]) | 1;
     577           0 :         prediction->d_weight[i] -= rshift32(prediction->d_weight[i] - srd*srd0, 8);
     578           0 :         predicted_difference += MUL64(reconstructed_differences[-i], prediction->d_weight[i]);
     579             :     }
     580             : 
     581           0 :     prediction->predicted_difference = av_clip_intp2(predicted_difference >> 22, 23);
     582           0 :     prediction->predicted_sample = av_clip_intp2(predictor + prediction->predicted_difference, 23);
     583           0 : }
     584             : 
     585           0 : static void aptx_process_subband(InvertQuantize *invert_quantize,
     586             :                                  Prediction *prediction,
     587             :                                  int32_t quantized_sample, int32_t dither,
     588             :                                  ConstTables *tables)
     589             : {
     590             :     int32_t sign, same_sign[2], weight[2], sw1, range;
     591             : 
     592           0 :     aptx_invert_quantization(invert_quantize, quantized_sample, dither, tables);
     593             : 
     594           0 :     sign = FFDIFFSIGN(invert_quantize->reconstructed_difference,
     595             :                       -prediction->predicted_difference);
     596           0 :     same_sign[0] = sign * prediction->prev_sign[0];
     597           0 :     same_sign[1] = sign * prediction->prev_sign[1];
     598           0 :     prediction->prev_sign[0] = prediction->prev_sign[1];
     599           0 :     prediction->prev_sign[1] = sign | 1;
     600             : 
     601           0 :     range = 0x100000;
     602           0 :     sw1 = rshift32(-same_sign[1] * prediction->s_weight[1], 1);
     603           0 :     sw1 = (av_clip(sw1, -range, range) & ~0xF) << 4;
     604             : 
     605           0 :     range = 0x300000;
     606           0 :     weight[0] = 254 * prediction->s_weight[0] + 0x800000*same_sign[0] + sw1;
     607           0 :     prediction->s_weight[0] = av_clip(rshift32(weight[0], 8), -range, range);
     608             : 
     609           0 :     range = 0x3C0000 - prediction->s_weight[0];
     610           0 :     weight[1] = 255 * prediction->s_weight[1] + 0xC00000*same_sign[1];
     611           0 :     prediction->s_weight[1] = av_clip(rshift32(weight[1], 8), -range, range);
     612             : 
     613           0 :     aptx_prediction_filtering(prediction,
     614             :                               invert_quantize->reconstructed_difference,
     615             :                               tables->prediction_order);
     616           0 : }
     617             : 
     618           0 : static void aptx_invert_quantize_and_prediction(Channel *channel)
     619             : {
     620             :     int subband;
     621           0 :     for (subband = 0; subband < NB_SUBBANDS; subband++)
     622           0 :         aptx_process_subband(&channel->invert_quantize[subband],
     623             :                              &channel->prediction[subband],
     624             :                              channel->quantize[subband].quantized_sample,
     625             :                              channel->dither[subband],
     626             :                              &tables[subband]);
     627           0 : }
     628             : 
     629           0 : static int32_t aptx_quantized_parity(Channel *channel)
     630             : {
     631           0 :     int32_t parity = channel->dither_parity;
     632             :     int subband;
     633             : 
     634           0 :     for (subband = 0; subband < NB_SUBBANDS; subband++)
     635           0 :         parity ^= channel->quantize[subband].quantized_sample;
     636             : 
     637           0 :     return parity & 1;
     638             : }
     639             : 
     640             : /* For each sample, ensure that the parity of all subbands of all channels
     641             :  * is 0 except once every 8 samples where the parity is forced to 1. */
     642           0 : static int aptx_check_parity(Channel channels[NB_CHANNELS], int32_t *idx)
     643             : {
     644           0 :     int32_t parity = aptx_quantized_parity(&channels[LEFT])
     645           0 :                    ^ aptx_quantized_parity(&channels[RIGHT]);
     646             : 
     647           0 :     int eighth = *idx == 7;
     648           0 :     *idx = (*idx + 1) & 7;
     649             : 
     650           0 :     return parity ^ eighth;
     651             : }
     652             : 
     653           0 : static void aptx_insert_sync(Channel channels[NB_CHANNELS], int32_t *idx)
     654             : {
     655           0 :     if (aptx_check_parity(channels, idx)) {
     656             :         int i;
     657             :         Channel *c;
     658             :         static const int map[] = { 1, 2, 0, 3 };
     659           0 :         Quantize *min = &channels[NB_CHANNELS-1].quantize[map[0]];
     660           0 :         for (c = &channels[NB_CHANNELS-1]; c >= channels; c--)
     661           0 :             for (i = 0; i < NB_SUBBANDS; i++)
     662           0 :                 if (c->quantize[map[i]].error < min->error)
     663           0 :                     min = &c->quantize[map[i]];
     664             : 
     665             :         /* Forcing the desired parity is done by offsetting by 1 the quantized
     666             :          * sample from the subband featuring the smallest quantization error. */
     667           0 :         min->quantized_sample = min->quantized_sample_parity_change;
     668             :     }
     669           0 : }
     670             : 
     671           0 : static uint16_t aptx_pack_codeword(Channel *channel)
     672             : {
     673           0 :     int32_t parity = aptx_quantized_parity(channel);
     674           0 :     return (((channel->quantize[3].quantized_sample & 0x06) | parity) << 13)
     675           0 :          | (((channel->quantize[2].quantized_sample & 0x03)         ) << 11)
     676           0 :          | (((channel->quantize[1].quantized_sample & 0x0F)         ) <<  7)
     677           0 :          | (((channel->quantize[0].quantized_sample & 0x7F)         ) <<  0);
     678             : }
     679             : 
     680           0 : static void aptx_unpack_codeword(Channel *channel, uint16_t codeword)
     681             : {
     682           0 :     channel->quantize[0].quantized_sample = sign_extend(codeword >>  0, 7);
     683           0 :     channel->quantize[1].quantized_sample = sign_extend(codeword >>  7, 4);
     684           0 :     channel->quantize[2].quantized_sample = sign_extend(codeword >> 11, 2);
     685           0 :     channel->quantize[3].quantized_sample = sign_extend(codeword >> 13, 3);
     686           0 :     channel->quantize[3].quantized_sample = (channel->quantize[3].quantized_sample & ~1)
     687           0 :                                           | aptx_quantized_parity(channel);
     688           0 : }
     689             : 
     690           0 : static void aptx_encode_samples(AptXContext *ctx,
     691             :                                 int32_t samples[NB_CHANNELS][4],
     692             :                                 uint8_t output[2*NB_CHANNELS])
     693             : {
     694             :     int channel;
     695           0 :     for (channel = 0; channel < NB_CHANNELS; channel++)
     696           0 :         aptx_encode_channel(&ctx->channels[channel], samples[channel]);
     697             : 
     698           0 :     aptx_insert_sync(ctx->channels, &ctx->sync_idx);
     699             : 
     700           0 :     for (channel = 0; channel < NB_CHANNELS; channel++) {
     701           0 :         aptx_invert_quantize_and_prediction(&ctx->channels[channel]);
     702           0 :         AV_WB16(output + 2*channel, aptx_pack_codeword(&ctx->channels[channel]));
     703             :     }
     704           0 : }
     705             : 
     706           0 : static int aptx_decode_samples(AptXContext *ctx,
     707             :                                 const uint8_t input[2*NB_CHANNELS],
     708             :                                 int32_t samples[NB_CHANNELS][4])
     709             : {
     710             :     int channel, ret;
     711             : 
     712           0 :     for (channel = 0; channel < NB_CHANNELS; channel++) {
     713             :         uint16_t codeword;
     714           0 :         aptx_generate_dither(&ctx->channels[channel]);
     715             : 
     716           0 :         codeword = AV_RB16(input + 2*channel);
     717           0 :         aptx_unpack_codeword(&ctx->channels[channel], codeword);
     718           0 :         aptx_invert_quantize_and_prediction(&ctx->channels[channel]);
     719             :     }
     720             : 
     721           0 :     ret = aptx_check_parity(ctx->channels, &ctx->sync_idx);
     722             : 
     723           0 :     for (channel = 0; channel < NB_CHANNELS; channel++)
     724           0 :         aptx_decode_channel(&ctx->channels[channel], samples[channel]);
     725             : 
     726           0 :     return ret;
     727             : }
     728             : 
     729             : 
     730           0 : static av_cold int aptx_init(AVCodecContext *avctx)
     731             : {
     732           0 :     AptXContext *s = avctx->priv_data;
     733             :     int chan, subband;
     734             : 
     735           0 :     if (avctx->frame_size == 0)
     736           0 :         avctx->frame_size = 1024;
     737             : 
     738           0 :     if (avctx->frame_size & 3) {
     739           0 :         av_log(avctx, AV_LOG_ERROR, "Frame size must be a multiple of 4 samples\n");
     740           0 :         return AVERROR(EINVAL);
     741             :     }
     742             : 
     743           0 :     for (chan = 0; chan < NB_CHANNELS; chan++) {
     744           0 :         Channel *channel = &s->channels[chan];
     745           0 :         for (subband = 0; subband < NB_SUBBANDS; subband++) {
     746           0 :             Prediction *prediction = &channel->prediction[subband];
     747           0 :             prediction->prev_sign[0] = 1;
     748           0 :             prediction->prev_sign[1] = 1;
     749             :         }
     750             :     }
     751             : 
     752           0 :     ff_af_queue_init(avctx, &s->afq);
     753           0 :     return 0;
     754             : }
     755             : 
     756           0 : static int aptx_decode_frame(AVCodecContext *avctx, void *data,
     757             :                              int *got_frame_ptr, AVPacket *avpkt)
     758             : {
     759           0 :     AptXContext *s = avctx->priv_data;
     760           0 :     AVFrame *frame = data;
     761             :     int pos, channel, sample, ret;
     762             : 
     763           0 :     if (avpkt->size < 4) {
     764           0 :         av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
     765           0 :         return AVERROR_INVALIDDATA;
     766             :     }
     767             : 
     768             :     /* get output buffer */
     769           0 :     frame->channels = NB_CHANNELS;
     770           0 :     frame->format = AV_SAMPLE_FMT_S32P;
     771           0 :     frame->nb_samples = avpkt->size & ~3;
     772           0 :     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
     773           0 :         return ret;
     774             : 
     775           0 :     for (pos = 0; pos < frame->nb_samples; pos += 4) {
     776             :         int32_t samples[NB_CHANNELS][4];
     777             : 
     778           0 :         if (aptx_decode_samples(s, &avpkt->data[pos], samples)) {
     779           0 :             av_log(avctx, AV_LOG_ERROR, "Synchronization error\n");
     780           0 :             return AVERROR_INVALIDDATA;
     781             :         }
     782             : 
     783           0 :         for (channel = 0; channel < NB_CHANNELS; channel++)
     784           0 :             for (sample = 0; sample < 4; sample++)
     785           0 :                 AV_WN32A(&frame->data[channel][4*(sample+pos)],
     786             :                          samples[channel][sample] << 8);
     787             :     }
     788             : 
     789           0 :     *got_frame_ptr = 1;
     790           0 :     return frame->nb_samples;
     791             : }
     792             : 
     793           0 : static int aptx_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     794             :                              const AVFrame *frame, int *got_packet_ptr)
     795             : {
     796           0 :     AptXContext *s = avctx->priv_data;
     797             :     int pos, channel, sample, ret;
     798             : 
     799           0 :     if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
     800           0 :         return ret;
     801             : 
     802           0 :     if ((ret = ff_alloc_packet2(avctx, avpkt, frame->nb_samples, 0)) < 0)
     803           0 :         return ret;
     804             : 
     805           0 :     for (pos = 0; pos < frame->nb_samples; pos += 4) {
     806             :         int32_t samples[NB_CHANNELS][4];
     807             : 
     808           0 :         for (channel = 0; channel < NB_CHANNELS; channel++)
     809           0 :             for (sample = 0; sample < 4; sample++)
     810           0 :                 samples[channel][sample] = (int32_t)AV_RN32A(&frame->data[channel][4*(sample+pos)]) >> 8;
     811             : 
     812           0 :         aptx_encode_samples(s, samples, avpkt->data + pos);
     813             :     }
     814             : 
     815           0 :     ff_af_queue_remove(&s->afq, frame->nb_samples, &avpkt->pts, &avpkt->duration);
     816           0 :     *got_packet_ptr = 1;
     817           0 :     return 0;
     818             : }
     819             : 
     820           0 : static av_cold int aptx_close(AVCodecContext *avctx)
     821             : {
     822           0 :     AptXContext *s = avctx->priv_data;
     823           0 :     ff_af_queue_close(&s->afq);
     824           0 :     return 0;
     825             : }
     826             : 
     827             : 
     828             : #if CONFIG_APTX_DECODER
     829             : AVCodec ff_aptx_decoder = {
     830             :     .name                  = "aptx",
     831             :     .long_name             = NULL_IF_CONFIG_SMALL("aptX (Audio Processing Technology for Bluetooth)"),
     832             :     .type                  = AVMEDIA_TYPE_AUDIO,
     833             :     .id                    = AV_CODEC_ID_APTX,
     834             :     .priv_data_size        = sizeof(AptXContext),
     835             :     .init                  = aptx_init,
     836             :     .decode                = aptx_decode_frame,
     837             :     .close                 = aptx_close,
     838             :     .capabilities          = AV_CODEC_CAP_DR1,
     839             :     .channel_layouts       = (const uint64_t[]) { AV_CH_LAYOUT_STEREO, 0},
     840             :     .sample_fmts           = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P,
     841             :                                                              AV_SAMPLE_FMT_NONE },
     842             : };
     843             : #endif
     844             : 
     845             : #if CONFIG_APTX_ENCODER
     846             : AVCodec ff_aptx_encoder = {
     847             :     .name                  = "aptx",
     848             :     .long_name             = NULL_IF_CONFIG_SMALL("aptX (Audio Processing Technology for Bluetooth)"),
     849             :     .type                  = AVMEDIA_TYPE_AUDIO,
     850             :     .id                    = AV_CODEC_ID_APTX,
     851             :     .priv_data_size        = sizeof(AptXContext),
     852             :     .init                  = aptx_init,
     853             :     .encode2               = aptx_encode_frame,
     854             :     .close                 = aptx_close,
     855             :     .channel_layouts       = (const uint64_t[]) { AV_CH_LAYOUT_STEREO, 0},
     856             :     .sample_fmts           = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P,
     857             :                                                              AV_SAMPLE_FMT_NONE },
     858             :     .supported_samplerates = (const int[]) {8000, 16000, 24000, 32000, 44100, 48000, 0},
     859             : };
     860             : #endif

Generated by: LCOV version 1.13