GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/dss_sp.c Lines: 243 266 91.4 %
Date: 2021-04-18 21:26:34 Branches: 107 130 82.3 %

Line Branch Exec Source
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
2
static av_cold int dss_sp_decode_init(AVCodecContext *avctx)
292
{
293
2
    DssSpContext *p = avctx->priv_data;
294
2
    avctx->channel_layout = AV_CH_LAYOUT_MONO;
295
2
    avctx->sample_fmt     = AV_SAMPLE_FMT_S16;
296
2
    avctx->channels       = 1;
297
2
    avctx->sample_rate    = 11025;
298
299
2
    memset(p->history, 0, sizeof(p->history));
300
2
    p->pulse_dec_mode = 1;
301
2
    p->avctx          = avctx;
302
303
2
    return 0;
304
}
305
306
31
static void dss_sp_unpack_coeffs(DssSpContext *p, const uint8_t *src)
307
{
308
    GetBitContext gb;
309
31
    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
682
    for (i = 0; i < DSS_SP_FRAME_SIZE; i += 2) {
317
651
        p->bits[i]     = src[i + 1];
318
651
        p->bits[i + 1] = src[i];
319
    }
320
321
31
    init_get_bits(&gb, p->bits, DSS_SP_FRAME_SIZE * 8);
322
323
93
    for (i = 0; i < 2; i++)
324
62
        fparam->filter_idx[i] = get_bits(&gb, 5);
325
217
    for (; i < 8; i++)
326
186
        fparam->filter_idx[i] = get_bits(&gb, 4);
327
217
    for (; i < 14; i++)
328
186
        fparam->filter_idx[i] = get_bits(&gb, 3);
329
330
155
    for (subframe_idx = 0; subframe_idx < 4; subframe_idx++) {
331
124
        fparam->sf_adaptive_gain[subframe_idx] = get_bits(&gb, 5);
332
333
124
        fparam->sf[subframe_idx].combined_pulse_pos = get_bits_long(&gb, 31);
334
335
124
        fparam->sf[subframe_idx].gain = get_bits(&gb, 6);
336
337
992
        for (i = 0; i < 7; i++)
338
868
            fparam->sf[subframe_idx].pulse_val[i] = get_bits(&gb, 3);
339
    }
340
341
155
    for (subframe_idx = 0; subframe_idx < 4; subframe_idx++) {
342
124
        unsigned int C72_binomials[PULSE_MAX] = {
343
            72, 2556, 59640, 1028790, 13991544, 156238908, 1473109704,
344
            3379081753
345
        };
346
124
        unsigned int combined_pulse_pos =
347
124
            fparam->sf[subframe_idx].combined_pulse_pos;
348
124
        int index = 6;
349
350
124
        if (combined_pulse_pos < C72_binomials[PULSE_MAX - 1]) {
351
124
            if (p->pulse_dec_mode) {
352
                int pulse, pulse_idx;
353
124
                pulse              = PULSE_MAX - 1;
354
124
                pulse_idx          = 71;
355
124
                combined_pulse_pos =
356
124
                    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
992
                for (i = 0; i < 7; i++) {
363
868
                    for (;
364
                         combined_pulse_pos <
365
8323
                         dss_sp_combinatorial_table[pulse][pulse_idx];
366
7455
                         --pulse_idx)
367
                        ;
368
868
                    combined_pulse_pos -=
369
868
                        dss_sp_combinatorial_table[pulse][pulse_idx];
370
868
                    pulse--;
371
868
                    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
31
    combined_pitch = get_bits(&gb, 24);
401
402
31
    fparam->pitch_lag[0] = (combined_pitch % 151) + 36;
403
404
31
    combined_pitch /= 151;
405
406
93
    for (i = 1; i < SUBFRAMES - 1; i++) {
407
62
        fparam->pitch_lag[i] = combined_pitch % 48;
408
62
        combined_pitch      /= 48;
409
    }
410
31
    if (combined_pitch > 47) {
411
        av_log (p->avctx, AV_LOG_WARNING, "combined_pitch was too large\n");
412
        combined_pitch = 0;
413
    }
414
31
    fparam->pitch_lag[i] = combined_pitch;
415
416
31
    pitch_lag = fparam->pitch_lag[0];
417
124
    for (i = 1; i < SUBFRAMES; i++) {
418
93
        if (pitch_lag > 162) {
419
11
            fparam->pitch_lag[i] += 162 - 23;
420
        } else {
421
82
            tmp = pitch_lag - 23;
422
82
            if (tmp < 36)
423
19
                tmp = 36;
424
82
            fparam->pitch_lag[i] += tmp;
425
        }
426
93
        pitch_lag = fparam->pitch_lag[i];
427
    }
428
31
}
429
430
31
static void dss_sp_unpack_filter(DssSpContext *p)
431
{
432
    int i;
433
434
465
    for (i = 0; i < 14; i++)
435
434
        p->lpc_filter[i] = dss_sp_filter_cb[i][p->fparam.filter_idx[i]];
436
31
}
437
438
31
static void dss_sp_convert_coeffs(int32_t *lpc_filter, int32_t *coeffs)
439
{
440
    int a, a_plus, i;
441
442
31
    coeffs[0] = 0x2000;
443
465
    for (a = 0; a < 14; a++) {
444
434
        a_plus         = a + 1;
445
434
        coeffs[a_plus] = lpc_filter[a] >> 2;
446
434
        if (a_plus / 2 >= 1) {
447
1922
            for (i = 1; i <= a_plus / 2; i++) {
448
                int coeff_1, coeff_2, tmp;
449
450
1519
                coeff_1 = coeffs[i];
451
1519
                coeff_2 = coeffs[a_plus - i];
452
453
1519
                tmp = DSS_SP_FORMULA(coeff_1, lpc_filter[a], coeff_2);
454
1519
                coeffs[i] = av_clip_int16(tmp);
455
456
1519
                tmp = DSS_SP_FORMULA(coeff_2, lpc_filter[a], coeff_1);
457
1519
                coeffs[a_plus - i] = av_clip_int16(tmp);
458
            }
459
        }
460
    }
461
31
}
462
463
124
static void dss_sp_add_pulses(int32_t *vector_buf,
464
                              const struct DssSpSubframe *sf)
465
{
466
    int i;
467
468
992
    for (i = 0; i < 7; i++)
469
868
        vector_buf[sf->pulse_pos[i]] += (dss_sp_fixed_cb_gain[sf->gain] *
470
868
                                         dss_sp_pulse_val[sf->pulse_val[i]] +
471
868
                                         0x4000) >> 15;
472
124
}
473
474
124
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
124
    if (pitch_lag < 72)
482
2628
        for (i = 0; i < 72; i++)
483
2592
            vector[i] = prev_exc[pitch_lag - i % pitch_lag];
484
    else
485
6424
        for (i = 0; i < 72; i++)
486
6336
            vector[i] = prev_exc[pitch_lag - i];
487
488
9052
    for (i = 0; i < 72; i++) {
489
8928
        int tmp = gain * vector[i] >> 11;
490
8928
        vector[i] = av_clip_int16(tmp);
491
    }
492
124
}
493
494
744
static void dss_sp_scale_vector(int32_t *vec, int bits, int size)
495
{
496
    int i;
497
498
744
    if (bits < 0)
499
13020
        for (i = 0; i < size; i++)
500
12648
            vec[i] = vec[i] >> -bits;
501
    else
502
13020
        for (i = 0; i < size; i++)
503
12648
            vec[i] = vec[i] * (1 << bits);
504
744
}
505
506
124
static void dss_sp_update_buf(int32_t *hist, int32_t *vector)
507
{
508
    int i;
509
510
14260
    for (i = 114; i > 0; i--)
511
14136
        vector[i + 72] = vector[i];
512
513
9052
    for (i = 0; i < 72; i++)
514
8928
        vector[72 - i] = hist[i];
515
124
}
516
517
248
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
18104
    for (a = 0; a < 72; a++) {
523
        int i, tmp;
524
525
17856
        tmp = dst[a] * filter_buf[0];
526
527
267840
        for (i = 14; i > 0; i--)
528
249984
            tmp -= error_buf[i] * (unsigned)filter_buf[i];
529
530
267840
        for (i = 14; i > 0; i--)
531
249984
            error_buf[i] = error_buf[i - 1];
532
533
17856
        tmp = (int)(tmp + 4096U) >> 13;
534
535
17856
        error_buf[1] = tmp;
536
537
17856
        dst[a] = av_clip_int16(tmp);
538
    }
539
248
}
540
541
124
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
9052
    for (a = 0; a < 72; a++) {
547
8928
        int i, tmp = 0;
548
549
8928
        audio_buf[0] = dst[a];
550
551
142848
        for (i = 14; i >= 0; i--)
552
133920
            tmp += audio_buf[i] * filter_buf[i];
553
554
133920
        for (i = 14; i > 0; i--)
555
124992
            audio_buf[i] = audio_buf[i - 1];
556
557
8928
        tmp = (tmp + 4096) >> 13;
558
559
8928
        dst[a] = av_clip_int16(tmp);
560
    }
561
124
}
562
563
248
static void dss_sp_vec_mult(const int32_t *src, int32_t *dst,
564
                            const int16_t *mult)
565
{
566
    int i;
567
568
248
    dst[0] = src[0];
569
570
3720
    for (i = 1; i < 15; i++)
571
3472
        dst[i] = (src[i] * mult[i] + 0x4000) >> 15;
572
248
}
573
574
124
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
124
    val = 1;
581
9052
    for (i = 0; i < size; i++)
582
8928
        val |= FFABS(vector_buf[i]);
583
584
1025
    for (max_val = 0; val <= 0x4000; ++max_val)
585
901
        val *= 2;
586
124
    return max_val;
587
}
588
589
248
static int dss_sp_vector_sum(DssSpContext *p, int size)
590
{
591
248
    int i, sum = 0;
592
18104
    for (i = 0; i < size; i++)
593
17856
        sum += FFABS(p->vector_buf[i]);
594
248
    return sum;
595
}
596
597
124
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
124
    int bias, vsum_2 = 0, vsum_1 = 0, v36, normalize_bits;
