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

   1 /*
   2  * Digital Speech Standard - Standard Play mode (DSS SP) audio decoder.
   3  * Copyright (C) 2014 Oleksij Rempel <linux@rempel-privat.de>
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "libavutil/channel_layout.h"
  23 #include "libavutil/common.h"
  24 #include "libavutil/mem.h"
  25 #include "libavutil/mem_internal.h"
  26 #include "libavutil/opt.h"
  27
  28 #include "avcodec.h"
  29 #include "get_bits.h"
  30 #include "internal.h"
  31
  32 #define SUBFRAMES 4
  33 #define PULSE_MAX 8
  34
  35 #define DSS_SP_FRAME_SIZE        42
  36 #define DSS_SP_SAMPLE_COUNT     (66 * SUBFRAMES)
  37 #define DSS_SP_FORMULA(a, b, c) ((int)((((a) * (1 << 15)) + (b) * (unsigned)(c)) + 0x4000) >> 15)
  38
  39 typedef struct DssSpSubframe {
  40     int16_t gain;
  41     int32_t combined_pulse_pos;
  42     int16_t pulse_pos[7];
  43     int16_t pulse_val[7];
  44 } DssSpSubframe;
  45
  46 typedef struct DssSpFrame {
  47     int16_t filter_idx[14];
  48     int16_t sf_adaptive_gain[SUBFRAMES];
  49     int16_t pitch_lag[SUBFRAMES];
  50     struct DssSpSubframe sf[SUBFRAMES];
  51 } DssSpFrame;
  52
  53 typedef struct DssSpContext {
  54     AVCodecContext *avctx;
  55     int32_t excitation[288 + 6];
  56     int32_t history[187];
  57     DssSpFrame fparam;
  58     int32_t working_buffer[SUBFRAMES][72];
  59     int32_t audio_buf[15];
  60     int32_t err_buf1[15];
  61     int32_t lpc_filter[14];
  62     int32_t filter[15];
  63     int32_t vector_buf[72];
  64     int noise_state;
  65     int32_t err_buf2[15];
  66
  67     int pulse_dec_mode;
  68
  69     DECLARE_ALIGNED(16, uint8_t, bits)[DSS_SP_FRAME_SIZE +
  70                                        AV_INPUT_BUFFER_PADDING_SIZE];
  71 } DssSpContext;
  72
  73 /*
  74  * Used for the coding/decoding of the pulse positions for the MP-MLQ codebook.
  75  */
  76 static const uint32_t dss_sp_combinatorial_table[PULSE_MAX][72] = {
  77     {       0,         0,         0,          0,          0,          0,
  78             0,         0,         0,          0,          0,          0,
  79             0,         0,         0,          0,          0,          0,
  80             0,         0,         0,          0,          0,          0,
  81             0,         0,         0,          0,          0,          0,
  82             0,         0,         0,          0,          0,          0,
  83             0,         0,         0,          0,          0,          0,
  84             0,         0,         0,          0,          0,          0,
  85             0,         0,         0,          0,          0,          0,
  86             0,         0,         0,          0,          0,          0,
  87             0,         0,         0,          0,          0,          0,
  88             0,         0,         0,          0,          0,          0 },
  89     {       0,         1,         2,          3,          4,          5,
  90             6,         7,         8,          9,         10,         11,
  91            12,        13,        14,         15,         16,         17,
  92            18,        19,        20,         21,         22,         23,
  93            24,        25,        26,         27,         28,         29,
  94            30,        31,        32,         33,         34,         35,
  95            36,        37,        38,         39,         40,         41,
  96            42,        43,        44,         45,         46,         47,
  97            48,        49,        50,         51,         52,         53,
  98            54,        55,        56,         57,         58,         59,
  99            60,        61,        62,         63,         64,         65,
 100            66,        67,        68,         69,         70,         71 },
 101     {       0,         0,         1,          3,          6,         10,
 102            15,        21,        28,         36,         45,         55,
 103            66,        78,        91,        105,        120,        136,
 104           153,       171,       190,        210,        231,        253,
 105           276,       300,       325,        351,        378,        406,
 106           435,       465,       496,        528,        561,        595,
 107           630,       666,       703,        741,        780,        820,
 108           861,       903,       946,        990,       1035,       1081,
 109          1128,      1176,      1225,       1275,       1326,       1378,
 110          1431,      1485,      1540,       1596,       1653,       1711,
 111          1770,      1830,      1891,       1953,       2016,       2080,
 112          2145,      2211,      2278,       2346,       2415,       2485 },
 113     {       0,         0,         0,          1,          4,         10,
 114            20,        35,        56,         84,        120,        165,
 115           220,       286,       364,        455,        560,        680,
 116           816,       969,      1140,       1330,       1540,       1771,
 117          2024,      2300,      2600,       2925,       3276,       3654,
 118          4060,      4495,      4960,       5456,       5984,       6545,
 119          7140,      7770,      8436,       9139,       9880,      10660,
 120         11480,     12341,     13244,      14190,      15180,      16215,
 121         17296,     18424,     19600,      20825,      22100,      23426,
 122         24804,     26235,     27720,      29260,      30856,      32509,
 123         34220,     35990,     37820,      39711,      41664,      43680,
 124         45760,     47905,     50116,      52394,      54740,      57155 },
 125     {       0,         0,         0,          0,          1,          5,
 126            15,        35,        70,        126,        210,        330,
 127           495,       715,      1001,       1365,       1820,       2380,
 128          3060,      3876,      4845,       5985,       7315,       8855,
 129         10626,     12650,     14950,      17550,      20475,      23751,
 130         27405,     31465,     35960,      40920,      46376,      52360,
 131         58905,     66045,     73815,      82251,      91390,     101270,
 132        111930,    123410,    135751,     148995,     163185,     178365,
 133        194580,    211876,    230300,     249900,     270725,     292825,
 134        316251,    341055,    367290,     395010,     424270,     455126,
 135        487635,    521855,    557845,     595665,     635376,     677040,
 136        720720,    766480,    814385,     864501,     916895,     971635 },
 137     {       0,         0,         0,          0,          0,          1,
 138             6,        21,        56,        126,        252,        462,
 139           792,      1287,      2002,       3003,       4368,       6188,
 140          8568,     11628,     15504,      20349,      26334,      33649,
 141         42504,     53130,     65780,      80730,      98280,     118755,
 142        142506,    169911,    201376,     237336,     278256,     324632,
 143        376992,    435897,    501942,     575757,     658008,     749398,
 144        850668,    962598,   1086008,    1221759,    1370754,    1533939,
 145       1712304,   1906884,   2118760,    2349060,    2598960,    2869685,
 146       3162510,   3478761,   3819816,    4187106,    4582116,    5006386,
 147       5461512,   5949147,   6471002,    7028847,    7624512,    8259888,
 148       8936928,   9657648,  10424128,   11238513,   12103014,   13019909 },
 149     {       0,         0,         0,          0,          0,          0,
 150             1,         7,        28,         84,        210,        462,
 151           924,      1716,      3003,       5005,       8008,      12376,
 152         18564,     27132,     38760,      54264,      74613,     100947,
 153        134596,    177100,    230230,     296010,     376740,     475020,
 154        593775,    736281,    906192,    1107568,    1344904,    1623160,
 155       1947792,   2324784,   2760681,    3262623,    3838380,    4496388,
 156       5245786,   6096454,   7059052,    8145060,    9366819,   10737573,
 157      12271512,  13983816,  15890700,   18009460,   20358520,   22957480,
 158      25827165,  28989675,  32468436,   36288252,   40475358,   45057474,
 159      50063860,  55525372,  61474519,   67945521,   74974368,   82598880,
 160      90858768,  99795696, 109453344,  119877472,  131115985,  143218999 },
 161     {       0,         0,         0,          0,          0,          0,
 162             0,         1,         8,         36,        120,        330,
 163           792,      1716,      3432,       6435,      11440,      19448,
 164         31824,     50388,     77520,     116280,     170544,     245157,
 165        346104,    480700,    657800,     888030,    1184040,    1560780,
 166       2035800,   2629575,   3365856,    4272048,    5379616,    6724520,
 167       8347680,  10295472,  12620256,   15380937,   18643560,   22481940,
 168      26978328,  32224114,  38320568,   45379620,   53524680,   62891499,
 169      73629072,  85900584,  99884400,  115775100,  133784560,  154143080,
 170     177100560, 202927725, 231917400,  264385836,  300674088,  341149446,
 171     386206920, 436270780, 491796152,  553270671,  621216192,  696190560,
 172     778789440, 869648208, 969443904, 1078897248, 1198774720, 1329890705 },
 173 };
 174
 175 static const int16_t dss_sp_filter_cb[14][32] = {
 176     { -32653, -32587, -32515, -32438, -32341, -32216, -32062, -31881,
 177       -31665, -31398, -31080, -30724, -30299, -29813, -29248, -28572,
 178       -27674, -26439, -24666, -22466, -19433, -16133, -12218,  -7783,
 179        -2834,   1819,   6544,  11260,  16050,  20220,  24774,  28120 },
 180
 181     { -27503, -24509, -20644, -17496, -14187, -11277,  -8420,  -5595,
 182        -3013,   -624,   1711,   3880,   5844,   7774,   9739,  11592,
 183        13364,  14903,  16426,  17900,  19250,  20586,  21803,  23006,
 184        24142,  25249,  26275,  27300,  28359,  29249,  30118,  31183 },
 185
 186     { -27827, -24208, -20943, -17781, -14843, -11848,  -9066,  -6297,
 187        -3660,   -910,   1918,   5025,   8223,  11649,  15086,  18423,
 188            0,      0,      0,      0,      0,      0,      0,      0,
 189            0,      0,      0,      0,      0,      0,      0,      0 },
 190
 191     { -17128, -11975,  -8270,  -5123,  -2296,    183,   2503,   4707,
 192         6798,   8945,  11045,  13239,  15528,  18248,  21115,  24785,
 193            0,      0,      0,      0,      0,      0,      0,      0,
 194            0,      0,      0,      0,      0,      0,      0,      0 },
 195
 196     { -21557, -17280, -14286, -11644,  -9268,  -7087,  -4939,  -2831,
 197         -691,   1407,   3536,   5721,   8125,  10677,  13721,  17731,
 198            0,      0,      0,      0,      0,      0,      0,      0,
 199            0,      0,      0,      0,      0,      0,      0,      0 },
 200
 201     { -15030, -10377,  -7034,  -4327,  -1900,    364,   2458,   4450,
 202         6422,   8374,  10374,  12486,  14714,  16997,  19626,  22954,
 203            0,      0,      0,      0,      0,      0,      0,      0,
 204            0,      0,      0,      0,      0,      0,      0,      0 },
 205
 206     { -16155, -12362,  -9698,  -7460,  -5258,  -3359,  -1547,    219,
 207         1916,   3599,   5299,   6994,   8963,  11226,  13716,  16982,
 208            0,      0,      0,      0,      0,      0,      0,      0,
 209            0,      0,      0,      0,      0,      0,      0,      0 },
 210
 211     { -14742,  -9848,  -6921,  -4648,  -2769,  -1065,    499,   2083,
 212         3633,   5219,   6857,   8580,  10410,  12672,  15561,  20101,
 213            0,      0,      0,      0,      0,      0,      0,      0,
 214            0,      0,      0,      0,      0,      0,      0,      0 },
 215
 216     { -11099,  -7014,  -3855,  -1025,   1680,   4544,   7807,  11932,
 217            0,      0,      0,      0,      0,      0,      0,      0,
 218            0,      0,      0,      0,      0,      0,      0,      0,
 219            0,      0,      0,      0,      0,      0,      0,      0 },
 220
 221     {  -9060,  -4570,  -1381,   1419,   4034,   6728,   9865,  14149,
 222            0,      0,      0,      0,      0,      0,      0,      0,
 223            0,      0,      0,      0,      0,      0,      0,      0,
 224            0,      0,      0,      0,      0,      0,      0,      0 },
 225
 226     { -12450,  -7985,  -4596,  -1734,    961,   3629,   6865,  11142,
 227            0,      0,      0,      0,      0,      0,      0,      0,
 228            0,      0,      0,      0,      0,      0,      0,      0,
 229            0,      0,      0,      0,      0,      0,      0,      0 },
 230
 231     { -11831,  -7404,  -4010,  -1096,   1606,   4291,   7386,  11482,
 232            0,      0,      0,      0,      0,      0,      0,      0,
 233            0,      0,      0,      0,      0,      0,      0,      0,
 234            0,      0,      0,      0,      0,      0,      0,      0 },
 235
 236     { -13404,  -9250,  -5995,  -3312,   -890,   1594,   4464,   8198,
 237            0,      0,      0,      0,      0,      0,      0,      0,
 238            0,      0,      0,      0,      0,      0,      0,      0,
 239            0,      0,      0,      0,      0,      0,      0,      0 },
 240
 241     { -11239,  -7220,  -4040,  -1406,    971,   3321,   6006,   9697,
 242            0,      0,      0,      0,      0,      0,      0,      0,
 243            0,      0,      0,      0,      0,      0,      0,      0,
 244            0,      0,      0,      0,      0,      0,      0,      0 },
 245 };
 246
 247 static const uint16_t  dss_sp_fixed_cb_gain[64] = {
 248        0,    4,    8,   13,   17,   22,   26,   31,
 249       35,   40,   44,   48,   53,   58,   63,   69,
 250       76,   83,   91,   99,  109,  119,  130,  142,
 251      155,  170,  185,  203,  222,  242,  265,  290,
 252      317,  346,  378,  414,  452,  494,  540,  591,
 253      646,  706,  771,  843,  922, 1007, 1101, 1204,
 254     1316, 1438, 1572, 1719, 1879, 2053, 2244, 2453,
 255     2682, 2931, 3204, 3502, 3828, 4184, 4574, 5000,
 256 };
 257
 258 static const int16_t  dss_sp_pulse_val[8] = {
 259     -31182, -22273, -13364, -4455, 4455, 13364, 22273, 31182
 260 };
 261
 262 static const uint16_t binary_decreasing_array[] = {
 263     32767, 16384, 8192, 4096, 2048, 1024, 512, 256,
 264     128, 64, 32, 16, 8, 4, 2,
 265 };
 266
 267 static const uint16_t dss_sp_unc_decreasing_array[] = {
 268     32767, 26214, 20972, 16777, 13422, 10737, 8590, 6872,
 269     5498, 4398, 3518, 2815, 2252, 1801, 1441,
 270 };
 271
 272 static const uint16_t dss_sp_adaptive_gain[] = {
 273      102,  231,  360,  488,  617,  746,  875, 1004,
 274     1133, 1261, 1390, 1519, 1648, 1777, 1905, 2034,
 275     2163, 2292, 2421, 2550, 2678, 2807, 2936, 3065,
 276     3194, 3323, 3451, 3580, 3709, 3838, 3967, 4096,
 277 };
 278
 279 static const int32_t dss_sp_sinc[67] = {
 280       262,   293,   323,   348,   356,   336,   269,   139,
 281       -67,  -358,  -733, -1178, -1668, -2162, -2607, -2940,
 282     -3090, -2986, -2562, -1760,  -541,  1110,  3187,  5651,
 283      8435, 11446, 14568, 17670, 20611, 23251, 25460, 27125,
 284     28160, 28512, 28160,
 285     27125, 25460, 23251, 20611, 17670, 14568, 11446,  8435,
 286      5651,  3187,  1110,  -541, -1760, -2562, -2986, -3090,
 287     -2940, -2607, -2162, -1668, -1178,  -733,  -358,   -67,
 288       139,   269,   336,   356,   348,   323,   293,   262,
 289 };
 290
 291 static av_cold int dss_sp_decode_init(AVCodecContext *avctx)
 292 {
 293     DssSpContext *p = avctx->priv_data;
 294     avctx->channel_layout = AV_CH_LAYOUT_MONO;
 295     avctx->sample_fmt     = AV_SAMPLE_FMT_S16;
 296     avctx->channels       = 1;
 297     avctx->sample_rate    = 11025;
 298
 299     memset(p->history, 0, sizeof(p->history));
 300     p->pulse_dec_mode = 1;
 301     p->avctx          = avctx;
 302
 303     return 0;
 304 }
 305
 306 static void dss_sp_unpack_coeffs(DssSpContext *p, const uint8_t *src)
 307 {
 308     GetBitContext gb;
 309     DssSpFrame *fparam = &p->fparam;
 310     int i;
 311     int subframe_idx;
 312     uint32_t combined_pitch;
 313     uint32_t tmp;
 314     uint32_t pitch_lag;
 315
 316     for (i = 0; i < DSS_SP_FRAME_SIZE; i += 2) {
 317         p->bits[i]     = src[i + 1];
 318         p->bits[i + 1] = src[i];
 319     }
 320
 321     init_get_bits(&gb, p->bits, DSS_SP_FRAME_SIZE * 8);
 322
 323     for (i = 0; i < 2; i++)
 324         fparam->filter_idx[i] = get_bits(&gb, 5);
 325     for (; i < 8; i++)
 326         fparam->filter_idx[i] = get_bits(&gb, 4);
 327     for (; i < 14; i++)
 328         fparam->filter_idx[i] = get_bits(&gb, 3);
 329
 330     for (subframe_idx = 0; subframe_idx < 4; subframe_idx++) {
 331         fparam->sf_adaptive_gain[subframe_idx] = get_bits(&gb, 5);
 332
 333         fparam->sf[subframe_idx].combined_pulse_pos = get_bits_long(&gb, 31);
 334
 335         fparam->sf[subframe_idx].gain = get_bits(&gb, 6);
 336
 337         for (i = 0; i < 7; i++)
 338             fparam->sf[subframe_idx].pulse_val[i] = get_bits(&gb, 3);
 339     }
 340
 341     for (subframe_idx = 0; subframe_idx < 4; subframe_idx++) {
 342         unsigned int C72_binomials[PULSE_MAX] = {
 343             72, 2556, 59640, 1028790, 13991544, 156238908, 1473109704,
 344             3379081753
 345         };
 346         unsigned int combined_pulse_pos =
 347             fparam->sf[subframe_idx].combined_pulse_pos;
 348         int index = 6;
 349
 350         if (combined_pulse_pos < C72_binomials[PULSE_MAX - 1]) {
 351             if (p->pulse_dec_mode) {
 352                 int pulse, pulse_idx;
 353                 pulse              = PULSE_MAX - 1;
 354                 pulse_idx          = 71;
 355                 combined_pulse_pos =
 356                     fparam->sf[subframe_idx].combined_pulse_pos;
 357
 358                 /* this part seems to be close to g723.1 gen_fcb_excitation()
 359                  * RATE_6300 */
 360
 361                 /* TODO: what is 7? size of subframe? */
 362                 for (i = 0; i < 7; i++) {
 363                     for (;
 364                          combined_pulse_pos <
 365                          dss_sp_combinatorial_table[pulse][pulse_idx];
 366                          --pulse_idx)
 367                         ;
 368                     combined_pulse_pos -=
 369                         dss_sp_combinatorial_table[pulse][pulse_idx];
 370                     pulse--;
 371                     fparam->sf[subframe_idx].pulse_pos[i] = pulse_idx;
 372                 }
 373             }
 374         } else {
 375             p->pulse_dec_mode = 0;
 376
 377             /* why do we need this? */
 378             fparam->sf[subframe_idx].pulse_pos[6] = 0;
 379
 380             for (i = 71; i >= 0; i--) {
 381                 if (C72_binomials[index] <= combined_pulse_pos) {
 382                     combined_pulse_pos -= C72_binomials[index];
 383
 384                     fparam->sf[subframe_idx].pulse_pos[6 - index] = i;
 385
 386                     if (!index)
 387                         break;
 388                     --index;
 389                 }
 390                 --C72_binomials[0];
 391                 if (index) {
 392                     int a;
 393                     for (a = 0; a < index; a++)
 394                         C72_binomials[a + 1] -= C72_binomials[a];
 395                 }
 396             }
 397         }
 398     }
 399
 400     combined_pitch = get_bits(&gb, 24);
 401
 402     fparam->pitch_lag[0] = (combined_pitch % 151) + 36;
 403
 404     combined_pitch /= 151;
 405
 406     for (i = 1; i < SUBFRAMES - 1; i++) {
 407         fparam->pitch_lag[i] = combined_pitch % 48;
 408         combined_pitch      /= 48;
 409     }
 410     if (combined_pitch > 47) {
 411         av_log (p->avctx, AV_LOG_WARNING, "combined_pitch was too large\n");
 412         combined_pitch = 0;
 413     }
 414     fparam->pitch_lag[i] = combined_pitch;
 415
 416     pitch_lag = fparam->pitch_lag[0];
 417     for (i = 1; i < SUBFRAMES; i++) {
 418         if (pitch_lag > 162) {
 419             fparam->pitch_lag[i] += 162 - 23;
 420         } else {
 421             tmp = pitch_lag - 23;
 422             if (tmp < 36)
 423                 tmp = 36;
 424             fparam->pitch_lag[i] += tmp;
 425         }
 426         pitch_lag = fparam->pitch_lag[i];
 427     }
 428 }
 429
 430 static void dss_sp_unpack_filter(DssSpContext *p)
 431 {
 432     int i;
 433
 434     for (i = 0; i < 14; i++)
 435         p->lpc_filter[i] = dss_sp_filter_cb[i][p->fparam.filter_idx[i]];
 436 }
 437
 438 static void dss_sp_convert_coeffs(int32_t *lpc_filter, int32_t *coeffs)
 439 {
 440     int a, a_plus, i;
 441
 442     coeffs[0] = 0x2000;
 443     for (a = 0; a < 14; a++) {
 444         a_plus         = a + 1;
 445         coeffs[a_plus] = lpc_filter[a] >> 2;
 446         if (a_plus / 2 >= 1) {
 447             for (i = 1; i <= a_plus / 2; i++) {
 448                 int coeff_1, coeff_2, tmp;
 449
 450                 coeff_1 = coeffs[i];
 451                 coeff_2 = coeffs[a_plus - i];
 452
 453                 tmp = DSS_SP_FORMULA(coeff_1, lpc_filter[a], coeff_2);
 454                 coeffs[i] = av_clip_int16(tmp);
 455
 456                 tmp = DSS_SP_FORMULA(coeff_2, lpc_filter[a], coeff_1);
 457                 coeffs[a_plus - i] = av_clip_int16(tmp);
 458             }
 459         }
 460     }
 461 }
 462
 463 static void dss_sp_add_pulses(int32_t *vector_buf,
 464                               const struct DssSpSubframe *sf)
 465 {
 466     int i;
 467
 468     for (i = 0; i < 7; i++)
 469         vector_buf[sf->pulse_pos[i]] += (dss_sp_fixed_cb_gain[sf->gain] *
 470                                          dss_sp_pulse_val[sf->pulse_val[i]] +
 471                                          0x4000) >> 15;
 472 }
 473
 474 static void dss_sp_gen_exc(int32_t *vector, int32_t *prev_exc,
 475                            int pitch_lag, int gain)
 476 {
 477     int i;
 478
 479     /* do we actually need this check? we can use just [a3 - i % a3]
 480      * for both cases */
 481     if (pitch_lag < 72)
 482         for (i = 0; i < 72; i++)
 483             vector[i] = prev_exc[pitch_lag - i % pitch_lag];
 484     else
 485         for (i = 0; i < 72; i++)
 486             vector[i] = prev_exc[pitch_lag - i];
 487
 488     for (i = 0; i < 72; i++) {
 489         int tmp = gain * vector[i] >> 11;
 490         vector[i] = av_clip_int16(tmp);
 491     }
 492 }
 493
 494 static void dss_sp_scale_vector(int32_t *vec, int bits, int size)
 495 {
 496     int i;
 497
 498     if (bits < 0)
 499         for (i = 0; i < size; i++)
 500             vec[i] = vec[i] >> -bits;
 501     else
 502         for (i = 0; i < size; i++)
 503             vec[i] = vec[i] * (1 << bits);
 504 }
 505
 506 static void dss_sp_update_buf(int32_t *hist, int32_t *vector)
 507 {
 508     int i;
 509
 510     for (i = 114; i > 0; i--)
 511         vector[i + 72] = vector[i];
 512
 513     for (i = 0; i < 72; i++)
 514         vector[72 - i] = hist[i];
 515 }
 516
 517 static void dss_sp_shift_sq_sub(const int32_t *filter_buf,
 518                                 int32_t *error_buf, int32_t *dst)
 519 {
 520     int a;
 521
 522     for (a = 0; a < 72; a++) {
 523         int i, tmp;
 524
 525         tmp = dst[a] * filter_buf[0];
 526
 527         for (i = 14; i > 0; i--)
 528             tmp -= error_buf[i] * (unsigned)filter_buf[i];
 529
 530         for (i = 14; i > 0; i--)
 531             error_buf[i] = error_buf[i - 1];
 532
 533         tmp = (int)(tmp + 4096U) >> 13;
 534
 535         error_buf[1] = tmp;
 536
 537         dst[a] = av_clip_int16(tmp);
 538     }
 539 }
 540
 541 static void dss_sp_shift_sq_add(const int32_t *filter_buf, int32_t *audio_buf,
 542                                 int32_t *dst)
 543 {
 544     int a;
 545
 546     for (a = 0; a < 72; a++) {
 547         int i, tmp = 0;
 548
 549         audio_buf[0] = dst[a];
 550
 551         for (i = 14; i >= 0; i--)
 552             tmp += audio_buf[i] * filter_buf[i];
 553
 554         for (i = 14; i > 0; i--)
 555             audio_buf[i] = audio_buf[i - 1];
 556
 557         tmp = (tmp + 4096) >> 13;
 558
 559         dst[a] = av_clip_int16(tmp);
 560     }
 561 }
 562
 563 static void dss_sp_vec_mult(const int32_t *src, int32_t *dst,
 564                             const int16_t *mult)
 565 {
 566     int i;
 567
 568     dst[0] = src[0];
 569
 570     for (i = 1; i < 15; i++)
 571         dst[i] = (src[i] * mult[i] + 0x4000) >> 15;
 572 }
 573
 574 static int dss_sp_get_normalize_bits(int32_t *vector_buf, int16_t size)
 575 {
 576     unsigned int val;
 577     int max_val;
 578     int i;
 579
 580     val = 1;
 581     for (i = 0; i < size; i++)
 582         val |= FFABS(vector_buf[i]);
 583
 584     for (max_val = 0; val <= 0x4000; ++max_val)
 585         val *= 2;
 586     return max_val;
 587 }
 588
 589 static int dss_sp_vector_sum(DssSpContext *p, int size)
 590 {
 591     int i, sum = 0;
 592     for (i = 0; i < size; i++)
 593         sum += FFABS(p->vector_buf[i]);
 594     return sum;
 595 }
 596
 597 static void dss_sp_sf_synthesis(DssSpContext *p, int32_t lpc_filter,
 598                                 int32_t *dst, int size)
 599 {
 600     int32_t tmp_buf[15];
 601     int32_t noise[72];
 602     int bias, vsum_2 = 0, vsum_1 = 0, v36, normalize_bits;
 603     int i, tmp;
 604
 605     if (size > 0) {
 606         vsum_1 = dss_sp_vector_sum(p, size);
 607
 608         if (vsum_1 > 0xFFFFF)
 609             vsum_1 = 0xFFFFF;
 610     }
 611
 612     normalize_bits = dss_sp_get_normalize_bits(p->vector_buf, size);
 613
 614     dss_sp_scale_vector(p->vector_buf, normalize_bits - 3, size);
 615     dss_sp_scale_vector(p->audio_buf, normalize_bits, 15);
 616     dss_sp_scale_vector(p->err_buf1, normalize_bits, 15);
 617
 618     v36 = p->err_buf1[1];
 619
 620     dss_sp_vec_mult(p->filter, tmp_buf, binary_decreasing_array);
 621     dss_sp_shift_sq_add(tmp_buf, p->audio_buf, p->vector_buf);
 622
 623     dss_sp_vec_mult(p->filter, tmp_buf, dss_sp_unc_decreasing_array);
 624     dss_sp_shift_sq_sub(tmp_buf, p->err_buf1, p->vector_buf);
 625
 626     /* lpc_filter can be negative */
 627     lpc_filter = lpc_filter >> 1;
 628     if (lpc_filter >= 0)
 629         lpc_filter = 0;
 630
 631     if (size > 1) {
 632         for (i = size - 1; i > 0; i--) {
 633             tmp = DSS_SP_FORMULA(p->vector_buf[i], lpc_filter,
 634                                  p->vector_buf[i - 1]);
 635             p->vector_buf[i] = av_clip_int16(tmp);
 636         }
 637     }
 638
 639     tmp              = DSS_SP_FORMULA(p->vector_buf[0], lpc_filter, v36);
 640     p->vector_buf[0] = av_clip_int16(tmp);
 641
 642     dss_sp_scale_vector(p->vector_buf, -normalize_bits, size);
 643     dss_sp_scale_vector(p->audio_buf, -normalize_bits, 15);
 644     dss_sp_scale_vector(p->err_buf1, -normalize_bits, 15);
 645
 646     if (size > 0)
 647         vsum_2 = dss_sp_vector_sum(p, size);
 648
 649     if (vsum_2 >= 0x40)
 650         tmp = (vsum_1 << 11) / vsum_2;
 651     else
 652         tmp = 1;
 653
 654     bias     = 409 * tmp >> 15 << 15;
 655     tmp      = (bias + 32358 * p->noise_state) >> 15;
 656     noise[0] = av_clip_int16(tmp);
 657
 658     for (i = 1; i < size; i++) {
 659         tmp      = (bias + 32358 * noise[i - 1]) >> 15;
 660         noise[i] = av_clip_int16(tmp);
 661     }
 662
 663     p->noise_state = noise[size - 1];
 664     for (i = 0; i < size; i++) {
 665         tmp    = (p->vector_buf[i] * noise[i]) >> 11;
 666         dst[i] = av_clip_int16(tmp);
 667     }
 668 }
 669
 670 static void dss_sp_update_state(DssSpContext *p, int32_t *dst)
 671 {
 672     int i, offset = 6, counter = 0, a = 0;
 673
 674     for (i = 0; i < 6; i++)
 675         p->excitation[i] = p->excitation[288 + i];
 676
 677     for (i = 0; i < 72 * SUBFRAMES; i++)
 678         p->excitation[6 + i] = dst[i];
 679
 680     do {
 681         int tmp = 0;
 682
 683         for (i = 0; i < 6; i++)
 684             tmp += p->excitation[offset--] * dss_sp_sinc[a + i * 11];
 685
 686         offset += 7;
 687
 688         tmp >>= 15;
 689         dst[counter] = av_clip_int16(tmp);
 690
 691         counter++;
 692
 693         a = (a + 1) % 11;
 694         if (!a)
 695             offset++;
 696     } while (offset < FF_ARRAY_ELEMS(p->excitation));
 697 }
 698
 699 static void dss_sp_32to16bit(int16_t *dst, int32_t *src, int size)
 700 {
 701     int i;
 702
 703     for (i = 0; i < size; i++)
 704         dst[i] = av_clip_int16(src[i]);
 705 }
 706
 707 static int dss_sp_decode_one_frame(DssSpContext *p,
 708                                    int16_t *abuf_dst, const uint8_t *abuf_src)
 709 {
 710     int i, j;
 711
 712     dss_sp_unpack_coeffs(p, abuf_src);
 713
 714     dss_sp_unpack_filter(p);
 715
 716     dss_sp_convert_coeffs(p->lpc_filter, p->filter);
 717
 718     for (j = 0; j < SUBFRAMES; j++) {
 719         dss_sp_gen_exc(p->vector_buf, p->history,
 720                        p->fparam.pitch_lag[j],
 721                        dss_sp_adaptive_gain[p->fparam.sf_adaptive_gain[j]]);
 722
 723         dss_sp_add_pulses(p->vector_buf, &p->fparam.sf[j]);
 724
 725         dss_sp_update_buf(p->vector_buf, p->history);
 726
 727         for (i = 0; i < 72; i++)
 728             p->vector_buf[i] = p->history[72 - i];
 729
 730         dss_sp_shift_sq_sub(p->filter,
 731                             p->err_buf2, p->vector_buf);
 732
 733         dss_sp_sf_synthesis(p, p->lpc_filter[0],
 734                             &p->working_buffer[j][0], 72);
 735     }
 736
 737     dss_sp_update_state(p, &p->working_buffer[0][0]);
 738
 739     dss_sp_32to16bit(abuf_dst,
 740                      &p->working_buffer[0][0], 264);
 741     return 0;
 742 }
 743
 744 static int dss_sp_decode_frame(AVCodecContext *avctx, void *data,
 745                                int *got_frame_ptr, AVPacket *avpkt)
 746 {
 747     DssSpContext *p    = avctx->priv_data;
 748     AVFrame *frame     = data;
 749     const uint8_t *buf = avpkt->data;
 750     int buf_size       = avpkt->size;
 751
 752     int16_t *out;
 753     int ret;
 754
 755     if (buf_size < DSS_SP_FRAME_SIZE) {
 756         if (buf_size)
 757             av_log(avctx, AV_LOG_WARNING,
 758                    "Expected %d bytes, got %d - skipping packet.\n",
 759                    DSS_SP_FRAME_SIZE, buf_size);
 760         *got_frame_ptr = 0;
 761         return AVERROR_INVALIDDATA;
 762     }
 763
 764     frame->nb_samples = DSS_SP_SAMPLE_COUNT;
 765     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
 766         return ret;
 767
 768     out = (int16_t *)frame->data[0];
 769
 770     dss_sp_decode_one_frame(p, out, buf);
 771
 772     *got_frame_ptr = 1;
 773
 774     return DSS_SP_FRAME_SIZE;
 775 }
 776
 777 const AVCodec ff_dss_sp_decoder = {
 778     .name           = "dss_sp",
 779     .long_name      = NULL_IF_CONFIG_SMALL("Digital Speech Standard - Standard Play mode (DSS SP)"),
 780     .type           = AVMEDIA_TYPE_AUDIO,
 781     .id             = AV_CODEC_ID_DSS_SP,
 782     .priv_data_size = sizeof(DssSpContext),
 783     .init           = dss_sp_decode_init,
 784     .decode         = dss_sp_decode_frame,
 785     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
 786 };