exr: fix out of bounds read in get_code
[ffmpeg.git] / libavcodec / opus_silk.c
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
31 typedef 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
44 struct 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
64 static 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
69 static const uint16_t silk_model_stereo_s2[] = {256, 85, 171, 256};
70
71 static const uint16_t silk_model_stereo_s3[] = {256, 51, 102, 154, 205, 256};
72
73 static const uint16_t silk_model_mid_only[] = {256, 192, 256};
74
75 static const uint16_t silk_model_frame_type_inactive[] = {256, 26, 256};
76
77 static const uint16_t silk_model_frame_type_active[] = {256, 24, 98, 246, 256};
78
79 static 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
85 static const uint16_t silk_model_gain_lowbits[] = {256, 32, 64, 96, 128, 160, 192, 224, 256};
86
87 static 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 };
92 static 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
112 static 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
134 static const uint16_t silk_model_lsf_s2_ext[] = { 256, 156, 216, 240, 249, 253, 255, 256 };
135
136 static const uint16_t silk_model_lsf_interpolation_offset[] = { 256, 13, 35, 64, 75, 256 };
137
138 static 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
143 static const uint16_t silk_model_pitch_lowbits_nb[]= { 256, 64, 128, 192, 256 };
144
145 static const uint16_t silk_model_pitch_lowbits_mb[]= { 256, 43, 85, 128, 171, 213, 256 };
146
147 static const uint16_t silk_model_pitch_lowbits_wb[]= { 256, 32, 64, 96, 128, 160, 192, 224, 256 };
148
149 static 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
154 static const uint16_t silk_model_pitch_contour_nb10ms[] = { 256, 143, 193, 256 };
155
156 static const uint16_t silk_model_pitch_contour_nb20ms[] = {
157     256,  68,  80, 101, 118, 137, 159, 189, 213, 230, 246, 256
158 };
159
160 static const uint16_t silk_model_pitch_contour_mbwb10ms[] = {
161     256,  91, 137, 176, 195, 209, 221, 229, 236, 242, 247, 252, 256
162 };
163
164 static 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
170 static const uint16_t silk_model_ltp_filter[] = { 256, 77, 157, 256 };
171
172 static const uint16_t silk_model_ltp_filter0_sel[] = {
173     256, 185, 200, 213, 226, 235, 244, 250, 256
174 };
175
176 static 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
180 static 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
185 static const uint16_t silk_model_ltp_scale_index[] = { 256, 128, 192, 256 };
186
187 static const uint16_t silk_model_lcg_seed[] = { 256, 64, 128, 192, 256 };
188
189 static 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
194 static 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
219 static 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
291 static const uint16_t silk_model_excitation_lsb[] = {256, 136, 256};
292
293 static 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
351 static 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
356 static 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
391 static 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
426 static 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
431 static 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
436 static 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
471 static 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
506 static 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
541 static 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
576 static const uint16_t silk_lsf_min_spacing_nbmb[] = {
577     250, 3, 6, 3, 3, 3, 4, 3, 3, 3, 461
578 };
579
580 static 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
584 static const uint8_t silk_lsf_ordering_nbmb[] = {
585     0, 9, 6, 3, 4, 5, 8, 1, 2, 7
586 };
587
588 static 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
592 static 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
628 static const uint16_t silk_pitch_scale[]   = {  4,   6,   8};
629
630 static const uint16_t silk_pitch_min_lag[] = { 16,  24,  32};
631
632 static const uint16_t silk_pitch_max_lag[] = {144, 216, 288};
633
634 static const int8_t silk_pitch_offset_nb10ms[3][2] = {
635     { 0,  0},
636     { 1,  0},
637     { 0,  1}
638 };
639
640 static 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
654 static 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
669 static 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
706 static 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
717 static 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
736 static 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
771 static const uint16_t silk_ltp_scale_factor[] = {15565, 12288, 8192};
772
773 static const uint8_t silk_shell_blocks[3][2] = {
774     { 5, 10}, // NB
775     { 8, 15}, // MB
776     {10, 20}  // WB
777 };
778
779 static const uint8_t silk_quant_offset[2][2] = { /* (0.23) */
780     {25, 60}, // Inactive or Unvoiced
781     { 8, 25}  // Voiced
782 };
783
784 static const int silk_stereo_interp_len[3] = {
785     64, 96, 128
786 };
787
788 static 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[i];
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
867 static 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
918 static 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
934 static 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
1019 static 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_uintp2(value, 15);
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
1116 static 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
1129 static 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
1223 static 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_uintp2(FFMAX((delta_gain<<1) - 16,
1292                                      frame->log_gain + delta_gain - 4), 6);
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
1450 static 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
1480 static 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
1498 int 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
1562 void ff_silk_free(SilkContext **ps)
1563 {
1564     av_freep(ps);
1565 }
1566
1567 void 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
1575 int 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 }