603
    int i, tmp;
604
605
124
    if (size > 0) {
606
124
        vsum_1 = dss_sp_vector_sum(p, size);
607
608
124
        if (vsum_1 > 0xFFFFF)
609
            vsum_1 = 0xFFFFF;
610
    }
611
612
124
    normalize_bits = dss_sp_get_normalize_bits(p->vector_buf, size);
613
614
124
    dss_sp_scale_vector(p->vector_buf, normalize_bits - 3, size);
615
124
    dss_sp_scale_vector(p->audio_buf, normalize_bits, 15);
616
124
    dss_sp_scale_vector(p->err_buf1, normalize_bits, 15);
617
618
124
    v36 = p->err_buf1[1];
619
620
124
    dss_sp_vec_mult(p->filter, tmp_buf, binary_decreasing_array);
621
124
    dss_sp_shift_sq_add(tmp_buf, p->audio_buf, p->vector_buf);
622
623
124
    dss_sp_vec_mult(p->filter, tmp_buf, dss_sp_unc_decreasing_array);
624
124
    dss_sp_shift_sq_sub(tmp_buf, p->err_buf1, p->vector_buf);
625
626
    /* lpc_filter can be negative */
627
124
    lpc_filter = lpc_filter >> 1;
628
124
    if (lpc_filter >= 0)
