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
dss_sp_decode_init(AVCodecContext * avctx)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
dss_sp_unpack_coeffs(DssSpContext * p,const uint8_t * src)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
dss_sp_unpack_filter(DssSpContext * p)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
dss_sp_convert_coeffs(int32_t * lpc_filter,int32_t * coeffs)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
dss_sp_add_pulses(int32_t * vector_buf,const struct DssSpSubframe * sf)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
dss_sp_gen_exc(int32_t * vector,int32_t * prev_exc,int pitch_lag,int gain)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
dss_sp_scale_vector(int32_t * vec,int bits,int size)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
dss_sp_update_buf(int32_t * hist,int32_t * vector)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
dss_sp_shift_sq_sub(const int32_t * filter_buf,int32_t * error_buf,int32_t * dst)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
dss_sp_shift_sq_add(const int32_t * filter_buf,int32_t * audio_buf,int32_t * dst)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
dss_sp_vec_mult(const int32_t * src,int32_t * dst,const int16_t * mult)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
dss_sp_get_normalize_bits(int32_t * vector_buf,int16_t size)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
dss_sp_vector_sum(DssSpContext * p,int size)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
dss_sp_sf_synthesis(DssSpContext * p,int32_t lpc_filter,int32_t * dst,int size)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
dss_sp_update_state(DssSpContext * p,int32_t * dst)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
dss_sp_32to16bit(int16_t * dst,int32_t * src,int size)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
dss_sp_decode_one_frame(DssSpContext * p,int16_t * abuf_dst,const uint8_t * abuf_src)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
dss_sp_decode_frame(AVCodecContext * avctx,void * data,int * got_frame_ptr,AVPacket * avpkt)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 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 };
787