1 /*
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 /*
12 * entropy_coding.c
13 *
14 * This header file defines all of the functions used to arithmetically
15 * encode the iSAC bistream
16 *
17 */
18
19
20 #include "entropy_coding.h"
21 #include "settings.h"
22 #include "arith_routines.h"
23 #include "signal_processing_library.h"
24 #include "spectrum_ar_model_tables.h"
25 #include "lpc_tables.h"
26 #include "pitch_gain_tables.h"
27 #include "pitch_lag_tables.h"
28 #include "encode_lpc_swb.h"
29 #include "lpc_shape_swb12_tables.h"
30 #include "lpc_shape_swb16_tables.h"
31 #include "lpc_gain_swb_tables.h"
32 #include "os_specific_inline.h"
33
34 #include <math.h>
35 #include <string.h>
36
37 static const uint16_t kLpcVecPerSegmentUb12 = 5;
38 static const uint16_t kLpcVecPerSegmentUb16 = 4;
39
40 /* CDF array for encoder bandwidth (12 vs 16 kHz) indicator. */
41 static const uint16_t kOneBitEqualProbCdf[3] = {
42 0, 32768, 65535 };
43
44 /* Pointer to cdf array for encoder bandwidth (12 vs 16 kHz) indicator. */
45 static const uint16_t* kOneBitEqualProbCdf_ptr[1] = {
46 kOneBitEqualProbCdf };
47
48 /*
49 * Initial cdf index for decoder of encoded bandwidth
50 * (12 vs 16 kHz) indicator.
51 */
52 static const uint16_t kOneBitEqualProbInitIndex[1] = { 1 };
53
54
55 static const int kIsSWB12 = 1;
56
57 /* compute correlation from power spectrum */
FindCorrelation(int32_t * PSpecQ12,int32_t * CorrQ7)58 static void FindCorrelation(int32_t* PSpecQ12, int32_t* CorrQ7) {
59 int32_t summ[FRAMESAMPLES / 8];
60 int32_t diff[FRAMESAMPLES / 8];
61 const int16_t* CS_ptrQ9;
62 int32_t sum;
63 int k, n;
64
65 for (k = 0; k < FRAMESAMPLES / 8; k++) {
66 summ[k] = (PSpecQ12[k] + PSpecQ12[FRAMESAMPLES_QUARTER - 1 - k] + 16) >> 5;
67 diff[k] = (PSpecQ12[k] - PSpecQ12[FRAMESAMPLES_QUARTER - 1 - k] + 16) >> 5;
68 }
69
70 sum = 2;
71 for (n = 0; n < FRAMESAMPLES / 8; n++) {
72 sum += summ[n];
73 }
74 CorrQ7[0] = sum;
75
76 for (k = 0; k < AR_ORDER; k += 2) {
77 sum = 0;
78 CS_ptrQ9 = WebRtcIsac_kCos[k];
79 for (n = 0; n < FRAMESAMPLES / 8; n++)
80 sum += (CS_ptrQ9[n] * diff[n] + 256) >> 9;
81 CorrQ7[k + 1] = sum;
82 }
83
84 for (k = 1; k < AR_ORDER; k += 2) {
85 sum = 0;
86 CS_ptrQ9 = WebRtcIsac_kCos[k];
87 for (n = 0; n < FRAMESAMPLES / 8; n++)
88 sum += (CS_ptrQ9[n] * summ[n] + 256) >> 9;
89 CorrQ7[k + 1] = sum;
90 }
91 }
92
93 /* compute inverse AR power spectrum */
94 /* Changed to the function used in iSAC FIX for compatibility reasons */
FindInvArSpec(const int16_t * ARCoefQ12,const int32_t gainQ10,int32_t * CurveQ16)95 static void FindInvArSpec(const int16_t* ARCoefQ12,
96 const int32_t gainQ10,
97 int32_t* CurveQ16) {
98 int32_t CorrQ11[AR_ORDER + 1];
99 int32_t sum, tmpGain;
100 int32_t diffQ16[FRAMESAMPLES / 8];
101 const int16_t* CS_ptrQ9;
102 int k, n;
103 int16_t round, shftVal = 0, sh;
104
105 sum = 0;
106 for (n = 0; n < AR_ORDER + 1; n++) {
107 sum += WEBRTC_SPL_MUL(ARCoefQ12[n], ARCoefQ12[n]); /* Q24 */
108 }
109 sum = ((sum >> 6) * 65 + 32768) >> 16; /* Q8 */
110 CorrQ11[0] = (sum * gainQ10 + 256) >> 9;
111
112 /* To avoid overflow, we shift down gainQ10 if it is large.
113 * We will not lose any precision */
114 if (gainQ10 > 400000) {
115 tmpGain = gainQ10 >> 3;
116 round = 32;
117 shftVal = 6;
118 } else {
119 tmpGain = gainQ10;
120 round = 256;
121 shftVal = 9;
122 }
123
124 for (k = 1; k < AR_ORDER + 1; k++) {
125 sum = 16384;
126 for (n = k; n < AR_ORDER + 1; n++)
127 sum += WEBRTC_SPL_MUL(ARCoefQ12[n - k], ARCoefQ12[n]); /* Q24 */
128 sum >>= 15;
129 CorrQ11[k] = (sum * tmpGain + round) >> shftVal;
130 }
131 sum = CorrQ11[0] << 7;
132 for (n = 0; n < FRAMESAMPLES / 8; n++) {
133 CurveQ16[n] = sum;
134 }
135 for (k = 1; k < AR_ORDER; k += 2) {
136 for (n = 0; n < FRAMESAMPLES / 8; n++) {
137 CurveQ16[n] += (WebRtcIsac_kCos[k][n] * CorrQ11[k + 1] + 2) >> 2;
138 }
139 }
140
141 CS_ptrQ9 = WebRtcIsac_kCos[0];
142
143 /* If CorrQ11[1] too large we avoid getting overflow in the
144 * calculation by shifting */
145 sh = WebRtcSpl_NormW32(CorrQ11[1]);
146 if (CorrQ11[1] == 0) { /* Use next correlation */
147 sh = WebRtcSpl_NormW32(CorrQ11[2]);
148 }
149 if (sh < 9) {
150 shftVal = 9 - sh;
151 } else {
152 shftVal = 0;
153 }
154 for (n = 0; n < FRAMESAMPLES / 8; n++) {
155 diffQ16[n] = (CS_ptrQ9[n] * (CorrQ11[1] >> shftVal) + 2) >> 2;
156 }
157 for (k = 2; k < AR_ORDER; k += 2) {
158 CS_ptrQ9 = WebRtcIsac_kCos[k];
159 for (n = 0; n < FRAMESAMPLES / 8; n++) {
160 diffQ16[n] += (CS_ptrQ9[n] * (CorrQ11[k + 1] >> shftVal) + 2) >> 2;
161 }
162 }
163
164 for (k = 0; k < FRAMESAMPLES / 8; k++) {
165 CurveQ16[FRAMESAMPLES_QUARTER - 1 - k] = CurveQ16[k] -
166 (diffQ16[k] << shftVal);
167 CurveQ16[k] += diffQ16[k] << shftVal;
168 }
169 }
170
171 /* Generate array of dither samples in Q7. */
GenerateDitherQ7Lb(int16_t * bufQ7,uint32_t seed,int length,int16_t AvgPitchGain_Q12)172 static void GenerateDitherQ7Lb(int16_t* bufQ7, uint32_t seed,
173 int length, int16_t AvgPitchGain_Q12) {
174 int k, shft;
175 int16_t dither1_Q7, dither2_Q7, dither_gain_Q14;
176
177 /* This threshold should be equal to that in decode_spec(). */
178 if (AvgPitchGain_Q12 < 614) {
179 for (k = 0; k < length - 2; k += 3) {
180 /* New random unsigned int. */
181 seed = (seed * 196314165) + 907633515;
182
183 /* Fixed-point dither sample between -64 and 64 (Q7). */
184 /* dither = seed * 128 / 4294967295 */
185 dither1_Q7 = (int16_t)(((int)seed + 16777216) >> 25);
186
187 /* New random unsigned int. */
188 seed = (seed * 196314165) + 907633515;
189
190 /* Fixed-point dither sample between -64 and 64. */
191 dither2_Q7 = (int16_t)(((int)seed + 16777216) >> 25);
192
193 shft = (seed >> 25) & 15;
194 if (shft < 5) {
195 bufQ7[k] = dither1_Q7;
196 bufQ7[k + 1] = dither2_Q7;
197 bufQ7[k + 2] = 0;
198 } else if (shft < 10) {
199 bufQ7[k] = dither1_Q7;
200 bufQ7[k + 1] = 0;
201 bufQ7[k + 2] = dither2_Q7;
202 } else {
203 bufQ7[k] = 0;
204 bufQ7[k + 1] = dither1_Q7;
205 bufQ7[k + 2] = dither2_Q7;
206 }
207 }
208 } else {
209 dither_gain_Q14 = (int16_t)(22528 - 10 * AvgPitchGain_Q12);
210
211 /* Dither on half of the coefficients. */
212 for (k = 0; k < length - 1; k += 2) {
213 /* New random unsigned int */
214 seed = (seed * 196314165) + 907633515;
215
216 /* Fixed-point dither sample between -64 and 64. */
217 dither1_Q7 = (int16_t)(((int)seed + 16777216) >> 25);
218
219 /* Dither sample is placed in either even or odd index. */
220 shft = (seed >> 25) & 1; /* Either 0 or 1 */
221
222 bufQ7[k + shft] = (((dither_gain_Q14 * dither1_Q7) + 8192) >> 14);
223 bufQ7[k + 1 - shft] = 0;
224 }
225 }
226 }
227
228
229
230 /******************************************************************************
231 * GenerateDitherQ7LbUB()
232 *
233 * generate array of dither samples in Q7 There are less zeros in dither
234 * vector compared to GenerateDitherQ7Lb.
235 *
236 * A uniform random number generator with the range of [-64 64] is employed
237 * but the generated dithers are scaled by 0.35, a heuristic scaling.
238 *
239 * Input:
240 * -seed : the initial seed for the random number generator.
241 * -length : the number of dither values to be generated.
242 *
243 * Output:
244 * -bufQ7 : pointer to a buffer where dithers are written to.
245 */
GenerateDitherQ7LbUB(int16_t * bufQ7,uint32_t seed,int length)246 static void GenerateDitherQ7LbUB(
247 int16_t* bufQ7,
248 uint32_t seed,
249 int length) {
250 int k;
251 for (k = 0; k < length; k++) {
252 /* new random unsigned int */
253 seed = (seed * 196314165) + 907633515;
254
255 /* Fixed-point dither sample between -64 and 64 (Q7). */
256 /* bufQ7 = seed * 128 / 4294967295 */
257 bufQ7[k] = (int16_t)(((int)seed + 16777216) >> 25);
258
259 /* Scale by 0.35. */
260 bufQ7[k] = (int16_t)WEBRTC_SPL_MUL_16_16_RSFT(bufQ7[k], 2048, 13);
261 }
262 }
263
264 /*
265 * Function to decode the complex spectrum from the bit stream
266 * returns the total number of bytes in the stream.
267 */
WebRtcIsac_DecodeSpec(Bitstr * streamdata,int16_t AvgPitchGain_Q12,enum ISACBand band,double * fr,double * fi)268 int WebRtcIsac_DecodeSpec(Bitstr* streamdata, int16_t AvgPitchGain_Q12,
269 enum ISACBand band, double* fr, double* fi) {
270 int16_t DitherQ7[FRAMESAMPLES];
271 int16_t data[FRAMESAMPLES];
272 int32_t invARSpec2_Q16[FRAMESAMPLES_QUARTER];
273 uint16_t invARSpecQ8[FRAMESAMPLES_QUARTER];
274 int16_t ARCoefQ12[AR_ORDER + 1];
275 int16_t RCQ15[AR_ORDER];
276 int16_t gainQ10;
277 int32_t gain2_Q10, res;
278 int32_t in_sqrt;
279 int32_t newRes;
280 int k, len, i;
281 int is_12khz = !kIsSWB12;
282 int num_dft_coeff = FRAMESAMPLES;
283 /* Create dither signal. */
284 if (band == kIsacLowerBand) {
285 GenerateDitherQ7Lb(DitherQ7, streamdata->W_upper, FRAMESAMPLES,
286 AvgPitchGain_Q12);
287 } else {
288 GenerateDitherQ7LbUB(DitherQ7, streamdata->W_upper, FRAMESAMPLES);
289 if (band == kIsacUpperBand12) {
290 is_12khz = kIsSWB12;
291 num_dft_coeff = FRAMESAMPLES_HALF;
292 }
293 }
294
295 /* Decode model parameters. */
296 if (WebRtcIsac_DecodeRc(streamdata, RCQ15) < 0)
297 return -ISAC_RANGE_ERROR_DECODE_SPECTRUM;
298
299 WebRtcSpl_ReflCoefToLpc(RCQ15, AR_ORDER, ARCoefQ12);
300
301 if (WebRtcIsac_DecodeGain2(streamdata, &gain2_Q10) < 0)
302 return -ISAC_RANGE_ERROR_DECODE_SPECTRUM;
303
304 /* Compute inverse AR power spectrum. */
305 FindInvArSpec(ARCoefQ12, gain2_Q10, invARSpec2_Q16);
306
307 /* Convert to magnitude spectrum,
308 * by doing square-roots (modified from SPLIB). */
309 res = 1 << (WebRtcSpl_GetSizeInBits(invARSpec2_Q16[0]) >> 1);
310 for (k = 0; k < FRAMESAMPLES_QUARTER; k++) {
311 in_sqrt = invARSpec2_Q16[k];
312 i = 10;
313
314 /* Negative values make no sense for a real sqrt-function. */
315 if (in_sqrt < 0)
316 in_sqrt = -in_sqrt;
317
318 newRes = (in_sqrt / res + res) >> 1;
319 do {
320 res = newRes;
321 newRes = (in_sqrt / res + res) >> 1;
322 } while (newRes != res && i-- > 0);
323
324 invARSpecQ8[k] = (int16_t)newRes;
325 }
326
327 len = WebRtcIsac_DecLogisticMulti2(data, streamdata, invARSpecQ8, DitherQ7,
328 num_dft_coeff, is_12khz);
329 /* Arithmetic decoding of spectrum. */
330 if (len < 1) {
331 return -ISAC_RANGE_ERROR_DECODE_SPECTRUM;
332 }
333
334 switch (band) {
335 case kIsacLowerBand: {
336 /* Scale down spectral samples with low SNR. */
337 int32_t p1;
338 int32_t p2;
339 if (AvgPitchGain_Q12 <= 614) {
340 p1 = 30 << 10;
341 p2 = 32768 + (33 << 16);
342 } else {
343 p1 = 36 << 10;
344 p2 = 32768 + (40 << 16);
345 }
346 for (k = 0; k < FRAMESAMPLES; k += 4) {
347 gainQ10 = WebRtcSpl_DivW32W16ResW16(p1, (int16_t)(
348 (invARSpec2_Q16[k >> 2] + p2) >> 16));
349 *fr++ = (double)((data[ k ] * gainQ10 + 512) >> 10) / 128.0;
350 *fi++ = (double)((data[k + 1] * gainQ10 + 512) >> 10) / 128.0;
351 *fr++ = (double)((data[k + 2] * gainQ10 + 512) >> 10) / 128.0;
352 *fi++ = (double)((data[k + 3] * gainQ10 + 512) >> 10) / 128.0;
353 }
354 break;
355 }
356 case kIsacUpperBand12: {
357 for (k = 0, i = 0; k < FRAMESAMPLES_HALF; k += 4) {
358 fr[i] = (double)data[ k ] / 128.0;
359 fi[i] = (double)data[k + 1] / 128.0;
360 i++;
361 fr[i] = (double)data[k + 2] / 128.0;
362 fi[i] = (double)data[k + 3] / 128.0;
363 i++;
364 }
365 /* The second half of real and imaginary coefficients is zero. This is
366 * due to using the old FFT module which requires two signals as input
367 * while in 0-12 kHz mode we only have 8-12 kHz band, and the second
368 * signal is set to zero. */
369 memset(&fr[FRAMESAMPLES_QUARTER], 0, FRAMESAMPLES_QUARTER *
370 sizeof(double));
371 memset(&fi[FRAMESAMPLES_QUARTER], 0, FRAMESAMPLES_QUARTER *
372 sizeof(double));
373 break;
374 }
375 case kIsacUpperBand16: {
376 for (i = 0, k = 0; k < FRAMESAMPLES; k += 4, i++) {
377 fr[i] = (double)data[ k ] / 128.0;
378 fi[i] = (double)data[k + 1] / 128.0;
379 fr[(FRAMESAMPLES_HALF) - 1 - i] = (double)data[k + 2] / 128.0;
380 fi[(FRAMESAMPLES_HALF) - 1 - i] = (double)data[k + 3] / 128.0;
381 }
382 break;
383 }
384 }
385 return len;
386 }
387
388
WebRtcIsac_EncodeSpec(const int16_t * fr,const int16_t * fi,int16_t AvgPitchGain_Q12,enum ISACBand band,Bitstr * streamdata)389 int WebRtcIsac_EncodeSpec(const int16_t* fr, const int16_t* fi,
390 int16_t AvgPitchGain_Q12, enum ISACBand band,
391 Bitstr* streamdata) {
392 int16_t ditherQ7[FRAMESAMPLES];
393 int16_t dataQ7[FRAMESAMPLES];
394 int32_t PSpec[FRAMESAMPLES_QUARTER];
395 int32_t invARSpec2_Q16[FRAMESAMPLES_QUARTER];
396 uint16_t invARSpecQ8[FRAMESAMPLES_QUARTER];
397 int32_t CorrQ7[AR_ORDER + 1];
398 int32_t CorrQ7_norm[AR_ORDER + 1];
399 int16_t RCQ15[AR_ORDER];
400 int16_t ARCoefQ12[AR_ORDER + 1];
401 int32_t gain2_Q10;
402 int16_t val;
403 int32_t nrg, res;
404 uint32_t sum;
405 int32_t in_sqrt;
406 int32_t newRes;
407 int16_t err;
408 uint32_t nrg_u32;
409 int shift_var;
410 int k, n, j, i;
411 int is_12khz = !kIsSWB12;
412 int num_dft_coeff = FRAMESAMPLES;
413
414 /* Create dither signal. */
415 if (band == kIsacLowerBand) {
416 GenerateDitherQ7Lb(ditherQ7, streamdata->W_upper, FRAMESAMPLES,
417 AvgPitchGain_Q12);
418 } else {
419 GenerateDitherQ7LbUB(ditherQ7, streamdata->W_upper, FRAMESAMPLES);
420 if (band == kIsacUpperBand12) {
421 is_12khz = kIsSWB12;
422 num_dft_coeff = FRAMESAMPLES_HALF;
423 }
424 }
425
426 /* add dither and quantize, and compute power spectrum */
427 switch (band) {
428 case kIsacLowerBand: {
429 for (k = 0; k < FRAMESAMPLES; k += 4) {
430 val = ((*fr++ + ditherQ7[k] + 64) & 0xFF80) - ditherQ7[k];
431 dataQ7[k] = val;
432 sum = val * val;
433
434 val = ((*fi++ + ditherQ7[k + 1] + 64) & 0xFF80) - ditherQ7[k + 1];
435 dataQ7[k + 1] = val;
436 sum += val * val;
437
438 val = ((*fr++ + ditherQ7[k + 2] + 64) & 0xFF80) - ditherQ7[k + 2];
439 dataQ7[k + 2] = val;
440 sum += val * val;
441
442 val = ((*fi++ + ditherQ7[k + 3] + 64) & 0xFF80) - ditherQ7[k + 3];
443 dataQ7[k + 3] = val;
444 sum += val * val;
445
446 PSpec[k >> 2] = sum >> 2;
447 }
448 break;
449 }
450 case kIsacUpperBand12: {
451 for (k = 0, j = 0; k < FRAMESAMPLES_HALF; k += 4) {
452 val = ((*fr++ + ditherQ7[k] + 64) & 0xFF80) - ditherQ7[k];
453 dataQ7[k] = val;
454 sum = val * val;
455
456 val = ((*fi++ + ditherQ7[k + 1] + 64) & 0xFF80) - ditherQ7[k + 1];
457 dataQ7[k + 1] = val;
458 sum += val * val;
459
460 PSpec[j++] = sum >> 1;
461
462 val = ((*fr++ + ditherQ7[k + 2] + 64) & 0xFF80) - ditherQ7[k + 2];
463 dataQ7[k + 2] = val;
464 sum = val * val;
465
466 val = ((*fi++ + ditherQ7[k + 3] + 64) & 0xFF80) - ditherQ7[k + 3];
467 dataQ7[k + 3] = val;
468 sum += val * val;
469
470 PSpec[j++] = sum >> 1;
471 }
472 break;
473 }
474 case kIsacUpperBand16: {
475 for (j = 0, k = 0; k < FRAMESAMPLES; k += 4, j++) {
476 val = ((fr[j] + ditherQ7[k] + 64) & 0xFF80) - ditherQ7[k];
477 dataQ7[k] = val;
478 sum = val * val;
479
480 val = ((fi[j] + ditherQ7[k + 1] + 64) & 0xFF80) - ditherQ7[k + 1];
481 dataQ7[k + 1] = val;
482 sum += val * val;
483
484 val = ((fr[(FRAMESAMPLES_HALF) - 1 - j] + ditherQ7[k + 2] + 64) &
485 0xFF80) - ditherQ7[k + 2];
486 dataQ7[k + 2] = val;
487 sum += val * val;
488
489 val = ((fi[(FRAMESAMPLES_HALF) - 1 - j] + ditherQ7[k + 3] + 64) &
490 0xFF80) - ditherQ7[k + 3];
491 dataQ7[k + 3] = val;
492 sum += val * val;
493
494 PSpec[k >> 2] = sum >> 2;
495 }
496 break;
497 }
498 }
499
500 /* compute correlation from power spectrum */
501 FindCorrelation(PSpec, CorrQ7);
502
503 /* Find AR coefficients */
504 /* Aumber of bit shifts to 14-bit normalize CorrQ7[0]
505 * (leaving room for sign) */
506 shift_var = WebRtcSpl_NormW32(CorrQ7[0]) - 18;
507
508 if (shift_var > 0) {
509 for (k = 0; k < AR_ORDER + 1; k++) {
510 CorrQ7_norm[k] = CorrQ7[k] << shift_var;
511 }
512 } else {
513 for (k = 0; k < AR_ORDER + 1; k++) {
514 CorrQ7_norm[k] = CorrQ7[k] >> (-shift_var);
515 }
516 }
517
518 /* Find RC coefficients. */
519 WebRtcSpl_AutoCorrToReflCoef(CorrQ7_norm, AR_ORDER, RCQ15);
520
521 /* Quantize & code RC Coefficient. */
522 WebRtcIsac_EncodeRc(RCQ15, streamdata);
523
524 /* RC -> AR coefficients */
525 WebRtcSpl_ReflCoefToLpc(RCQ15, AR_ORDER, ARCoefQ12);
526
527 /* Compute ARCoef' * Corr * ARCoef in Q19. */
528 nrg = 0;
529 for (j = 0; j <= AR_ORDER; j++) {
530 for (n = 0; n <= j; n++) {
531 nrg += (ARCoefQ12[j] * ((CorrQ7_norm[j - n] * ARCoefQ12[n] + 256) >> 9) +
532 4) >> 3;
533 }
534 for (n = j + 1; n <= AR_ORDER; n++) {
535 nrg += (ARCoefQ12[j] * ((CorrQ7_norm[n - j] * ARCoefQ12[n] + 256) >> 9) +
536 4) >> 3;
537 }
538 }
539
540 nrg_u32 = (uint32_t)nrg;
541 if (shift_var > 0) {
542 nrg_u32 = nrg_u32 >> shift_var;
543 } else {
544 nrg_u32 = nrg_u32 << (-shift_var);
545 }
546 if (nrg_u32 > 0x7FFFFFFF) {
547 nrg = 0x7FFFFFFF;
548 } else {
549 nrg = (int32_t)nrg_u32;
550 }
551 /* Also shifts 31 bits to the left! */
552 gain2_Q10 = WebRtcSpl_DivResultInQ31(FRAMESAMPLES_QUARTER, nrg);
553
554 /* Quantize & code gain2_Q10. */
555 if (WebRtcIsac_EncodeGain2(&gain2_Q10, streamdata)) {
556 return -1;
557 }
558
559 /* Compute inverse AR power spectrum. */
560 FindInvArSpec(ARCoefQ12, gain2_Q10, invARSpec2_Q16);
561 /* Convert to magnitude spectrum, by doing square-roots
562 * (modified from SPLIB). */
563 res = 1 << (WebRtcSpl_GetSizeInBits(invARSpec2_Q16[0]) >> 1);
564 for (k = 0; k < FRAMESAMPLES_QUARTER; k++) {
565 in_sqrt = invARSpec2_Q16[k];
566 i = 10;
567 /* Negative values make no sense for a real sqrt-function. */
568 if (in_sqrt < 0) {
569 in_sqrt = -in_sqrt;
570 }
571 newRes = (in_sqrt / res + res) >> 1;
572 do {
573 res = newRes;
574 newRes = (in_sqrt / res + res) >> 1;
575 } while (newRes != res && i-- > 0);
576
577 invARSpecQ8[k] = (int16_t)newRes;
578 }
579 /* arithmetic coding of spectrum */
580 err = WebRtcIsac_EncLogisticMulti2(streamdata, dataQ7, invARSpecQ8,
581 num_dft_coeff, is_12khz);
582 if (err < 0) {
583 return (err);
584 }
585 return 0;
586 }
587
588
589 /* step-up */
WebRtcIsac_Rc2Poly(double * RC,int N,double * a)590 void WebRtcIsac_Rc2Poly(double* RC, int N, double* a) {
591 int m, k;
592 double tmp[MAX_AR_MODEL_ORDER];
593
594 a[0] = 1.0;
595 tmp[0] = 1.0;
596 for (m = 1; m <= N; m++) {
597 /* copy */
598 memcpy(&tmp[1], &a[1], (m - 1) * sizeof(double));
599 a[m] = RC[m - 1];
600 for (k = 1; k < m; k++) {
601 a[k] += RC[m - 1] * tmp[m - k];
602 }
603 }
604 return;
605 }
606
607 /* step-down */
WebRtcIsac_Poly2Rc(double * a,int N,double * RC)608 void WebRtcIsac_Poly2Rc(double* a, int N, double* RC) {
609 int m, k;
610 double tmp[MAX_AR_MODEL_ORDER];
611 double tmp_inv;
612
613 RC[N - 1] = a[N];
614 for (m = N - 1; m > 0; m--) {
615 tmp_inv = 1.0 / (1.0 - RC[m] * RC[m]);
616 for (k = 1; k <= m; k++) {
617 tmp[k] = (a[k] - RC[m] * a[m - k + 1]) * tmp_inv;
618 }
619
620 memcpy(&a[1], &tmp[1], (m - 1) * sizeof(double));
621 RC[m - 1] = tmp[m];
622 }
623 return;
624 }
625
626
627 #define MAX_ORDER 100
628
629 /* Matlab's LAR definition */
WebRtcIsac_Rc2Lar(const double * refc,double * lar,int order)630 void WebRtcIsac_Rc2Lar(const double* refc, double* lar, int order) {
631 int k;
632 for (k = 0; k < order; k++) {
633 lar[k] = log((1 + refc[k]) / (1 - refc[k]));
634 }
635 }
636
637
WebRtcIsac_Lar2Rc(const double * lar,double * refc,int order)638 void WebRtcIsac_Lar2Rc(const double* lar, double* refc, int order) {
639 int k;
640 double tmp;
641
642 for (k = 0; k < order; k++) {
643 tmp = exp(lar[k]);
644 refc[k] = (tmp - 1) / (tmp + 1);
645 }
646 }
647
WebRtcIsac_Poly2Lar(double * lowband,int orderLo,double * hiband,int orderHi,int Nsub,double * lars)648 void WebRtcIsac_Poly2Lar(double* lowband, int orderLo, double* hiband,
649 int orderHi, int Nsub, double* lars) {
650 int k;
651 double rc[MAX_ORDER], *inpl, *inph, *outp;
652
653 inpl = lowband;
654 inph = hiband;
655 outp = lars;
656 for (k = 0; k < Nsub; k++) {
657 /* gains */
658 outp[0] = inpl[0];
659 outp[1] = inph[0];
660 outp += 2;
661
662 /* Low band */
663 inpl[0] = 1.0;
664 WebRtcIsac_Poly2Rc(inpl, orderLo, rc);
665 WebRtcIsac_Rc2Lar(rc, outp, orderLo);
666 outp += orderLo;
667
668 /* High band */
669 inph[0] = 1.0;
670 WebRtcIsac_Poly2Rc(inph, orderHi, rc);
671 WebRtcIsac_Rc2Lar(rc, outp, orderHi);
672 outp += orderHi;
673
674 inpl += orderLo + 1;
675 inph += orderHi + 1;
676 }
677 }
678
679
WebRtcIsac_Poly2LarUB(double * lpcVecs,int16_t bandwidth)680 int16_t WebRtcIsac_Poly2LarUB(double* lpcVecs, int16_t bandwidth) {
681 double poly[MAX_ORDER];
682 double rc[MAX_ORDER];
683 double* ptrIO;
684 int16_t vecCntr;
685 int16_t vecSize;
686 int16_t numVec;
687
688 vecSize = UB_LPC_ORDER;
689 switch (bandwidth) {
690 case isac12kHz: {
691 numVec = UB_LPC_VEC_PER_FRAME;
692 break;
693 }
694 case isac16kHz: {
695 numVec = UB16_LPC_VEC_PER_FRAME;
696 break;
697 }
698 default:
699 return -1;
700 }
701
702 ptrIO = lpcVecs;
703 poly[0] = 1.0;
704 for (vecCntr = 0; vecCntr < numVec; vecCntr++) {
705 memcpy(&poly[1], ptrIO, sizeof(double) * vecSize);
706 WebRtcIsac_Poly2Rc(poly, vecSize, rc);
707 WebRtcIsac_Rc2Lar(rc, ptrIO, vecSize);
708 ptrIO += vecSize;
709 }
710 return 0;
711 }
712
713
WebRtcIsac_Lar2Poly(double * lars,double * lowband,int orderLo,double * hiband,int orderHi,int Nsub)714 void WebRtcIsac_Lar2Poly(double* lars, double* lowband, int orderLo,
715 double* hiband, int orderHi, int Nsub) {
716 int k, orderTot;
717 double rc[MAX_ORDER], *outpl, *outph, *inp;
718
719 orderTot = (orderLo + orderHi + 2);
720 outpl = lowband;
721 outph = hiband;
722 /* First two elements of 'inp' store gains*/
723 inp = lars;
724 for (k = 0; k < Nsub; k++) {
725 /* Low band */
726 WebRtcIsac_Lar2Rc(&inp[2], rc, orderLo);
727 WebRtcIsac_Rc2Poly(rc, orderLo, outpl);
728
729 /* High band */
730 WebRtcIsac_Lar2Rc(&inp[orderLo + 2], rc, orderHi);
731 WebRtcIsac_Rc2Poly(rc, orderHi, outph);
732
733 /* gains */
734 outpl[0] = inp[0];
735 outph[0] = inp[1];
736
737 outpl += orderLo + 1;
738 outph += orderHi + 1;
739 inp += orderTot;
740 }
741 }
742
743 /*
744 * assumes 2 LAR vectors interpolates to 'numPolyVec' A-polynomials
745 * Note: 'numPolyVecs' includes the first and the last point of the interval
746 */
WebRtcIsac_Lar2PolyInterpolUB(double * larVecs,double * percepFilterParams,int numPolyVecs)747 void WebRtcIsac_Lar2PolyInterpolUB(double* larVecs, double* percepFilterParams,
748 int numPolyVecs) {
749 int polyCntr, coeffCntr;
750 double larInterpol[UB_LPC_ORDER];
751 double rc[UB_LPC_ORDER];
752 double delta[UB_LPC_ORDER];
753
754 /* calculate the step-size for linear interpolation coefficients */
755 for (coeffCntr = 0; coeffCntr < UB_LPC_ORDER; coeffCntr++) {
756 delta[coeffCntr] = (larVecs[UB_LPC_ORDER + coeffCntr] -
757 larVecs[coeffCntr]) / (numPolyVecs - 1);
758 }
759
760 for (polyCntr = 0; polyCntr < numPolyVecs; polyCntr++) {
761 for (coeffCntr = 0; coeffCntr < UB_LPC_ORDER; coeffCntr++) {
762 larInterpol[coeffCntr] = larVecs[coeffCntr] +
763 delta[coeffCntr] * polyCntr;
764 }
765 WebRtcIsac_Lar2Rc(larInterpol, rc, UB_LPC_ORDER);
766
767 /* convert to A-polynomial, the following function returns A[0] = 1;
768 * which is written where gains had to be written. Then we write the
769 * gain (outside this function). This way we say a memcpy. */
770 WebRtcIsac_Rc2Poly(rc, UB_LPC_ORDER, percepFilterParams);
771 percepFilterParams += (UB_LPC_ORDER + 1);
772 }
773 }
774
WebRtcIsac_DecodeLpc(Bitstr * streamdata,double * LPCCoef_lo,double * LPCCoef_hi)775 int WebRtcIsac_DecodeLpc(Bitstr* streamdata, double* LPCCoef_lo,
776 double* LPCCoef_hi) {
777 double lars[KLT_ORDER_GAIN + KLT_ORDER_SHAPE];
778 int err;
779
780 err = WebRtcIsac_DecodeLpcCoef(streamdata, lars);
781 if (err < 0) {
782 return -ISAC_RANGE_ERROR_DECODE_LPC;
783 }
784 WebRtcIsac_Lar2Poly(lars, LPCCoef_lo, ORDERLO, LPCCoef_hi, ORDERHI,
785 SUBFRAMES);
786 return 0;
787 }
788
WebRtcIsac_DecodeInterpolLpcUb(Bitstr * streamdata,double * percepFilterParams,int16_t bandwidth)789 int16_t WebRtcIsac_DecodeInterpolLpcUb(Bitstr* streamdata,
790 double* percepFilterParams,
791 int16_t bandwidth) {
792 double lpcCoeff[UB_LPC_ORDER * UB16_LPC_VEC_PER_FRAME];
793 int err;
794 int interpolCntr;
795 int subframeCntr;
796 int16_t numSegments;
797 int16_t numVecPerSegment;
798 int16_t numGains;
799
800 double percepFilterGains[SUBFRAMES << 1];
801 double* ptrOutParam = percepFilterParams;
802
803 err = WebRtcIsac_DecodeLpcCoefUB(streamdata, lpcCoeff, percepFilterGains,
804 bandwidth);
805 if (err < 0) {
806 return -ISAC_RANGE_ERROR_DECODE_LPC;
807 }
808
809 switch (bandwidth) {
810 case isac12kHz: {
811 numGains = SUBFRAMES;
812 numSegments = UB_LPC_VEC_PER_FRAME - 1;
813 numVecPerSegment = kLpcVecPerSegmentUb12;
814 break;
815 }
816 case isac16kHz: {
817 numGains = SUBFRAMES << 1;
818 numSegments = UB16_LPC_VEC_PER_FRAME - 1;
819 numVecPerSegment = kLpcVecPerSegmentUb16;
820 break;
821 }
822 default:
823 return -1;
824 }
825
826 for (interpolCntr = 0; interpolCntr < numSegments; interpolCntr++) {
827 WebRtcIsac_Lar2PolyInterpolUB(&lpcCoeff[interpolCntr * UB_LPC_ORDER],
828 ptrOutParam, numVecPerSegment + 1);
829 ptrOutParam += (numVecPerSegment * (UB_LPC_ORDER + 1));
830 }
831
832 ptrOutParam = percepFilterParams;
833
834 if (bandwidth == isac16kHz) {
835 ptrOutParam += (1 + UB_LPC_ORDER);
836 }
837
838 for (subframeCntr = 0; subframeCntr < numGains; subframeCntr++) {
839 *ptrOutParam = percepFilterGains[subframeCntr];
840 ptrOutParam += (1 + UB_LPC_ORDER);
841 }
842 return 0;
843 }
844
845
846 /* decode & dequantize LPC Coef */
WebRtcIsac_DecodeLpcCoef(Bitstr * streamdata,double * LPCCoef)847 int WebRtcIsac_DecodeLpcCoef(Bitstr* streamdata, double* LPCCoef) {
848 int j, k, n, pos, pos2, posg, poss, offsg, offss, offs2;
849 int index_g[KLT_ORDER_GAIN], index_s[KLT_ORDER_SHAPE];
850 double tmpcoeffs_g[KLT_ORDER_GAIN], tmpcoeffs_s[KLT_ORDER_SHAPE];
851 double tmpcoeffs2_g[KLT_ORDER_GAIN], tmpcoeffs2_s[KLT_ORDER_SHAPE];
852 double sum;
853 int err;
854 int model = 1;
855
856 /* entropy decoding of model number */
857 /* We are keeping this for backward compatibility of bit-streams. */
858 err = WebRtcIsac_DecHistOneStepMulti(&model, streamdata,
859 WebRtcIsac_kQKltModelCdfPtr,
860 WebRtcIsac_kQKltModelInitIndex, 1);
861 if (err < 0) {
862 return err;
863 }
864 /* Only accepted value of model is 0. It is kept in bit-stream for backward
865 * compatibility. */
866 if (model != 0) {
867 return -ISAC_DISALLOWED_LPC_MODEL;
868 }
869
870 /* entropy decoding of quantization indices */
871 err = WebRtcIsac_DecHistOneStepMulti(
872 index_s, streamdata, WebRtcIsac_kQKltCdfPtrShape,
873 WebRtcIsac_kQKltInitIndexShape, KLT_ORDER_SHAPE);
874 if (err < 0) {
875 return err;
876 }
877 err = WebRtcIsac_DecHistOneStepMulti(
878 index_g, streamdata, WebRtcIsac_kQKltCdfPtrGain,
879 WebRtcIsac_kQKltInitIndexGain, KLT_ORDER_GAIN);
880 if (err < 0) {
881 return err;
882 }
883
884 /* find quantization levels for coefficients */
885 for (k = 0; k < KLT_ORDER_SHAPE; k++) {
886 tmpcoeffs_s[k] =
887 WebRtcIsac_kQKltLevelsShape[WebRtcIsac_kQKltOffsetShape[k] +
888 index_s[k]];
889 }
890 for (k = 0; k < KLT_ORDER_GAIN; k++) {
891 tmpcoeffs_g[k] = WebRtcIsac_kQKltLevelsGain[WebRtcIsac_kQKltOffsetGain[k] +
892 index_g[k]];
893 }
894
895 /* Inverse KLT */
896
897 /* Left transform, transpose matrix! */
898 offsg = 0;
899 offss = 0;
900 posg = 0;
901 poss = 0;
902 for (j = 0; j < SUBFRAMES; j++) {
903 offs2 = 0;
904 for (k = 0; k < LPC_GAIN_ORDER; k++) {
905 sum = 0;
906 pos = offsg;
907 pos2 = offs2;
908 for (n = 0; n < LPC_GAIN_ORDER; n++) {
909 sum += tmpcoeffs_g[pos++] * WebRtcIsac_kKltT1Gain[pos2++];
910 }
911 tmpcoeffs2_g[posg++] = sum;
912 offs2 += LPC_GAIN_ORDER;
913 }
914 offs2 = 0;
915 for (k = 0; k < LPC_SHAPE_ORDER; k++) {
916 sum = 0;
917 pos = offss;
918 pos2 = offs2;
919 for (n = 0; n < LPC_SHAPE_ORDER; n++) {
920 sum += tmpcoeffs_s[pos++] * WebRtcIsac_kKltT1Shape[pos2++];
921 }
922 tmpcoeffs2_s[poss++] = sum;
923 offs2 += LPC_SHAPE_ORDER;
924 }
925 offsg += LPC_GAIN_ORDER;
926 offss += LPC_SHAPE_ORDER;
927 }
928
929 /* Right transform, transpose matrix */
930 offsg = 0;
931 offss = 0;
932 posg = 0;
933 poss = 0;
934 for (j = 0; j < SUBFRAMES; j++) {
935 posg = offsg;
936 for (k = 0; k < LPC_GAIN_ORDER; k++) {
937 sum = 0;
938 pos = k;
939 pos2 = j;
940 for (n = 0; n < SUBFRAMES; n++) {
941 sum += tmpcoeffs2_g[pos] * WebRtcIsac_kKltT2Gain[pos2];
942 pos += LPC_GAIN_ORDER;
943 pos2 += SUBFRAMES;
944
945 }
946 tmpcoeffs_g[posg++] = sum;
947 }
948 poss = offss;
949 for (k = 0; k < LPC_SHAPE_ORDER; k++) {
950 sum = 0;
951 pos = k;
952 pos2 = j;
953 for (n = 0; n < SUBFRAMES; n++) {
954 sum += tmpcoeffs2_s[pos] * WebRtcIsac_kKltT2Shape[pos2];
955 pos += LPC_SHAPE_ORDER;
956 pos2 += SUBFRAMES;
957 }
958 tmpcoeffs_s[poss++] = sum;
959 }
960 offsg += LPC_GAIN_ORDER;
961 offss += LPC_SHAPE_ORDER;
962 }
963
964 /* scaling, mean addition, and gain restoration */
965 posg = 0;
966 poss = 0;
967 pos = 0;
968 for (k = 0; k < SUBFRAMES; k++) {
969 /* log gains */
970 LPCCoef[pos] = tmpcoeffs_g[posg] / LPC_GAIN_SCALE;
971 LPCCoef[pos] += WebRtcIsac_kLpcMeansGain[posg];
972 LPCCoef[pos] = exp(LPCCoef[pos]);
973 pos++;
974 posg++;
975 LPCCoef[pos] = tmpcoeffs_g[posg] / LPC_GAIN_SCALE;
976 LPCCoef[pos] += WebRtcIsac_kLpcMeansGain[posg];
977 LPCCoef[pos] = exp(LPCCoef[pos]);
978 pos++;
979 posg++;
980
981 /* Low-band LAR coefficients. */
982 for (n = 0; n < LPC_LOBAND_ORDER; n++, pos++, poss++) {
983 LPCCoef[pos] = tmpcoeffs_s[poss] / LPC_LOBAND_SCALE;
984 LPCCoef[pos] += WebRtcIsac_kLpcMeansShape[poss];
985 }
986
987 /* High-band LAR coefficients. */
988 for (n = 0; n < LPC_HIBAND_ORDER; n++, pos++, poss++) {
989 LPCCoef[pos] = tmpcoeffs_s[poss] / LPC_HIBAND_SCALE;
990 LPCCoef[pos] += WebRtcIsac_kLpcMeansShape[poss];
991 }
992 }
993 return 0;
994 }
995
996 /* Encode LPC in LAR domain. */
WebRtcIsac_EncodeLar(double * LPCCoef,Bitstr * streamdata,IsacSaveEncoderData * encData)997 void WebRtcIsac_EncodeLar(double* LPCCoef, Bitstr* streamdata,
998 IsacSaveEncoderData* encData) {
999 int j, k, n, pos, pos2, poss, offss, offs2;
1000 int index_s[KLT_ORDER_SHAPE];
1001 int index_ovr_s[KLT_ORDER_SHAPE];
1002 double tmpcoeffs_s[KLT_ORDER_SHAPE];
1003 double tmpcoeffs2_s[KLT_ORDER_SHAPE];
1004 double sum;
1005 const int kModel = 0;
1006
1007 /* Mean removal and scaling. */
1008 poss = 0;
1009 pos = 0;
1010 for (k = 0; k < SUBFRAMES; k++) {
1011 /* First two element are gains, move over them. */
1012 pos += 2;
1013
1014 /* Low-band LAR coefficients. */
1015 for (n = 0; n < LPC_LOBAND_ORDER; n++, poss++, pos++) {
1016 tmpcoeffs_s[poss] = LPCCoef[pos] - WebRtcIsac_kLpcMeansShape[poss];
1017 tmpcoeffs_s[poss] *= LPC_LOBAND_SCALE;
1018 }
1019
1020 /* High-band LAR coefficients. */
1021 for (n = 0; n < LPC_HIBAND_ORDER; n++, poss++, pos++) {
1022 tmpcoeffs_s[poss] = LPCCoef[pos] - WebRtcIsac_kLpcMeansShape[poss];
1023 tmpcoeffs_s[poss] *= LPC_HIBAND_SCALE;
1024 }
1025 }
1026
1027 /* KLT */
1028
1029 /* Left transform. */
1030 offss = 0;
1031 for (j = 0; j < SUBFRAMES; j++) {
1032 poss = offss;
1033 for (k = 0; k < LPC_SHAPE_ORDER; k++) {
1034 sum = 0;
1035 pos = offss;
1036 pos2 = k;
1037 for (n = 0; n < LPC_SHAPE_ORDER; n++) {
1038 sum += tmpcoeffs_s[pos++] * WebRtcIsac_kKltT1Shape[pos2];
1039 pos2 += LPC_SHAPE_ORDER;
1040 }
1041 tmpcoeffs2_s[poss++] = sum;
1042 }
1043 offss += LPC_SHAPE_ORDER;
1044 }
1045
1046 /* Right transform. */
1047 offss = 0;
1048 offs2 = 0;
1049 for (j = 0; j < SUBFRAMES; j++) {
1050 poss = offss;
1051 for (k = 0; k < LPC_SHAPE_ORDER; k++) {
1052 sum = 0;
1053 pos = k;
1054 pos2 = offs2;
1055 for (n = 0; n < SUBFRAMES; n++) {
1056 sum += tmpcoeffs2_s[pos] * WebRtcIsac_kKltT2Shape[pos2++];
1057 pos += LPC_SHAPE_ORDER;
1058 }
1059 tmpcoeffs_s[poss++] = sum;
1060 }
1061 offs2 += SUBFRAMES;
1062 offss += LPC_SHAPE_ORDER;
1063 }
1064
1065 /* Quantize coefficients. */
1066 for (k = 0; k < KLT_ORDER_SHAPE; k++) {
1067 index_s[k] = (WebRtcIsac_lrint(tmpcoeffs_s[k] / KLT_STEPSIZE)) +
1068 WebRtcIsac_kQKltQuantMinShape[k];
1069 if (index_s[k] < 0) {
1070 index_s[k] = 0;
1071 } else if (index_s[k] > WebRtcIsac_kQKltMaxIndShape[k]) {
1072 index_s[k] = WebRtcIsac_kQKltMaxIndShape[k];
1073 }
1074 index_ovr_s[k] = WebRtcIsac_kQKltOffsetShape[k] + index_s[k];
1075 }
1076
1077
1078 /* Only one model remains in this version of the code, kModel = 0. We
1079 * are keeping for bit-streams to be backward compatible. */
1080 /* entropy coding of model number */
1081 WebRtcIsac_EncHistMulti(streamdata, &kModel, WebRtcIsac_kQKltModelCdfPtr, 1);
1082
1083 /* Save data for creation of multiple bit streams */
1084 /* Entropy coding of quantization indices - shape only. */
1085 WebRtcIsac_EncHistMulti(streamdata, index_s, WebRtcIsac_kQKltCdfPtrShape,
1086 KLT_ORDER_SHAPE);
1087
1088 /* Save data for creation of multiple bit streams. */
1089 for (k = 0; k < KLT_ORDER_SHAPE; k++) {
1090 encData->LPCindex_s[KLT_ORDER_SHAPE * encData->startIdx + k] = index_s[k];
1091 }
1092
1093 /* Find quantization levels for shape coefficients. */
1094 for (k = 0; k < KLT_ORDER_SHAPE; k++) {
1095 tmpcoeffs_s[k] = WebRtcIsac_kQKltLevelsShape[index_ovr_s[k]];
1096 }
1097 /* Inverse KLT. */
1098 /* Left transform, transpose matrix.! */
1099 offss = 0;
1100 poss = 0;
1101 for (j = 0; j < SUBFRAMES; j++) {
1102 offs2 = 0;
1103 for (k = 0; k < LPC_SHAPE_ORDER; k++) {
1104 sum = 0;
1105 pos = offss;
1106 pos2 = offs2;
1107 for (n = 0; n < LPC_SHAPE_ORDER; n++) {
1108 sum += tmpcoeffs_s[pos++] * WebRtcIsac_kKltT1Shape[pos2++];
1109 }
1110 tmpcoeffs2_s[poss++] = sum;
1111 offs2 += LPC_SHAPE_ORDER;
1112 }
1113 offss += LPC_SHAPE_ORDER;
1114 }
1115
1116 /* Right transform, Transpose matrix */
1117 offss = 0;
1118 poss = 0;
1119 for (j = 0; j < SUBFRAMES; j++) {
1120 poss = offss;
1121 for (k = 0; k < LPC_SHAPE_ORDER; k++) {
1122 sum = 0;
1123 pos = k;
1124 pos2 = j;
1125 for (n = 0; n < SUBFRAMES; n++) {
1126 sum += tmpcoeffs2_s[pos] * WebRtcIsac_kKltT2Shape[pos2];
1127 pos += LPC_SHAPE_ORDER;
1128 pos2 += SUBFRAMES;
1129 }
1130 tmpcoeffs_s[poss++] = sum;
1131 }
1132 offss += LPC_SHAPE_ORDER;
1133 }
1134
1135 /* Scaling, mean addition, and gain restoration. */
1136 poss = 0;
1137 pos = 0;
1138 for (k = 0; k < SUBFRAMES; k++) {
1139 /* Ignore gains. */
1140 pos += 2;
1141
1142 /* Low band LAR coefficients. */
1143 for (n = 0; n < LPC_LOBAND_ORDER; n++, pos++, poss++) {
1144 LPCCoef[pos] = tmpcoeffs_s[poss] / LPC_LOBAND_SCALE;
1145 LPCCoef[pos] += WebRtcIsac_kLpcMeansShape[poss];
1146 }
1147
1148 /* High band LAR coefficients. */
1149 for (n = 0; n < LPC_HIBAND_ORDER; n++, pos++, poss++) {
1150 LPCCoef[pos] = tmpcoeffs_s[poss] / LPC_HIBAND_SCALE;
1151 LPCCoef[pos] += WebRtcIsac_kLpcMeansShape[poss];
1152 }
1153 }
1154 }
1155
1156
WebRtcIsac_EncodeLpcLb(double * LPCCoef_lo,double * LPCCoef_hi,Bitstr * streamdata,IsacSaveEncoderData * encData)1157 void WebRtcIsac_EncodeLpcLb(double* LPCCoef_lo, double* LPCCoef_hi,
1158 Bitstr* streamdata, IsacSaveEncoderData* encData) {
1159 double lars[KLT_ORDER_GAIN + KLT_ORDER_SHAPE];
1160 int k;
1161
1162 WebRtcIsac_Poly2Lar(LPCCoef_lo, ORDERLO, LPCCoef_hi, ORDERHI, SUBFRAMES,
1163 lars);
1164 WebRtcIsac_EncodeLar(lars, streamdata, encData);
1165 WebRtcIsac_Lar2Poly(lars, LPCCoef_lo, ORDERLO, LPCCoef_hi, ORDERHI,
1166 SUBFRAMES);
1167 /* Save data for creation of multiple bit streams (and transcoding). */
1168 for (k = 0; k < (ORDERLO + 1)*SUBFRAMES; k++) {
1169 encData->LPCcoeffs_lo[(ORDERLO + 1)*SUBFRAMES * encData->startIdx + k] =
1170 LPCCoef_lo[k];
1171 }
1172 for (k = 0; k < (ORDERHI + 1)*SUBFRAMES; k++) {
1173 encData->LPCcoeffs_hi[(ORDERHI + 1)*SUBFRAMES * encData->startIdx + k] =
1174 LPCCoef_hi[k];
1175 }
1176 }
1177
1178
WebRtcIsac_EncodeLpcUB(double * lpcVecs,Bitstr * streamdata,double * interpolLPCCoeff,int16_t bandwidth,ISACUBSaveEncDataStruct * encData)1179 int16_t WebRtcIsac_EncodeLpcUB(double* lpcVecs, Bitstr* streamdata,
1180 double* interpolLPCCoeff,
1181 int16_t bandwidth,
1182 ISACUBSaveEncDataStruct* encData) {
1183 double U[UB_LPC_ORDER * UB16_LPC_VEC_PER_FRAME];
1184 int idx[UB_LPC_ORDER * UB16_LPC_VEC_PER_FRAME];
1185 int interpolCntr;
1186
1187 WebRtcIsac_Poly2LarUB(lpcVecs, bandwidth);
1188 WebRtcIsac_RemoveLarMean(lpcVecs, bandwidth);
1189 WebRtcIsac_DecorrelateIntraVec(lpcVecs, U, bandwidth);
1190 WebRtcIsac_DecorrelateInterVec(U, lpcVecs, bandwidth);
1191 WebRtcIsac_QuantizeUncorrLar(lpcVecs, idx, bandwidth);
1192
1193 WebRtcIsac_CorrelateInterVec(lpcVecs, U, bandwidth);
1194 WebRtcIsac_CorrelateIntraVec(U, lpcVecs, bandwidth);
1195 WebRtcIsac_AddLarMean(lpcVecs, bandwidth);
1196
1197 switch (bandwidth) {
1198 case isac12kHz: {
1199 /* Store the indices to be used for multiple encoding. */
1200 memcpy(encData->indexLPCShape, idx, UB_LPC_ORDER *
1201 UB_LPC_VEC_PER_FRAME * sizeof(int));
1202 WebRtcIsac_EncHistMulti(streamdata, idx, WebRtcIsac_kLpcShapeCdfMatUb12,
1203 UB_LPC_ORDER * UB_LPC_VEC_PER_FRAME);
1204 for (interpolCntr = 0; interpolCntr < UB_INTERPOL_SEGMENTS;
1205 interpolCntr++) {
1206 WebRtcIsac_Lar2PolyInterpolUB(lpcVecs, interpolLPCCoeff,
1207 kLpcVecPerSegmentUb12 + 1);
1208 lpcVecs += UB_LPC_ORDER;
1209 interpolLPCCoeff += (kLpcVecPerSegmentUb12 * (UB_LPC_ORDER + 1));
1210 }
1211 break;
1212 }
1213 case isac16kHz: {
1214 /* Store the indices to be used for multiple encoding. */
1215 memcpy(encData->indexLPCShape, idx, UB_LPC_ORDER *
1216 UB16_LPC_VEC_PER_FRAME * sizeof(int));
1217 WebRtcIsac_EncHistMulti(streamdata, idx, WebRtcIsac_kLpcShapeCdfMatUb16,
1218 UB_LPC_ORDER * UB16_LPC_VEC_PER_FRAME);
1219 for (interpolCntr = 0; interpolCntr < UB16_INTERPOL_SEGMENTS;
1220 interpolCntr++) {
1221 WebRtcIsac_Lar2PolyInterpolUB(lpcVecs, interpolLPCCoeff,
1222 kLpcVecPerSegmentUb16 + 1);
1223 lpcVecs += UB_LPC_ORDER;
1224 interpolLPCCoeff += (kLpcVecPerSegmentUb16 * (UB_LPC_ORDER + 1));
1225 }
1226 break;
1227 }
1228 default:
1229 return -1;
1230 }
1231 return 0;
1232 }
1233
WebRtcIsac_EncodeLpcGainLb(double * LPCCoef_lo,double * LPCCoef_hi,Bitstr * streamdata,IsacSaveEncoderData * encData)1234 void WebRtcIsac_EncodeLpcGainLb(double* LPCCoef_lo, double* LPCCoef_hi,
1235 Bitstr* streamdata,
1236 IsacSaveEncoderData* encData) {
1237 int j, k, n, pos, pos2, posg, offsg, offs2;
1238 int index_g[KLT_ORDER_GAIN];
1239 int index_ovr_g[KLT_ORDER_GAIN];
1240 double tmpcoeffs_g[KLT_ORDER_GAIN];
1241 double tmpcoeffs2_g[KLT_ORDER_GAIN];
1242 double sum;
1243 /* log gains, mean removal and scaling */
1244 posg = 0;
1245 for (k = 0; k < SUBFRAMES; k++) {
1246 tmpcoeffs_g[posg] = log(LPCCoef_lo[(LPC_LOBAND_ORDER + 1) * k]);
1247 tmpcoeffs_g[posg] -= WebRtcIsac_kLpcMeansGain[posg];
1248 tmpcoeffs_g[posg] *= LPC_GAIN_SCALE;
1249 posg++;
1250 tmpcoeffs_g[posg] = log(LPCCoef_hi[(LPC_HIBAND_ORDER + 1) * k]);
1251 tmpcoeffs_g[posg] -= WebRtcIsac_kLpcMeansGain[posg];
1252 tmpcoeffs_g[posg] *= LPC_GAIN_SCALE;
1253 posg++;
1254 }
1255
1256 /* KLT */
1257
1258 /* Left transform. */
1259 offsg = 0;
1260 for (j = 0; j < SUBFRAMES; j++) {
1261 posg = offsg;
1262 for (k = 0; k < LPC_GAIN_ORDER; k++) {
1263 sum = 0;
1264 pos = offsg;
1265 pos2 = k;
1266 for (n = 0; n < LPC_GAIN_ORDER; n++) {
1267 sum += tmpcoeffs_g[pos++] * WebRtcIsac_kKltT1Gain[pos2];
1268 pos2 += LPC_GAIN_ORDER;
1269 }
1270 tmpcoeffs2_g[posg++] = sum;
1271 }
1272 offsg += LPC_GAIN_ORDER;
1273 }
1274
1275 /* Right transform. */
1276 offsg = 0;
1277 offs2 = 0;
1278 for (j = 0; j < SUBFRAMES; j++) {
1279 posg = offsg;
1280 for (k = 0; k < LPC_GAIN_ORDER; k++) {
1281 sum = 0;
1282 pos = k;
1283 pos2 = offs2;
1284 for (n = 0; n < SUBFRAMES; n++) {
1285 sum += tmpcoeffs2_g[pos] * WebRtcIsac_kKltT2Gain[pos2++];
1286 pos += LPC_GAIN_ORDER;
1287 }
1288 tmpcoeffs_g[posg++] = sum;
1289 }
1290 offs2 += SUBFRAMES;
1291 offsg += LPC_GAIN_ORDER;
1292 }
1293
1294 /* Quantize coefficients. */
1295 for (k = 0; k < KLT_ORDER_GAIN; k++) {
1296 /* Get index. */
1297 pos2 = WebRtcIsac_lrint(tmpcoeffs_g[k] / KLT_STEPSIZE);
1298 index_g[k] = (pos2) + WebRtcIsac_kQKltQuantMinGain[k];
1299 if (index_g[k] < 0) {
1300 index_g[k] = 0;
1301 } else if (index_g[k] > WebRtcIsac_kQKltMaxIndGain[k]) {
1302 index_g[k] = WebRtcIsac_kQKltMaxIndGain[k];
1303 }
1304 index_ovr_g[k] = WebRtcIsac_kQKltOffsetGain[k] + index_g[k];
1305
1306 /* Find quantization levels for coefficients. */
1307 tmpcoeffs_g[k] = WebRtcIsac_kQKltLevelsGain[index_ovr_g[k]];
1308
1309 /* Save data for creation of multiple bit streams. */
1310 encData->LPCindex_g[KLT_ORDER_GAIN * encData->startIdx + k] = index_g[k];
1311 }
1312
1313 /* Entropy coding of quantization indices - gain. */
1314 WebRtcIsac_EncHistMulti(streamdata, index_g, WebRtcIsac_kQKltCdfPtrGain,
1315 KLT_ORDER_GAIN);
1316
1317 /* Find quantization levels for coefficients. */
1318 /* Left transform. */
1319 offsg = 0;
1320 posg = 0;
1321 for (j = 0; j < SUBFRAMES; j++) {
1322 offs2 = 0;
1323 for (k = 0; k < LPC_GAIN_ORDER; k++) {
1324 sum = 0;
1325 pos = offsg;
1326 pos2 = offs2;
1327 for (n = 0; n < LPC_GAIN_ORDER; n++)
1328 sum += tmpcoeffs_g[pos++] * WebRtcIsac_kKltT1Gain[pos2++];
1329 tmpcoeffs2_g[posg++] = sum;
1330 offs2 += LPC_GAIN_ORDER;
1331 }
1332 offsg += LPC_GAIN_ORDER;
1333 }
1334
1335 /* Right transform, transpose matrix. */
1336 offsg = 0;
1337 posg = 0;
1338 for (j = 0; j < SUBFRAMES; j++) {
1339 posg = offsg;
1340 for (k = 0; k < LPC_GAIN_ORDER; k++) {
1341 sum = 0;
1342 pos = k;
1343 pos2 = j;
1344 for (n = 0; n < SUBFRAMES; n++) {
1345 sum += tmpcoeffs2_g[pos] * WebRtcIsac_kKltT2Gain[pos2];
1346 pos += LPC_GAIN_ORDER;
1347 pos2 += SUBFRAMES;
1348 }
1349 tmpcoeffs_g[posg++] = sum;
1350 }
1351 offsg += LPC_GAIN_ORDER;
1352 }
1353
1354
1355 /* Scaling, mean addition, and gain restoration. */
1356 posg = 0;
1357 for (k = 0; k < SUBFRAMES; k++) {
1358 sum = tmpcoeffs_g[posg] / LPC_GAIN_SCALE;
1359 sum += WebRtcIsac_kLpcMeansGain[posg];
1360 LPCCoef_lo[k * (LPC_LOBAND_ORDER + 1)] = exp(sum);
1361 pos++;
1362 posg++;
1363 sum = tmpcoeffs_g[posg] / LPC_GAIN_SCALE;
1364 sum += WebRtcIsac_kLpcMeansGain[posg];
1365 LPCCoef_hi[k * (LPC_HIBAND_ORDER + 1)] = exp(sum);
1366 pos++;
1367 posg++;
1368 }
1369
1370 }
1371
WebRtcIsac_EncodeLpcGainUb(double * lpGains,Bitstr * streamdata,int * lpcGainIndex)1372 void WebRtcIsac_EncodeLpcGainUb(double* lpGains, Bitstr* streamdata,
1373 int* lpcGainIndex) {
1374 double U[UB_LPC_GAIN_DIM];
1375 int idx[UB_LPC_GAIN_DIM];
1376 WebRtcIsac_ToLogDomainRemoveMean(lpGains);
1377 WebRtcIsac_DecorrelateLPGain(lpGains, U);
1378 WebRtcIsac_QuantizeLpcGain(U, idx);
1379 /* Store the index for re-encoding for FEC. */
1380 memcpy(lpcGainIndex, idx, UB_LPC_GAIN_DIM * sizeof(int));
1381 WebRtcIsac_CorrelateLpcGain(U, lpGains);
1382 WebRtcIsac_AddMeanToLinearDomain(lpGains);
1383 WebRtcIsac_EncHistMulti(streamdata, idx, WebRtcIsac_kLpcGainCdfMat,
1384 UB_LPC_GAIN_DIM);
1385 }
1386
1387
WebRtcIsac_StoreLpcGainUb(double * lpGains,Bitstr * streamdata)1388 void WebRtcIsac_StoreLpcGainUb(double* lpGains, Bitstr* streamdata) {
1389 double U[UB_LPC_GAIN_DIM];
1390 int idx[UB_LPC_GAIN_DIM];
1391 WebRtcIsac_ToLogDomainRemoveMean(lpGains);
1392 WebRtcIsac_DecorrelateLPGain(lpGains, U);
1393 WebRtcIsac_QuantizeLpcGain(U, idx);
1394 WebRtcIsac_EncHistMulti(streamdata, idx, WebRtcIsac_kLpcGainCdfMat,
1395 UB_LPC_GAIN_DIM);
1396 }
1397
1398
1399
WebRtcIsac_DecodeLpcGainUb(double * lpGains,Bitstr * streamdata)1400 int16_t WebRtcIsac_DecodeLpcGainUb(double* lpGains, Bitstr* streamdata) {
1401 double U[UB_LPC_GAIN_DIM];
1402 int idx[UB_LPC_GAIN_DIM];
1403 int err;
1404 err = WebRtcIsac_DecHistOneStepMulti(idx, streamdata,
1405 WebRtcIsac_kLpcGainCdfMat,
1406 WebRtcIsac_kLpcGainEntropySearch,
1407 UB_LPC_GAIN_DIM);
1408 if (err < 0) {
1409 return -1;
1410 }
1411 WebRtcIsac_DequantizeLpcGain(idx, U);
1412 WebRtcIsac_CorrelateLpcGain(U, lpGains);
1413 WebRtcIsac_AddMeanToLinearDomain(lpGains);
1414 return 0;
1415 }
1416
1417
1418
1419 /* decode & dequantize RC */
WebRtcIsac_DecodeRc(Bitstr * streamdata,int16_t * RCQ15)1420 int WebRtcIsac_DecodeRc(Bitstr* streamdata, int16_t* RCQ15) {
1421 int k, err;
1422 int index[AR_ORDER];
1423
1424 /* entropy decoding of quantization indices */
1425 err = WebRtcIsac_DecHistOneStepMulti(index, streamdata,
1426 WebRtcIsac_kQArRcCdfPtr,
1427 WebRtcIsac_kQArRcInitIndex, AR_ORDER);
1428 if (err < 0)
1429 return err;
1430
1431 /* find quantization levels for reflection coefficients */
1432 for (k = 0; k < AR_ORDER; k++) {
1433 RCQ15[k] = *(WebRtcIsac_kQArRcLevelsPtr[k] + index[k]);
1434 }
1435 return 0;
1436 }
1437
1438
1439 /* quantize & code RC */
WebRtcIsac_EncodeRc(int16_t * RCQ15,Bitstr * streamdata)1440 void WebRtcIsac_EncodeRc(int16_t* RCQ15, Bitstr* streamdata) {
1441 int k;
1442 int index[AR_ORDER];
1443
1444 /* quantize reflection coefficients (add noise feedback?) */
1445 for (k = 0; k < AR_ORDER; k++) {
1446 index[k] = WebRtcIsac_kQArRcInitIndex[k];
1447 // The safe-guards in following while conditions are to suppress gcc 4.8.3
1448 // warnings, Issue 2888. Otherwise, first and last elements of
1449 // |WebRtcIsac_kQArBoundaryLevels| are such that the following search
1450 // *never* cause an out-of-boundary read.
1451 if (RCQ15[k] > WebRtcIsac_kQArBoundaryLevels[index[k]]) {
1452 while (index[k] + 1 < NUM_AR_RC_QUANT_BAUNDARY &&
1453 RCQ15[k] > WebRtcIsac_kQArBoundaryLevels[index[k] + 1]) {
1454 index[k]++;
1455 }
1456 } else {
1457 while (index[k] > 0 &&
1458 RCQ15[k] < WebRtcIsac_kQArBoundaryLevels[--index[k]]) ;
1459 }
1460 RCQ15[k] = *(WebRtcIsac_kQArRcLevelsPtr[k] + index[k]);
1461 }
1462
1463 /* entropy coding of quantization indices */
1464 WebRtcIsac_EncHistMulti(streamdata, index, WebRtcIsac_kQArRcCdfPtr, AR_ORDER);
1465 }
1466
1467
1468 /* decode & dequantize squared Gain */
WebRtcIsac_DecodeGain2(Bitstr * streamdata,int32_t * gainQ10)1469 int WebRtcIsac_DecodeGain2(Bitstr* streamdata, int32_t* gainQ10) {
1470 int index, err;
1471
1472 /* entropy decoding of quantization index */
1473 err = WebRtcIsac_DecHistOneStepMulti(&index, streamdata,
1474 WebRtcIsac_kQGainCdf_ptr,
1475 WebRtcIsac_kQGainInitIndex, 1);
1476 if (err < 0) {
1477 return err;
1478 }
1479 /* find quantization level */
1480 *gainQ10 = WebRtcIsac_kQGain2Levels[index];
1481 return 0;
1482 }
1483
1484
1485 /* quantize & code squared Gain */
WebRtcIsac_EncodeGain2(int32_t * gainQ10,Bitstr * streamdata)1486 int WebRtcIsac_EncodeGain2(int32_t* gainQ10, Bitstr* streamdata) {
1487 int index;
1488
1489 /* find quantization index */
1490 index = WebRtcIsac_kQGainInitIndex[0];
1491 if (*gainQ10 > WebRtcIsac_kQGain2BoundaryLevels[index]) {
1492 while (*gainQ10 > WebRtcIsac_kQGain2BoundaryLevels[index + 1]) {
1493 index++;
1494 }
1495 } else {
1496 while (*gainQ10 < WebRtcIsac_kQGain2BoundaryLevels[--index]) ;
1497 }
1498 /* De-quantize */
1499 *gainQ10 = WebRtcIsac_kQGain2Levels[index];
1500
1501 /* entropy coding of quantization index */
1502 WebRtcIsac_EncHistMulti(streamdata, &index, WebRtcIsac_kQGainCdf_ptr, 1);
1503 return 0;
1504 }
1505
1506
1507 /* code and decode Pitch Gains and Lags functions */
1508
1509 /* decode & dequantize Pitch Gains */
WebRtcIsac_DecodePitchGain(Bitstr * streamdata,int16_t * PitchGains_Q12)1510 int WebRtcIsac_DecodePitchGain(Bitstr* streamdata,
1511 int16_t* PitchGains_Q12) {
1512 int index_comb, err;
1513 const uint16_t* WebRtcIsac_kQPitchGainCdf_ptr[1];
1514
1515 /* Entropy decoding of quantization indices */
1516 *WebRtcIsac_kQPitchGainCdf_ptr = WebRtcIsac_kQPitchGainCdf;
1517 err = WebRtcIsac_DecHistBisectMulti(&index_comb, streamdata,
1518 WebRtcIsac_kQPitchGainCdf_ptr,
1519 WebRtcIsac_kQCdfTableSizeGain, 1);
1520 /* Error check, Q_mean_Gain.. tables are of size 144 */
1521 if ((err < 0) || (index_comb < 0) || (index_comb >= 144)) {
1522 return -ISAC_RANGE_ERROR_DECODE_PITCH_GAIN;
1523 }
1524 /* De-quantize back to pitch gains by table look-up. */
1525 PitchGains_Q12[0] = WebRtcIsac_kQMeanGain1Q12[index_comb];
1526 PitchGains_Q12[1] = WebRtcIsac_kQMeanGain2Q12[index_comb];
1527 PitchGains_Q12[2] = WebRtcIsac_kQMeanGain3Q12[index_comb];
1528 PitchGains_Q12[3] = WebRtcIsac_kQMeanGain4Q12[index_comb];
1529 return 0;
1530 }
1531
1532
1533 /* Quantize & code Pitch Gains. */
WebRtcIsac_EncodePitchGain(int16_t * PitchGains_Q12,Bitstr * streamdata,IsacSaveEncoderData * encData)1534 void WebRtcIsac_EncodePitchGain(int16_t* PitchGains_Q12,
1535 Bitstr* streamdata,
1536 IsacSaveEncoderData* encData) {
1537 int k, j;
1538 double C;
1539 double S[PITCH_SUBFRAMES];
1540 int index[3];
1541 int index_comb;
1542 const uint16_t* WebRtcIsac_kQPitchGainCdf_ptr[1];
1543 double PitchGains[PITCH_SUBFRAMES] = {0, 0, 0, 0};
1544
1545 /* Take the asin. */
1546 for (k = 0; k < PITCH_SUBFRAMES; k++) {
1547 PitchGains[k] = ((float)PitchGains_Q12[k]) / 4096;
1548 S[k] = asin(PitchGains[k]);
1549 }
1550
1551 /* Find quantization index; only for the first three
1552 * transform coefficients. */
1553 for (k = 0; k < 3; k++) {
1554 /* transform */
1555 C = 0.0;
1556 for (j = 0; j < PITCH_SUBFRAMES; j++) {
1557 C += WebRtcIsac_kTransform[k][j] * S[j];
1558 }
1559 /* Quantize */
1560 index[k] = WebRtcIsac_lrint(C / PITCH_GAIN_STEPSIZE);
1561
1562 /* Check that the index is not outside the boundaries of the table. */
1563 if (index[k] < WebRtcIsac_kIndexLowerLimitGain[k]) {
1564 index[k] = WebRtcIsac_kIndexLowerLimitGain[k];
1565 } else if (index[k] > WebRtcIsac_kIndexUpperLimitGain[k]) {
1566 index[k] = WebRtcIsac_kIndexUpperLimitGain[k];
1567 }
1568 index[k] -= WebRtcIsac_kIndexLowerLimitGain[k];
1569 }
1570
1571 /* Calculate unique overall index. */
1572 index_comb = WebRtcIsac_kIndexMultsGain[0] * index[0] +
1573 WebRtcIsac_kIndexMultsGain[1] * index[1] + index[2];
1574
1575 /* unquantize back to pitch gains by table look-up */
1576 PitchGains_Q12[0] = WebRtcIsac_kQMeanGain1Q12[index_comb];
1577 PitchGains_Q12[1] = WebRtcIsac_kQMeanGain2Q12[index_comb];
1578 PitchGains_Q12[2] = WebRtcIsac_kQMeanGain3Q12[index_comb];
1579 PitchGains_Q12[3] = WebRtcIsac_kQMeanGain4Q12[index_comb];
1580
1581 /* entropy coding of quantization pitch gains */
1582 *WebRtcIsac_kQPitchGainCdf_ptr = WebRtcIsac_kQPitchGainCdf;
1583 WebRtcIsac_EncHistMulti(streamdata, &index_comb,
1584 WebRtcIsac_kQPitchGainCdf_ptr, 1);
1585 encData->pitchGain_index[encData->startIdx] = index_comb;
1586 }
1587
1588
1589
1590 /* Pitch LAG */
1591 /* Decode & de-quantize Pitch Lags. */
WebRtcIsac_DecodePitchLag(Bitstr * streamdata,int16_t * PitchGain_Q12,double * PitchLags)1592 int WebRtcIsac_DecodePitchLag(Bitstr* streamdata, int16_t* PitchGain_Q12,
1593 double* PitchLags) {
1594 int k, err;
1595 double StepSize;
1596 double C;
1597 int index[PITCH_SUBFRAMES];
1598 double mean_gain;
1599 const double* mean_val2, *mean_val3, *mean_val4;
1600 const int16_t* lower_limit;
1601 const uint16_t* init_index;
1602 const uint16_t* cdf_size;
1603 const uint16_t** cdf;
1604 double PitchGain[4] = {0, 0, 0, 0};
1605
1606 /* compute mean pitch gain */
1607 mean_gain = 0.0;
1608 for (k = 0; k < 4; k++) {
1609 PitchGain[k] = ((float)PitchGain_Q12[k]) / 4096;
1610 mean_gain += PitchGain[k];
1611 }
1612 mean_gain /= 4.0;
1613
1614 /* voicing classification. */
1615 if (mean_gain < 0.2) {
1616 StepSize = WebRtcIsac_kQPitchLagStepsizeLo;
1617 cdf = WebRtcIsac_kQPitchLagCdfPtrLo;
1618 cdf_size = WebRtcIsac_kQPitchLagCdfSizeLo;
1619 mean_val2 = WebRtcIsac_kQMeanLag2Lo;
1620 mean_val3 = WebRtcIsac_kQMeanLag3Lo;
1621 mean_val4 = WebRtcIsac_kQMeanLag4Lo;
1622 lower_limit = WebRtcIsac_kQIndexLowerLimitLagLo;
1623 init_index = WebRtcIsac_kQInitIndexLagLo;
1624 } else if (mean_gain < 0.4) {
1625 StepSize = WebRtcIsac_kQPitchLagStepsizeMid;
1626 cdf = WebRtcIsac_kQPitchLagCdfPtrMid;
1627 cdf_size = WebRtcIsac_kQPitchLagCdfSizeMid;
1628 mean_val2 = WebRtcIsac_kQMeanLag2Mid;
1629 mean_val3 = WebRtcIsac_kQMeanLag3Mid;
1630 mean_val4 = WebRtcIsac_kQMeanLag4Mid;
1631 lower_limit = WebRtcIsac_kQIndexLowerLimitLagMid;
1632 init_index = WebRtcIsac_kQInitIndexLagMid;
1633 } else {
1634 StepSize = WebRtcIsac_kQPitchLagStepsizeHi;
1635 cdf = WebRtcIsac_kQPitchLagCdfPtrHi;
1636 cdf_size = WebRtcIsac_kQPitchLagCdfSizeHi;
1637 mean_val2 = WebRtcIsac_kQMeanLag2Hi;
1638 mean_val3 = WebRtcIsac_kQMeanLag3Hi;
1639 mean_val4 = WebRtcIsac_kQMeanLag4Hi;
1640 lower_limit = WebRtcIsac_kQindexLowerLimitLagHi;
1641 init_index = WebRtcIsac_kQInitIndexLagHi;
1642 }
1643
1644 /* Entropy decoding of quantization indices. */
1645 err = WebRtcIsac_DecHistBisectMulti(index, streamdata, cdf, cdf_size, 1);
1646 if ((err < 0) || (index[0] < 0)) {
1647 return -ISAC_RANGE_ERROR_DECODE_PITCH_LAG;
1648 }
1649 err = WebRtcIsac_DecHistOneStepMulti(index + 1, streamdata, cdf + 1,
1650 init_index, 3);
1651 if (err < 0) {
1652 return -ISAC_RANGE_ERROR_DECODE_PITCH_LAG;
1653 }
1654
1655 /* Unquantize back to transform coefficients and do the inverse transform:
1656 * S = T'*C. */
1657 C = (index[0] + lower_limit[0]) * StepSize;
1658 for (k = 0; k < PITCH_SUBFRAMES; k++) {
1659 PitchLags[k] = WebRtcIsac_kTransformTranspose[k][0] * C;
1660 }
1661 C = mean_val2[index[1]];
1662 for (k = 0; k < PITCH_SUBFRAMES; k++) {
1663 PitchLags[k] += WebRtcIsac_kTransformTranspose[k][1] * C;
1664 }
1665 C = mean_val3[index[2]];
1666 for (k = 0; k < PITCH_SUBFRAMES; k++) {
1667 PitchLags[k] += WebRtcIsac_kTransformTranspose[k][2] * C;
1668 }
1669 C = mean_val4[index[3]];
1670 for (k = 0; k < PITCH_SUBFRAMES; k++) {
1671 PitchLags[k] += WebRtcIsac_kTransformTranspose[k][3] * C;
1672 }
1673 return 0;
1674 }
1675
1676
1677
1678 /* Quantize & code pitch lags. */
WebRtcIsac_EncodePitchLag(double * PitchLags,int16_t * PitchGain_Q12,Bitstr * streamdata,IsacSaveEncoderData * encData)1679 void WebRtcIsac_EncodePitchLag(double* PitchLags, int16_t* PitchGain_Q12,
1680 Bitstr* streamdata,
1681 IsacSaveEncoderData* encData) {
1682 int k, j;
1683 double StepSize;
1684 double C;
1685 int index[PITCH_SUBFRAMES];
1686 double mean_gain;
1687 const double* mean_val2, *mean_val3, *mean_val4;
1688 const int16_t* lower_limit, *upper_limit;
1689 const uint16_t** cdf;
1690 double PitchGain[4] = {0, 0, 0, 0};
1691
1692 /* compute mean pitch gain */
1693 mean_gain = 0.0;
1694 for (k = 0; k < 4; k++) {
1695 PitchGain[k] = ((float)PitchGain_Q12[k]) / 4096;
1696 mean_gain += PitchGain[k];
1697 }
1698 mean_gain /= 4.0;
1699
1700 /* Save data for creation of multiple bit streams */
1701 encData->meanGain[encData->startIdx] = mean_gain;
1702
1703 /* Voicing classification. */
1704 if (mean_gain < 0.2) {
1705 StepSize = WebRtcIsac_kQPitchLagStepsizeLo;
1706 cdf = WebRtcIsac_kQPitchLagCdfPtrLo;
1707 mean_val2 = WebRtcIsac_kQMeanLag2Lo;
1708 mean_val3 = WebRtcIsac_kQMeanLag3Lo;
1709 mean_val4 = WebRtcIsac_kQMeanLag4Lo;
1710 lower_limit = WebRtcIsac_kQIndexLowerLimitLagLo;
1711 upper_limit = WebRtcIsac_kQIndexUpperLimitLagLo;
1712 } else if (mean_gain < 0.4) {
1713 StepSize = WebRtcIsac_kQPitchLagStepsizeMid;
1714 cdf = WebRtcIsac_kQPitchLagCdfPtrMid;
1715 mean_val2 = WebRtcIsac_kQMeanLag2Mid;
1716 mean_val3 = WebRtcIsac_kQMeanLag3Mid;
1717 mean_val4 = WebRtcIsac_kQMeanLag4Mid;
1718 lower_limit = WebRtcIsac_kQIndexLowerLimitLagMid;
1719 upper_limit = WebRtcIsac_kQIndexUpperLimitLagMid;
1720 } else {
1721 StepSize = WebRtcIsac_kQPitchLagStepsizeHi;
1722 cdf = WebRtcIsac_kQPitchLagCdfPtrHi;
1723 mean_val2 = WebRtcIsac_kQMeanLag2Hi;
1724 mean_val3 = WebRtcIsac_kQMeanLag3Hi;
1725 mean_val4 = WebRtcIsac_kQMeanLag4Hi;
1726 lower_limit = WebRtcIsac_kQindexLowerLimitLagHi;
1727 upper_limit = WebRtcIsac_kQindexUpperLimitLagHi;
1728 }
1729
1730 /* find quantization index */
1731 for (k = 0; k < 4; k++) {
1732 /* transform */
1733 C = 0.0;
1734 for (j = 0; j < PITCH_SUBFRAMES; j++) {
1735 C += WebRtcIsac_kTransform[k][j] * PitchLags[j];
1736 }
1737 /* quantize */
1738 index[k] = WebRtcIsac_lrint(C / StepSize);
1739
1740 /* check that the index is not outside the boundaries of the table */
1741 if (index[k] < lower_limit[k]) {
1742 index[k] = lower_limit[k];
1743 } else if (index[k] > upper_limit[k]) index[k] = upper_limit[k]; {
1744 index[k] -= lower_limit[k];
1745 }
1746 /* Save data for creation of multiple bit streams */
1747 encData->pitchIndex[PITCH_SUBFRAMES * encData->startIdx + k] = index[k];
1748 }
1749
1750 /* Un-quantize back to transform coefficients and do the inverse transform:
1751 * S = T'*C */
1752 C = (index[0] + lower_limit[0]) * StepSize;
1753 for (k = 0; k < PITCH_SUBFRAMES; k++) {
1754 PitchLags[k] = WebRtcIsac_kTransformTranspose[k][0] * C;
1755 }
1756 C = mean_val2[index[1]];
1757 for (k = 0; k < PITCH_SUBFRAMES; k++) {
1758 PitchLags[k] += WebRtcIsac_kTransformTranspose[k][1] * C;
1759 }
1760 C = mean_val3[index[2]];
1761 for (k = 0; k < PITCH_SUBFRAMES; k++) {
1762 PitchLags[k] += WebRtcIsac_kTransformTranspose[k][2] * C;
1763 }
1764 C = mean_val4[index[3]];
1765 for (k = 0; k < PITCH_SUBFRAMES; k++) {
1766 PitchLags[k] += WebRtcIsac_kTransformTranspose[k][3] * C;
1767 }
1768 /* entropy coding of quantization pitch lags */
1769 WebRtcIsac_EncHistMulti(streamdata, index, cdf, PITCH_SUBFRAMES);
1770 }
1771
1772
1773
1774 /* Routines for in-band signaling of bandwidth estimation */
1775 /* Histograms based on uniform distribution of indices */
1776 /* Move global variables later! */
1777
1778
1779 /* cdf array for frame length indicator */
1780 const uint16_t WebRtcIsac_kFrameLengthCdf[4] = {
1781 0, 21845, 43690, 65535 };
1782
1783 /* pointer to cdf array for frame length indicator */
1784 const uint16_t* WebRtcIsac_kFrameLengthCdf_ptr[1] = {
1785 WebRtcIsac_kFrameLengthCdf };
1786
1787 /* initial cdf index for decoder of frame length indicator */
1788 const uint16_t WebRtcIsac_kFrameLengthInitIndex[1] = { 1 };
1789
1790
WebRtcIsac_DecodeFrameLen(Bitstr * streamdata,int16_t * framesamples)1791 int WebRtcIsac_DecodeFrameLen(Bitstr* streamdata, int16_t* framesamples) {
1792 int frame_mode, err;
1793 err = 0;
1794 /* entropy decoding of frame length [1:30ms,2:60ms] */
1795 err = WebRtcIsac_DecHistOneStepMulti(&frame_mode, streamdata,
1796 WebRtcIsac_kFrameLengthCdf_ptr,
1797 WebRtcIsac_kFrameLengthInitIndex, 1);
1798 if (err < 0)
1799 return -ISAC_RANGE_ERROR_DECODE_FRAME_LENGTH;
1800
1801 switch (frame_mode) {
1802 case 1:
1803 *framesamples = 480; /* 30ms */
1804 break;
1805 case 2:
1806 *framesamples = 960; /* 60ms */
1807 break;
1808 default:
1809 err = -ISAC_DISALLOWED_FRAME_MODE_DECODER;
1810 }
1811 return err;
1812 }
1813
WebRtcIsac_EncodeFrameLen(int16_t framesamples,Bitstr * streamdata)1814 int WebRtcIsac_EncodeFrameLen(int16_t framesamples, Bitstr* streamdata) {
1815 int frame_mode, status;
1816
1817 status = 0;
1818 frame_mode = 0;
1819 /* entropy coding of frame length [1:480 samples,2:960 samples] */
1820 switch (framesamples) {
1821 case 480:
1822 frame_mode = 1;
1823 break;
1824 case 960:
1825 frame_mode = 2;
1826 break;
1827 default:
1828 status = - ISAC_DISALLOWED_FRAME_MODE_ENCODER;
1829 }
1830
1831 if (status < 0)
1832 return status;
1833
1834 WebRtcIsac_EncHistMulti(streamdata, &frame_mode,
1835 WebRtcIsac_kFrameLengthCdf_ptr, 1);
1836 return status;
1837 }
1838
1839 /* cdf array for estimated bandwidth */
1840 static const uint16_t kBwCdf[25] = {
1841 0, 2731, 5461, 8192, 10923, 13653, 16384, 19114, 21845, 24576, 27306, 30037,
1842 32768, 35498, 38229, 40959, 43690, 46421, 49151, 51882, 54613, 57343, 60074,
1843 62804, 65535 };
1844
1845 /* pointer to cdf array for estimated bandwidth */
1846 static const uint16_t* kBwCdfPtr[1] = { kBwCdf };
1847
1848 /* initial cdf index for decoder of estimated bandwidth*/
1849 static const uint16_t kBwInitIndex[1] = { 7 };
1850
1851
WebRtcIsac_DecodeSendBW(Bitstr * streamdata,int16_t * BWno)1852 int WebRtcIsac_DecodeSendBW(Bitstr* streamdata, int16_t* BWno) {
1853 int BWno32, err;
1854
1855 /* entropy decoding of sender's BW estimation [0..23] */
1856 err = WebRtcIsac_DecHistOneStepMulti(&BWno32, streamdata, kBwCdfPtr,
1857 kBwInitIndex, 1);
1858 if (err < 0) {
1859 return -ISAC_RANGE_ERROR_DECODE_BANDWIDTH;
1860 }
1861 *BWno = (int16_t)BWno32;
1862 return err;
1863 }
1864
WebRtcIsac_EncodeReceiveBw(int * BWno,Bitstr * streamdata)1865 void WebRtcIsac_EncodeReceiveBw(int* BWno, Bitstr* streamdata) {
1866 /* entropy encoding of receiver's BW estimation [0..23] */
1867 WebRtcIsac_EncHistMulti(streamdata, BWno, kBwCdfPtr, 1);
1868 }
1869
1870
1871 /* estimate code length of LPC Coef */
WebRtcIsac_TranscodeLPCCoef(double * LPCCoef_lo,double * LPCCoef_hi,int * index_g)1872 void WebRtcIsac_TranscodeLPCCoef(double* LPCCoef_lo, double* LPCCoef_hi,
1873 int* index_g) {
1874 int j, k, n, pos, pos2, posg, offsg, offs2;
1875 int index_ovr_g[KLT_ORDER_GAIN];
1876 double tmpcoeffs_g[KLT_ORDER_GAIN];
1877 double tmpcoeffs2_g[KLT_ORDER_GAIN];
1878 double sum;
1879
1880 /* log gains, mean removal and scaling */
1881 posg = 0;
1882 for (k = 0; k < SUBFRAMES; k++) {
1883 tmpcoeffs_g[posg] = log(LPCCoef_lo[(LPC_LOBAND_ORDER + 1) * k]);
1884 tmpcoeffs_g[posg] -= WebRtcIsac_kLpcMeansGain[posg];
1885 tmpcoeffs_g[posg] *= LPC_GAIN_SCALE;
1886 posg++;
1887 tmpcoeffs_g[posg] = log(LPCCoef_hi[(LPC_HIBAND_ORDER + 1) * k]);
1888 tmpcoeffs_g[posg] -= WebRtcIsac_kLpcMeansGain[posg];
1889 tmpcoeffs_g[posg] *= LPC_GAIN_SCALE;
1890 posg++;
1891 }
1892
1893 /* KLT */
1894
1895 /* Left transform. */
1896 offsg = 0;
1897 for (j = 0; j < SUBFRAMES; j++) {
1898 posg = offsg;
1899 for (k = 0; k < LPC_GAIN_ORDER; k++) {
1900 sum = 0;
1901 pos = offsg;
1902 pos2 = k;
1903 for (n = 0; n < LPC_GAIN_ORDER; n++) {
1904 sum += tmpcoeffs_g[pos++] * WebRtcIsac_kKltT1Gain[pos2];
1905 pos2 += LPC_GAIN_ORDER;
1906 }
1907 tmpcoeffs2_g[posg++] = sum;
1908 }
1909 offsg += LPC_GAIN_ORDER;
1910 }
1911
1912 /* Right transform. */
1913 offsg = 0;
1914 offs2 = 0;
1915 for (j = 0; j < SUBFRAMES; j++) {
1916 posg = offsg;
1917 for (k = 0; k < LPC_GAIN_ORDER; k++) {
1918 sum = 0;
1919 pos = k;
1920 pos2 = offs2;
1921 for (n = 0; n < SUBFRAMES; n++) {
1922 sum += tmpcoeffs2_g[pos] * WebRtcIsac_kKltT2Gain[pos2++];
1923 pos += LPC_GAIN_ORDER;
1924 }
1925 tmpcoeffs_g[posg++] = sum;
1926 }
1927 offs2 += SUBFRAMES;
1928 offsg += LPC_GAIN_ORDER;
1929 }
1930
1931
1932 /* quantize coefficients */
1933 for (k = 0; k < KLT_ORDER_GAIN; k++) {
1934 /* Get index. */
1935 pos2 = WebRtcIsac_lrint(tmpcoeffs_g[k] / KLT_STEPSIZE);
1936 index_g[k] = (pos2) + WebRtcIsac_kQKltQuantMinGain[k];
1937 if (index_g[k] < 0) {
1938 index_g[k] = 0;
1939 } else if (index_g[k] > WebRtcIsac_kQKltMaxIndGain[k]) {
1940 index_g[k] = WebRtcIsac_kQKltMaxIndGain[k];
1941 }
1942 index_ovr_g[k] = WebRtcIsac_kQKltOffsetGain[k] + index_g[k];
1943
1944 /* find quantization levels for coefficients */
1945 tmpcoeffs_g[k] = WebRtcIsac_kQKltLevelsGain[index_ovr_g[k]];
1946 }
1947 }
1948
1949
1950 /* Decode & de-quantize LPC Coefficients. */
WebRtcIsac_DecodeLpcCoefUB(Bitstr * streamdata,double * lpcVecs,double * percepFilterGains,int16_t bandwidth)1951 int WebRtcIsac_DecodeLpcCoefUB(Bitstr* streamdata, double* lpcVecs,
1952 double* percepFilterGains,
1953 int16_t bandwidth) {
1954 int index_s[KLT_ORDER_SHAPE];
1955
1956 double U[UB_LPC_ORDER * UB16_LPC_VEC_PER_FRAME];
1957 int err;
1958
1959 /* Entropy decoding of quantization indices. */
1960 switch (bandwidth) {
1961 case isac12kHz: {
1962 err = WebRtcIsac_DecHistOneStepMulti(
1963 index_s, streamdata, WebRtcIsac_kLpcShapeCdfMatUb12,
1964 WebRtcIsac_kLpcShapeEntropySearchUb12, UB_LPC_ORDER *
1965 UB_LPC_VEC_PER_FRAME);
1966 break;
1967 }
1968 case isac16kHz: {
1969 err = WebRtcIsac_DecHistOneStepMulti(
1970 index_s, streamdata, WebRtcIsac_kLpcShapeCdfMatUb16,
1971 WebRtcIsac_kLpcShapeEntropySearchUb16, UB_LPC_ORDER *
1972 UB16_LPC_VEC_PER_FRAME);
1973 break;
1974 }
1975 default:
1976 return -1;
1977 }
1978
1979 if (err < 0) {
1980 return err;
1981 }
1982
1983 WebRtcIsac_DequantizeLpcParam(index_s, lpcVecs, bandwidth);
1984 WebRtcIsac_CorrelateInterVec(lpcVecs, U, bandwidth);
1985 WebRtcIsac_CorrelateIntraVec(U, lpcVecs, bandwidth);
1986 WebRtcIsac_AddLarMean(lpcVecs, bandwidth);
1987 WebRtcIsac_DecodeLpcGainUb(percepFilterGains, streamdata);
1988
1989 if (bandwidth == isac16kHz) {
1990 /* Decode another set of Gains. */
1991 WebRtcIsac_DecodeLpcGainUb(&percepFilterGains[SUBFRAMES], streamdata);
1992 }
1993 return 0;
1994 }
1995
WebRtcIsac_EncodeBandwidth(enum ISACBandwidth bandwidth,Bitstr * streamData)1996 int16_t WebRtcIsac_EncodeBandwidth(enum ISACBandwidth bandwidth,
1997 Bitstr* streamData) {
1998 int bandwidthMode;
1999 switch (bandwidth) {
2000 case isac12kHz: {
2001 bandwidthMode = 0;
2002 break;
2003 }
2004 case isac16kHz: {
2005 bandwidthMode = 1;
2006 break;
2007 }
2008 default:
2009 return -ISAC_DISALLOWED_ENCODER_BANDWIDTH;
2010 }
2011 WebRtcIsac_EncHistMulti(streamData, &bandwidthMode, kOneBitEqualProbCdf_ptr,
2012 1);
2013 return 0;
2014 }
2015
WebRtcIsac_DecodeBandwidth(Bitstr * streamData,enum ISACBandwidth * bandwidth)2016 int16_t WebRtcIsac_DecodeBandwidth(Bitstr* streamData,
2017 enum ISACBandwidth* bandwidth) {
2018 int bandwidthMode;
2019 if (WebRtcIsac_DecHistOneStepMulti(&bandwidthMode, streamData,
2020 kOneBitEqualProbCdf_ptr,
2021 kOneBitEqualProbInitIndex, 1) < 0) {
2022 return -ISAC_RANGE_ERROR_DECODE_BANDWITH;
2023 }
2024 switch (bandwidthMode) {
2025 case 0: {
2026 *bandwidth = isac12kHz;
2027 break;
2028 }
2029 case 1: {
2030 *bandwidth = isac16kHz;
2031 break;
2032 }
2033 default:
2034 return -ISAC_DISALLOWED_BANDWIDTH_MODE_DECODER;
2035 }
2036 return 0;
2037 }
2038
WebRtcIsac_EncodeJitterInfo(int32_t jitterIndex,Bitstr * streamData)2039 int16_t WebRtcIsac_EncodeJitterInfo(int32_t jitterIndex,
2040 Bitstr* streamData) {
2041 /* This is to avoid LINUX warning until we change 'int' to 'Word32'. */
2042 int intVar;
2043
2044 if ((jitterIndex < 0) || (jitterIndex > 1)) {
2045 return -1;
2046 }
2047 intVar = (int)(jitterIndex);
2048 /* Use the same CDF table as for bandwidth
2049 * both take two values with equal probability.*/
2050 WebRtcIsac_EncHistMulti(streamData, &intVar, kOneBitEqualProbCdf_ptr, 1);
2051 return 0;
2052 }
2053
WebRtcIsac_DecodeJitterInfo(Bitstr * streamData,int32_t * jitterInfo)2054 int16_t WebRtcIsac_DecodeJitterInfo(Bitstr* streamData,
2055 int32_t* jitterInfo) {
2056 int intVar;
2057 /* Use the same CDF table as for bandwidth
2058 * both take two values with equal probability. */
2059 if (WebRtcIsac_DecHistOneStepMulti(&intVar, streamData,
2060 kOneBitEqualProbCdf_ptr,
2061 kOneBitEqualProbInitIndex, 1) < 0) {
2062 return -ISAC_RANGE_ERROR_DECODE_BANDWITH;
2063 }
2064 *jitterInfo = (int16_t)(intVar);
2065 return 0;
2066 }
2067