629
        lpc_filter = 0;
630
631
124
    if (size > 1) {
632
8928
        for (i = size - 1; i > 0; i--) {
633
8804
            tmp = DSS_SP_FORMULA(p->vector_buf[i], lpc_filter,
634
                                 p->vector_buf[i - 1]);
635
8804
            p->vector_buf[i] = av_clip_int16(tmp);
636
        }
637
    }
638
639
124
    tmp              = DSS_SP_FORMULA(p->vector_buf[0], lpc_filter, v36);
640
124
    p->vector_buf[0] = av_clip_int16(tmp);
641
642
124
    dss_sp_scale_vector(p->vector_buf, -normalize_bits, size);
643
124
    dss_sp_scale_vector(p->audio_buf, -normalize_bits, 15);
644
124
    dss_sp_scale_vector(p->err_buf1, -normalize_bits, 15);
645
646
124
    if (size > 0)
647
124
        vsum_2 = dss_sp_vector_sum(p, size);
648
649
124
    if (vsum_2 >= 0x40)
650
124
        tmp = (vsum_1 << 11) / vsum_2;
651
    else
652
        tmp = 1;
653
654
124
    bias     = 409 * tmp >> 15 << 15;
655
124
    tmp      = (bias + 32358 * p->noise_state) >> 15;
