Line data Source code
1 : /******************************************************************************
2 : * ETSI TS 103 634 V1.5.1 *
3 : * Low Complexity Communication Codec Plus (LC3plus) *
4 : * *
5 : * Copyright licence is solely granted through ETSI Intellectual Property *
6 : * Rights Policy, 3rd April 2019. No patent licence is granted by implication, *
7 : * estoppel or otherwise. *
8 : ******************************************************************************/
9 :
10 : #include "options.h"
11 : #include "wmc_auto.h"
12 : #include "functions.h"
13 :
14 : static void xcorr(LC3_FLOAT* in, LC3_FLOAT* out, LC3_INT lag, LC3_INT inLen);
15 : static void levdown(LC3_FLOAT* anxt, LC3_FLOAT* out_a, LC3_INT* len);
16 : static void poly2rc(LC3_FLOAT* a, LC3_FLOAT* out, LC3_INT len);
17 :
18 4773838 : void xcorr(LC3_FLOAT* in, LC3_FLOAT* out, LC3_INT lag, LC3_INT inLen)
19 : {
20 : LC3_INT32 m;
21 :
22 :
23 29838204 : for (m = 0; m <= lag; m++) {
24 : /* Calculate correlation */
25 25064366 : out[m] = mac_loop(in, &in[m], (inLen - m));
26 : }
27 4773838 : }
28 :
29 2362460 : void levinsonDurbin(LC3_FLOAT* r, LC3_FLOAT* out_lev, LC3_FLOAT* rc_unq, LC3_FLOAT* error, LC3_INT len)
30 : {
31 : LC3_INT t, i, j;
32 : LC3_FLOAT g, v, sum, buf_tmp[10];
33 :
34 2362460 : g = r[1] / r[0];
35 2362460 : out_lev[0] = g;
36 :
37 2362460 : v = (1.0 - g * g) * r[0];
38 2362460 : rc_unq[0] = -g;
39 :
40 9849144 : for (t = 1; t < len; t++) {
41 :
42 7486684 : sum = 0;
43 23857616 : for (i = 1; i <= t; i++) {
44 16370932 : sum += out_lev[i - 1] * r[i];
45 : }
46 :
47 7486684 : g = (r[t + 1] - sum) / v;
48 :
49 7486684 : j = 1;
50 23857616 : for (i = t - 1; i >= 0; i--) {
51 16370932 : buf_tmp[j] = out_lev[j - 1] - g * out_lev[i];
52 16370932 : j++;
53 : }
54 :
55 7486684 : move_float(&out_lev[1], &buf_tmp[1], len);
56 :
57 7486684 : out_lev[0] = g;
58 :
59 7486684 : v = v * (1 - g * g);
60 7486684 : rc_unq[t] = -g;
61 : }
62 :
63 : /* Reorder out_lev */
64 2362460 : out_lev[0] = 1;
65 2362460 : j = 1;
66 12211604 : for (i = len - 1; i >= 0; i--) {
67 9849144 : buf_tmp[j] = -out_lev[i];
68 9849144 : j++;
69 : }
70 :
71 2362460 : move_float(&out_lev[1], &buf_tmp[1], (len - 1));
72 :
73 2362460 : out_lev[len] = rc_unq[len - 1];
74 :
75 2362460 : *error = v;
76 2362460 : }
77 :
78 0 : void levdown(LC3_FLOAT* anxt, LC3_FLOAT* out_a, LC3_INT* len)
79 : {
80 : LC3_INT32 i, j;
81 : LC3_FLOAT tmp_buf[8], knxt;
82 : LC3_FLOAT norm;
83 :
84 0 : memset(tmp_buf, 0, 8 * sizeof(LC3_FLOAT));
85 : /* Initial length = 9 */
86 :
87 : /* Drop the leading 1 */
88 :
89 0 : *len = *len - 1; /* Lenght = 8 */
90 :
91 : /* Last coefficient */
92 0 : knxt = anxt[*len]; /* At [7] */
93 :
94 0 : *len = *len - 1; /* Lenght = 7 */
95 :
96 0 : j = 0;
97 0 : for (i = *len - 1; i >= 0; i--) {
98 0 : tmp_buf[j] = knxt * anxt[i + 1];
99 0 : j++;
100 : }
101 :
102 0 : norm = 1.0 / (1.0 - (LC3_FABS(knxt)) * (LC3_FABS(knxt)));
103 :
104 0 : out_a[0] = 1;
105 0 : for (i = 0; i < *len; i++) {
106 0 : out_a[i + 1] = (anxt[i + 1] - tmp_buf[i]) * norm;
107 : }
108 :
109 0 : *len = *len + 1; /* Length = 8 */
110 0 : }
111 :
112 0 : void poly2rc(LC3_FLOAT* a, LC3_FLOAT* out, LC3_INT len)
113 : {
114 : LC3_INT k, i, len_old;
115 : LC3_FLOAT buf[9];
116 :
117 0 : len_old = len;
118 :
119 0 : zero_float(out, len - 1);
120 :
121 : /* Length = 9 */
122 :
123 : /* Normalize */
124 0 : for (i = 0; i < len; i++) {
125 0 : a[i] = a[i] / a[0];
126 : }
127 :
128 0 : out[len - 1] = a[len - 1];
129 :
130 : /* Process */
131 0 : for (k = len - 2; k >= 0; k--) {
132 0 : levdown(a, buf, &len);
133 0 : out[k] = buf[len - 1]; /* Store last value */
134 :
135 0 : move_float(a, buf, len);
136 : }
137 :
138 : /* Shift output array by one to the left to lose leading 1 */
139 0 : for (i = 0; i < len_old - 1; i++) {
140 0 : out[i] = out[i + 1];
141 : }
142 0 : }
143 :
144 :
145 1189311 : void processTnsCoder_fl(LC3_FLOAT* x, LC3_INT bw_cutoff_idx, LC3_INT bw_fcbin, LC3_INT fs, LC3_INT N, LC3_INT frame_dms, LC3_INT nBits,
146 : LC3_INT* order_out, LC3_INT* rc_idx, LC3_INT* tns_numfilters, LC3_INT* bits_out
147 : , LC3_INT16 near_nyquist_flag
148 : )
149 : {
150 : LC3_INT i, stopfreq[2], startfreq[2], f, numfilters, maxOrder, bits, sub,
151 : subdiv_startfreq, subdiv_stopfreq, j, rc_idx_tmp[MAXLAG], order_tmp, tmp, tns;
152 : LC3_FLOAT minPGfac, minPredictionGain, maxPG, xcorr_out[MAXLAG + 1], sum,
153 : subdiv_len, nSubdivisions, r[MAXLAG + 1], rc_unq[MAXLAG + 1], error_lev, predGain,
154 1189311 : alpha, rc[MAXLAG], st[MAXLAG + 1] = {0}, s, tmpSave, tmp_fl;
155 : const LC3_INT* order;
156 : LC3_FLOAT inv_sum, x_val;
157 : LC3_FLOAT alpha_loc;
158 : LC3_INT32 iIndex;
159 :
160 : /* Init */
161 :
162 1189311 : if (fs >= 32000 && frame_dms >= 50) {
163 1189291 : numfilters = 2;
164 : } else {
165 20 : numfilters = 1;
166 : }
167 :
168 : /* 40 * frame_dms / 10 = 4 * frame_dms */
169 1189311 : if (N > 4 * frame_dms)
170 : {
171 1189303 : N = 4 * frame_dms;
172 1189303 : fs = 40000;
173 : }
174 :
175 1189311 : if (numfilters == 1) {
176 20 : startfreq[0] = floor(600 * N * 2 / fs) + 1;
177 20 : stopfreq[0] = N;
178 : } else {
179 1189291 : startfreq[0] = floor(600 * N * 2 / fs) + 1;
180 1189291 : startfreq[1] = N / 2 + 1;
181 1189291 : stopfreq[0] = N / 2;
182 1189291 : stopfreq[1] = N;
183 : }
184 :
185 1189311 : switch (frame_dms)
186 : {
187 16 : case 25:
188 16 : maxOrder = 4;
189 16 : nSubdivisions = 2.0;
190 16 : break;
191 1139323 : case 50:
192 1139323 : maxOrder = 4;
193 1139323 : nSubdivisions = 2.0;
194 1139323 : break;
195 0 : case 75:
196 0 : maxOrder = 8;
197 0 : nSubdivisions = 3;
198 0 : break;
199 49972 : case 100:
200 49972 : maxOrder = 8;
201 49972 : nSubdivisions = 3.0;
202 49972 : break;
203 : }
204 :
205 1189311 : minPredictionGain = 1.5;
206 :
207 1189311 : if (nBits >= 4.8 * frame_dms) {
208 1189311 : order = order1_tns;
209 : } else {
210 0 : order = order2_tns;
211 : }
212 :
213 : /* Processing */
214 1189311 : if (bw_cutoff_idx >= 3 && numfilters == 2) {
215 1173149 : numfilters = 2;
216 1173149 : startfreq[1] = bw_fcbin / 2 + 1;
217 1173149 : stopfreq[0] = bw_fcbin / 2;
218 1173149 : stopfreq[1] = bw_fcbin;
219 : } else {
220 16162 : numfilters = 1;
221 16162 : stopfreq[0] = bw_fcbin;
222 : }
223 :
224 1189311 : bits = 0;
225 :
226 3551771 : for (f = 0; f < numfilters; f++) {
227 2362460 : subdiv_len = ((LC3_FLOAT)stopfreq[f] + 1.0 - (LC3_FLOAT)startfreq[f]) / nSubdivisions;
228 :
229 2362460 : zero_float(r, MAXLAG+1);
230 :
231 7136298 : for (sub = 1; sub <= nSubdivisions; sub++) {
232 4799180 : subdiv_startfreq = floor(subdiv_len * (sub - 1)) + startfreq[f] - 1;
233 4799180 : subdiv_stopfreq = floor(subdiv_len * sub) + startfreq[f] - 1;
234 :
235 4799180 : if (fs == 32000 && frame_dms == 75)
236 : {
237 0 : if (subdiv_startfreq == 83)
238 : {
239 0 : subdiv_startfreq = 82;
240 : }
241 :
242 0 : if (subdiv_stopfreq == 83)
243 : {
244 0 : subdiv_stopfreq = 82;
245 : }
246 :
247 0 : if (subdiv_startfreq == 160)
248 : {
249 0 : subdiv_startfreq = 159;
250 : }
251 :
252 0 : if (subdiv_stopfreq == 160)
253 : {
254 0 : subdiv_stopfreq = 159;
255 : }
256 : }
257 :
258 4799180 : sum = 0;
259 240855941 : for (i = subdiv_startfreq; i < subdiv_stopfreq; i++) {
260 236056761 : sum += x[i] * x[i];
261 : }
262 :
263 4799180 : if (sum < LC3_EPS) {
264 25342 : zero_float(r, MAXLAG+1);
265 25342 : r[0] = 1;
266 25342 : break;
267 : }
268 :
269 4773838 : xcorr(&x[subdiv_startfreq], xcorr_out, maxOrder, subdiv_stopfreq - subdiv_startfreq);
270 :
271 4773838 : inv_sum = 1.0 / sum;
272 29838204 : for (i = 0; i <= maxOrder; i++) {
273 25064366 : r[i] = r[i] + xcorr_out[i] * inv_sum;
274 : }
275 : }
276 :
277 14574064 : for (i = 0; i <= maxOrder; i++) {
278 12211604 : r[i] = r[i] * lagw_tns[i];
279 : }
280 :
281 2362460 : levinsonDurbin(r, xcorr_out, rc_unq, &error_lev, maxOrder);
282 :
283 2362460 : predGain = r[0] / error_lev;
284 :
285 2362460 : if (predGain > minPredictionGain && near_nyquist_flag == 0) {
286 270469 : tns = 1;
287 : } else {
288 2091991 : tns = 0;
289 : }
290 :
291 2362460 : bits++;
292 :
293 2362460 : if (tns == 1) {
294 270469 : minPGfac = 0.85;
295 270469 : maxPG = 2;
296 270469 : if (nBits >= 4.8 * frame_dms) {
297 270469 : maxPG = minPredictionGain;
298 : }
299 :
300 : /* LPC weighting */
301 270469 : if (predGain < maxPG) {
302 0 : alpha = (maxPG - predGain) * (minPGfac - 1.0) / (maxPG - minPredictionGain) + 1.0;
303 :
304 0 : alpha_loc = 1;
305 0 : for (i = 0; i <= maxOrder; i++) {
306 0 : xcorr_out[i] = xcorr_out[i] * alpha_loc;
307 0 : alpha_loc *= alpha;
308 : }
309 :
310 0 : poly2rc(xcorr_out, rc_unq, maxOrder + 1);
311 : }
312 :
313 : /* PARCOR Quantization */
314 1413561 : for (i = 0; i < maxOrder; i++)
315 : {
316 1143092 : iIndex = 1;
317 1143092 : x_val = rc_unq[i];
318 :
319 12331508 : while ((iIndex < 17) && (x_val > quants_thr_tns[iIndex - 1]))
320 : {
321 11188416 : iIndex = (iIndex + 1);
322 : }
323 1143092 : rc_idx_tmp[i] = (iIndex - 2);
324 : }
325 :
326 : /* Filter Order */
327 270469 : order_tmp = 0;
328 1413561 : for (i = 0; i < maxOrder; i++) {
329 1143092 : rc[i] = quants_pts_tns[rc_idx_tmp[i]];
330 :
331 1143092 : if (rc[i] != 0) {
332 950151 : order_tmp = i + 1;
333 : }
334 : }
335 :
336 270469 : order_out[f] = order_tmp;
337 :
338 : // Disable TNS if order is 0:
339 270469 : if (order_out[f] == 0) {
340 0 : tns = 0;
341 :
342 : // Jump to else statement
343 0 : goto tns_disabled;
344 : }
345 270469 : tmp = order[order_out[f] - 1];
346 :
347 : /* Huffman Coding of PARCOR coefficients */
348 1300352 : for (i = 0; i <= order_out[f] - 1; i++) {
349 1029883 : tmp += huff_bits_tns[i][rc_idx_tmp[i]];
350 : }
351 :
352 270469 : bits = bits + ceil((LC3_FLOAT)tmp / 2048.0);
353 :
354 270469 : j = 0;
355 1300352 : for (i = f * 8; i <= f * 8 + order_out[f] - 1; i++) {
356 1029883 : rc_idx[i] = rc_idx_tmp[j];
357 1029883 : j++;
358 : }
359 : } else {
360 2091991 : tns_disabled:
361 2091991 : order_out[f] = 0;
362 : }
363 :
364 : /* Filtering */
365 2362460 : if (tns == 1) {
366 28018855 : for (i = startfreq[f]; i <= stopfreq[f]; i++) {
367 27748386 : s = x[i - 1];
368 27748386 : tmpSave = s;
369 :
370 110341088 : for (j = 0; j < order_out[f] - 1; j++) {
371 82592702 : tmp_fl = rc[j] * s + st[j];
372 82592702 : s += rc[j] * st[j];
373 :
374 82592702 : st[j] = tmpSave;
375 82592702 : tmpSave = tmp_fl;
376 : }
377 :
378 27748386 : s += rc[order_out[f] - 1] * st[order_out[f] - 1];
379 :
380 27748386 : st[order_out[f] - 1] = tmpSave;
381 27748386 : x[i - 1] = s;
382 : }
383 : }
384 : }
385 :
386 1189311 : *tns_numfilters = numfilters;
387 1189311 : *bits_out = bits;
388 1189311 : }
|
