2
* Copyright (c) 2012 Andrew D'Addesio
3
* Copyright (c) 2013-2014 Mozilla Corporation
5
* This file is part of Libav.
7
* Libav 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.
12
* Libav 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.
17
* You should have received a copy of the GNU Lesser General Public
18
* License along with Libav; if not, write to the Free Software
19
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31
typedef struct SilkFrame {
37
float output [2 * SILK_HISTORY];
38
float lpc_history[2 * SILK_HISTORY];
45
AVCodecContext *avctx;
52
int nlsf_interp_factor;
54
enum OpusBandwidth bandwidth;
58
float prev_stereo_weights[2];
59
float stereo_weights[2];
61
int prev_coded_channels;
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
69
static const uint16_t silk_model_stereo_s2[] = {256, 85, 171, 256};
71
static const uint16_t silk_model_stereo_s3[] = {256, 51, 102, 154, 205, 256};
73
static const uint16_t silk_model_mid_only[] = {256, 192, 256};
75
static const uint16_t silk_model_frame_type_inactive[] = {256, 26, 256};
77
static const uint16_t silk_model_frame_type_active[] = {256, 24, 98, 246, 256};
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}
85
static const uint16_t silk_model_gain_lowbits[] = {256, 32, 64, 96, 128, 160, 192, 224, 256};
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
92
static const uint16_t silk_model_lsf_s1[2][2][33] = {
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
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
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
112
static const uint16_t silk_model_lsf_s2[32][10] = {
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 },
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 }
134
static const uint16_t silk_model_lsf_s2_ext[] = { 256, 156, 216, 240, 249, 253, 255, 256 };
136
static const uint16_t silk_model_lsf_interpolation_offset[] = { 256, 13, 35, 64, 75, 256 };
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
143
static const uint16_t silk_model_pitch_lowbits_nb[]= { 256, 64, 128, 192, 256 };
145
static const uint16_t silk_model_pitch_lowbits_mb[]= { 256, 43, 85, 128, 171, 213, 256 };
147
static const uint16_t silk_model_pitch_lowbits_wb[]= { 256, 32, 64, 96, 128, 160, 192, 224, 256 };
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
154
static const uint16_t silk_model_pitch_contour_nb10ms[] = { 256, 143, 193, 256 };
156
static const uint16_t silk_model_pitch_contour_nb20ms[] = {
157
256, 68, 80, 101, 118, 137, 159, 189, 213, 230, 246, 256
160
static const uint16_t silk_model_pitch_contour_mbwb10ms[] = {
161
256, 91, 137, 176, 195, 209, 221, 229, 236, 242, 247, 252, 256
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,
170
static const uint16_t silk_model_ltp_filter[] = { 256, 77, 157, 256 };
172
static const uint16_t silk_model_ltp_filter0_sel[] = {
173
256, 185, 200, 213, 226, 235, 244, 250, 256
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
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
185
static const uint16_t silk_model_ltp_scale_index[] = { 256, 128, 192, 256 };
187
static const uint16_t silk_model_lcg_seed[] = { 256, 64, 128, 192, 256 };
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
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 }
219
static const uint16_t silk_model_pulse_location[4][168] = {
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
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
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
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
291
static const uint16_t silk_model_excitation_lsb[] = {256, 136, 256};
293
static const uint16_t silk_model_excitation_sign[3][2][7][3] = {
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
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 }
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 }
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}
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}
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 }
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 }
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 }
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 }
576
static const uint16_t silk_lsf_min_spacing_nbmb[] = {
577
250, 3, 6, 3, 3, 3, 4, 3, 3, 3, 461
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
584
static const uint8_t silk_lsf_ordering_nbmb[] = {
585
0, 9, 6, 3, 4, 5, 8, 1, 2, 7
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
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,
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,
628
static const uint16_t silk_pitch_scale[] = { 4, 6, 8};
630
static const uint16_t silk_pitch_min_lag[] = { 16, 24, 32};
632
static const uint16_t silk_pitch_max_lag[] = {144, 216, 288};
634
static const int8_t silk_pitch_offset_nb10ms[3][2] = {
640
static const int8_t silk_pitch_offset_nb20ms[11][4] = {
654
static const int8_t silk_pitch_offset_mbwb10ms[12][2] = {
669
static const int8_t silk_pitch_offset_mbwb20ms[34][4] = {
706
static const int8_t silk_ltp_filter0_taps[8][5] = {
709
{ 12, 28, 41, 13, -4},
710
{ -9, 15, 42, 25, 14},
711
{ 1, -2, 62, 41, -9},
712
{-10, 37, 65, -4, 3},
714
{ 16, 14, 38, -3, 33}
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},
722
{ 6, -11, 74, 53, -9},
723
{-12, 55, 76, -12, 8},
724
{ -3, 3, 93, 27, -4},
725
{ 26, 39, 59, 3, -8},
727
{ -8, 22, 44, -6, 7},
729
{ -7, 20, 101, -7, 4},
731
{-15, 33, 68, 2, 23},
732
{ -2, 55, 46, -2, 15},
736
static const int8_t silk_ltp_filter2_taps[32][5] = {
737
{ -6, 27, 61, 39, 5},
739
{ -2, 60, 65, 6, -4},
740
{ -1, -5, 73, 56, 1},
741
{ -9, 19, 94, 29, -9},
743
{ 8, -19, 102, 46, -13},
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},
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},
771
static const uint16_t silk_ltp_scale_factor[] = {15565, 12288, 8192};
773
static const uint8_t silk_shell_blocks[3][2] = {
779
static const uint8_t silk_quant_offset[2][2] = { /* (0.23) */
780
{25, 60}, // Inactive or Unvoiced
784
static const int silk_stereo_interp_len[3] = {
788
static inline void silk_stabilize_lsf(int16_t nlsf[16], int order, const uint16_t min_delta[17])
791
for (pass = 0; pass < 20; pass++) {
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]);
798
if (diff < min_diff) {
806
if (min_diff == 0) /* no issues; stabilized */
809
/* wiggle one or two LSFs */
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];
817
/* repel away from current position */
818
int min_center = 0, max_center = 32768, center_val;
821
for (i = 0; i < k; i++)
822
min_center += min_delta[i];
823
min_center += min_delta[k] >> 1;
826
for (i = order; i > k; i--)
827
max_center -= min_delta[k];
828
max_center -= min_delta[k] >> 1;
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));
835
nlsf[k - 1] = center_val - (min_delta[k] >> 1);
836
nlsf[k] = nlsf[k - 1] + min_delta[k];
840
/* resort to the fall-back method, the standard method for LSF stabilization */
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];
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];
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];
867
static inline int silk_is_lpc_stable(const int16_t lpc[16], int order)
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;
874
/* initialize the first row for the Levinson recursion */
875
for (k = 0; k < order; k++) {
877
row[k] = lpc[k] * 4096;
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
891
if (FFABS(row[k]) > 16773022)
894
rc = -(row[k] * 128);
895
gaindiv = (1 << 30) - MULH(rc, rc);
897
totalinvgain = MULH(totalinvgain, gaindiv) << 2;
899
return (totalinvgain >= 107374);
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));
907
/* switch to the next row of the LPC coefficients */
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);
918
static void silk_lsp2poly(const int32_t lsp[16], int32_t pol[16], int half_order)
922
pol[0] = 65536; // 1.0 in Q16
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);
930
pol[1] -= lsp[2 * i];
934
static void silk_lsf2lpc(const int16_t nlsf[16], float lpcf[16], int order)
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
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];
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;
954
silk_lsp2poly(lsp , p, order >> 1);
955
silk_lsp2poly(lsp + 1, q, order >> 1);
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];
963
/* limit the range of the LPC coefficients to each fit within an int16_t */
964
for (i = 0; i < 10; i++) {
966
unsigned int maxabs = 0;
967
for (j = 0, k = 0; j < order; j++) {
968
unsigned int x = FFABS(lpc32[k]);
975
maxabs = (maxabs + 16) >> 5; // convert to Q12
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);
983
for (k = 0; k < order; k++) {
984
lpc32[k] = ROUND_MULL(lpc32[k], chirp, 16);
985
chirp = (chirp_base * chirp + 32768) >> 16;
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
998
for (k = 0; k < order; k++)
999
lpc[k] = (lpc32[k] + 16) >> 5;
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);
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;
1015
for (i = 0; i < order; i++)
1016
lpcf[i] = lpc[i] / 4096.0f;
1019
static inline void silk_decode_lpc(SilkContext *s, SilkFrame *frame,
1021
float lpc_leadin[16], float lpc[16],
1022
int *lpc_order, int *has_lpc_leadin, int voiced)
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
1030
*lpc_order = order = s->wb ? 16 : 10;
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);
1044
/* reverse the backwards-prediction step */
1045
for (i = order - 1; i >= 0; i--) {
1046
int qstep = s->wb ? 9830 : 11796;
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;
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;
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;
1066
/* find the weight of the residual */
1067
/* TODO: precompute */
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;
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);
1079
value = cur * 128 + (lsf_res[i] * 16384) / weight;
1080
nlsf[i] = av_clip(value, 0, 32767);
1083
/* stabilize the NLSF coefficients */
1084
silk_stabilize_lsf(nlsf, order, s->wb ? silk_lsf_min_spacing_wb :
1085
silk_lsf_min_spacing_nbmb);
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;
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));
1104
s->nlsf_interp_factor = offset;
1106
silk_lsf2lpc(nlsf, lpc, order);
1108
s->nlsf_interp_factor = 4;
1109
silk_lsf2lpc(nlsf, lpc, order);
1112
memcpy(frame->nlsf, nlsf, order * sizeof(nlsf[0]));
1113
memcpy(frame->lpc, lpc, order * sizeof(lpc[0]));
1116
static inline void silk_count_children(OpusRangeCoder *rc, int model, int32_t total,
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];
1129
static inline void silk_decode_excitation(SilkContext *s, OpusRangeCoder *rc,
1131
int qoffset_high, int active, int voiced)
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
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]);
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]);
1156
/* decode pulse locations using PVQ */
1157
for (i = 0; i < shellblocks; i++) {
1158
if (pulsecount[i] != 0) {
1160
int32_t * location = excitation + 16*i;
1161
int32_t branch[4][2];
1162
branch[0][0] = pulsecount[i];
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);
1179
memset(excitation + 16*i, 0, 16*sizeof(int32_t));
1182
/* decode least significant bits */
1183
for (i = 0; i < shellblocks << 4; i++) {
1185
for (bit = 0; bit < lsbcount[i >> 4]; bit++)
1186
excitation[i] = (excitation[i] << 1) |
1187
opus_rc_getsymbol(rc, silk_model_excitation_lsb);
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)]);
1196
excitation[i] *= -1;
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;
1207
/* invert samples pseudorandomly */
1208
seed = 196314165 * seed + 907633515;
1209
if (seed & 0x80000000)
1210
excitation[i] *= -1;
1213
excitationf[i] = excitation[i] / 8388608.0f;
1217
/** Maximum residual history according to 4.2.7.6.1 */
1218
#define SILK_MAX_LAG (288 + LTP_ORDER / 2)
1220
/** Order of the LTP filter */
1223
static void silk_decode_frame(SilkContext *s, OpusRangeCoder *rc,
1224
int frame_num, int channel, int coded_channels, int active, int active1)
1227
int voiced; // combines with active to indicate inactive, active, or active+voiced
1229
int order; // order of the LPC coefficients
1230
float lpc_leadin[16], lpc_body[16], residual[SILK_MAX_LAG + SILK_HISTORY];
1241
SilkFrame * const frame = s->frame + channel;
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);
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)
1259
s->stereo_weights[0] = (w[0] - w[1]) / 8192.0;
1260
s->stereo_weights[1] = w[1] / 8192.0;
1262
/* and read the mid-only flag */
1263
s->midonly = active1 ? 0 : opus_rc_getsymbol(rc, silk_model_mid_only);
1266
/* obtain frame type */
1268
qoffset_high = opus_rc_getsymbol(rc, silk_model_frame_type_inactive);
1271
int type = opus_rc_getsymbol(rc, silk_model_frame_type_active);
1272
qoffset_high = type & 1;
1276
/* obtain subframe quantization gains */
1277
for (i = 0; i < s->subframes; i++) {
1279
int ipart, fpart, lingain;
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);
1287
log_gain = FFMAX(log_gain, frame->log_gain - 16);
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);
1295
frame->log_gain = log_gain;
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;
1305
/* obtain LPC filter coefficients */
1306
silk_decode_lpc(s, frame, rc, lpc_leadin, lpc_body, &order, &has_lpc_leadin, voiced);
1308
/* obtain pitch lags, if this is a voiced frame */
1310
int lag_absolute = (!frame_num || !frame->prev_voiced);
1311
int primarylag; // primary pitch lag for the entire SILK frame
1313
const int8_t * offsets;
1315
if (!lag_absolute) {
1316
int delta = opus_rc_getsymbol(rc, silk_model_pitch_delta);
1318
primarylag = frame->primarylag + delta - 9;
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
1330
highbits = opus_rc_getsymbol(rc, silk_model_pitch_highbits);
1331
lowbits = opus_rc_getsymbol(rc, model[s->bandwidth]);
1333
primarylag = silk_pitch_min_lag[s->bandwidth] +
1334
highbits*silk_pitch_scale[s->bandwidth] + lowbits;
1336
frame->primarylag = primarylag;
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)];
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)];
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]);
1356
/* obtain LTP filter coefficients */
1357
ltpfilter = opus_rc_getsymbol(rc, silk_model_ltp_filter);
1358
for (i = 0; i < s->subframes; i++) {
1360
const uint16_t *filter_sel[] = {
1361
silk_model_ltp_filter0_sel, silk_model_ltp_filter1_sel,
1362
silk_model_ltp_filter2_sel
1364
const int8_t (*filter_taps[])[5] = {
1365
silk_ltp_filter0_taps, silk_ltp_filter1_taps, silk_ltp_filter2_taps
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;
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;
1379
/* generate the excitation signal for the entire frame */
1380
silk_decode_excitation(s, rc, residual + SILK_MAX_LAG, qoffset_high,
1383
/* skip synthesising the side channel if we want mono-only */
1384
if (s->output_channels == channel)
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;
1400
if (i < 2 || s->nlsf_interp_factor == 4) {
1401
out_end = -i * s->sflength;
1404
out_end = -(i - 2) * s->sflength;
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++) {
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;
1418
float rescale = sf[i-1].gain / sf[i].gain;
1419
for (j = out_end; j < 0; j++)
1420
resptr[j] *= rescale;
1424
for (j = 0; j < s->sflength; j++) {
1426
for (k = 0; k < LTP_ORDER; k++)
1427
sum += sf[i].ltptaps[k] * resptr[j - sf[i].pitchlag + LTP_ORDER/2 - k];
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];
1439
dst[j] = av_clipf(sum, -1.0f, 1.0f);
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));
1450
static void silk_unmix_ms(SilkContext *s, float *l, float *r)
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];
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]);
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);
1470
for (; i < s->flength; i++) {
1471
float p0 = 0.25 * (mid[i - 2] + 2 * mid[i - 1] + mid[i]);
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);
1477
memcpy(s->prev_stereo_weights, s->stereo_weights, sizeof(s->stereo_weights));
1480
static void silk_flush_frame(SilkFrame *frame)
1485
memset(frame->output, 0, sizeof(frame->output));
1486
memset(frame->lpc_history, 0, sizeof(frame->lpc_history));
1488
memset(frame->lpc, 0, sizeof(frame->lpc));
1489
memset(frame->nlsf, 0, sizeof(frame->nlsf));
1491
frame->log_gain = 0;
1493
frame->primarylag = 0;
1494
frame->prev_voiced = 0;
1498
int ff_silk_decode_superframe(SilkContext *s, OpusRangeCoder *rc,
1500
enum OpusBandwidth bandwidth,
1504
int active[2][6], redundancy[2];
1505
int nb_frames, i, j;
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);
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;
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;
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);
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;
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]);
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]);
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));
1553
silk_unmix_ms(s, output[0] + i * s->flength, output[1] + i * s->flength);
1559
return nb_frames * s->flength;
1562
void ff_silk_free(SilkContext **ps)
1567
void ff_silk_flush(SilkContext *s)
1569
silk_flush_frame(&s->frame[0]);
1570
silk_flush_frame(&s->frame[1]);
1572
memset(s->prev_stereo_weights, 0, sizeof(s->prev_stereo_weights));
1575
int ff_silk_init(AVCodecContext *avctx, SilkContext **ps, int output_channels)
1579
if (output_channels != 1 && output_channels != 2) {
1580
av_log(avctx, AV_LOG_ERROR, "Invalid number of output channels: %d\n",
1582
return AVERROR(EINVAL);
1585
s = av_mallocz(sizeof(*s));
1587
return AVERROR(ENOMEM);
1590
s->output_channels = output_channels;
added
removed
libavcodec/opus_silk.c