656
124
    noise[0] = av_clip_int16(tmp);
657
658
8928
    for (i = 1; i < size; i++) {
659
8804
        tmp      = (bias + 32358 * noise[i - 1]) >> 15;
660
8804
        noise[i] = av_clip_int16(tmp);
661
    }
662
663
124
    p->noise_state = noise[size - 1];
664
9052
    for (i = 0; i < size; i++) {
665
8928
        tmp    = (p->vector_buf[i] * noise[i]) >> 11;
666
8928
        dst[i] = av_clip_int16(tmp);
667
    }
668
124
}
669
670
31
static void dss_sp_update_state(DssSpContext *p, int32_t *dst)
671
{
672
31
    int i, offset = 6, counter = 0, a = 0;
673
674
217
    for (i = 0; i < 6; i++)
675
186
        p->excitation[i] = p->excitation[288 + i];
676
677
8959
    for (i = 0; i < 72 * SUBFRAMES; i++)
678
8928
        p->excitation[6 + i] = dst[i];
679
680
    do {
681
8184
        int tmp = 0;
682
683
57288
        for (i = 0; i < 6; i++)
684
49104
            tmp += p->excitation[offset--] * dss_sp_sinc[a + i * 11];
685
686
8184
        offset += 7;
687
688
8184
        tmp >>= 15;
689
8184
        dst[counter] = av_clip_int16(tmp);
690
691
8184
        counter++;
692
693
8184
        a = (a + 1) % 11;
694
8184
        if (!a)
695
744
            offset++;
696
8184
    } while (offset < FF_ARRAY_ELEMS(p->excitation));
697
31
}
698
699
31
static void dss_sp_32to16bit(int16_t *dst, int32_t *src, int size)
700
{
701
    int i;
702
703
8215
    for (i = 0; i < size; i++)
704
8184
        dst[i] = av_clip_int16(src[i]);
705
31
}
706
707
31
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
31
    dss_sp_unpack_coeffs(p, abuf_src);
713
714
31
    dss_sp_unpack_filter(p);
715
716
31
    dss_sp_convert_coeffs(p->lpc_filter, p->filter);
717
718
155
    for (j = 0; j < SUBFRAMES; j++) {
719
124
        dss_sp_gen_exc(p->vector_buf, p->history,
720
124
                       p->fparam.pitch_lag[j],
721
124
                       dss_sp_adaptive_gain[p->fparam.sf_adaptive_gain[j]]);
722
723
124
        dss_sp_add_pulses(p->vector_buf, &p->fparam.sf[j]);
724
725
124
        dss_sp_update_buf(p->vector_buf, p->history);
726
727
9052
        for (i = 0; i < 72; i++)
728
8928
            p->vector_buf[i] = p->history[72 - i];
729
730
124
        dss_sp_shift_sq_sub(p->filter,
731
124
                            p->err_buf2, p->vector_buf);
732
733
124
        dss_sp_sf_synthesis(p, p->lpc_filter[0],
734
                            &p->working_buffer[j][0], 72);
735
    }
736
737
31
    dss_sp_update_state(p, &p->working_buffer[0][0]);
738
739
31
    dss_sp_32to16bit(abuf_dst,
740
                     &p->working_buffer[0][0], 264);
741
31
    return 0;
742
}
743
744
31
static int dss_sp_decode_frame(AVCodecContext *avctx, void *data,
745
                               int *got_frame_ptr, AVPacket *avpkt)
746
{
747
31
    DssSpContext *p    = avctx->priv_data;
748
31
    AVFrame *frame     = data;
749
31
    const uint8_t *buf = avpkt->data;
750
31
    int buf_size       = avpkt->size;
751
752
    int16_t *out;
753
    int ret;
754
755
31
    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
31
    frame->nb_samples = DSS_SP_SAMPLE_COUNT;
765
31
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
766
        return ret;
767
768
31
    out = (int16_t *)frame->data[0];
769
770
31
    dss_sp_decode_one_frame(p, out, buf);
771
772
31
    *got_frame_ptr = 1;
773
774
31
    return DSS_SP_FRAME_SIZE;
775
}
776
777
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
};