Line data Source code
1 : /******************************************************************************
2 : * ETSI TS 103 634 V1.6.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 "setup_enc_lc3plus.h"
13 : #include "functions.h"
14 : #include <stdio.h>
15 :
16 : /* if encoder is null only size is reported */
17 5503 : int alloc_encoder(LC3PLUS_Enc* encoder, int channels)
18 : {
19 5503 : int ch = 0;
20 5503 : size_t size = sizeof(LC3PLUS_Enc);
21 :
22 11006 : for (ch = 0; ch < channels; ch++) {
23 5503 : EncSetup* setup = balloc(encoder, &size, sizeof(EncSetup));
24 5503 : if (encoder) {
25 2199 : encoder->channel_setup[ch] = setup;
26 : }
27 : }
28 :
29 5503 : return (int)size;
30 : }
31 :
32 2199 : LC3PLUS_Error FillEncSetup(LC3PLUS_Enc* encoder, int samplerate, int channels
33 : , int hrmode
34 : , int32_t lfe_channel_array[]
35 : )
36 : {
37 2199 : int ch = 0;
38 2199 : memset(encoder, 0, lc3plus_enc_get_size(samplerate, channels));
39 2199 : alloc_encoder(encoder, channels);
40 :
41 2199 : encoder->fs = CODEC_FS(samplerate);
42 2199 : encoder->fs_in = samplerate;
43 2199 : encoder->fs_idx = FS2FS_IDX(encoder->fs);
44 2199 : encoder->frame_dms = LC3PLUS_FRAME_DURATION_10MS;
45 :
46 2199 : if (encoder->fs_idx > 4) {
47 0 : encoder->fs_idx = 5;
48 : }
49 :
50 2199 : encoder->hrmode = hrmode != 0;
51 :
52 2199 : encoder->channels = channels;
53 2199 : encoder->frame_ms = LC3PLUS_FRAME_DURATION_10MS;
54 2199 : encoder->envelope_bits = 38;
55 2199 : encoder->global_gain_bits = 8;
56 2199 : encoder->noise_fac_bits = 3;
57 2199 : encoder->BW_cutoff_bits = BW_cutoff_bits_all[encoder->fs_idx];
58 :
59 2199 : encoder->r12k8_mem_in_len = 2 * 8 * encoder->fs / 12800;
60 2199 : encoder->r12k8_mem_out_len = 24;
61 :
62 2199 : if (lfe_channel_array != NULL)
63 : {
64 4398 : for (ch = 0; ch < encoder->channels; ch++)
65 : {
66 2199 : encoder->channel_setup[ch]->lfe = lfe_channel_array[ch] != 0;
67 : }
68 : }
69 :
70 2199 : encoder->bw_ctrl_active = 0;
71 2199 : encoder->bandwidth = encoder->fs / 2;
72 2199 : encoder->bandwidth_preset = encoder->fs / 2;
73 :
74 :
75 2199 : if (encoder->fs == 8000) {
76 0 : encoder->tilt = 14;
77 2199 : } else if (encoder->fs == 16000) {
78 2 : encoder->tilt = 18;
79 2197 : } else if (encoder->fs == 24000) {
80 0 : encoder->tilt = 22;
81 2197 : } else if (encoder->fs == 32000) {
82 2 : encoder->tilt = 26;
83 2195 : } else if (encoder->fs == 48000) {
84 2195 : encoder->tilt = 30;
85 : }
86 0 : else if (encoder->fs == 96000) {
87 0 : encoder->tilt = 34;
88 : }
89 :
90 2199 : set_enc_frame_params(encoder);
91 2199 : return LC3PLUS_OK;
92 : }
93 :
94 : /* set frame config params */
95 4398 : void set_enc_frame_params(LC3PLUS_Enc* encoder)
96 : {
97 4398 : int ch = 0;
98 : EncSetup* setup;
99 :
100 : #ifdef CR9_C_ADD_1p25MS
101 : #ifndef FIX_TX_RX_STRUCT_STEREO
102 : encoder->Tx_ltpf = 0;
103 : #endif
104 : #endif
105 : #ifdef FIX_FLOAT_LT_NORMCORR_INIT
106 4398 : encoder->long_term_norm_corr= (0xFFFF >> 2)/32768.0;
107 : #endif
108 :
109 4398 : encoder->frame_length = ceil(encoder->fs * 10 / 1000); /* fs * 0.01*2^6 */
110 4398 : if (encoder->hrmode == 1)
111 : {
112 0 : encoder->yLen = encoder->frame_length;
113 : }
114 : else
115 : {
116 4398 : encoder->yLen = MIN(MAX_BW, encoder->frame_length);
117 4398 : encoder->sns_damping = 0.85;
118 : }
119 :
120 4398 : encoder->stEnc_mdct_mem_len = encoder->frame_length - encoder->la_zeroes;
121 4398 : encoder->bands_number = 64;
122 4398 : encoder->nSubdivisions = 3;
123 4398 : encoder->near_nyquist_index = encoder->bands_number - 2;
124 4398 : encoder->near_nyquist_flag = 0;
125 4398 : encoder->ltpf_mem_in_len = LTPF_MEMIN_LEN;
126 :
127 4398 : if (encoder->fs_idx == 5)
128 : {
129 0 : encoder->hrmode = 1;
130 : }
131 :
132 4398 : if (encoder->hrmode)
133 : {
134 0 : encoder->BW_cutoff_bits = 0;
135 : }
136 : else
137 : {
138 4398 : encoder->BW_cutoff_bits = BW_cutoff_bits_all[encoder->fs_idx];
139 : }
140 :
141 4398 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_10MS) {
142 2380 : encoder->la_zeroes = MDCT_la_zeroes[encoder->fs_idx];
143 2380 : if (encoder->hrmode)
144 : {
145 0 : encoder->bands_offset = ACC_COEFF_PER_BAND_HR[encoder->fs_idx];
146 : }
147 : else
148 : {
149 2380 : encoder->bands_offset = ACC_COEFF_PER_BAND[encoder->fs_idx];
150 : }
151 2380 : encoder->cutoffBins = BW_cutoff_bin_all;
152 :
153 2380 : encoder->attdec_nblocks = 4;
154 2380 : encoder->attdec_damping = 0.5;
155 2380 : encoder->attdec_hangover_thresh = 2;
156 : }
157 2018 : else if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_7p5MS) {
158 0 : if (encoder->hrmode)
159 : {
160 0 : encoder->bands_offset = ACC_COEFF_PER_BAND_7_5ms_HR[encoder->fs_idx];
161 : }
162 : else
163 : {
164 0 : encoder->bands_offset = ACC_COEFF_PER_BAND_7_5ms[encoder->fs_idx];
165 : }
166 0 : encoder->la_zeroes = MDCT_la_zeroes_7_5ms[encoder->fs_idx];
167 0 : encoder->cutoffBins = BW_cutoff_bin_all_7_5ms;
168 0 : encoder->attdec_nblocks = 3;
169 0 : encoder->attdec_damping = 0.3;
170 0 : encoder->attdec_hangover_thresh = 1;
171 :
172 0 : encoder->frame_length = (encoder->frame_length >> 2) * 3;
173 0 : encoder->yLen = (encoder->yLen >> 2) * 3;
174 :
175 0 : encoder->stEnc_mdct_mem_len = encoder->frame_length - encoder->la_zeroes;
176 0 : if (encoder->hrmode)
177 : {
178 0 : encoder->bands_number = bands_number_7_5ms_HR[encoder->fs_idx];
179 : }
180 : else
181 : {
182 0 : encoder->bands_number = bands_number_7_5ms[encoder->fs_idx];
183 : }
184 0 : encoder->nSubdivisions = 3;
185 0 : encoder->near_nyquist_index = encoder->bands_number - 4;
186 0 : encoder->r12k8_mem_out_len = ceil(2.0 * ((LC3_FLOAT) encoder->frame_length / 2.0 - (LC3_FLOAT) encoder->la_zeroes) * 12800.0 / (LC3_FLOAT) encoder->fs - 8.0);
187 : }
188 2018 : else if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_5MS) {
189 2016 : encoder->frame_length = encoder->frame_length >> 1;
190 2016 : encoder->yLen /= 2;
191 2016 : encoder->stEnc_mdct_mem_len = encoder->frame_length - encoder->la_zeroes;
192 2016 : encoder->bands_number = bands_number_5ms[encoder->fs_idx];
193 2016 : encoder->nSubdivisions = 2;
194 2016 : encoder->near_nyquist_index = encoder->bands_number - 3;
195 2016 : encoder->la_zeroes = MDCT_la_zeroes_5ms[encoder->fs_idx];
196 2016 : if (encoder->hrmode)
197 : {
198 0 : encoder->bands_offset = ACC_COEFF_PER_BAND_5ms_HR[encoder->fs_idx];
199 : }
200 : else
201 : {
202 2016 : encoder->bands_offset = ACC_COEFF_PER_BAND_5ms[encoder->fs_idx];
203 : }
204 2016 : encoder->cutoffBins = BW_cutoff_bin_all_5ms;
205 : #ifdef FIX_LTPF_PITCH_MEM_LEN
206 2016 : encoder->ltpf_mem_in_len = LTPF_MEMIN_LEN + LEN_12K8 / 2;
207 : #endif
208 : }
209 2 : else if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_2p5MS) {
210 2 : encoder->la_zeroes = MDCT_la_zeroes_2_5ms[encoder->fs_idx];
211 2 : if (encoder->hrmode)
212 : {
213 0 : encoder->bands_offset = ACC_COEFF_PER_BAND_2_5ms_HR[encoder->fs_idx];
214 : }
215 : else
216 : {
217 2 : encoder->bands_offset = ACC_COEFF_PER_BAND_2_5ms[encoder->fs_idx];
218 : }
219 2 : encoder->cutoffBins = BW_cutoff_bin_all_2_5ms;
220 2 : encoder->frame_length = encoder->frame_length >> 2;
221 2 : encoder->yLen /= 4;
222 2 : encoder->stEnc_mdct_mem_len = encoder->frame_length - encoder->la_zeroes;
223 2 : if (encoder->hrmode)
224 : {
225 0 : encoder->bands_number = bands_number_2_5ms_HR[encoder->fs_idx];
226 : }
227 : else
228 : {
229 2 : encoder->bands_number = bands_number_2_5ms[encoder->fs_idx];
230 : }
231 :
232 2 : encoder->nSubdivisions = 2;
233 2 : encoder->near_nyquist_index = encoder->bands_number - 2;
234 : #ifdef FIX_LTPF_PITCH_MEM_LEN
235 2 : encoder->ltpf_mem_in_len = LTPF_MEMIN_LEN + (3 * (LEN_12K8 / 4));
236 : #else
237 : encoder->ltpf_mem_in_len = LTPF_MEMIN_LEN + (LEN_12K8 >> 2);
238 : #endif
239 : }
240 : #ifdef CR9_C_ADD_1p25MS
241 0 : else if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_1p25MS) {
242 0 : encoder->la_zeroes = MDCT_la_zeroes_1_25ms[encoder->fs_idx];
243 0 : if (encoder->hrmode)
244 : {
245 0 : assert(0);
246 : }
247 : else
248 : {
249 0 : encoder->bands_offset = ACC_COEFF_PER_BAND_1_25ms[encoder->fs_idx];
250 : }
251 0 : encoder->cutoffBins = BW_cutoff_bin_all_1_25ms;
252 0 : encoder->frame_length = encoder->frame_length >> 3;
253 0 : encoder->yLen /= 8;
254 0 : encoder->stEnc_mdct_mem_len = encoder->frame_length - encoder->la_zeroes;
255 0 : if (encoder->hrmode)
256 : {
257 0 : assert(0);
258 : }
259 : else
260 : {
261 0 : encoder->bands_number = bands_number_1_25ms[encoder->fs_idx];
262 0 : encoder->BW_cutoff_bits = 0; /* transmit no bw bits */
263 0 : encoder->bw_ctrl_active = 1;
264 : }
265 :
266 0 : encoder->nSubdivisions = 2;
267 0 : encoder->near_nyquist_index = encoder->bands_number - 2;
268 : #ifdef FIX_LTPF_PITCH_MEM_LEN
269 0 : encoder->ltpf_mem_in_len = LTPF_MEMIN_LEN + (7 * (LEN_12K8 / 8));
270 : #else
271 : encoder->ltpf_mem_in_len = LTPF_MEMIN_LEN + (LEN_12K8 >> 1) + 16;
272 : #endif
273 0 : encoder->r12k8_mem_out_len = 8;
274 :
275 0 : encoder->attdec_damping = 32767.0/32768.0;
276 : }
277 : #endif
278 :
279 8796 : for (ch = 0; ch < encoder->channels; ch++) {
280 4398 : setup = encoder->channel_setup[ch];
281 4398 : setup->olpa_mem_pitch = 17;
282 4398 : setup->pitch_flag = 0;
283 4398 : if (setup->mdctStruct.mem != NULL) {
284 2199 : mdct_free(&setup->mdctStruct);
285 2199 : mdct_init(&setup->mdctStruct, encoder->frame_length, encoder->frame_dms, encoder->fs_idx, encoder->hrmode);
286 :
287 2199 : dct2_free(&setup->dct2StructSNS);
288 2199 : dct2_init(&setup->dct2StructSNS, M);
289 : }
290 : else
291 : {
292 2199 : mdct_init(&setup->mdctStruct, encoder->frame_length, encoder->frame_dms, encoder->fs_idx, encoder->hrmode);
293 2199 : dct2_init(&setup->dct2StructSNS, M);
294 : }
295 : }
296 4398 : }
297 :
298 : /* change encoder bitrate */
299 333838 : LC3PLUS_Error update_enc_bitrate(LC3PLUS_Enc* encoder, int bitrate)
300 : {
301 333838 : int ch = 0, bitsTmp = 0, minBR = 0, maxBR = 0, totalBytes = 0;
302 333838 : LC3_INT channel_bytes = 0;
303 :
304 : #ifdef ENABLE_HR_MODE_FL
305 : #ifdef CR12_D_FIX_BITRATE_LIMITS
306 333838 : LC3_INT fec_slot_bytes_min = 0, check_bytes = 0;
307 : #else
308 : LC3_INT max_bytes = 0;
309 : #endif
310 333838 : if (encoder->hrmode)
311 : {
312 0 : switch (encoder->frame_dms)
313 : {
314 : #ifdef CR9_C_ADD_1p25MS
315 0 : case LC3PLUS_FRAME_DURATION_1p25MS:
316 0 : assert(0);
317 : maxBR = 672000;
318 : if (encoder->fs == 48000) {minBR = MIN_BR_25MS_48KHZ_HR;}
319 : else if (encoder->fs == 96000) {minBR = MIN_BR_25MS_96KHZ_HR;}
320 : else { return LC3PLUS_HRMODE_ERROR;}
321 : break;
322 : #endif
323 0 : case LC3PLUS_FRAME_DURATION_2p5MS:
324 0 : maxBR = 672000;
325 0 : if (encoder->fs == 48000) {minBR = MIN_BR_25MS_48KHZ_HR;}
326 0 : else if (encoder->fs == 96000) {minBR = MIN_BR_25MS_96KHZ_HR;}
327 0 : else { return LC3PLUS_HRMODE_ERROR;}
328 0 : break;
329 0 : case LC3PLUS_FRAME_DURATION_5MS:
330 0 : maxBR = 600000;
331 0 : if (encoder->fs == 48000) {minBR = MIN_BR_50MS_48KHZ_HR;}
332 0 : else if (encoder->fs == 96000) {minBR = MIN_BR_50MS_96KHZ_HR;}
333 0 : else { return LC3PLUS_HRMODE_ERROR;}
334 0 : break;
335 0 : case LC3PLUS_FRAME_DURATION_7p5MS:
336 0 : maxBR = 500000;
337 0 : if (encoder->fs == 48000) {minBR = MIN_BR_075DMS_48KHZ_HR;}
338 0 : else if (encoder->fs == 96000) {minBR = MIN_BR_075DMS_96KHZ_HR;}
339 0 : else {return LC3PLUS_HRMODE_ERROR;}
340 0 : break;
341 0 : case LC3PLUS_FRAME_DURATION_10MS:
342 0 : maxBR = 500000;
343 0 : if (encoder->fs == 48000) {minBR = MIN_BR_100MS_48KHZ_HR;}
344 0 : else if (encoder->fs == 96000) {minBR = MIN_BR_100MS_96KHZ_HR;}
345 0 : else { return LC3PLUS_HRMODE_ERROR;}
346 0 : break;
347 0 : default:
348 0 : return LC3PLUS_HRMODE_ERROR;
349 : }
350 : }
351 : else
352 : #endif /* ENABLE_HR_MODE_FL */
353 : {
354 333838 : minBR = (MIN_NBYTES << 3);
355 333838 : maxBR = MAX_BR;
356 :
357 333838 : switch (encoder->frame_dms)
358 : {
359 : #ifdef CR9_C_ADD_1p25MS
360 0 : case LC3PLUS_FRAME_DURATION_1p25MS:
361 0 : minBR = MIN_BR_0125DMS;
362 0 : maxBR = MAX_BR_0125DMS;
363 0 : break;
364 : #endif
365 2 : case LC3PLUS_FRAME_DURATION_2p5MS:
366 2 : minBR = MIN_BR_025DMS;
367 2 : maxBR = MAX_BR;
368 2 : break;
369 302443 : case LC3PLUS_FRAME_DURATION_5MS:
370 302443 : minBR = MIN_BR_050DMS;
371 302443 : maxBR = MAX_BR;
372 : /* have additional limitations for 5.0ms */
373 302443 : switch (encoder->fs_in)
374 : {
375 0 : case 8000: maxBR = MAX_BR_050DMS_NB; break;
376 302443 : default: break;
377 : }
378 302443 : break;
379 0 : case LC3PLUS_FRAME_DURATION_7p5MS:
380 0 : minBR = MIN_BR_075DMS;
381 0 : maxBR = MAX_BR_075DMS;
382 : /* have additional limitations for 7.5ms */
383 0 : switch (encoder->fs_in)
384 : {
385 0 : case 8000: maxBR = MAX_BR_075DMS_NB ; break;
386 0 : case 16000: maxBR = MAX_BR_075DMS_WB ; break;
387 0 : case 24000: maxBR = MAX_BR_075DMS_SSWB; break;
388 0 : default: break;
389 : }
390 0 : break;
391 31393 : case LC3PLUS_FRAME_DURATION_10MS:
392 : /* have additional limitations for 10ms */
393 31393 : minBR = MIN_BR_100DMS;
394 31393 : maxBR = MAX_BR;
395 31393 : switch (encoder->fs_in)
396 : {
397 0 : case 8000: maxBR = MAX_BR_100DMS_NB ; break;
398 2 : case 16000: maxBR = MAX_BR_100DMS_WB ; break;
399 0 : case 24000: maxBR = MAX_BR_100DMS_SSWB; break;
400 31391 : default: maxBR = MAX_BR; break;
401 : }
402 31393 : break;
403 0 : case LC3PLUS_FRAME_DURATION_UNDEFINED:
404 0 : return LC3PLUS_FRAMEMS_ERROR;
405 : }
406 333838 : maxBR *= (encoder->fs_in == 44100 ? 441. / 480 : 1);
407 : }
408 333838 : minBR *= encoder->channels;
409 333838 : maxBR *= encoder->channels;
410 :
411 333838 : encoder->combined_channel_coding = 0;
412 :
413 333838 : if (encoder->channels > 1 && encoder->epmode)
414 : {
415 0 : if (encoder->bitrate * encoder->frame_length / (8 * encoder->fs_in) <= 160)
416 : {
417 0 : encoder->combined_channel_coding = 1;
418 : }
419 : }
420 :
421 333838 : if (encoder->epmode > 0)
422 : {
423 : #ifdef CR12_D_FIX_BITRATE_LIMITS
424 : #ifdef ENABLE_HR_MODE_FL
425 0 : if (encoder->hrmode){
426 0 : switch( encoder->frame_dms )
427 : {
428 0 : case LC3PLUS_FRAME_DURATION_2p5MS:
429 0 : if( encoder->fs_in == 48000){
430 0 : fec_slot_bytes_min = FEC_SLOT_BYTES_MIN_025DMS_48KHZ_HR;
431 : } else {
432 0 : fec_slot_bytes_min = FEC_SLOT_BYTES_MIN_025DMS_96KHZ_HR;
433 : }
434 0 : break;
435 0 : case LC3PLUS_FRAME_DURATION_5MS:
436 0 : if( encoder->fs_in == 48000){
437 0 : fec_slot_bytes_min = FEC_SLOT_BYTES_MIN_050DMS_48KHZ_HR;
438 : } else {
439 0 : fec_slot_bytes_min = FEC_SLOT_BYTES_MIN_050DMS_96KHZ_HR;
440 : }
441 0 : break;
442 0 : case LC3PLUS_FRAME_DURATION_7p5MS:
443 0 : if( encoder->fs_in == 48000){
444 0 : fec_slot_bytes_min = FEC_SLOT_BYTES_MIN_075DMS_48KHZ_HR;
445 : } else {
446 0 : fec_slot_bytes_min = FEC_SLOT_BYTES_MIN_075DMS_96KHZ_HR;
447 : }
448 0 : break;
449 0 : case LC3PLUS_FRAME_DURATION_10MS:
450 0 : if( encoder->fs_in == 48000){
451 0 : fec_slot_bytes_min = FEC_SLOT_BYTES_MIN_100DMS_48KHZ_HR;
452 : } else {
453 0 : fec_slot_bytes_min = FEC_SLOT_BYTES_MIN_100DMS_96KHZ_HR;
454 : }
455 0 : break;
456 0 : default:
457 0 : return LC3PLUS_FRAMEMS_ERROR;
458 : }
459 : }
460 : else
461 : #endif
462 : {
463 0 : fec_slot_bytes_min = FEC_SLOT_BYTES_MIN;
464 : }
465 :
466 :
467 0 : check_bytes = bitrate * encoder->frame_length / ( 8 * encoder->fs_in * encoder->channels );
468 0 : maxBR = FEC_SLOT_BYTES_MAX * ( 8 * encoder->fs_in * encoder->channels ) / encoder->frame_length;
469 0 : if ( check_bytes < fec_slot_bytes_min || bitrate > maxBR )
470 : #else
471 : max_bytes = bitrate * encoder->frame_length / (8 * encoder->fs_in * encoder->channels);
472 : if (max_bytes < FEC_SLOT_BYTES_MIN || max_bytes > FEC_SLOT_BYTES_MAX)
473 : #endif /* CR12_D_FIX_BITRATE_LIMITS */
474 : {
475 0 : encoder->lc3_br_set = 0;
476 0 : return LC3PLUS_BITRATE_ERROR;
477 : }
478 : }
479 :
480 333838 : if (encoder->combined_channel_coding)
481 : {
482 0 : totalBytes = fec_get_data_size(encoder->epmode, encoder->combined_channel_coding,
483 0 : bitrate * encoder->frame_length / (8 * encoder->fs_in));
484 :
485 0 : encoder->channel_setup[0]->n_pccw =
486 0 : fec_get_n_pccw(bitrate * encoder->frame_length / (8 * encoder->fs_in), encoder->epmode,
487 0 : encoder->combined_channel_coding);
488 :
489 0 : encoder->channel_setup[0]->n_pc = fec_get_n_pc(encoder->epmode, encoder->channel_setup[0]->n_pccw,
490 0 : bitrate * encoder->frame_length / (8 * encoder->fs_in));
491 : }
492 : else
493 : {
494 333838 : totalBytes = bitrate * encoder->frame_length / (8 * encoder->fs_in);
495 : }
496 :
497 333838 : if (encoder->frame_dms <= LC3PLUS_FRAME_DURATION_5MS)
498 : {
499 302445 : encoder->tnsMaxOrder = 4;
500 : } else {
501 31393 : encoder->tnsMaxOrder = 8;
502 : }
503 :
504 333838 : if (bitrate < minBR || bitrate > maxBR) {
505 0 : return LC3PLUS_BITRATE_ERROR;
506 : }
507 :
508 333838 : encoder->lc3_br_set = 1;
509 667676 : for (ch = 0; ch < encoder->channels; ch++) {
510 :
511 333838 : EncSetup* setup = encoder->channel_setup[ch];
512 :
513 333838 : setup->targetBytes = totalBytes / encoder->channels + (ch < (totalBytes % encoder->channels));
514 333838 : channel_bytes = totalBytes / encoder->channels + (ch < (totalBytes % encoder->channels));
515 :
516 333838 : if (encoder->combined_channel_coding)
517 : {
518 0 : setup->targetBytes = channel_bytes;
519 : }
520 : else
521 : {
522 333838 : setup->targetBytes = fec_get_data_size(encoder->epmode, encoder->combined_channel_coding, channel_bytes);
523 333838 : setup->n_pccw = fec_get_n_pccw(channel_bytes, encoder->epmode, encoder->combined_channel_coding);
524 333838 : setup->n_pc = fec_get_n_pc(encoder->epmode, setup->n_pccw, channel_bytes);
525 : }
526 : /* reduce bandwith to 12kHz if bitrate is low */
527 333838 : if (encoder->frame_dms == LC3PLUS_FRAME_DURATION_10MS &&
528 31393 : ((setup->targetBytes < 40 && encoder->fs == 48000) ||
529 31393 : (setup->targetBytes < 36 && encoder->fs == 32000)))
530 : {
531 0 : encoder->bandwidth = MIN(12000, encoder->bandwidth_preset);
532 : }
533 : else
534 : {
535 : /* channel with highest index has lowest bitrate.
536 : For a second channel with lower targetBytes, bandwidth is overwritten */
537 333838 : encoder->bandwidth = encoder->bandwidth_preset;
538 : }
539 333838 : encoder->bw_ctrl_cutoff_bin = encoder->bandwidth * (encoder->frame_dms * 1.25 * 10) / 5000;
540 333838 : encoder->bw_index = (encoder->bandwidth / 4000) - 1;
541 333838 : setup->total_bits = setup->targetBytes << 3;
542 667676 : setup->targetBitsInit = setup->total_bits - encoder->envelope_bits - encoder->global_gain_bits -
543 667676 : encoder->noise_fac_bits - encoder->BW_cutoff_bits -
544 333838 : getLastNzBits (encoder->frame_length) - 2 - 1;
545 :
546 333838 : if (setup->total_bits > 1280) {
547 117520 : setup->targetBitsInit = setup->targetBitsInit - 1;
548 : }
549 333838 : if (setup->total_bits > 2560) {
550 0 : setup->targetBitsInit = setup->targetBitsInit - 1;
551 : }
552 :
553 333838 : if (encoder->hrmode)
554 : {
555 0 : setup->targetBitsInit -= 1;
556 : }
557 :
558 333838 : setup->targetBitsAri = setup->total_bits;
559 333838 : setup->enable_lpc_weighting = setup->total_bits < 480;
560 :
561 333838 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_7p5MS) {
562 0 : setup->enable_lpc_weighting = setup->total_bits < 360;
563 : }
564 333838 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_5MS) {
565 302443 : setup->enable_lpc_weighting = setup->total_bits < 240;
566 : }
567 333838 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_2p5MS) {
568 2 : setup->enable_lpc_weighting = setup->total_bits < 120;
569 : }
570 : #ifdef CR9_C_ADD_1p25MS
571 333838 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_1p25MS) {
572 0 : setup->enable_lpc_weighting = setup->total_bits < 60;
573 : }
574 : #endif
575 : #ifdef FIX_BOTH_1p25_WB_GLOBGAINOFFSET_NONBE
576 333838 : if (encoder->frame_dms == LC3PLUS_FRAME_DURATION_1p25MS)
577 : {
578 0 : setup->quantizedGainOff = calc_GGainOffset_1p25(setup->total_bits, encoder->fs_idx); /* enc/dec common function */
579 : }
580 : else
581 : {
582 333838 : setup->quantizedGainOff =
583 333838 : -(MIN(115, setup->total_bits / (10 * (encoder->fs_idx + 1))) + 105 + 5 * (encoder->fs_idx + 1));
584 : }
585 : #else
586 : setup->quantizedGainOff =
587 : -(MIN(115, setup->total_bits / (10 * (encoder->fs_idx + 1))) + 105 + 5 * (encoder->fs_idx + 1));
588 : #endif
589 333838 : if (encoder->hrmode && encoder->fs_idx == 5)
590 : {
591 0 : setup->quantizedGainOff = MAX(setup->quantizedGainOff, -181);
592 : }
593 :
594 333838 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_10MS && ((encoder->fs_in >= 44100 && setup->targetBytes >= 100) ||
595 31393 : (encoder->fs_in == 32000 && setup->targetBytes >= 81)) && setup->targetBytes < 340 && encoder->hrmode == 0) {
596 31391 : setup->attack_handling = 1;
597 :
598 : }
599 302447 : else if (encoder->frame_dms == LC3PLUS_FRAME_DURATION_7p5MS && ((encoder->fs_in >= 44100 && setup->targetBytes >= 75) ||
600 0 : (encoder->fs_in == 32000 && setup->targetBytes >= 61)) && setup->targetBytes < 150 && encoder->hrmode == 0)
601 : {
602 0 : setup->attack_handling = 1;
603 : }
604 : else
605 : {
606 : /* reset for bitrate switching */
607 302447 : setup->attack_handling = 0;
608 :
609 302447 : setup->attdec_filter_mem[0] = 0;
610 302447 : setup->attdec_filter_mem[1] = 0;
611 :
612 302447 : setup->attdec_detected = 0;
613 302447 : setup->attdec_position = 0;
614 302447 : setup->attdec_acc_energy = 0;
615 : }
616 :
617 333838 : bitsTmp = setup->total_bits;
618 : #ifdef CR9_C_ADD_1p25MS
619 333838 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_1p25MS) {
620 0 : bitsTmp = bitsTmp * 8.0 * 0.42;
621 : }
622 : #endif
623 333838 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_2p5MS) {
624 2 : bitsTmp = bitsTmp * 4.0 * (1.0 - 0.4);
625 : }
626 333838 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_5MS) {
627 302443 : bitsTmp = bitsTmp * 2 - 160;
628 : }
629 333838 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_7p5MS) {
630 0 : bitsTmp = round(bitsTmp * 10 / 7.5);
631 : }
632 :
633 333838 : if (bitsTmp < 400 + (encoder->fs_idx - 1) * 80) {
634 0 : setup->ltpf_enable = 1;
635 333838 : } else if (bitsTmp < 480 + (encoder->fs_idx - 1) * 80) {
636 2 : setup->ltpf_enable = 1;
637 333836 : } else if (bitsTmp < 560 + (encoder->fs_idx - 1) * 80) {
638 0 : setup->ltpf_enable = 1;
639 333836 : } else if (bitsTmp < 640 + (encoder->fs_idx - 1) * 80) {
640 2 : setup->ltpf_enable = 1;
641 : } else {
642 333834 : setup->ltpf_enable = 0;
643 : }
644 333838 : if (encoder->hrmode) {
645 0 : setup->ltpf_enable = 0;
646 : }
647 :
648 : /* turn down SNS shaping for higher rates */
649 333838 : if (encoder->hrmode == 0) {
650 333838 : encoder->sns_damping = 0.85;
651 : } else {
652 0 : encoder->sns_damping = 0.6;
653 0 : if (encoder->fs_idx >= 4) {
654 0 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_10MS)
655 : {
656 0 : if (setup->total_bits > 4400) {
657 0 : encoder->sns_damping = 6881.0/32768.0;
658 : }
659 : }
660 0 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_7p5MS)
661 : {
662 0 : if (setup->total_bits > 3*4400/4) {
663 0 : encoder->sns_damping = 5898.0/32768.0;
664 : }
665 : }
666 0 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_5MS)
667 : {
668 0 : if (setup->total_bits > 4600/2) {
669 0 : encoder->sns_damping = 4915.0/32768.0;
670 : }
671 : }
672 0 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_2p5MS)
673 : {
674 0 : if (setup->total_bits > 4600/4) {
675 0 : encoder->sns_damping = 4915.0/32768.0;
676 : }
677 : }
678 : #ifdef CR9_C_ADD_1p25MS
679 0 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_1p25MS)
680 : {
681 0 : assert(0);
682 : if (setup->total_bits > 4600/4) {
683 : encoder->sns_damping = 4915.0/32768.0;
684 : }
685 : }
686 : #endif
687 : }
688 : }
689 :
690 333838 : if (encoder->hrmode && encoder->fs_idx >= 4)
691 0 : {
692 0 : int real_rate = setup->targetBytes * 8000 / (encoder->frame_ms * 1.25);
693 0 : setup->regBits = real_rate / 12500;
694 :
695 0 : if (encoder->fs_idx == 5)
696 : {
697 0 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_10MS)
698 : {
699 0 : setup->regBits +=2;
700 : }
701 0 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_7p5MS)
702 : {
703 0 : setup->regBits +=1;
704 : }
705 0 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_2p5MS)
706 : {
707 0 : setup->regBits -= 6;
708 : }
709 : #ifdef CR9_C_ADD_1p25MS
710 0 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_1p25MS)
711 : {
712 0 : assert(0);
713 : }
714 : #endif
715 : }
716 : else
717 : {
718 : #ifdef CR9_C_ADD_1p25MS
719 0 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_1p25MS)
720 : {
721 0 : assert(0);
722 : }
723 : #endif
724 0 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_2p5MS)
725 : {
726 0 : setup->regBits -= 6;
727 : }
728 0 : else if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_5MS)
729 : {
730 0 : setup->regBits += 0;
731 : }
732 0 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_7p5MS)
733 : {
734 0 : setup->regBits +=2;
735 : }
736 0 : if (encoder->frame_ms == LC3PLUS_FRAME_DURATION_10MS)
737 : {
738 0 : setup->regBits += 5;
739 : }
740 : }
741 0 : if (setup->regBits < 6)
742 : {
743 0 : setup->regBits = 6;
744 : }
745 0 : if (setup->regBits > 23)
746 : {
747 0 : setup->regBits = 23;
748 : }
749 : }
750 : else
751 : {
752 333838 : setup->regBits = -1;
753 : }
754 : }
755 :
756 333838 : encoder->bitrate = bitrate;
757 :
758 333838 : return LC3PLUS_OK;
759 : }
760 :
761 0 : void update_enc_bandwidth(LC3PLUS_Enc* encoder, int bandwidth)
762 : {
763 0 : int index = 0;
764 :
765 0 : if (bandwidth >= encoder->fs_in) {
766 0 : encoder->bandwidth = 0;
767 : }
768 : else
769 : {
770 0 : encoder->bandwidth = bandwidth;
771 0 : index = FS2FS_IDX(bandwidth);
772 0 : encoder->bw_ctrl_cutoff_bin = encoder->cutoffBins[index];
773 : }
774 0 : }
|
