repositories / deb_ffmpeg.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Imported Debian version 2.4.3~trusty1
[deb_ffmpeg.git] / ffmpeg / libavcodec / opus_silk.c
CommitLineData
2ba45a60
DM		 1/*
2 * Copyright (c) 2012 Andrew D'Addesio
3 * Copyright (c) 2013-2014 Mozilla Corporation
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/**
23 * @file
24 * Opus SILK decoder
25 */
26
27#include <stdint.h>
28
29#include "opus.h"
30
31typedef struct SilkFrame {
32 int coded;
33 int log_gain;
34 int16_t nlsf[16];
35 float lpc[16];
36
37 float output [2 * SILK_HISTORY];
38 float lpc_history[2 * SILK_HISTORY];
39 int primarylag;
40
41 int prev_voiced;
42} SilkFrame;
43
44struct SilkContext {
45 AVCodecContext *avctx;
46 int output_channels;
47
48 int midonly;
49 int subframes;
50 int sflength;
51 int flength;
52 int nlsf_interp_factor;
53
54 enum OpusBandwidth bandwidth;
55 int wb;
56
57 SilkFrame frame[2];
58 float prev_stereo_weights[2];
59 float stereo_weights[2];
60
61 int prev_coded_channels;
62};
63
64static const uint16_t silk_model_stereo_s1[] = {
65 256, 7, 9, 10, 11, 12, 22, 46, 54, 55, 56, 59, 82, 174, 197, 200,
66 201, 202, 210, 234, 244, 245, 246, 247, 249, 256
67};
68
69static const uint16_t silk_model_stereo_s2[] = {256, 85, 171, 256};
70
71static const uint16_t silk_model_stereo_s3[] = {256, 51, 102, 154, 205, 256};
72
73static const uint16_t silk_model_mid_only[] = {256, 192, 256};
74
75static const uint16_t silk_model_frame_type_inactive[] = {256, 26, 256};
76
77static const uint16_t silk_model_frame_type_active[] = {256, 24, 98, 246, 256};
78
79static const uint16_t silk_model_gain_highbits[3][9] = {
80 {256, 32, 144, 212, 241, 253, 254, 255, 256},
81 {256, 2, 19, 64, 124, 186, 233, 252, 256},
82 {256, 1, 4, 30, 101, 195, 245, 254, 256}
83};
84
85static const uint16_t silk_model_gain_lowbits[] = {256, 32, 64, 96, 128, 160, 192, 224, 256};
86
87static const uint16_t silk_model_gain_delta[] = {
88 256, 6, 11, 22, 53, 185, 206, 214, 218, 221, 223, 225, 227, 228, 229, 230,
89 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246,
90 247, 248, 249, 250, 251, 252, 253, 254, 255, 256
91};
92static const uint16_t silk_model_lsf_s1[2][2][33] = {
93 {
94 { // NB or MB, unvoiced
95 256, 44, 78, 108, 127, 148, 160, 171, 174, 177, 179, 195, 197, 199, 200, 205,
96 207, 208, 211, 214, 215, 216, 218, 220, 222, 225, 226, 235, 244, 246, 253, 255, 256
97 }, { // NB or MB, voiced
98 256, 1, 11, 12, 20, 23, 31, 39, 53, 66, 80, 81, 95, 107, 120, 131,
99 142, 154, 165, 175, 185, 196, 204, 213, 221, 228, 236, 237, 238, 244, 245, 251, 256
100 }
101 }, {
102 { // WB, unvoiced
103 256, 31, 52, 55, 72, 73, 81, 98, 102, 103, 121, 137, 141, 143, 146, 147,
104 157, 158, 161, 177, 188, 204, 206, 208, 211, 213, 224, 225, 229, 238, 246, 253, 256
105 }, { // WB, voiced
106 256, 1, 5, 21, 26, 44, 55, 60, 74, 89, 90, 93, 105, 118, 132, 146,
107 152, 166, 178, 180, 186, 187, 199, 211, 222, 232, 235, 245, 250, 251, 252, 253, 256
108 }
109 }
110};
111
112static const uint16_t silk_model_lsf_s2[32][10] = {
113 // NB, MB
114 { 256, 1, 2, 3, 18, 242, 253, 254, 255, 256 },
115 { 256, 1, 2, 4, 38, 221, 253, 254, 255, 256 },
116 { 256, 1, 2, 6, 48, 197, 252, 254, 255, 256 },
117 { 256, 1, 2, 10, 62, 185, 246, 254, 255, 256 },
118 { 256, 1, 4, 20, 73, 174, 248, 254, 255, 256 },
119 { 256, 1, 4, 21, 76, 166, 239, 254, 255, 256 },
120 { 256, 1, 8, 32, 85, 159, 226, 252, 255, 256 },
121 { 256, 1, 2, 20, 83, 161, 219, 249, 255, 256 },
122
123 // WB
124 { 256, 1, 2, 3, 12, 244, 253, 254, 255, 256 },
125 { 256, 1, 2, 4, 32, 218, 253, 254, 255, 256 },
126 { 256, 1, 2, 5, 47, 199, 252, 254, 255, 256 },
127 { 256, 1, 2, 12, 61, 187, 252, 254, 255, 256 },
128 { 256, 1, 5, 24, 72, 172, 249, 254, 255, 256 },
129 { 256, 1, 2, 16, 70, 170, 242, 254, 255, 256 },
130 { 256, 1, 2, 17, 78, 165, 226, 251, 255, 256 },
131 { 256, 1, 8, 29, 79, 156, 237, 254, 255, 256 }
132};
133
134static const uint16_t silk_model_lsf_s2_ext[] = { 256, 156, 216, 240, 249, 253, 255, 256 };
135
136static const uint16_t silk_model_lsf_interpolation_offset[] = { 256, 13, 35, 64, 75, 256 };
137
138static const uint16_t silk_model_pitch_highbits[] = {
139 256, 3, 6, 12, 23, 44, 74, 106, 125, 136, 146, 158, 171, 184, 196, 207,
140 216, 224, 231, 237, 241, 243, 245, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256
141};
142
143static const uint16_t silk_model_pitch_lowbits_nb[]= { 256, 64, 128, 192, 256 };
144
145static const uint16_t silk_model_pitch_lowbits_mb[]= { 256, 43, 85, 128, 171, 213, 256 };
146
147static const uint16_t silk_model_pitch_lowbits_wb[]= { 256, 32, 64, 96, 128, 160, 192, 224, 256 };
148
149static const uint16_t silk_model_pitch_delta[] = {
150 256, 46, 48, 50, 53, 57, 63, 73, 88, 114, 152, 182, 204, 219, 229, 236,
151 242, 246, 250, 252, 254, 256
152};
153
154static const uint16_t silk_model_pitch_contour_nb10ms[] = { 256, 143, 193, 256 };
155
156static const uint16_t silk_model_pitch_contour_nb20ms[] = {
157 256, 68, 80, 101, 118, 137, 159, 189, 213, 230, 246, 256
158};
159
160static const uint16_t silk_model_pitch_contour_mbwb10ms[] = {
161 256, 91, 137, 176, 195, 209, 221, 229, 236, 242, 247, 252, 256
162};
163
164static const uint16_t silk_model_pitch_contour_mbwb20ms[] = {
165 256, 33, 55, 73, 89, 104, 118, 132, 145, 158, 168, 177, 186, 194, 200, 206,
166 212, 217, 221, 225, 229, 232, 235, 238, 240, 242, 244, 246, 248, 250, 252, 253,
167 254, 255, 256
168};
169
170static const uint16_t silk_model_ltp_filter[] = { 256, 77, 157, 256 };
171
172static const uint16_t silk_model_ltp_filter0_sel[] = {
173 256, 185, 200, 213, 226, 235, 244, 250, 256
174};
175
176static const uint16_t silk_model_ltp_filter1_sel[] = {
177 256, 57, 91, 112, 132, 147, 160, 172, 185, 195, 205, 214, 224, 233, 241, 248, 256
178};
179
180static const uint16_t silk_model_ltp_filter2_sel[] = {
181 256, 15, 31, 45, 57, 69, 81, 92, 103, 114, 124, 133, 142, 151, 160, 168,
182 176, 184, 192, 199, 206, 212, 218, 223, 227, 232, 236, 240, 244, 247, 251, 254, 256
183};
184
185static const uint16_t silk_model_ltp_scale_index[] = { 256, 128, 192, 256 };
186
187static const uint16_t silk_model_lcg_seed[] = { 256, 64, 128, 192, 256 };
188
189static const uint16_t silk_model_exc_rate[2][10] = {
190 { 256, 15, 66, 78, 124, 169, 182, 215, 242, 256 }, // unvoiced
191 { 256, 33, 63, 99, 116, 150, 199, 217, 238, 256 } // voiced
192};
193
194static const uint16_t silk_model_pulse_count[11][19] = {
195 { 256, 131, 205, 230, 238, 241, 244, 245, 246,
196 247, 248, 249, 250, 251, 252, 253, 254, 255, 256 },
197 { 256, 58, 151, 211, 234, 241, 244, 245, 246,
198 247, 248, 249, 250, 251, 252, 253, 254, 255, 256 },
199 { 256, 43, 94, 140, 173, 197, 213, 224, 232,
200 238, 241, 244, 247, 249, 250, 251, 253, 254, 256 },
201 { 256, 17, 69, 140, 197, 228, 240, 245, 246,
202 247, 248, 249, 250, 251, 252, 253, 254, 255, 256 },
203 { 256, 6, 27, 68, 121, 170, 205, 226, 237,
204 243, 246, 248, 250, 251, 252, 253, 254, 255, 256 },
205 { 256, 7, 21, 43, 71, 100, 128, 153, 173,
206 190, 203, 214, 223, 230, 235, 239, 243, 246, 256 },
207 { 256, 2, 7, 21, 50, 92, 138, 179, 210,
208 229, 240, 246, 249, 251, 252, 253, 254, 255, 256 },
209 { 256, 1, 3, 7, 17, 36, 65, 100, 137,
210 171, 199, 219, 233, 241, 246, 250, 252, 254, 256 },
211 { 256, 1, 3, 5, 10, 19, 33, 53, 77,
212 104, 132, 158, 181, 201, 216, 227, 235, 241, 256 },
213 { 256, 1, 2, 3, 9, 36, 94, 150, 189,
214 214, 228, 238, 244, 247, 250, 252, 253, 254, 256 },
215 { 256, 2, 3, 9, 36, 94, 150, 189, 214,
216 228, 238, 244, 247, 250, 252, 253, 254, 256, 256 }
217};
218
219static const uint16_t silk_model_pulse_location[4][168] = {
220 {
221 256, 126, 256,
222 256, 56, 198, 256,
223 256, 25, 126, 230, 256,
224 256, 12, 72, 180, 244, 256,
225 256, 7, 42, 126, 213, 250, 256,
226 256, 4, 24, 83, 169, 232, 253, 256,
227 256, 3, 15, 53, 125, 200, 242, 254, 256,
228 256, 2, 10, 35, 89, 162, 221, 248, 255, 256,
229 256, 2, 7, 24, 63, 126, 191, 233, 251, 255, 256,
230 256, 1, 5, 17, 45, 94, 157, 211, 241, 252, 255, 256,
231 256, 1, 5, 13, 33, 70, 125, 182, 223, 245, 253, 255, 256,
232 256, 1, 4, 11, 26, 54, 98, 151, 199, 232, 248, 254, 255, 256,
233 256, 1, 3, 9, 21, 42, 77, 124, 172, 212, 237, 249, 254, 255, 256,
234 256, 1, 2, 6, 16, 33, 60, 97, 144, 187, 220, 241, 250, 254, 255, 256,
235 256, 1, 2, 3, 11, 25, 47, 80, 120, 163, 201, 229, 245, 253, 254, 255, 256,
236 256, 1, 2, 3, 4, 17, 35, 62, 98, 139, 180, 214, 238, 252, 253, 254, 255, 256
237 },{
238 256, 127, 256,
239 256, 53, 202, 256,
240 256, 22, 127, 233, 256,
241 256, 11, 72, 183, 246, 256,
242 256, 6, 41, 127, 215, 251, 256,
243 256, 4, 24, 83, 170, 232, 253, 256,
244 256, 3, 16, 56, 127, 200, 241, 254, 256,
245 256, 3, 12, 39, 92, 162, 218, 246, 255, 256,
246 256, 3, 11, 30, 67, 124, 185, 229, 249, 255, 256,
247 256, 3, 10, 25, 53, 97, 151, 200, 233, 250, 255, 256,
248 256, 1, 8, 21, 43, 77, 123, 171, 209, 237, 251, 255, 256,
249 256, 1, 2, 13, 35, 62, 97, 139, 186, 219, 244, 254, 255, 256,
250 256, 1, 2, 8, 22, 48, 85, 128, 171, 208, 234, 248, 254, 255, 256,
251 256, 1, 2, 6, 16, 36, 67, 107, 149, 189, 220, 240, 250, 254, 255, 256,
252 256, 1, 2, 5, 13, 29, 55, 90, 128, 166, 201, 227, 243, 251, 254, 255, 256,
253 256, 1, 2, 4, 10, 22, 43, 73, 109, 147, 183, 213, 234, 246, 252, 254, 255, 256
254 },{
255 256, 127, 256,
256 256, 49, 206, 256,
257 256, 20, 127, 236, 256,
258 256, 11, 71, 184, 246, 256,
259 256, 7, 43, 127, 214, 250, 256,
260 256, 6, 30, 87, 169, 229, 252, 256,
261 256, 5, 23, 62, 126, 194, 236, 252, 256,
262 256, 6, 20, 49, 96, 157, 209, 239, 253, 256,
263 256, 1, 16, 39, 74, 125, 175, 215, 245, 255, 256,
264 256, 1, 2, 23, 55, 97, 149, 195, 236, 254, 255, 256,
265 256, 1, 7, 23, 50, 86, 128, 170, 206, 233, 249, 255, 256,
266 256, 1, 6, 18, 39, 70, 108, 148, 186, 217, 238, 250, 255, 256,
267 256, 1, 4, 13, 30, 56, 90, 128, 166, 200, 226, 243, 252, 255, 256,
268 256, 1, 4, 11, 25, 47, 76, 110, 146, 180, 209, 231, 245, 252, 255, 256,
269 256, 1, 3, 8, 19, 37, 62, 93, 128, 163, 194, 219, 237, 248, 253, 255, 256,
270 256, 1, 2, 6, 15, 30, 51, 79, 111, 145, 177, 205, 226, 241, 250, 254, 255, 256
271 },{
272 256, 128, 256,
273 256, 42, 214, 256,
274 256, 21, 128, 235, 256,
275 256, 12, 72, 184, 245, 256,
276 256, 8, 42, 128, 214, 249, 256,
277 256, 8, 31, 86, 176, 231, 251, 256,
278 256, 5, 20, 58, 130, 202, 238, 253, 256,
279 256, 6, 18, 45, 97, 174, 221, 241, 251, 256,
280 256, 6, 25, 53, 88, 128, 168, 203, 231, 250, 256,
281 256, 4, 18, 40, 71, 108, 148, 185, 216, 238, 252, 256,
282 256, 3, 13, 31, 57, 90, 128, 166, 199, 225, 243, 253, 256,
283 256, 2, 10, 23, 44, 73, 109, 147, 183, 212, 233, 246, 254, 256,
284 256, 1, 6, 16, 33, 58, 90, 128, 166, 198, 223, 240, 250, 255, 256,
285 256, 1, 5, 12, 25, 46, 75, 110, 146, 181, 210, 231, 244, 251, 255, 256,
286 256, 1, 3, 8, 18, 35, 60, 92, 128, 164, 196, 221, 238, 248, 253, 255, 256,
287 256, 1, 3, 7, 14, 27, 48, 76, 110, 146, 180, 208, 229, 242, 249, 253, 255, 256
288 }
289};
290
291static const uint16_t silk_model_excitation_lsb[] = {256, 136, 256};
292
293static const uint16_t silk_model_excitation_sign[3][2][7][3] = {
294 { // Inactive
295 { // Low offset
296 {256, 2, 256},
297 {256, 207, 256},
298 {256, 189, 256},
299 {256, 179, 256},
300 {256, 174, 256},
301 {256, 163, 256},
302 {256, 157, 256}
303 }, { // High offset
304 {256, 58, 256},
305 {256, 245, 256},
306 {256, 238, 256},
307 {256, 232, 256},
308 {256, 225, 256},
309 {256, 220, 256},
310 {256, 211, 256}
311 }
312 }, { // Unvoiced
313 { // Low offset
314 {256, 1, 256},
315 {256, 210, 256},
316 {256, 190, 256},
317 {256, 178, 256},
318 {256, 169, 256},
319 {256, 162, 256},
320 {256, 152, 256}
321 }, { // High offset
322 {256, 48, 256},
323 {256, 242, 256},
324 {256, 235, 256},
325 {256, 224, 256},
326 {256, 214, 256},
327 {256, 205, 256},
328 {256, 190, 256}
329 }
330 }, { // Voiced
331 { // Low offset
332 {256, 1, 256},
333 {256, 162, 256},
334 {256, 152, 256},
335 {256, 147, 256},
336 {256, 144, 256},
337 {256, 141, 256},
338 {256, 138, 256}
339 }, { // High offset
340 {256, 8, 256},
341 {256, 203, 256},
342 {256, 187, 256},
343 {256, 176, 256},
344 {256, 168, 256},
345 {256, 161, 256},
346 {256, 154, 256}
347 }
348 }
349};
350
351static const int16_t silk_stereo_weights[] = {
352 -13732, -10050, -8266, -7526, -6500, -5000, -2950, -820,
353 820, 2950, 5000, 6500, 7526, 8266, 10050, 13732
354};
355
356static const uint8_t silk_lsf_s2_model_sel_nbmb[32][10] = {
357 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
358 { 1, 3, 1, 2, 2, 1, 2, 1, 1, 1 },
359 { 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
360 { 1, 2, 2, 2, 2, 1, 2, 1, 1, 1 },
361 { 2, 3, 3, 3, 3, 2, 2, 2, 2, 2 },
362 { 0, 5, 3, 3, 2, 2, 2, 2, 1, 1 },
363 { 0, 2, 2, 2, 2, 2, 2, 2, 2, 1 },
364 { 2, 3, 6, 4, 4, 4, 5, 4, 5, 5 },
365 { 2, 4, 5, 5, 4, 5, 4, 6, 4, 4 },
366 { 2, 4, 4, 7, 4, 5, 4, 5, 5, 4 },
367 { 4, 3, 3, 3, 2, 3, 2, 2, 2, 2 },
368 { 1, 5, 5, 6, 4, 5, 4, 5, 5, 5 },
369 { 2, 7, 4, 6, 5, 5, 5, 5, 5, 5 },
370 { 2, 7, 5, 5, 5, 5, 5, 6, 5, 4 },
371 { 3, 3, 5, 4, 4, 5, 4, 5, 4, 4 },
372 { 2, 3, 3, 5, 5, 4, 4, 4, 4, 4 },
373 { 2, 4, 4, 6, 4, 5, 4, 5, 5, 5 },
374 { 2, 5, 4, 6, 5, 5, 5, 4, 5, 4 },
375 { 2, 7, 4, 5, 4, 5, 4, 5, 5, 5 },
376 { 2, 5, 4, 6, 7, 6, 5, 6, 5, 4 },
377 { 3, 6, 7, 4, 6, 5, 5, 6, 4, 5 },
378 { 2, 7, 6, 4, 4, 4, 5, 4, 5, 5 },
379 { 4, 5, 5, 4, 6, 6, 5, 6, 5, 4 },
380 { 2, 5, 5, 6, 5, 6, 4, 6, 4, 4 },
381 { 4, 5, 5, 5, 3, 7, 4, 5, 5, 4 },
382 { 2, 3, 4, 5, 5, 6, 4, 5, 5, 4 },
383 { 2, 3, 2, 3, 3, 4, 2, 3, 3, 3 },
384 { 1, 1, 2, 2, 2, 2, 2, 3, 2, 2 },
385 { 4, 5, 5, 6, 6, 6, 5, 6, 4, 5 },
386 { 3, 5, 5, 4, 4, 4, 4, 3, 3, 2 },
387 { 2, 5, 3, 7, 5, 5, 4, 4, 5, 4 },
388 { 4, 4, 5, 4, 5, 6, 5, 6, 5, 4 }
389};
390
391static const uint8_t silk_lsf_s2_model_sel_wb[32][16] = {
392 { 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 },
393 { 10, 11, 11, 11, 11, 11, 10, 10, 10, 10, 10, 9, 9, 9, 8, 11 },
394 { 10, 13, 13, 11, 15, 12, 12, 13, 10, 13, 12, 13, 13, 12, 11, 11 },
395 { 8, 10, 9, 10, 10, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 9 },
396 { 8, 14, 13, 12, 14, 12, 15, 13, 12, 12, 12, 13, 13, 12, 12, 11 },
397 { 8, 11, 13, 13, 12, 11, 11, 13, 11, 11, 11, 11, 11, 11, 10, 12 },
398 { 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 },
399 { 8, 10, 14, 11, 15, 10, 13, 11, 12, 13, 13, 12, 11, 11, 10, 11 },
400 { 8, 14, 10, 14, 14, 12, 13, 12, 14, 13, 12, 12, 13, 11, 11, 11 },
401 { 10, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 },
402 { 8, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9 },
403 { 10, 10, 11, 12, 13, 11, 11, 11, 11, 11, 11, 11, 10, 10, 9, 11 },
404 { 10, 10, 11, 11, 12, 11, 11, 11, 11, 11, 11, 11, 11, 10, 9, 11 },
405 { 11, 12, 12, 12, 14, 12, 12, 13, 11, 13, 12, 12, 13, 12, 11, 12 },
406 { 8, 14, 12, 13, 12, 15, 13, 10, 14, 13, 15, 12, 12, 11, 13, 11 },
407 { 8, 9, 8, 9, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 9, 8 },
408 { 9, 14, 13, 15, 13, 12, 13, 11, 12, 13, 12, 12, 12, 11, 11, 12 },
409 { 9, 11, 11, 12, 12, 11, 11, 13, 10, 11, 11, 13, 13, 13, 11, 12 },
410 { 10, 11, 11, 10, 10, 10, 11, 10, 9, 10, 9, 10, 9, 9, 9, 12 },
411 { 8, 10, 11, 13, 11, 11, 10, 10, 10, 9, 9, 8, 8, 8, 8, 8 },
412 { 11, 12, 11, 13, 11, 11, 10, 10, 9, 9, 9, 9, 9, 10, 10, 12 },
413 { 10, 14, 11, 15, 15, 12, 13, 12, 13, 11, 13, 11, 11, 10, 11, 11 },
414 { 10, 11, 13, 14, 14, 11, 13, 11, 12, 12, 11, 11, 11, 11, 10, 12 },
415 { 9, 11, 11, 12, 12, 12, 12, 11, 13, 13, 13, 11, 9, 9, 9, 9 },
416 { 10, 13, 11, 14, 14, 12, 15, 12, 12, 13, 11, 12, 12, 11, 11, 11 },
417 { 8, 14, 9, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 },
418 { 8, 14, 14, 11, 13, 10, 13, 13, 11, 12, 12, 15, 15, 12, 12, 12 },
419 { 11, 11, 15, 11, 13, 12, 11, 11, 11, 10, 10, 11, 11, 11, 10, 11 },
420 { 8, 8, 9, 8, 8, 8, 10, 9, 10, 9, 9, 10, 10, 10, 9, 9 },
421 { 8, 11, 10, 13, 11, 11, 10, 11, 10, 9, 8, 8, 9, 8, 8, 9 },
422 { 11, 13, 13, 12, 15, 13, 11, 11, 10, 11, 10, 10, 9, 8, 9, 8 },
423 { 10, 11, 13, 11, 12, 11, 11, 11, 10, 9, 10, 14, 12, 8, 8, 8 }
424};
425
426static const uint8_t silk_lsf_pred_weights_nbmb[2][9] = {
427 {179, 138, 140, 148, 151, 149, 153, 151, 163},
428 {116, 67, 82, 59, 92, 72, 100, 89, 92}
429};
430
431static const uint8_t silk_lsf_pred_weights_wb[2][15] = {
432 {175, 148, 160, 176, 178, 173, 174, 164, 177, 174, 196, 182, 198, 192, 182},
433 { 68, 62, 66, 60, 72, 117, 85, 90, 118, 136, 151, 142, 160, 142, 155}
434};
435
436static const uint8_t silk_lsf_weight_sel_nbmb[32][9] = {
437 { 0, 1, 0, 0, 0, 0, 0, 0, 0 },
438 { 1, 0, 0, 0, 0, 0, 0, 0, 0 },
439 { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
440 { 1, 1, 1, 0, 0, 0, 0, 1, 0 },
441 { 0, 1, 0, 0, 0, 0, 0, 0, 0 },
442 { 0, 1, 0, 0, 0, 0, 0, 0, 0 },
443 { 1, 0, 1, 1, 0, 0, 0, 1, 0 },
444 { 0, 1, 1, 0, 0, 1, 1, 0, 0 },
445 { 0, 0, 1, 1, 0, 1, 0, 1, 1 },
446 { 0, 0, 1, 1, 0, 0, 1, 1, 1 },
447 { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
448 { 0, 1, 0, 1, 1, 1, 1, 1, 0 },
449 { 0, 1, 0, 1, 1, 1, 1, 1, 0 },
450 { 0, 1, 1, 1, 1, 1, 1, 1, 0 },
451 { 1, 0, 1, 1, 0, 1, 1, 1, 1 },
452 { 0, 1, 1, 1, 1, 1, 0, 1, 0 },
453 { 0, 0, 1, 1, 0, 1, 0, 1, 0 },
454 { 0, 0, 1, 1, 1, 0, 1, 1, 1 },
455 { 0, 1, 1, 0, 0, 1, 1, 1, 0 },
456 { 0, 0, 0, 1, 1, 1, 0, 1, 0 },
457 { 0, 1, 1, 0, 0, 1, 0, 1, 0 },
458 { 0, 1, 1, 0, 0, 0, 1, 1, 0 },
459 { 0, 0, 0, 0, 0, 1, 1, 1, 1 },
460 { 0, 0, 1, 1, 0, 0, 0, 1, 1 },
461 { 0, 0, 0, 1, 0, 1, 1, 1, 1 },
462 { 0, 1, 1, 1, 1, 1, 1, 1, 0 },
463 { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
464 { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
465 { 0, 0, 1, 0, 1, 1, 0, 1, 0 },
466 { 1, 0, 0, 1, 0, 0, 0, 0, 0 },
467 { 0, 0, 0, 1, 1, 0, 1, 0, 1 },
468 { 1, 0, 1, 1, 0, 1, 1, 1, 1 }
469};
470
471static const uint8_t silk_lsf_weight_sel_wb[32][15] = {
472 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
473 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
474 { 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0 },
475 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
476 { 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0 },
477 { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
478 { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0 },
479 { 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1 },
480 { 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1 },
481 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
482 { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
483 { 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0 },
484 { 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0 },
485 { 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0 },
486 { 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1 },
487 { 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0 },
488 { 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0 },
489 { 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0 },
490 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
491 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
492 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
493 { 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0 },
494 { 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
495 { 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0 },
496 { 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1 },
497 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
498 { 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1 },
499 { 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1 },
500 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
501 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
502 { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
503 { 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0 }
504};
505
506static const uint8_t silk_lsf_codebook_nbmb[32][10] = {
507 { 12, 35, 60, 83, 108, 132, 157, 180, 206, 228 },
508 { 15, 32, 55, 77, 101, 125, 151, 175, 201, 225 },
509 { 19, 42, 66, 89, 114, 137, 162, 184, 209, 230 },
510 { 12, 25, 50, 72, 97, 120, 147, 172, 200, 223 },
511 { 26, 44, 69, 90, 114, 135, 159, 180, 205, 225 },
512 { 13, 22, 53, 80, 106, 130, 156, 180, 205, 228 },
513 { 15, 25, 44, 64, 90, 115, 142, 168, 196, 222 },
514 { 19, 24, 62, 82, 100, 120, 145, 168, 190, 214 },
515 { 22, 31, 50, 79, 103, 120, 151, 170, 203, 227 },
516 { 21, 29, 45, 65, 106, 124, 150, 171, 196, 224 },
517 { 30, 49, 75, 97, 121, 142, 165, 186, 209, 229 },
518 { 19, 25, 52, 70, 93, 116, 143, 166, 192, 219 },
519 { 26, 34, 62, 75, 97, 118, 145, 167, 194, 217 },
520 { 25, 33, 56, 70, 91, 113, 143, 165, 196, 223 },
521 { 21, 34, 51, 72, 97, 117, 145, 171, 196, 222 },
522 { 20, 29, 50, 67, 90, 117, 144, 168, 197, 221 },
523 { 22, 31, 48, 66, 95, 117, 146, 168, 196, 222 },
524 { 24, 33, 51, 77, 116, 134, 158, 180, 200, 224 },
525 { 21, 28, 70, 87, 106, 124, 149, 170, 194, 217 },
526 { 26, 33, 53, 64, 83, 117, 152, 173, 204, 225 },
527 { 27, 34, 65, 95, 108, 129, 155, 174, 210, 225 },
528 { 20, 26, 72, 99, 113, 131, 154, 176, 200, 219 },
529 { 34, 43, 61, 78, 93, 114, 155, 177, 205, 229 },
530 { 23, 29, 54, 97, 124, 138, 163, 179, 209, 229 },
531 { 30, 38, 56, 89, 118, 129, 158, 178, 200, 231 },
532 { 21, 29, 49, 63, 85, 111, 142, 163, 193, 222 },
533 { 27, 48, 77, 103, 133, 158, 179, 196, 215, 232 },
534 { 29, 47, 74, 99, 124, 151, 176, 198, 220, 237 },
535 { 33, 42, 61, 76, 93, 121, 155, 174, 207, 225 },
536 { 29, 53, 87, 112, 136, 154, 170, 188, 208, 227 },
537 { 24, 30, 52, 84, 131, 150, 166, 186, 203, 229 },
538 { 37, 48, 64, 84, 104, 118, 156, 177, 201, 230 }
539};
540
541static const uint8_t silk_lsf_codebook_wb[32][16] = {
542 { 7, 23, 38, 54, 69, 85, 100, 116, 131, 147, 162, 178, 193, 208, 223, 239 },
543 { 13, 25, 41, 55, 69, 83, 98, 112, 127, 142, 157, 171, 187, 203, 220, 236 },
544 { 15, 21, 34, 51, 61, 78, 92, 106, 126, 136, 152, 167, 185, 205, 225, 240 },
545 { 10, 21, 36, 50, 63, 79, 95, 110, 126, 141, 157, 173, 189, 205, 221, 237 },
546 { 17, 20, 37, 51, 59, 78, 89, 107, 123, 134, 150, 164, 184, 205, 224, 240 },
547 { 10, 15, 32, 51, 67, 81, 96, 112, 129, 142, 158, 173, 189, 204, 220, 236 },
548 { 8, 21, 37, 51, 65, 79, 98, 113, 126, 138, 155, 168, 179, 192, 209, 218 },
549 { 12, 15, 34, 55, 63, 78, 87, 108, 118, 131, 148, 167, 185, 203, 219, 236 },
550 { 16, 19, 32, 36, 56, 79, 91, 108, 118, 136, 154, 171, 186, 204, 220, 237 },
551 { 11, 28, 43, 58, 74, 89, 105, 120, 135, 150, 165, 180, 196, 211, 226, 241 },
552 { 6, 16, 33, 46, 60, 75, 92, 107, 123, 137, 156, 169, 185, 199, 214, 225 },
553 { 11, 19, 30, 44, 57, 74, 89, 105, 121, 135, 152, 169, 186, 202, 218, 234 },
554 { 12, 19, 29, 46, 57, 71, 88, 100, 120, 132, 148, 165, 182, 199, 216, 233 },
555 { 17, 23, 35, 46, 56, 77, 92, 106, 123, 134, 152, 167, 185, 204, 222, 237 },
556 { 14, 17, 45, 53, 63, 75, 89, 107, 115, 132, 151, 171, 188, 206, 221, 240 },
557 { 9, 16, 29, 40, 56, 71, 88, 103, 119, 137, 154, 171, 189, 205, 222, 237 },
558 { 16, 19, 36, 48, 57, 76, 87, 105, 118, 132, 150, 167, 185, 202, 218, 236 },
559 { 12, 17, 29, 54, 71, 81, 94, 104, 126, 136, 149, 164, 182, 201, 221, 237 },
560 { 15, 28, 47, 62, 79, 97, 115, 129, 142, 155, 168, 180, 194, 208, 223, 238 },
561 { 8, 14, 30, 45, 62, 78, 94, 111, 127, 143, 159, 175, 192, 207, 223, 239 },
562 { 17, 30, 49, 62, 79, 92, 107, 119, 132, 145, 160, 174, 190, 204, 220, 235 },
563 { 14, 19, 36, 45, 61, 76, 91, 108, 121, 138, 154, 172, 189, 205, 222, 238 },
564 { 12, 18, 31, 45, 60, 76, 91, 107, 123, 138, 154, 171, 187, 204, 221, 236 },
565 { 13, 17, 31, 43, 53, 70, 83, 103, 114, 131, 149, 167, 185, 203, 220, 237 },
566 { 17, 22, 35, 42, 58, 78, 93, 110, 125, 139, 155, 170, 188, 206, 224, 240 },
567 { 8, 15, 34, 50, 67, 83, 99, 115, 131, 146, 162, 178, 193, 209, 224, 239 },
568 { 13, 16, 41, 66, 73, 86, 95, 111, 128, 137, 150, 163, 183, 206, 225, 241 },
569 { 17, 25, 37, 52, 63, 75, 92, 102, 119, 132, 144, 160, 175, 191, 212, 231 },
570 { 19, 31, 49, 65, 83, 100, 117, 133, 147, 161, 174, 187, 200, 213, 227, 242 },
571 { 18, 31, 52, 68, 88, 103, 117, 126, 138, 149, 163, 177, 192, 207, 223, 239 },
572 { 16, 29, 47, 61, 76, 90, 106, 119, 133, 147, 161, 176, 193, 209, 224, 240 },
573 { 15, 21, 35, 50, 61, 73, 86, 97, 110, 119, 129, 141, 175, 198, 218, 237 }
574};
575
576static const uint16_t silk_lsf_min_spacing_nbmb[] = {
577 250, 3, 6, 3, 3, 3, 4, 3, 3, 3, 461
578};
579
580static const uint16_t silk_lsf_min_spacing_wb[] = {
581 100, 3, 40, 3, 3, 3, 5, 14, 14, 10, 11, 3, 8, 9, 7, 3, 347
582};
583
584static const uint8_t silk_lsf_ordering_nbmb[] = {
585 0, 9, 6, 3, 4, 5, 8, 1, 2, 7
586};
587
588static const uint8_t silk_lsf_ordering_wb[] = {
589 0, 15, 8, 7, 4, 11, 12, 3, 2, 13, 10, 5, 6, 9, 14, 1
590};
591
592static const int16_t silk_cosine[] = { /* (0.12) */
593 4096, 4095, 4091, 4085,
594 4076, 4065, 4052, 4036,
595 4017, 3997, 3973, 3948,
596 3920, 3889, 3857, 3822,
597 3784, 3745, 3703, 3659,
598 3613, 3564, 3513, 3461,
599 3406, 3349, 3290, 3229,
600 3166, 3102, 3035, 2967,
601 2896, 2824, 2751, 2676,
602 2599, 2520, 2440, 2359,
603 2276, 2191, 2106, 2019,
604 1931, 1842, 1751, 1660,
605 1568, 1474, 1380, 1285,
606 1189, 1093, 995, 897,
607 799, 700, 601, 501,
608 401, 301, 201, 101,
609 0, -101, -201, -301,
610 -401, -501, -601, -700,
611 -799, -897, -995, -1093,
612 -1189, -1285, -1380, -1474,
613 -1568, -1660, -1751, -1842,
614 -1931, -2019, -2106, -2191,
615 -2276, -2359, -2440, -2520,
616 -2599, -2676, -2751, -2824,
617 -2896, -2967, -3035, -3102,
618 -3166, -3229, -3290, -3349,
619 -3406, -3461, -3513, -3564,
620 -3613, -3659, -3703, -3745,
621 -3784, -3822, -3857, -3889,
622 -3920, -3948, -3973, -3997,
623 -4017, -4036, -4052, -4065,
624 -4076, -4085, -4091, -4095,
625 -4096
626};
627
628static const uint16_t silk_pitch_scale[] = { 4, 6, 8};
629
630static const uint16_t silk_pitch_min_lag[] = { 16, 24, 32};
631
632static const uint16_t silk_pitch_max_lag[] = {144, 216, 288};
633
634static const int8_t silk_pitch_offset_nb10ms[3][2] = {
635 { 0, 0},
636 { 1, 0},
637 { 0, 1}
638};
639
640static const int8_t silk_pitch_offset_nb20ms[11][4] = {
641 { 0, 0, 0, 0},
642 { 2, 1, 0, -1},
643 {-1, 0, 1, 2},
644 {-1, 0, 0, 1},
645 {-1, 0, 0, 0},
646 { 0, 0, 0, 1},
647 { 0, 0, 1, 1},
648 { 1, 1, 0, 0},
649 { 1, 0, 0, 0},
650 { 0, 0, 0, -1},
651 { 1, 0, 0, -1}
652};
653
654static const int8_t silk_pitch_offset_mbwb10ms[12][2] = {
655 { 0, 0},
656 { 0, 1},
657 { 1, 0},
658 {-1, 1},
659 { 1, -1},
660 {-1, 2},
661 { 2, -1},
662 {-2, 2},
663 { 2, -2},
664 {-2, 3},
665 { 3, -2},
666 {-3, 3}
667};
668
669static const int8_t silk_pitch_offset_mbwb20ms[34][4] = {
670 { 0, 0, 0, 0},
671 { 0, 0, 1, 1},
672 { 1, 1, 0, 0},
673 {-1, 0, 0, 0},
674 { 0, 0, 0, 1},
675 { 1, 0, 0, 0},
676 {-1, 0, 0, 1},
677 { 0, 0, 0, -1},
678 {-1, 0, 1, 2},
679 { 1, 0, 0, -1},
680 {-2, -1, 1, 2},
681 { 2, 1, 0, -1},
682 {-2, 0, 0, 2},
683 {-2, 0, 1, 3},
684 { 2, 1, -1, -2},
685 {-3, -1, 1, 3},
686 { 2, 0, 0, -2},
687 { 3, 1, 0, -2},
688 {-3, -1, 2, 4},
689 {-4, -1, 1, 4},
690 { 3, 1, -1, -3},
691 {-4, -1, 2, 5},
692 { 4, 2, -1, -3},
693 { 4, 1, -1, -4},
694 {-5, -1, 2, 6},
695 { 5, 2, -1, -4},
696 {-6, -2, 2, 6},
697 {-5, -2, 2, 5},
698 { 6, 2, -1, -5},
699 {-7, -2, 3, 8},
700 { 6, 2, -2, -6},
701 { 5, 2, -2, -5},
702 { 8, 3, -2, -7},
703 {-9, -3, 3, 9}
704};
705
706static const int8_t silk_ltp_filter0_taps[8][5] = {
707 { 4, 6, 24, 7, 5},
708 { 0, 0, 2, 0, 0},
709 { 12, 28, 41, 13, -4},
710 { -9, 15, 42, 25, 14},
711 { 1, -2, 62, 41, -9},
712 {-10, 37, 65, -4, 3},
713 { -6, 4, 66, 7, -8},
714 { 16, 14, 38, -3, 33}
715};
716
717static const int8_t silk_ltp_filter1_taps[16][5] = {
718 { 13, 22, 39, 23, 12},
719 { -1, 36, 64, 27, -6},
720 { -7, 10, 55, 43, 17},
721 { 1, 1, 8, 1, 1},
722 { 6, -11, 74, 53, -9},
723 {-12, 55, 76, -12, 8},
724 { -3, 3, 93, 27, -4},
725 { 26, 39, 59, 3, -8},
726 { 2, 0, 77, 11, 9},
727 { -8, 22, 44, -6, 7},
728 { 40, 9, 26, 3, 9},
729 { -7, 20, 101, -7, 4},
730 { 3, -8, 42, 26, 0},
731 {-15, 33, 68, 2, 23},
732 { -2, 55, 46, -2, 15},
733 { 3, -1, 21, 16, 41}
734};
735
736static const int8_t silk_ltp_filter2_taps[32][5] = {
737 { -6, 27, 61, 39, 5},
738 {-11, 42, 88, 4, 1},
739 { -2, 60, 65, 6, -4},
740 { -1, -5, 73, 56, 1},
741 { -9, 19, 94, 29, -9},
742 { 0, 12, 99, 6, 4},
743 { 8, -19, 102, 46, -13},
744 { 3, 2, 13, 3, 2},
745 { 9, -21, 84, 72, -18},
746 {-11, 46, 104, -22, 8},
747 { 18, 38, 48, 23, 0},
748 {-16, 70, 83, -21, 11},
749 { 5, -11, 117, 22, -8},
750 { -6, 23, 117, -12, 3},
751 { 3, -8, 95, 28, 4},
752 {-10, 15, 77, 60, -15},
753 { -1, 4, 124, 2, -4},
754 { 3, 38, 84, 24, -25},
755 { 2, 13, 42, 13, 31},
756 { 21, -4, 56, 46, -1},
757 { -1, 35, 79, -13, 19},
758 { -7, 65, 88, -9, -14},
759 { 20, 4, 81, 49, -29},
760 { 20, 0, 75, 3, -17},
761 { 5, -9, 44, 92, -8},
762 { 1, -3, 22, 69, 31},
763 { -6, 95, 41, -12, 5},
764 { 39, 67, 16, -4, 1},
765 { 0, -6, 120, 55, -36},
766 {-13, 44, 122, 4, -24},
767 { 81, 5, 11, 3, 7},
768 { 2, 0, 9, 10, 88}
769};
770
771static const uint16_t silk_ltp_scale_factor[] = {15565, 12288, 8192};
772
773static const uint8_t silk_shell_blocks[3][2] = {
774 { 5, 10}, // NB
775 { 8, 15}, // MB
776 {10, 20} // WB
777};
778
779static const uint8_t silk_quant_offset[2][2] = { /* (0.23) */
780 {25, 60}, // Inactive or Unvoiced
781 { 8, 25} // Voiced
782};
783
784static const int silk_stereo_interp_len[3] = {
785 64, 96, 128
786};
787
788static inline void silk_stabilize_lsf(int16_t nlsf[16], int order, const uint16_t min_delta[17])
789{
790 int pass, i;
791 for (pass = 0; pass < 20; pass++) {
792 int k, min_diff = 0;
793 for (i = 0; i < order+1; i++) {
794 int low = i != 0 ? nlsf[i-1] : 0;
795 int high = i != order ? nlsf[i] : 32768;
796 int diff = (high - low) - (min_delta[i]);
797
798 if (diff < min_diff) {
799 min_diff = diff;
800 k = i;
801
802 if (pass == 20)
803 break;
804 }
805 }
806 if (min_diff == 0) /* no issues; stabilized */
807 return;
808
809 /* wiggle one or two LSFs */
810 if (k == 0) {
811 /* repel away from lower bound */
812 nlsf[0] = min_delta[0];
813 } else if (k == order) {
814 /* repel away from higher bound */
815 nlsf[order-1] = 32768 - min_delta[order];
816 } else {
817 /* repel away from current position */
818 int min_center = 0, max_center = 32768, center_val;
819
820 /* lower extent */
821 for (i = 0; i < k; i++)
822 min_center += min_delta[i];
823 min_center += min_delta[k] >> 1;
824
825 /* upper extent */
826 for (i = order; i > k; i--)
827 max_center -= min_delta[k];
828 max_center -= min_delta[k] >> 1;
829
830 /* move apart */
831 center_val = nlsf[k - 1] + nlsf[k];
832 center_val = (center_val >> 1) + (center_val & 1); // rounded divide by 2
833 center_val = FFMIN(max_center, FFMAX(min_center, center_val));
834
835 nlsf[k - 1] = center_val - (min_delta[k] >> 1);
836 nlsf[k] = nlsf[k - 1] + min_delta[k];
837 }
838 }
839
840 /* resort to the fall-back method, the standard method for LSF stabilization */
841
842 /* sort; as the LSFs should be nearly sorted, use insertion sort */
843 for (i = 1; i < order; i++) {
844 int j, value = nlsf[i];
845 for (j = i - 1; j >= 0 && nlsf[j] > value; j--)
846 nlsf[j + 1] = nlsf[j];
847 nlsf[j + 1] = value;
848 }
849
850 /* push forwards to increase distance */
851 if (nlsf[0] < min_delta[0])
852 nlsf[0] = min_delta[0];
853 for (i = 1; i < order; i++)
854 if (nlsf[i] < nlsf[i - 1] + min_delta[i])
855 nlsf[i] = nlsf[i - 1] + min_delta[i];
856
857 /* push backwards to increase distance */
858 if (nlsf[order-1] > 32768 - min_delta[order])
859 nlsf[order-1] = 32768 - min_delta[order];
860 for (i = order-2; i >= 0; i--)
861 if (nlsf[i] > nlsf[i + 1] - min_delta[i+1])
862 nlsf[i] = nlsf[i + 1] - min_delta[i+1];
863
864 return;
865}
866
867static inline int silk_is_lpc_stable(const int16_t lpc[16], int order)
868{
869 int k, j, DC_resp = 0;
870 int32_t lpc32[2][16]; // Q24
871 int totalinvgain = 1 << 30; // 1.0 in Q30
872 int32_t *row = lpc32[0], *prevrow;
873
874 /* initialize the first row for the Levinson recursion */
875 for (k = 0; k < order; k++) {
876 DC_resp += lpc[k];
877 row[k] = lpc[k] * 4096;
878 }
879
880 if (DC_resp >= 4096)
881 return 0;
882
883 /* check if prediction gain pushes any coefficients too far */
884 for (k = order - 1; 1; k--) {
885 int rc; // Q31; reflection coefficient
886 int gaindiv; // Q30; inverse of the gain (the divisor)
887 int gain; // gain for this reflection coefficient
888 int fbits; // fractional bits used for the gain
889 int error; // Q29; estimate of the error of our partial estimate of 1/gaindiv
890
891 if (FFABS(row[k]) > 16773022)
892 return 0;
893
894 rc = -(row[k] * 128);
895 gaindiv = (1 << 30) - MULH(rc, rc);
896
897 totalinvgain = MULH(totalinvgain, gaindiv) << 2;
898 if (k == 0)
899 return (totalinvgain >= 107374);
900
901 /* approximate 1.0/gaindiv */
902 fbits = opus_ilog(gaindiv);
903 gain = ((1 << 29) - 1) / (gaindiv >> (fbits + 1 - 16)); // Q<fbits-16>
904 error = (1 << 29) - MULL(gaindiv << (15 + 16 - fbits), gain, 16);
905 gain = ((gain << 16) + (error * gain >> 13));
906
907 /* switch to the next row of the LPC coefficients */
908 prevrow = row;
909 row = lpc32[k & 1];
910
911 for (j = 0; j < k; j++) {
912 int x = prevrow[j] - ROUND_MULL(prevrow[k - j - 1], rc, 31);
913 row[j] = ROUND_MULL(x, gain, fbits);
914 }
915 }
916}
917
918static void silk_lsp2poly(const int32_t lsp[16], int32_t pol[16], int half_order)
919{
920 int i, j;
921
922 pol[0] = 65536; // 1.0 in Q16
923 pol[1] = -lsp[0];
924
925 for (i = 1; i < half_order; i++) {
926 pol[i + 1] = pol[i - 1] * 2 - ROUND_MULL(lsp[2 * i], pol[i], 16);
927 for (j = i; j > 1; j--)
928 pol[j] += pol[j - 2] - ROUND_MULL(lsp[2 * i], pol[j - 1], 16);
929
930 pol[1] -= lsp[2 * i];
931 }
932}
933
934static void silk_lsf2lpc(const int16_t nlsf[16], float lpcf[16], int order)
935{
936 int i, k;
937 int32_t lsp[16]; // Q17; 2*cos(LSF)
938 int32_t p[9], q[9]; // Q16
939 int32_t lpc32[16]; // Q17
940 int16_t lpc[16]; // Q12
941
942 /* convert the LSFs to LSPs, i.e. 2*cos(LSF) */
943 for (k = 0; k < order; k++) {
944 int index = nlsf[k] >> 8;
945 int offset = nlsf[k] & 255;
946 int k2 = (order == 10) ? silk_lsf_ordering_nbmb[k] : silk_lsf_ordering_wb[k];
947
948 /* interpolate and round */
949 lsp[k2] = silk_cosine[index] * 256;
950 lsp[k2] += (silk_cosine[index + 1] - silk_cosine[index]) * offset;
951 lsp[k2] = (lsp[k2] + 4) >> 3;
952 }
953
954 silk_lsp2poly(lsp , p, order >> 1);
955 silk_lsp2poly(lsp + 1, q, order >> 1);
956
957 /* reconstruct A(z) */
958 for (k = 0; k < order>>1; k++) {
959 lpc32[k] = -p[k + 1] - p[k] - q[k + 1] + q[k];
960 lpc32[order-k-1] = -p[k + 1] - p[k] + q[k + 1] - q[k];
961 }
962
963 /* limit the range of the LPC coefficients to each fit within an int16_t */
964 for (i = 0; i < 10; i++) {
965 int j;
966 unsigned int maxabs = 0;
967 for (j = 0, k = 0; j < order; j++) {
968 unsigned int x = FFABS(lpc32[k]);
969 if (x > maxabs) {
970 maxabs = x; // Q17
971 k = j;
972 }
973 }
974
975 maxabs = (maxabs + 16) >> 5; // convert to Q12
976
977 if (maxabs > 32767) {
978 /* perform bandwidth expansion */
979 unsigned int chirp, chirp_base; // Q16
980 maxabs = FFMIN(maxabs, 163838); // anything above this overflows chirp's numerator
981 chirp_base = chirp = 65470 - ((maxabs - 32767) << 14) / ((maxabs * (k+1)) >> 2);
982
983 for (k = 0; k < order; k++) {
984 lpc32[k] = ROUND_MULL(lpc32[k], chirp, 16);
985 chirp = (chirp_base * chirp + 32768) >> 16;
986 }
987 } else break;
988 }
989
990 if (i == 10) {
991 /* time's up: just clamp */
992 for (k = 0; k < order; k++) {
993 int x = (lpc32[k] + 16) >> 5;
994 lpc[k] = av_clip_int16(x);
995 lpc32[k] = lpc[k] << 5; // shortcut mandated by the spec; drops lower 5 bits
996 }
997 } else {
998 for (k = 0; k < order; k++)
999 lpc[k] = (lpc32[k] + 16) >> 5;
1000 }
1001
1002 /* if the prediction gain causes the LPC filter to become unstable,
1003 apply further bandwidth expansion on the Q17 coefficients */
1004 for (i = 1; i <= 16 && !silk_is_lpc_stable(lpc, order); i++) {
1005 unsigned int chirp, chirp_base;
1006 chirp_base = chirp = 65536 - (1 << i);
1007
1008 for (k = 0; k < order; k++) {
1009 lpc32[k] = ROUND_MULL(lpc32[k], chirp, 16);
1010 lpc[k] = (lpc32[k] + 16) >> 5;
1011 chirp = (chirp_base * chirp + 32768) >> 16;
1012 }
1013 }
1014
1015 for (i = 0; i < order; i++)
1016 lpcf[i] = lpc[i] / 4096.0f;
1017}
1018
1019static inline void silk_decode_lpc(SilkContext *s, SilkFrame *frame,
1020 OpusRangeCoder *rc,
1021 float lpc_leadin[16], float lpc[16],
1022 int *lpc_order, int *has_lpc_leadin, int voiced)
1023{
1024 int i;
1025 int order; // order of the LP polynomial; 10 for NB/MB and 16 for WB
1026 int8_t lsf_i1, lsf_i2[16]; // stage-1 and stage-2 codebook indices
1027 int16_t lsf_res[16]; // residual as a Q10 value
1028 int16_t nlsf[16]; // Q15
1029
1030 *lpc_order = order = s->wb ? 16 : 10;
1031
1032 /* obtain LSF stage-1 and stage-2 indices */
1033 lsf_i1 = opus_rc_getsymbol(rc, silk_model_lsf_s1[s->wb][voiced]);
1034 for (i = 0; i < order; i++) {
1035 int index = s->wb ? silk_lsf_s2_model_sel_wb [lsf_i1][i] :
1036 silk_lsf_s2_model_sel_nbmb[lsf_i1][i];
1037 lsf_i2[i] = opus_rc_getsymbol(rc, silk_model_lsf_s2[index]) - 4;
1038 if (lsf_i2[i] == -4)
1039 lsf_i2[i] -= opus_rc_getsymbol(rc, silk_model_lsf_s2_ext);
1040 else if (lsf_i2[i] == 4)
1041 lsf_i2[i] += opus_rc_getsymbol(rc, silk_model_lsf_s2_ext);
1042 }
1043
1044 /* reverse the backwards-prediction step */
1045 for (i = order - 1; i >= 0; i--) {
1046 int qstep = s->wb ? 9830 : 11796;
1047
1048 lsf_res[i] = lsf_i2[i] * 1024;
1049 if (lsf_i2[i] < 0) lsf_res[i] += 102;
1050 else if (lsf_i2[i] > 0) lsf_res[i] -= 102;
1051 lsf_res[i] = (lsf_res[i] * qstep) >> 16;
1052
1053 if (i + 1 < order) {
1054 int weight = s->wb ? silk_lsf_pred_weights_wb [silk_lsf_weight_sel_wb [lsf_i1][i]][i] :
1055 silk_lsf_pred_weights_nbmb[silk_lsf_weight_sel_nbmb[lsf_i1][i]][i];
1056 lsf_res[i] += (lsf_res[i+1] * weight) >> 8;
1057 }
1058 }
1059
1060 /* reconstruct the NLSF coefficients from the supplied indices */
1061 for (i = 0; i < order; i++) {
1062 const uint8_t * codebook = s->wb ? silk_lsf_codebook_wb [lsf_i1] :
1063 silk_lsf_codebook_nbmb[lsf_i1];
1064 int cur, prev, next, weight_sq, weight, ipart, fpart, y, value;
1065
1066 /* find the weight of the residual */
1067 /* TODO: precompute */
1068 cur = codebook[i];
1069 prev = i ? codebook[i - 1] : 0;
1070 next = i + 1 < order ? codebook[i + 1] : 256;
1071 weight_sq = (1024 / (cur - prev) + 1024 / (next - cur)) << 16;
1072
1073 /* approximate square-root with mandated fixed-point arithmetic */
1074 ipart = opus_ilog(weight_sq);
1075 fpart = (weight_sq >> (ipart-8)) & 127;
1076 y = ((ipart & 1) ? 32768 : 46214) >> ((32 - ipart)>>1);
1077 weight = y + ((213 * fpart * y) >> 16);
1078
1079 value = cur * 128 + (lsf_res[i] * 16384) / weight;
1080 nlsf[i] = av_clip(value, 0, 32767);
1081 }
1082
1083 /* stabilize the NLSF coefficients */
1084 silk_stabilize_lsf(nlsf, order, s->wb ? silk_lsf_min_spacing_wb :
1085 silk_lsf_min_spacing_nbmb);
1086
1087 /* produce an interpolation for the first 2 subframes, */
1088 /* and then convert both sets of NLSFs to LPC coefficients */
1089 *has_lpc_leadin = 0;
1090 if (s->subframes == 4) {
1091 int offset = opus_rc_getsymbol(rc, silk_model_lsf_interpolation_offset);
1092 if (offset != 4 && frame->coded) {
1093 *has_lpc_leadin = 1;
1094 if (offset != 0) {
1095 int16_t nlsf_leadin[16];
1096 for (i = 0; i < order; i++)
1097 nlsf_leadin[i] = frame->nlsf[i] +
1098 ((nlsf[i] - frame->nlsf[i]) * offset >> 2);
1099 silk_lsf2lpc(nlsf_leadin, lpc_leadin, order);
1100 } else /* avoid re-computation for a (roughly) 1-in-4 occurrence */
1101 memcpy(lpc_leadin, frame->lpc, 16 * sizeof(float));
1102 } else
1103 offset = 4;
1104 s->nlsf_interp_factor = offset;
1105
1106 silk_lsf2lpc(nlsf, lpc, order);
1107 } else {
1108 s->nlsf_interp_factor = 4;
1109 silk_lsf2lpc(nlsf, lpc, order);
1110 }
1111
1112 memcpy(frame->nlsf, nlsf, order * sizeof(nlsf[0]));
1113 memcpy(frame->lpc, lpc, order * sizeof(lpc[0]));
1114}
1115
1116static inline void silk_count_children(OpusRangeCoder *rc, int model, int32_t total,
1117 int32_t child[2])
1118{
1119 if (total != 0) {
1120 child[0] = opus_rc_getsymbol(rc,
1121 silk_model_pulse_location[model] + (((total - 1 + 5) * (total - 1)) >> 1));
1122 child[1] = total - child[0];
1123 } else {
1124 child[0] = 0;
1125 child[1] = 0;
1126 }
1127}
1128
1129static inline void silk_decode_excitation(SilkContext *s, OpusRangeCoder *rc,
1130 float* excitationf,
1131 int qoffset_high, int active, int voiced)
1132{
1133 int i;
1134 uint32_t seed;
1135 int shellblocks;
1136 int ratelevel;
1137 uint8_t pulsecount[20]; // total pulses in each shell block
1138 uint8_t lsbcount[20] = {0}; // raw lsbits defined for each pulse in each shell block
1139 int32_t excitation[320]; // Q23
1140
1141 /* excitation parameters */
1142 seed = opus_rc_getsymbol(rc, silk_model_lcg_seed);
1143 shellblocks = silk_shell_blocks[s->bandwidth][s->subframes >> 2];
1144 ratelevel = opus_rc_getsymbol(rc, silk_model_exc_rate[voiced]);
1145
1146 for (i = 0; i < shellblocks; i++) {
1147 pulsecount[i] = opus_rc_getsymbol(rc, silk_model_pulse_count[ratelevel]);
1148 if (pulsecount[i] == 17) {
1149 while (pulsecount[i] == 17 && ++lsbcount[i] != 10)
1150 pulsecount[i] = opus_rc_getsymbol(rc, silk_model_pulse_count[9]);
1151 if (lsbcount[i] == 10)
1152 pulsecount[i] = opus_rc_getsymbol(rc, silk_model_pulse_count[10]);
1153 }
1154 }
1155
1156 /* decode pulse locations using PVQ */
1157 for (i = 0; i < shellblocks; i++) {
1158 if (pulsecount[i] != 0) {
1159 int a, b, c, d;
1160 int32_t * location = excitation + 16*i;
1161 int32_t branch[4][2];
1162 branch[0][0] = pulsecount[i];
1163
1164 /* unrolled tail recursion */
1165 for (a = 0; a < 1; a++) {
1166 silk_count_children(rc, 0, branch[0][a], branch[1]);
1167 for (b = 0; b < 2; b++) {
1168 silk_count_children(rc, 1, branch[1][b], branch[2]);
1169 for (c = 0; c < 2; c++) {
1170 silk_count_children(rc, 2, branch[2][c], branch[3]);
1171 for (d = 0; d < 2; d++) {
1172 silk_count_children(rc, 3, branch[3][d], location);
1173 location += 2;
1174 }
1175 }
1176 }
1177 }
1178 } else
1179 memset(excitation + 16*i, 0, 16*sizeof(int32_t));
1180 }
1181
1182 /* decode least significant bits */
1183 for (i = 0; i < shellblocks << 4; i++) {
1184 int bit;
1185 for (bit = 0; bit < lsbcount[i >> 4]; bit++)
1186 excitation[i] = (excitation[i] << 1) |
1187 opus_rc_getsymbol(rc, silk_model_excitation_lsb);
1188 }
1189
1190 /* decode signs */
1191 for (i = 0; i < shellblocks << 4; i++) {
1192 if (excitation[i] != 0) {
1193 int sign = opus_rc_getsymbol(rc, silk_model_excitation_sign[active +
1194 voiced][qoffset_high][FFMIN(pulsecount[i >> 4], 6)]);
1195 if (sign == 0)
1196 excitation[i] *= -1;
1197 }
1198 }
1199
1200 /* assemble the excitation */
1201 for (i = 0; i < shellblocks << 4; i++) {
1202 int value = excitation[i];
1203 excitation[i] = value * 256 | silk_quant_offset[voiced][qoffset_high];
1204 if (value < 0) excitation[i] += 20;
1205 else if (value > 0) excitation[i] -= 20;
1206
1207 /* invert samples pseudorandomly */
1208 seed = 196314165 * seed + 907633515;
1209 if (seed & 0x80000000)
1210 excitation[i] *= -1;
1211 seed += value;
1212
1213 excitationf[i] = excitation[i] / 8388608.0f;
1214 }
1215}
1216
1217/** Maximum residual history according to 4.2.7.6.1 */
1218#define SILK_MAX_LAG (288 + LTP_ORDER / 2)
1219
1220/** Order of the LTP filter */
1221#define LTP_ORDER 5
1222
1223static void silk_decode_frame(SilkContext *s, OpusRangeCoder *rc,
1224 int frame_num, int channel, int coded_channels, int active, int active1)
1225{
1226 /* per frame */
1227 int voiced; // combines with active to indicate inactive, active, or active+voiced
1228 int qoffset_high;
1229 int order; // order of the LPC coefficients
1230 float lpc_leadin[16], lpc_body[16], residual[SILK_MAX_LAG + SILK_HISTORY];
1231 int has_lpc_leadin;
1232 float ltpscale;
1233
1234 /* per subframe */
1235 struct {
1236 float gain;
1237 int pitchlag;
1238 float ltptaps[5];
1239 } sf[4];
1240
1241 SilkFrame * const frame = s->frame + channel;
1242
1243 int i;
1244
1245 /* obtain stereo weights */
1246 if (coded_channels == 2 && channel == 0) {
1247 int n, wi[2], ws[2], w[2];
1248 n = opus_rc_getsymbol(rc, silk_model_stereo_s1);
1249 wi[0] = opus_rc_getsymbol(rc, silk_model_stereo_s2) + 3 * (n / 5);
1250 ws[0] = opus_rc_getsymbol(rc, silk_model_stereo_s3);
1251 wi[1] = opus_rc_getsymbol(rc, silk_model_stereo_s2) + 3 * (n % 5);
1252 ws[1] = opus_rc_getsymbol(rc, silk_model_stereo_s3);
1253
1254 for (i = 0; i < 2; i++)
1255 w[i] = silk_stereo_weights[wi[i]] +
1256 (((silk_stereo_weights[wi[i] + 1] - silk_stereo_weights[wi[i]]) * 6554) >> 16)
1257 * (ws[i]*2 + 1);
1258
1259 s->stereo_weights[0] = (w[0] - w[1]) / 8192.0;
1260 s->stereo_weights[1] = w[1] / 8192.0;
1261
1262 /* and read the mid-only flag */
1263 s->midonly = active1 ? 0 : opus_rc_getsymbol(rc, silk_model_mid_only);
1264 }
1265
1266 /* obtain frame type */
1267 if (!active) {
1268 qoffset_high = opus_rc_getsymbol(rc, silk_model_frame_type_inactive);
1269 voiced = 0;
1270 } else {
1271 int type = opus_rc_getsymbol(rc, silk_model_frame_type_active);
1272 qoffset_high = type & 1;
1273 voiced = type >> 1;
1274 }
1275
1276 /* obtain subframe quantization gains */
1277 for (i = 0; i < s->subframes; i++) {
1278 int log_gain; //Q7
1279 int ipart, fpart, lingain;
1280
1281 if (i == 0 && (frame_num == 0 || !frame->coded)) {
1282 /* gain is coded absolute */
1283 int x = opus_rc_getsymbol(rc, silk_model_gain_highbits[active + voiced]);
1284 log_gain = (x<<3) | opus_rc_getsymbol(rc, silk_model_gain_lowbits);
1285
1286 if (frame->coded)
1287 log_gain = FFMAX(log_gain, frame->log_gain - 16);
1288 } else {
1289 /* gain is coded relative */
1290 int delta_gain = opus_rc_getsymbol(rc, silk_model_gain_delta);
1291 log_gain = av_clip(FFMAX((delta_gain<<1) - 16,
1292 frame->log_gain + delta_gain - 4), 0, 63);
1293 }
1294
1295 frame->log_gain = log_gain;
1296
1297 /* approximate 2**(x/128) with a Q7 (i.e. non-integer) input */
1298 log_gain = (log_gain * 0x1D1C71 >> 16) + 2090;
1299 ipart = log_gain >> 7;
1300 fpart = log_gain & 127;
1301 lingain = (1 << ipart) + ((-174 * fpart * (128-fpart) >>16) + fpart) * ((1<<ipart) >> 7);
1302 sf[i].gain = lingain / 65536.0f;
1303 }
1304
1305 /* obtain LPC filter coefficients */
1306 silk_decode_lpc(s, frame, rc, lpc_leadin, lpc_body, &order, &has_lpc_leadin, voiced);
1307
1308 /* obtain pitch lags, if this is a voiced frame */
1309 if (voiced) {
1310 int lag_absolute = (!frame_num || !frame->prev_voiced);
1311 int primarylag; // primary pitch lag for the entire SILK frame
1312 int ltpfilter;
1313 const int8_t * offsets;
1314
1315 if (!lag_absolute) {
1316 int delta = opus_rc_getsymbol(rc, silk_model_pitch_delta);
1317 if (delta)
1318 primarylag = frame->primarylag + delta - 9;
1319 else
1320 lag_absolute = 1;
1321 }
1322
1323 if (lag_absolute) {
1324 /* primary lag is coded absolute */
1325 int highbits, lowbits;
1326 const uint16_t *model[] = {
1327 silk_model_pitch_lowbits_nb, silk_model_pitch_lowbits_mb,
1328 silk_model_pitch_lowbits_wb
1329 };
1330 highbits = opus_rc_getsymbol(rc, silk_model_pitch_highbits);
1331 lowbits = opus_rc_getsymbol(rc, model[s->bandwidth]);
1332
1333 primarylag = silk_pitch_min_lag[s->bandwidth] +
1334 highbits*silk_pitch_scale[s->bandwidth] + lowbits;
1335 }
1336 frame->primarylag = primarylag;
1337
1338 if (s->subframes == 2)
1339 offsets = (s->bandwidth == OPUS_BANDWIDTH_NARROWBAND)
1340 ? silk_pitch_offset_nb10ms[opus_rc_getsymbol(rc,
1341 silk_model_pitch_contour_nb10ms)]
1342 : silk_pitch_offset_mbwb10ms[opus_rc_getsymbol(rc,
1343 silk_model_pitch_contour_mbwb10ms)];
1344 else
1345 offsets = (s->bandwidth == OPUS_BANDWIDTH_NARROWBAND)
1346 ? silk_pitch_offset_nb20ms[opus_rc_getsymbol(rc,
1347 silk_model_pitch_contour_nb20ms)]
1348 : silk_pitch_offset_mbwb20ms[opus_rc_getsymbol(rc,
1349 silk_model_pitch_contour_mbwb20ms)];
1350
1351 for (i = 0; i < s->subframes; i++)
1352 sf[i].pitchlag = av_clip(primarylag + offsets[i],
1353 silk_pitch_min_lag[s->bandwidth],
1354 silk_pitch_max_lag[s->bandwidth]);
1355
1356 /* obtain LTP filter coefficients */
1357 ltpfilter = opus_rc_getsymbol(rc, silk_model_ltp_filter);
1358 for (i = 0; i < s->subframes; i++) {
1359 int index, j;
1360 const uint16_t *filter_sel[] = {
1361 silk_model_ltp_filter0_sel, silk_model_ltp_filter1_sel,
1362 silk_model_ltp_filter2_sel
1363 };
1364 const int8_t (*filter_taps[])[5] = {
1365 silk_ltp_filter0_taps, silk_ltp_filter1_taps, silk_ltp_filter2_taps
1366 };
1367 index = opus_rc_getsymbol(rc, filter_sel[ltpfilter]);
1368 for (j = 0; j < 5; j++)
1369 sf[i].ltptaps[j] = filter_taps[ltpfilter][index][j] / 128.0f;
1370 }
1371 }
1372
1373 /* obtain LTP scale factor */
1374 if (voiced && frame_num == 0)
1375 ltpscale = silk_ltp_scale_factor[opus_rc_getsymbol(rc,
1376 silk_model_ltp_scale_index)] / 16384.0f;
1377 else ltpscale = 15565.0f/16384.0f;
1378
1379 /* generate the excitation signal for the entire frame */
1380 silk_decode_excitation(s, rc, residual + SILK_MAX_LAG, qoffset_high,
1381 active, voiced);
1382
1383 /* skip synthesising the side channel if we want mono-only */
1384 if (s->output_channels == channel)
1385 return;
1386
1387 /* generate the output signal */
1388 for (i = 0; i < s->subframes; i++) {
1389 const float * lpc_coeff = (i < 2 && has_lpc_leadin) ? lpc_leadin : lpc_body;
1390 float *dst = frame->output + SILK_HISTORY + i * s->sflength;
1391 float *resptr = residual + SILK_MAX_LAG + i * s->sflength;
1392 float *lpc = frame->lpc_history + SILK_HISTORY + i * s->sflength;
1393 float sum;
1394 int j, k;
1395
1396 if (voiced) {
1397 int out_end;
1398 float scale;
1399
1400 if (i < 2 || s->nlsf_interp_factor == 4) {
1401 out_end = -i * s->sflength;
1402 scale = ltpscale;
1403 } else {
1404 out_end = -(i - 2) * s->sflength;
1405 scale = 1.0f;
1406 }
1407
1408 /* when the LPC coefficients change, a re-whitening filter is used */
1409 /* to produce a residual that accounts for the change */
1410 for (j = - sf[i].pitchlag - LTP_ORDER/2; j < out_end; j++) {
1411 sum = dst[j];
1412 for (k = 0; k < order; k++)
1413 sum -= lpc_coeff[k] * dst[j - k - 1];
1414 resptr[j] = av_clipf(sum, -1.0f, 1.0f) * scale / sf[i].gain;
1415 }
1416
1417 if (out_end) {
1418 float rescale = sf[i-1].gain / sf[i].gain;
1419 for (j = out_end; j < 0; j++)
1420 resptr[j] *= rescale;
1421 }
1422
1423 /* LTP synthesis */
1424 for (j = 0; j < s->sflength; j++) {
1425 sum = resptr[j];
1426 for (k = 0; k < LTP_ORDER; k++)
1427 sum += sf[i].ltptaps[k] * resptr[j - sf[i].pitchlag + LTP_ORDER/2 - k];
1428 resptr[j] = sum;
1429 }
1430 }
1431
1432 /* LPC synthesis */
1433 for (j = 0; j < s->sflength; j++) {
1434 sum = resptr[j] * sf[i].gain;
1435 for (k = 1; k <= order; k++)
1436 sum += lpc_coeff[k - 1] * lpc[j - k];
1437
1438 lpc[j] = sum;
1439 dst[j] = av_clipf(sum, -1.0f, 1.0f);
1440 }
1441 }
1442
1443 frame->prev_voiced = voiced;
1444 memmove(frame->lpc_history, frame->lpc_history + s->flength, SILK_HISTORY * sizeof(float));
1445 memmove(frame->output, frame->output + s->flength, SILK_HISTORY * sizeof(float));
1446
1447 frame->coded = 1;
1448}
1449
1450static void silk_unmix_ms(SilkContext *s, float *l, float *r)
1451{
1452 float *mid = s->frame[0].output + SILK_HISTORY - s->flength;
1453 float *side = s->frame[1].output + SILK_HISTORY - s->flength;
1454 float w0_prev = s->prev_stereo_weights[0];
1455 float w1_prev = s->prev_stereo_weights[1];
1456 float w0 = s->stereo_weights[0];
1457 float w1 = s->stereo_weights[1];
1458 int n1 = silk_stereo_interp_len[s->bandwidth];
1459 int i;
1460
1461 for (i = 0; i < n1; i++) {
1462 float interp0 = w0_prev + i * (w0 - w0_prev) / n1;
1463 float interp1 = w1_prev + i * (w1 - w1_prev) / n1;
1464 float p0 = 0.25 * (mid[i - 2] + 2 * mid[i - 1] + mid[i]);
1465
1466 l[i] = av_clipf((1 + interp1) * mid[i - 1] + side[i - 1] + interp0 * p0, -1.0, 1.0);
1467 r[i] = av_clipf((1 - interp1) * mid[i - 1] - side[i - 1] - interp0 * p0, -1.0, 1.0);
1468 }
1469
1470 for (; i < s->flength; i++) {
1471 float p0 = 0.25 * (mid[i - 2] + 2 * mid[i - 1] + mid[i]);
1472
1473 l[i] = av_clipf((1 + w1) * mid[i - 1] + side[i - 1] + w0 * p0, -1.0, 1.0);
1474 r[i] = av_clipf((1 - w1) * mid[i - 1] - side[i - 1] - w0 * p0, -1.0, 1.0);
1475 }
1476
1477 memcpy(s->prev_stereo_weights, s->stereo_weights, sizeof(s->stereo_weights));
1478}
1479
1480static void silk_flush_frame(SilkFrame *frame)
1481{
1482 if (!frame->coded)
1483 return;
1484
1485 memset(frame->output, 0, sizeof(frame->output));
1486 memset(frame->lpc_history, 0, sizeof(frame->lpc_history));
1487
1488 memset(frame->lpc, 0, sizeof(frame->lpc));
1489 memset(frame->nlsf, 0, sizeof(frame->nlsf));
1490
1491 frame->log_gain = 0;
1492
1493 frame->primarylag = 0;
1494 frame->prev_voiced = 0;
1495 frame->coded = 0;
1496}
1497
1498int ff_silk_decode_superframe(SilkContext *s, OpusRangeCoder *rc,
1499 float *output[2],
1500 enum OpusBandwidth bandwidth,
1501 int coded_channels,
1502 int duration_ms)
1503{
1504 int active[2][6], redundancy[2];
1505 int nb_frames, i, j;
1506
1507 if (bandwidth > OPUS_BANDWIDTH_WIDEBAND ||
1508 coded_channels > 2 || duration_ms > 60) {
1509 av_log(s->avctx, AV_LOG_ERROR, "Invalid parameters passed "
1510 "to the SILK decoder.\n");
1511 return AVERROR(EINVAL);
1512 }
1513
1514 nb_frames = 1 + (duration_ms > 20) + (duration_ms > 40);
1515 s->subframes = duration_ms / nb_frames / 5; // 5ms subframes
1516 s->sflength = 20 * (bandwidth + 2);
1517 s->flength = s->sflength * s->subframes;
1518 s->bandwidth = bandwidth;
1519 s->wb = bandwidth == OPUS_BANDWIDTH_WIDEBAND;
1520
1521 /* make sure to flush the side channel when switching from mono to stereo */
1522 if (coded_channels > s->prev_coded_channels)
1523 silk_flush_frame(&s->frame[1]);
1524 s->prev_coded_channels = coded_channels;
1525
1526 /* read the LP-layer header bits */
1527 for (i = 0; i < coded_channels; i++) {
1528 for (j = 0; j < nb_frames; j++)
1529 active[i][j] = opus_rc_p2model(rc, 1);
1530
1531 redundancy[i] = opus_rc_p2model(rc, 1);
1532 if (redundancy[i]) {
1533 av_log(s->avctx, AV_LOG_ERROR, "LBRR frames present; this is unsupported\n");
1534 return AVERROR_PATCHWELCOME;
1535 }
1536 }
1537
1538 for (i = 0; i < nb_frames; i++) {
1539 for (j = 0; j < coded_channels && !s->midonly; j++)
1540 silk_decode_frame(s, rc, i, j, coded_channels, active[j][i], active[1][i]);
1541
1542 /* reset the side channel if it is not coded */
1543 if (s->midonly && s->frame[1].coded)
1544 silk_flush_frame(&s->frame[1]);
1545
1546 if (coded_channels == 1 || s->output_channels == 1) {
1547 for (j = 0; j < s->output_channels; j++) {
1548 memcpy(output[j] + i * s->flength,
1549 s->frame[0].output + SILK_HISTORY - s->flength - 2,
1550 s->flength * sizeof(float));
1551 }
1552 } else {
1553 silk_unmix_ms(s, output[0] + i * s->flength, output[1] + i * s->flength);
1554 }
1555
1556 s->midonly = 0;
1557 }
1558
1559 return nb_frames * s->flength;
1560}
1561
1562void ff_silk_free(SilkContext **ps)
1563{
1564 av_freep(ps);
1565}
1566
1567void ff_silk_flush(SilkContext *s)
1568{
1569 silk_flush_frame(&s->frame[0]);
1570 silk_flush_frame(&s->frame[1]);
1571
1572 memset(s->prev_stereo_weights, 0, sizeof(s->prev_stereo_weights));
1573}
1574
1575int ff_silk_init(AVCodecContext *avctx, SilkContext **ps, int output_channels)
1576{
1577 SilkContext *s;
1578
1579 if (output_channels != 1 && output_channels != 2) {
1580 av_log(avctx, AV_LOG_ERROR, "Invalid number of output channels: %d\n",
1581 output_channels);
1582 return AVERROR(EINVAL);
1583 }
1584
1585 s = av_mallocz(sizeof(*s));
1586 if (!s)
1587 return AVERROR(ENOMEM);
1588
1589 s->avctx = avctx;
1590 s->output_channels = output_channels;
1591
1592 ff_silk_flush(s);
1593
1594 *ps = s;
1595
1596 return 0;
1597}
ffmpeg Piment Noir Debian package repository