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