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