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 "setup_enc_lc3.h"
13 : #include "functions.h"
14 : #include <stdio.h>
15 :
16 : /* if encoder is null only size is reported */
17 0 : int alloc_encoder(LC3PLUS_Enc* encoder, int channels)
18 : {
19 0 : int ch = 0;
20 0 : size_t size = sizeof(LC3PLUS_Enc);
21 :
22 0 : for (ch = 0; ch < channels; ch++) {
23 0 : EncSetup* setup = balloc(encoder, &size, sizeof(EncSetup));
24 0 : if (encoder) {
25 0 : encoder->channel_setup[ch] = setup;
26 : }
27 : }
28 :
29 0 : return (int)size;
30 : }
31 :
32 0 : LC3PLUS_Error FillEncSetup(LC3PLUS_Enc* encoder, int samplerate, int channels
33 : , int hrmode
34 : , int32_t lfe_channel_array[]
35 : )
36 : {
37 0 : int ch = 0;
38 0 : memset(encoder, 0, lc3plus_enc_get_size(samplerate, channels));
39 0 : alloc_encoder(encoder, channels);
40 :
41 0 : encoder->fs = CODEC_FS(samplerate);
42 0 : encoder->fs_in = samplerate;
43 0 : encoder->fs_idx = FS2FS_IDX(encoder->fs);
44 0 : encoder->frame_dms = 100;
45 :
46 0 : if (encoder->fs_idx > 4) {
47 0 : encoder->fs_idx = 5;
48 : }
49 :
50 0 : encoder->hrmode = hrmode != 0;
51 :
52 0 : encoder->channels = channels;
53 0 : encoder->frame_ms = 10;
54 0 : encoder->envelope_bits = 38;
55 0 : encoder->global_gain_bits = 8;
56 0 : encoder->noise_fac_bits = 3;
57 0 : encoder->BW_cutoff_bits = BW_cutoff_bits_all[encoder->fs_idx];
58 :
59 0 : encoder->r12k8_mem_in_len = 2 * 8 * encoder->fs / 12800;
60 0 : encoder->r12k8_mem_out_len = 24;
61 :
62 0 : if (lfe_channel_array != NULL)
63 : {
64 0 : for (ch = 0; ch < encoder->channels; ch++)
65 : {
66 0 : encoder->channel_setup[ch]->lfe = lfe_channel_array[ch] != 0;
67 : }
68 : }
69 :
70 0 : encoder->bw_ctrl_active = 0;
71 0 : encoder->bandwidth = encoder->fs / 2;
72 0 : encoder->bandwidth_preset = encoder->fs / 2;
73 :
74 :
75 0 : if (encoder->fs == 8000) {
76 0 : encoder->tilt = 14;
77 0 : } else if (encoder->fs == 16000) {
78 0 : encoder->tilt = 18;
79 0 : } else if (encoder->fs == 24000) {
80 0 : encoder->tilt = 22;
81 0 : } else if (encoder->fs == 32000) {
82 0 : encoder->tilt = 26;
83 0 : } else if (encoder->fs == 48000) {
84 0 : encoder->tilt = 30;
85 : }
86 0 : else if (encoder->fs == 96000) {
87 0 : encoder->tilt = 34;
88 : }
89 :
90 0 : set_enc_frame_params(encoder);
91 0 : return LC3PLUS_OK;
92 : }
93 :
94 : /* set frame config params */
95 0 : void set_enc_frame_params(LC3PLUS_Enc* encoder)
96 : {
97 0 : int ch = 0;
98 : EncSetup* setup;
99 :
100 0 : encoder->frame_length = ceil(encoder->fs * 10 / 1000); /* fs * 0.01*2^6 */
101 0 : if (encoder->hrmode == 1)
102 : {
103 0 : encoder->yLen = encoder->frame_length;
104 : }
105 : else
106 : {
107 0 : encoder->yLen = MIN(MAX_BW, encoder->frame_length);
108 0 : encoder->sns_damping = 0.85;
109 : }
110 :
111 0 : encoder->stEnc_mdct_mem_len = encoder->frame_length - encoder->la_zeroes;
112 0 : encoder->bands_number = 64;
113 0 : encoder->nSubdivisions = 3;
114 0 : encoder->near_nyquist_index = encoder->bands_number - 2;
115 0 : encoder->near_nyquist_flag = 0;
116 0 : encoder->ltpf_mem_in_len = LTPF_MEMIN_LEN;
117 :
118 0 : if (encoder->fs_idx == 5)
119 : {
120 0 : encoder->hrmode = 1;
121 : }
122 :
123 0 : if (encoder->hrmode)
124 : {
125 0 : encoder->BW_cutoff_bits = 0;
126 : }
127 : else
128 : {
129 0 : encoder->BW_cutoff_bits = BW_cutoff_bits_all[encoder->fs_idx];
130 : }
131 :
132 0 : if (encoder->frame_ms == 10) {
133 0 : encoder->la_zeroes = MDCT_la_zeroes[encoder->fs_idx];
134 0 : if (encoder->hrmode)
135 : {
136 0 : encoder->bands_offset = ACC_COEFF_PER_BAND_HR[encoder->fs_idx];
137 : }
138 : else
139 : {
140 0 : encoder->bands_offset = ACC_COEFF_PER_BAND[encoder->fs_idx];
141 : }
142 0 : encoder->cutoffBins = BW_cutoff_bin_all;
143 :
144 0 : encoder->attdec_nblocks = 4;
145 0 : encoder->attdec_damping = 0.5;
146 0 : encoder->attdec_hangover_thresh = 2;
147 : }
148 0 : else if (encoder->frame_ms == 7.5) {
149 0 : if (encoder->hrmode)
150 : {
151 0 : encoder->bands_offset = ACC_COEFF_PER_BAND_7_5ms_HR[encoder->fs_idx];
152 : }
153 : else
154 : {
155 0 : encoder->bands_offset = ACC_COEFF_PER_BAND_7_5ms[encoder->fs_idx];
156 : }
157 0 : encoder->la_zeroes = MDCT_la_zeroes_7_5ms[encoder->fs_idx];
158 0 : encoder->cutoffBins = BW_cutoff_bin_all_7_5ms;
159 0 : encoder->attdec_nblocks = 3;
160 0 : encoder->attdec_damping = 0.3;
161 0 : encoder->attdec_hangover_thresh = 1;
162 :
163 0 : encoder->frame_length = (encoder->frame_length >> 2) * 3;
164 0 : encoder->yLen = (encoder->yLen >> 2) * 3;
165 :
166 0 : encoder->stEnc_mdct_mem_len = encoder->frame_length - encoder->la_zeroes;
167 0 : if (encoder->hrmode)
168 : {
169 0 : encoder->bands_number = bands_number_7_5ms_HR[encoder->fs_idx];
170 : }
171 : else
172 : {
173 0 : encoder->bands_number = bands_number_7_5ms[encoder->fs_idx];
174 : }
175 0 : encoder->nSubdivisions = 3;
176 0 : encoder->near_nyquist_index = encoder->bands_number - 4;
177 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);
178 : }
179 0 : else if (encoder->frame_ms == 5) {
180 0 : encoder->frame_length = encoder->frame_length >> 1;
181 0 : encoder->yLen /= 2;
182 0 : encoder->stEnc_mdct_mem_len = encoder->frame_length - encoder->la_zeroes;
183 0 : encoder->bands_number = bands_number_5ms[encoder->fs_idx];
184 0 : encoder->nSubdivisions = 2;
185 0 : encoder->near_nyquist_index = encoder->bands_number - 3;
186 0 : encoder->la_zeroes = MDCT_la_zeroes_5ms[encoder->fs_idx];
187 0 : if (encoder->hrmode)
188 : {
189 0 : encoder->bands_offset = ACC_COEFF_PER_BAND_5ms_HR[encoder->fs_idx];
190 : }
191 : else
192 : {
193 0 : encoder->bands_offset = ACC_COEFF_PER_BAND_5ms[encoder->fs_idx];
194 : }
195 0 : encoder->cutoffBins = BW_cutoff_bin_all_5ms;
196 : }
197 0 : else if (encoder->frame_ms == 2.5) {
198 0 : encoder->la_zeroes = MDCT_la_zeroes_2_5ms[encoder->fs_idx];
199 0 : if (encoder->hrmode)
200 : {
201 0 : encoder->bands_offset = ACC_COEFF_PER_BAND_2_5ms_HR[encoder->fs_idx];
202 : }
203 : else
204 : {
205 0 : encoder->bands_offset = ACC_COEFF_PER_BAND_2_5ms[encoder->fs_idx];
206 : }
207 0 : encoder->cutoffBins = BW_cutoff_bin_all_2_5ms;
208 0 : encoder->frame_length = encoder->frame_length >> 2;
209 0 : encoder->yLen /= 4;
210 0 : encoder->stEnc_mdct_mem_len = encoder->frame_length - encoder->la_zeroes;
211 0 : if (encoder->hrmode)
212 : {
213 0 : encoder->bands_number = bands_number_2_5ms_HR[encoder->fs_idx];
214 : }
215 : else
216 : {
217 0 : encoder->bands_number = bands_number_2_5ms[encoder->fs_idx];
218 : }
219 :
220 0 : encoder->nSubdivisions = 2;
221 0 : encoder->near_nyquist_index = encoder->bands_number - 2;
222 0 : encoder->ltpf_mem_in_len = LTPF_MEMIN_LEN + (LEN_12K8 >> 2);
223 : }
224 :
225 0 : for (ch = 0; ch < encoder->channels; ch++) {
226 0 : setup = encoder->channel_setup[ch];
227 :
228 0 : setup->olpa_mem_pitch = 17;
229 0 : setup->pitch_flag = 0;
230 0 : if (setup->mdctStruct.mem != NULL) {
231 0 : mdct_free(&setup->mdctStruct);
232 0 : mdct_init(&setup->mdctStruct, encoder->frame_length, encoder->frame_dms, encoder->fs_idx, encoder->hrmode);
233 :
234 0 : dct2_free(&setup->dct2StructSNS);
235 0 : dct2_init(&setup->dct2StructSNS, M);
236 : }
237 : else
238 : {
239 0 : mdct_init(&setup->mdctStruct, encoder->frame_length, encoder->frame_dms, encoder->fs_idx, encoder->hrmode);
240 0 : dct2_init(&setup->dct2StructSNS, M);
241 : }
242 : }
243 0 : }
244 :
245 : /* change encoder bitrate */
246 0 : LC3PLUS_Error update_enc_bitrate(LC3PLUS_Enc* encoder, int bitrate)
247 : {
248 0 : int ch = 0, bitsTmp = 0, minBR = 0, maxBR = 0, totalBytes = 0;
249 0 : LC3_INT channel_bytes = 0, max_bytes = 0;
250 :
251 : #ifdef ENABLE_HR_MODE_FL
252 0 : if (encoder->hrmode)
253 : {
254 0 : switch (encoder->frame_dms)
255 : {
256 0 : case 25:
257 0 : maxBR = 672000;
258 0 : if (encoder->fs == 48000) {minBR = MIN_BR_25MS_48KHZ_HR;}
259 0 : else if (encoder->fs == 96000) {minBR = MIN_BR_25MS_96KHZ_HR;}
260 0 : else { return LC3PLUS_HRMODE_ERROR;}
261 0 : break;
262 0 : case 50:
263 0 : maxBR = 600000;
264 0 : if (encoder->fs == 48000) {minBR = MIN_BR_50MS_48KHZ_HR;}
265 0 : else if (encoder->fs == 96000) {minBR = MIN_BR_50MS_96KHZ_HR;}
266 0 : else { return LC3PLUS_HRMODE_ERROR;}
267 0 : break;
268 0 : case 75:
269 0 : maxBR = 500000;
270 0 : if (encoder->fs == 48000) {minBR = MIN_BR_075DMS_48KHZ_HR;}
271 0 : else if (encoder->fs == 96000) {minBR = MIN_BR_075DMS_96KHZ_HR;}
272 0 : else {return LC3PLUS_HRMODE_ERROR;}
273 0 : break;
274 0 : case 100:
275 0 : maxBR = 500000;
276 0 : if (encoder->fs == 48000) {minBR = MIN_BR_100MS_48KHZ_HR;}
277 0 : else if (encoder->fs == 96000) {minBR = MIN_BR_100MS_96KHZ_HR;}
278 0 : else { return LC3PLUS_HRMODE_ERROR;}
279 0 : break;
280 0 : default:
281 0 : return LC3PLUS_HRMODE_ERROR;
282 : }
283 : }
284 : else
285 : #endif /* ENABLE_HR_MODE_FL */
286 : {
287 0 : minBR = (MIN_NBYTES << 3);
288 0 : maxBR = MAX_BR;
289 :
290 0 : switch (encoder->frame_dms)
291 : {
292 0 : case 25:
293 0 : minBR = MIN_BR_025DMS;
294 0 : maxBR = MAX_BR;
295 0 : break;
296 0 : case 50:
297 0 : minBR = MIN_BR_050DMS;
298 0 : maxBR = MAX_BR;
299 : /* have additional limitations for 5.0ms */
300 0 : switch (encoder->fs_in)
301 : {
302 0 : case 8000: maxBR = MAX_BR_050DMS_NB; break;
303 0 : default: break;
304 : }
305 0 : break;
306 0 : case 75:
307 0 : minBR = MIN_BR_075DMS;
308 0 : maxBR = MAX_BR_075DMS;
309 : /* have additional limitations for 7.5ms */
310 0 : switch (encoder->fs_in)
311 : {
312 0 : case 8000: maxBR = MAX_BR_075DMS_NB ; break;
313 0 : case 16000: maxBR = MAX_BR_075DMS_WB ; break;
314 0 : case 24000: maxBR = MAX_BR_075DMS_SSWB; break;
315 0 : default: break;
316 : }
317 0 : break;
318 0 : case 100:
319 : /* have additional limitations for 10ms */
320 0 : minBR = MIN_BR_100DMS;
321 0 : maxBR = MAX_BR;
322 0 : switch (encoder->fs_in)
323 : {
324 0 : case 8000: maxBR = MAX_BR_100DMS_NB ; break;
325 0 : case 16000: maxBR = MAX_BR_100DMS_WB ; break;
326 0 : case 24000: maxBR = MAX_BR_100DMS_SSWB; break;
327 0 : default: maxBR = MAX_BR; break;
328 : }
329 0 : break;
330 0 : default: return LC3PLUS_FRAMEMS_ERROR;
331 : }
332 0 : maxBR *= (encoder->fs_in == 44100 ? 441. / 480 : 1);
333 : }
334 0 : minBR *= encoder->channels;
335 0 : maxBR *= encoder->channels;
336 :
337 0 : encoder->combined_channel_coding = 0;
338 :
339 0 : if (encoder->channels > 1 && encoder->epmode)
340 : {
341 0 : if (encoder->bitrate * encoder->frame_length / (8 * encoder->fs_in) <= 160)
342 : {
343 0 : encoder->combined_channel_coding = 1;
344 : }
345 : }
346 :
347 0 : if (encoder->epmode > 0)
348 : {
349 0 : max_bytes = bitrate * encoder->frame_length / (8 * encoder->fs_in * encoder->channels);
350 0 : if (max_bytes < FEC_SLOT_BYTES_MIN || max_bytes > FEC_SLOT_BYTES_MAX)
351 : {
352 0 : encoder->lc3_br_set = 0;
353 0 : return LC3PLUS_BITRATE_ERROR;
354 : }
355 : }
356 :
357 0 : if (encoder->combined_channel_coding)
358 : {
359 0 : totalBytes = fec_get_data_size(encoder->epmode, encoder->combined_channel_coding,
360 0 : bitrate * encoder->frame_length / (8 * encoder->fs_in));
361 :
362 0 : encoder->channel_setup[0]->n_pccw =
363 0 : fec_get_n_pccw(bitrate * encoder->frame_length / (8 * encoder->fs_in), encoder->epmode,
364 0 : encoder->combined_channel_coding);
365 :
366 0 : encoder->channel_setup[0]->n_pc = fec_get_n_pc(encoder->epmode, encoder->channel_setup[0]->n_pccw,
367 0 : bitrate * encoder->frame_length / (8 * encoder->fs_in));
368 : }
369 : else
370 : {
371 0 : totalBytes = bitrate * encoder->frame_length / (8 * encoder->fs_in);
372 : }
373 :
374 0 : if (encoder->frame_dms <= 50)
375 : {
376 0 : encoder->tnsMaxOrder = 4;
377 : } else {
378 0 : encoder->tnsMaxOrder = 8;
379 : }
380 :
381 0 : if (bitrate < minBR || bitrate > maxBR) {
382 0 : return LC3PLUS_BITRATE_ERROR;
383 : }
384 :
385 0 : encoder->lc3_br_set = 1;
386 0 : for (ch = 0; ch < encoder->channels; ch++) {
387 :
388 0 : EncSetup* setup = encoder->channel_setup[ch];
389 :
390 0 : setup->targetBytes = totalBytes / encoder->channels + (ch < (totalBytes % encoder->channels));
391 0 : channel_bytes = totalBytes / encoder->channels + (ch < (totalBytes % encoder->channels));
392 :
393 0 : if (encoder->combined_channel_coding)
394 : {
395 0 : setup->targetBytes = channel_bytes;
396 : }
397 : else
398 : {
399 0 : setup->targetBytes = fec_get_data_size(encoder->epmode, encoder->combined_channel_coding, channel_bytes);
400 0 : setup->n_pccw = fec_get_n_pccw(channel_bytes, encoder->epmode, encoder->combined_channel_coding);
401 0 : setup->n_pc = fec_get_n_pc(encoder->epmode, setup->n_pccw, channel_bytes);
402 : }
403 : // reduce bandwith to 12kHz if bitrate is low
404 0 : if (encoder->frame_dms == 100 &&
405 0 : ((setup->targetBytes < 40 && encoder->fs == 48000) ||
406 0 : (setup->targetBytes < 36 && encoder->fs == 32000)))
407 : {
408 0 : encoder->bandwidth = MIN(12000, encoder->bandwidth_preset);
409 : }
410 : else
411 : {
412 : /* channel with highest index has lowest bitrate.
413 : For a second channel with lower targetBytes, bandwidth is overwritten */
414 0 : encoder->bandwidth = encoder->bandwidth_preset;
415 : }
416 0 : encoder->bw_ctrl_cutoff_bin = encoder->bandwidth * encoder->frame_dms / 5000;
417 0 : encoder->bw_index = (encoder->bandwidth / 4000) - 1;
418 0 : setup->total_bits = setup->targetBytes << 3;
419 0 : setup->targetBitsInit = setup->total_bits - encoder->envelope_bits - encoder->global_gain_bits -
420 0 : encoder->noise_fac_bits - encoder->BW_cutoff_bits -
421 0 : ceil(LC3_LOGTWO(encoder->frame_length / 2)) - 2 - 1;
422 :
423 0 : if (setup->total_bits > 1280) {
424 0 : setup->targetBitsInit = setup->targetBitsInit - 1;
425 : }
426 0 : if (setup->total_bits > 2560) {
427 0 : setup->targetBitsInit = setup->targetBitsInit - 1;
428 : }
429 :
430 0 : if (encoder->hrmode)
431 : {
432 0 : setup->targetBitsInit -= 1;
433 : }
434 :
435 0 : setup->targetBitsAri = setup->total_bits;
436 0 : setup->enable_lpc_weighting = setup->total_bits < 480;
437 :
438 0 : if (encoder->frame_ms == 7.5) {
439 0 : setup->enable_lpc_weighting = setup->total_bits < 360;
440 : }
441 0 : if (encoder->frame_ms == 5) {
442 0 : setup->enable_lpc_weighting = setup->total_bits < 240;
443 : }
444 0 : if (encoder->frame_ms == 2.5) {
445 0 : setup->enable_lpc_weighting = setup->total_bits < 120;
446 : }
447 :
448 0 : setup->quantizedGainOff =
449 0 : -(MIN(115, setup->total_bits / (10 * (encoder->fs_idx + 1))) + 105 + 5 * (encoder->fs_idx + 1));
450 :
451 0 : if (encoder->hrmode && encoder->fs_idx == 5)
452 : {
453 0 : setup->quantizedGainOff = MAX(setup->quantizedGainOff, -181);
454 : }
455 :
456 0 : if (encoder->frame_ms == 10 && ((encoder->fs_in >= 44100 && setup->targetBytes >= 100) ||
457 0 : (encoder->fs_in == 32000 && setup->targetBytes >= 81)) && setup->targetBytes < 340 && encoder->hrmode == 0) {
458 0 : setup->attack_handling = 1;
459 :
460 : }
461 0 : else if (encoder->frame_dms == 75 && ((encoder->fs_in >= 44100 && setup->targetBytes >= 75) ||
462 0 : (encoder->fs_in == 32000 && setup->targetBytes >= 61)) && setup->targetBytes < 150 && encoder->hrmode == 0)
463 : {
464 0 : setup->attack_handling = 1;
465 : }
466 : else
467 : {
468 : /* reset for bitrate switching */
469 0 : setup->attack_handling = 0;
470 :
471 0 : setup->attdec_filter_mem[0] = 0;
472 0 : setup->attdec_filter_mem[1] = 0;
473 :
474 0 : setup->attdec_detected = 0;
475 0 : setup->attdec_position = 0;
476 0 : setup->attdec_acc_energy = 0;
477 : }
478 :
479 0 : bitsTmp = setup->total_bits;
480 0 : if (encoder->frame_ms == 2.5) {
481 0 : bitsTmp = bitsTmp * 4.0 * (1.0 - 0.4);
482 : }
483 0 : if (encoder->frame_ms == 5) {
484 0 : bitsTmp = bitsTmp * 2 - 160;
485 : }
486 0 : if (encoder->frame_ms == 7.5) {
487 0 : bitsTmp = round(bitsTmp * 10 / 7.5);
488 : }
489 :
490 0 : if (bitsTmp < 400 + (encoder->fs_idx - 1) * 80) {
491 0 : setup->ltpf_enable = 1;
492 0 : } else if (bitsTmp < 480 + (encoder->fs_idx - 1) * 80) {
493 0 : setup->ltpf_enable = 1;
494 0 : } else if (bitsTmp < 560 + (encoder->fs_idx - 1) * 80) {
495 0 : setup->ltpf_enable = 1;
496 0 : } else if (bitsTmp < 640 + (encoder->fs_idx - 1) * 80) {
497 0 : setup->ltpf_enable = 1;
498 : } else {
499 0 : setup->ltpf_enable = 0;
500 : }
501 0 : if (encoder->hrmode) {
502 0 : setup->ltpf_enable = 0;
503 : }
504 :
505 : /* turn down SNS shaping for higher rates */
506 0 : if (encoder->hrmode == 0) {
507 0 : encoder->sns_damping = 0.85;
508 : } else {
509 0 : encoder->sns_damping = 0.6;
510 0 : if (encoder->fs_idx >= 4) {
511 0 : if (encoder->frame_ms == 10)
512 : {
513 0 : if (setup->total_bits > 4400) {
514 0 : encoder->sns_damping = 6881.0/32768.0;
515 : }
516 : }
517 0 : if (encoder->frame_ms == 7.5)
518 : {
519 0 : if (setup->total_bits > 3*4400/4) {
520 0 : encoder->sns_damping = 5898.0/32768.0;
521 : }
522 : }
523 0 : if (encoder->frame_ms == 5)
524 : {
525 0 : if (setup->total_bits > 4600/2) {
526 0 : encoder->sns_damping = 4915.0/32768.0;
527 : }
528 : }
529 0 : if (encoder->frame_ms == 2.5)
530 : {
531 0 : if (setup->total_bits > 4600/4) {
532 0 : encoder->sns_damping = 4915.0/32768.0;
533 : }
534 : }
535 : }
536 : }
537 :
538 0 : if (encoder->hrmode && encoder->fs_idx >= 4)
539 0 : {
540 0 : int real_rate = setup->targetBytes * 8000 / encoder->frame_ms;
541 0 : setup->regBits = real_rate / 12500;
542 :
543 0 : if (encoder->fs_idx == 5)
544 : {
545 0 : if (encoder->frame_ms == 10)
546 : {
547 0 : setup->regBits +=2;
548 : }
549 0 : if (encoder->frame_ms == 7.5)
550 : {
551 0 : setup->regBits +=1;
552 : }
553 0 : if (encoder->frame_ms == 2.5)
554 : {
555 0 : setup->regBits -= 6;
556 : }
557 : }
558 : else
559 : {
560 0 : if (encoder->frame_ms == 2.5)
561 : {
562 0 : setup->regBits -= 6;
563 : }
564 0 : else if (encoder->frame_ms == 5)
565 : {
566 0 : setup->regBits += 0;
567 : }
568 0 : if (encoder->frame_ms == 7.5)
569 : {
570 0 : setup->regBits +=2;
571 : }
572 0 : if (encoder->frame_ms == 10)
573 : {
574 0 : setup->regBits += 5;
575 : }
576 : }
577 0 : if (setup->regBits < 6)
578 : {
579 0 : setup->regBits = 6;
580 : }
581 0 : if (setup->regBits > 23)
582 : {
583 0 : setup->regBits = 23;
584 : }
585 : }
586 : else
587 : {
588 0 : setup->regBits = -1;
589 : }
590 : }
591 :
592 0 : encoder->bitrate = bitrate;
593 :
594 0 : return LC3PLUS_OK;
595 : }
596 :
597 0 : void update_enc_bandwidth(LC3PLUS_Enc* encoder, int bandwidth)
598 : {
599 0 : int index = 0;
600 :
601 0 : if (bandwidth >= encoder->fs_in) {
602 0 : encoder->bandwidth = 0;
603 : }
604 : else
605 : {
606 0 : encoder->bandwidth = bandwidth;
607 0 : index = FS2FS_IDX(bandwidth);
608 0 : encoder->bw_ctrl_cutoff_bin = encoder->cutoffBins[index];
609 : }
610 0 : }
|
