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 "functions.h"
11 : #include "setup_enc_lc3.h"
12 :
13 : /* if encoder is null only size is reported */
14 0 : int alloc_encoder(LC3PLUS_Enc *encoder, int samplerate, int channels)
15 : {
16 0 : int ch = 0;
17 0 : size_t size = sizeof(LC3PLUS_Enc);
18 0 : void * mdct_mem32 = NULL, *stEnc_mdct_mem = NULL;
19 :
20 0 : for (ch = 0; ch < channels; ch++)
21 : {
22 0 : EncSetup *setup = balloc(encoder, &size, sizeof(EncSetup));
23 0 : mdct_mem32 = balloc(encoder, &size, sizeof(*setup->mdct_mem32) * DYN_MAX_MDCT_LEN(samplerate));
24 0 : stEnc_mdct_mem = balloc(encoder, &size, sizeof(*setup->stEnc_mdct_mem) * DYN_MAX_MDCT_LEN(samplerate));
25 0 : if (encoder)
26 : {
27 0 : encoder->channel_setup[ch] = setup;
28 0 : setup->mdct_mem32 = mdct_mem32;
29 0 : setup->stEnc_mdct_mem = stEnc_mdct_mem;
30 : }
31 : }
32 :
33 0 : return (int)size;
34 : }
35 :
36 0 : LC3PLUS_Error FillEncSetup(LC3PLUS_Enc *encoder, int samplerate, int channels
37 : #ifdef ENABLE_HR_MODE
38 : , int hrmode
39 : #endif
40 : , int32_t lfe_channel_array[]
41 : )
42 : {
43 0 : int ch = 0;
44 :
45 0 : memset(encoder, 0, lc3plus_enc_get_size(samplerate, channels));
46 0 : alloc_encoder(encoder, samplerate, channels);
47 :
48 0 : encoder->fs = CODEC_FS(samplerate);
49 0 : encoder->fs_in = samplerate;
50 0 : encoder->fs_idx = FS2FS_IDX(encoder->fs);
51 :
52 : #ifdef ENABLE_HR_MODE
53 0 : if (encoder->fs_idx > 4)
54 : {
55 0 : encoder->fs_idx = 5;
56 : }
57 0 : encoder->hrmode = hrmode != 0;
58 : #endif
59 :
60 0 : encoder->channels = channels;
61 0 : encoder->frame_dms = 100;
62 0 : encoder->envelope_bits = 38;
63 0 : encoder->global_gain_bits = 8;
64 0 : encoder->noise_fac_bits = 3;
65 0 : encoder->r12k8_mem_in_len = extract_l(L_shr_pos(Mpy_32_16_lc3plus(encoder->fs, 20972), 9));
66 0 : encoder->r12k8_mem_out_len = 24;
67 0 : encoder->epmr = LC3PLUS_EPMR_ZERO;
68 0 : encoder->bw_ctrl_active = 0;
69 0 : encoder->bandwidth = L_shr_pos(encoder->fs, 1);
70 0 : encoder->bandwidth_preset = L_shr_pos(encoder->fs, 1);
71 :
72 0 : if (lfe_channel_array != NULL)
73 : {
74 0 : for (ch = 0; ch < encoder->channels; ch++)
75 : {
76 0 : encoder->channel_setup[ch]->lfe = lfe_channel_array[ch] != 0;
77 : }
78 : }
79 :
80 0 : for (ch = 0; ch < encoder->channels; ch++)
81 : {
82 0 : encoder->channel_setup[ch]->x_exp = 15;
83 0 : encoder->channel_setup[ch]->resamp_exp = 17;
84 : }
85 :
86 0 : set_enc_frame_params(encoder);
87 :
88 0 : return lc3plus_enc_set_ep_mode(encoder, LC3PLUS_EP_OFF); /* also calls update_enc_bitrate */
89 : }
90 :
91 : /* set frame config params */
92 0 : void set_enc_frame_params(LC3PLUS_Enc *encoder)
93 : {
94 : Word16 tmp;
95 :
96 0 : encoder->frame_length = extract_l(L_shr_pos(Mpy_32_16_lc3plus(encoder->fs, 20972), 6)); /* fs * 0.01*2^6 */
97 :
98 : #ifdef ENABLE_HR_MODE
99 0 : if (encoder->hrmode)
100 : {
101 0 : encoder->BW_cutoff_bits = 0;
102 : }
103 : else
104 : #endif
105 : {
106 0 : encoder->BW_cutoff_bits = BW_cutoff_bits_all[encoder->fs_idx];
107 : }
108 :
109 0 : SWITCH (encoder->frame_dms)
110 : {
111 0 : case 25:
112 0 : encoder->frame_length = shr_pos(encoder->frame_length, 2);
113 0 : encoder->la_zeroes = LowDelayShapes_n960_la_zeroes_2_5ms[encoder->fs_idx];
114 0 : encoder->stEnc_mdct_mem_len = sub(encoder->frame_length, encoder->la_zeroes);
115 0 : encoder->nSubdivisions = 2;
116 0 : encoder->ltpf_mem_in_len = LTPF_MEMIN_LEN + (LEN_12K8 >> 2);
117 :
118 : #ifdef ENABLE_HR_MODE
119 0 : if (encoder->hrmode)
120 : {
121 0 : encoder->bands_number = bands_number_2_5ms_HR[encoder->fs_idx];
122 0 : encoder->bands_offset = bands_offset_2_5ms_HR[encoder->fs_idx - 4];
123 0 : encoder->W_fx = LowDelayShapes_n960_HRA_2_5ms[encoder->fs_idx - 4];
124 0 : encoder->W_size = LowDelayShapes_n960_len_2_5ms[encoder->fs_idx];
125 0 : encoder->yLen = encoder->frame_length;
126 : }
127 : else
128 : #endif
129 : {
130 0 : encoder->yLen = s_min(MAX_BW >> 2, encoder->frame_length);
131 0 : encoder->W_fx = LowDelayShapes_n960_2_5ms[encoder->fs_idx];
132 0 : encoder->W_size = LowDelayShapes_n960_len_2_5ms[encoder->fs_idx];
133 0 : encoder->bands_number = bands_number_2_5ms[encoder->fs_idx];
134 0 : encoder->bands_offset = bands_offset_2_5ms[encoder->fs_idx];
135 0 : encoder->near_nyquist_index = encoder->bands_number - 2;
136 0 : encoder->near_nyquist_flag = 0;
137 : }
138 :
139 0 : BREAK;
140 0 : case 50:
141 0 : encoder->frame_length = shr_pos(encoder->frame_length, 1);
142 0 : encoder->la_zeroes = LowDelayShapes_n960_la_zeroes_5ms[encoder->fs_idx];
143 0 : encoder->stEnc_mdct_mem_len = sub(encoder->frame_length, encoder->la_zeroes);
144 0 : encoder->nSubdivisions = 2;
145 0 : encoder->ltpf_mem_in_len = LTPF_MEMIN_LEN + (LEN_12K8 >> 1);
146 :
147 : #ifdef ENABLE_HR_MODE
148 0 : if (encoder->hrmode)
149 : {
150 0 : encoder->bands_offset = bands_offset_5ms_HR[encoder->fs_idx - 4];
151 0 : encoder->W_fx = LowDelayShapes_n960_HRA_5ms[encoder->fs_idx - 4];
152 0 : encoder->W_size = LowDelayShapes_n960_len_5ms[encoder->fs_idx];
153 0 : encoder->yLen = encoder->frame_length;
154 0 : encoder->bands_number = bands_number_5ms[encoder->fs_idx];
155 : }
156 : else
157 : #endif
158 : {
159 0 : encoder->yLen = s_min(MAX_BW >> 1, encoder->frame_length);
160 0 : encoder->W_fx = LowDelayShapes_n960_5ms[encoder->fs_idx];
161 0 : encoder->W_size = LowDelayShapes_n960_len_5ms[encoder->fs_idx];
162 0 : encoder->bands_number = bands_number_5ms[encoder->fs_idx];
163 0 : encoder->bands_offset = bands_offset_5ms[encoder->fs_idx];
164 0 : encoder->near_nyquist_index = encoder->bands_number - 3;
165 0 : encoder->near_nyquist_flag = 0;
166 : }
167 0 : encoder->ltpf_mem_in_len = LTPF_MEMIN_LEN;
168 0 : BREAK;
169 :
170 0 : case 75:
171 0 : tmp = shr_pos(encoder->frame_length, 2);
172 0 : encoder->frame_length = add(tmp, add(tmp, tmp));
173 0 : encoder->la_zeroes = LowDelayShapes_n960_la_zeroes_7_5ms[encoder->fs_idx];
174 0 : encoder->stEnc_mdct_mem_len = sub(encoder->frame_length, encoder->la_zeroes);
175 0 : encoder->bands_number = bands_number_7_5ms[encoder->fs_idx];
176 0 : encoder->nSubdivisions = 3;
177 0 : encoder->ltpf_mem_in_len = LTPF_MEMIN_LEN;
178 0 : encoder->attdec_nblocks = 3;
179 0 : encoder->attdec_damping = 9830;
180 0 : encoder->attdec_hangover_thresh = 1;
181 0 : encoder->r12k8_mem_out_len = 44;
182 0 : encoder->near_nyquist_index = encoder->bands_number - 4;
183 0 : encoder->near_nyquist_flag = 0;
184 : #ifdef ENABLE_HR_MODE
185 0 : if (encoder->hrmode)
186 : {
187 0 : encoder->yLen = encoder->frame_length;
188 0 : encoder->W_fx = LowDelayShapes_n960_HRA_7_5ms[encoder->fs_idx - 4];
189 0 : encoder->W_size = LowDelayShapes_n960_len_7_5ms[encoder->fs_idx];
190 0 : encoder->bands_number = bands_number_7_5ms[encoder->fs_idx];
191 0 : encoder->bands_offset = bands_offset_7_5ms_HR[encoder->fs_idx - 4];
192 : }
193 : else
194 : #endif
195 : {
196 0 : encoder->yLen = s_min((MAX_BW >> 2) * 3, encoder->frame_length);
197 0 : encoder->W_fx = LowDelayShapes_n960_7_5ms[encoder->fs_idx];
198 0 : encoder->W_size = LowDelayShapes_n960_len_7_5ms[encoder->fs_idx];
199 0 : encoder->bands_number = bands_number_7_5ms[encoder->fs_idx];
200 0 : encoder->bands_offset = bands_offset_7_5ms[encoder->fs_idx];
201 : }
202 0 : BREAK;
203 :
204 0 : case 100:
205 0 : encoder->la_zeroes = LowDelayShapes_n960_la_zeroes[encoder->fs_idx];
206 0 : encoder->stEnc_mdct_mem_len = sub(encoder->frame_length, encoder->la_zeroes);
207 0 : encoder->bands_number = 64;
208 0 : encoder->nSubdivisions = 3;
209 0 : encoder->ltpf_mem_in_len = LTPF_MEMIN_LEN;
210 0 : encoder->attdec_nblocks = 4;
211 0 : encoder->attdec_damping = 16384;
212 0 : encoder->attdec_hangover_thresh = 2;
213 0 : encoder->near_nyquist_index = encoder->bands_number - 2;
214 0 : encoder->near_nyquist_flag = 0;
215 :
216 : #ifdef ENABLE_HR_MODE
217 0 : if (encoder->hrmode)
218 : {
219 0 : encoder->bands_offset = bands_offset_HR[encoder->fs_idx - 4];
220 0 : encoder->W_fx = LowDelayShapes_n960_HRA[encoder->fs_idx - 4];
221 0 : encoder->W_size = LowDelayShapes_n960_len[encoder->fs_idx];
222 0 : encoder->yLen = encoder->frame_length;
223 : }
224 : else
225 : #endif
226 : {
227 0 : encoder->yLen = s_min(MAX_BW, encoder->frame_length);
228 0 : encoder->W_fx = LowDelayShapes_n960[encoder->fs_idx];
229 0 : encoder->W_size = LowDelayShapes_n960_len[encoder->fs_idx];
230 0 : encoder->bands_offset = bands_offset[encoder->fs_idx];
231 : }
232 0 : BREAK;
233 : }
234 0 : }
235 :
236 : /* change encoder bitrate */
237 0 : LC3PLUS_Error update_enc_bitrate(LC3PLUS_Enc *encoder, int bitrate)
238 : {
239 0 : int ch = 0;
240 0 : int totalBytes = 0, maxBR = 0, minBR = 0, max_bytes = 0;
241 0 : int channel_bytes = 0;
242 :
243 : #ifdef ENABLE_HR_MODE
244 0 : if (encoder->hrmode)
245 : {
246 0 : switch (encoder->frame_dms)
247 : {
248 0 : case 25:
249 0 : maxBR = 672000;
250 0 : if (encoder->fs == 48000)
251 : {
252 0 : minBR = MIN_BR_25MS_48KHZ_HR;
253 : }
254 0 : else if (encoder->fs == 96000)
255 : {
256 0 : minBR = MIN_BR_25MS_96KHZ_HR;
257 : }
258 : else
259 : {
260 0 : return LC3PLUS_HRMODE_ERROR;
261 : }
262 0 : break;
263 0 : case 50:
264 0 : maxBR = 600000;
265 0 : if (encoder->fs == 48000)
266 : {
267 0 : minBR = MIN_BR_50MS_48KHZ_HR;
268 : }
269 0 : else if (encoder->fs == 96000)
270 : {
271 0 : minBR = MIN_BR_50MS_96KHZ_HR;
272 : }
273 : else
274 : {
275 0 : return LC3PLUS_HRMODE_ERROR;
276 : }
277 0 : break;
278 0 : case 75:
279 0 : maxBR = 500000;
280 0 : if (encoder->fs == 48000) {minBR = MIN_BR_075DMS_48KHZ_HR;}
281 0 : else if (encoder->fs == 96000) {minBR = MIN_BR_075DMS_96KHZ_HR;}
282 0 : else {return LC3PLUS_HRMODE_ERROR;}
283 0 : BREAK;
284 0 : case 100:
285 0 : maxBR = 500000;
286 0 : if (encoder->fs == 48000)
287 : {
288 0 : minBR = MIN_BR_100MS_48KHZ_HR;
289 : }
290 0 : else if (encoder->fs == 96000)
291 : {
292 0 : minBR = MIN_BR_100MS_96KHZ_HR;
293 : }
294 : else
295 : {
296 0 : return LC3PLUS_HRMODE_ERROR;
297 : }
298 0 : break;
299 0 : default: return LC3PLUS_HRMODE_ERROR;
300 : }
301 : }
302 : else
303 : {
304 0 : minBR = (MIN_NBYTES << 3);
305 0 : maxBR = MAX_BR;
306 :
307 0 : switch (encoder->frame_dms)
308 : {
309 0 : case 25:
310 0 : minBR = MIN_BR_025DMS;
311 0 : maxBR = MAX_BR;
312 0 : BREAK;
313 0 : case 50:
314 0 : minBR = MIN_BR_050DMS;
315 0 : maxBR = MAX_BR;
316 : /* have additional limitations for 5.0ms */
317 0 : SWITCH (encoder->fs_in)
318 : {
319 : #ifdef SUBSET_NB
320 0 : case 8000: maxBR = MAX_BR_050DMS_NB; BREAK;
321 : #endif
322 0 : default: BREAK;
323 : }
324 0 : BREAK;
325 0 : case 75:
326 0 : minBR = MIN_BR_075DMS;
327 0 : maxBR = MAX_BR_075DMS; // special value for maxBR @ 7.5ms
328 : /* have additional limitations for 7.5ms */
329 0 : SWITCH (encoder->fs_in)
330 : {
331 : #ifdef SUBSET_NB
332 0 : case 8000: maxBR = MAX_BR_075DMS_NB ; BREAK;
333 : #endif
334 : #ifdef SUBSET_WB
335 0 : case 16000: maxBR = MAX_BR_075DMS_WB ; BREAK;
336 : #endif
337 : #ifdef SUBSET_SSWB
338 0 : case 24000: maxBR = MAX_BR_075DMS_SSWB; BREAK;
339 : #endif
340 0 : default: BREAK;
341 : }
342 0 : BREAK;
343 0 : case 100:
344 : /* have additional limitations for 10ms */
345 0 : minBR = MIN_BR_100DMS;
346 0 : maxBR = MAX_BR;
347 0 : SWITCH (encoder->fs_in)
348 : {
349 : #ifdef SUBSET_NB
350 0 : case 8000: maxBR = MAX_BR_100DMS_NB ; BREAK;
351 : #endif
352 : #ifdef SUBSET_WB
353 0 : case 16000: maxBR = MAX_BR_100DMS_WB ; BREAK;
354 : #endif
355 : #ifdef SUBSET_SSWB
356 0 : case 24000: maxBR = MAX_BR_100DMS_SSWB; BREAK;
357 : #endif
358 0 : default: maxBR = MAX_BR; BREAK;
359 : }
360 0 : BREAK;
361 0 : default: return LC3PLUS_FRAMEMS_ERROR;
362 : }
363 :
364 : /* 441/480 in Q31 and 1000/75 in Q23 */
365 0 : if (encoder->fs_in == 44100)
366 : {
367 0 : minBR = Mpy_32_32_lc3plus(minBR, 1973000602);
368 0 : maxBR = Mpy_32_32_lc3plus(maxBR, 1973000602);
369 : }
370 : }
371 : #else /* ENABLE_HR_MODE */
372 : minBR = (MIN_NBYTES << 3);
373 : maxBR = MAX_BR;
374 :
375 : switch (encoder->frame_dms)
376 : {
377 : case 25:
378 : minBR = MIN_BR_025DMS;
379 : maxBR = MAX_BR;
380 : BREAK;
381 : case 50:
382 : minBR = MIN_BR_050DMS;
383 : maxBR = MAX_BR;
384 : /* have additional limitations for 5.0ms */
385 : SWITCH (encoder->fs_in)
386 : {
387 : #ifdef SUBSET_NB
388 : case 8000: maxBR = MAX_BR_050DMS_NB; BREAK;
389 : #endif
390 : default: BREAK;
391 : }
392 : BREAK;
393 : case 75:
394 : minBR = MIN_BR_075DMS;
395 : maxBR = MAX_BR_075DMS; // special value for maxBR @ 7.5ms
396 : /* have additional limitations for 7.5ms */
397 : SWITCH (encoder->fs_in)
398 : {
399 : #ifdef SUBSET_NB
400 : case 8000: maxBR = MAX_BR_075DMS_NB ; BREAK;
401 : #endif
402 : #ifdef SUBSET_WB
403 : case 16000: maxBR = MAX_BR_075DMS_WB ; BREAK;
404 : #endif
405 : #ifdef SUBSET_SSWB
406 : case 24000: maxBR = MAX_BR_075DMS_SSWB; BREAK;
407 : #endif
408 : default: BREAK;
409 : }
410 : BREAK;
411 : case 100:
412 : /* have additional limitations for 10ms */
413 : minBR = MIN_BR_100DMS;
414 : maxBR = MAX_BR;
415 : SWITCH (encoder->fs_in)
416 : {
417 : #ifdef SUBSET_NB
418 : case 8000: maxBR = MAX_BR_100DMS_NB ; BREAK;
419 : #endif
420 : #ifdef SUBSET_WB
421 : case 16000: maxBR = MAX_BR_100DMS_WB ; BREAK;
422 : #endif
423 : #ifdef SUBSET_SSWB
424 : case 24000: maxBR = MAX_BR_100DMS_SSWB; BREAK;
425 : #endif
426 : default: maxBR = MAX_BR; BREAK;
427 : }
428 : BREAK;
429 : default: return LC3PLUS_FRAMEMS_ERROR;
430 : }
431 :
432 : /* 441/480 in Q31 and 1000/75 in Q23 */
433 : if (encoder->fs_in == 44100)
434 : {
435 : minBR = Mpy_32_32_lc3plus(minBR, 1973000602);
436 : maxBR = Mpy_32_32_lc3plus(maxBR, 1973000602);
437 : }
438 : #endif /* ENABLE_HR_MODE */
439 :
440 0 : minBR *= encoder->channels;
441 0 : maxBR *= encoder->channels;
442 :
443 0 : if (bitrate < minBR || bitrate > maxBR)
444 : {
445 0 : return LC3PLUS_BITRATE_ERROR;
446 : }
447 :
448 0 : encoder->bitrate = bitrate;
449 0 : encoder->lc3_br_set = 1;
450 :
451 : /* move stuff to encoder->channel_setup */
452 :
453 0 : encoder->combined_channel_coding = 0;
454 0 : if (encoder->channels > 1 && encoder->epmode)
455 : {
456 0 : if (encoder->bitrate * encoder->frame_length / (8 * encoder->fs_in) <= 160)
457 : {
458 0 : encoder->combined_channel_coding = 1;
459 : }
460 : }
461 :
462 0 : if (encoder->epmode > 0)
463 : {
464 0 : max_bytes = bitrate * encoder->frame_length / (8 * encoder->fs_in * encoder->channels);
465 :
466 0 : if (max_bytes < FEC_SLOT_BYTES_MIN || max_bytes > FEC_SLOT_BYTES_MAX)
467 : {
468 0 : return LC3PLUS_BITRATE_ERROR;
469 : }
470 : }
471 :
472 0 : if (encoder->combined_channel_coding)
473 : {
474 0 : totalBytes = fec_get_data_size(encoder->epmode, encoder->combined_channel_coding,
475 0 : bitrate * (Word32)encoder->frame_length / (8 * encoder->fs_in));
476 :
477 0 : encoder->channel_setup[0]->n_pccw =
478 0 : fec_get_n_pccw(bitrate * (Word32)encoder->frame_length / (8 * encoder->fs_in), encoder->epmode,
479 0 : encoder->combined_channel_coding);
480 :
481 0 : encoder->channel_setup[0]->n_pc = fec_get_n_pc(encoder->epmode, encoder->channel_setup[0]->n_pccw,
482 0 : bitrate * (Word32)encoder->frame_length / (8 * encoder->fs_in));
483 : }
484 : else
485 : {
486 0 : totalBytes = bitrate * (Word32)encoder->frame_length / (8 * encoder->fs_in);
487 : }
488 :
489 0 : for (ch = 0; ch < encoder->channels; ch++)
490 : {
491 0 : EncSetup *setup = encoder->channel_setup[ch];
492 0 : channel_bytes = totalBytes / encoder->channels + (ch < (totalBytes % encoder->channels));
493 :
494 0 : if (encoder->combined_channel_coding)
495 : {
496 0 : setup->targetBytes = channel_bytes;
497 : }
498 : else
499 : {
500 0 : setup->targetBytes = fec_get_data_size(encoder->epmode, encoder->combined_channel_coding, channel_bytes);
501 0 : setup->n_pccw = fec_get_n_pccw(channel_bytes, encoder->epmode, encoder->combined_channel_coding);
502 0 : setup->n_pc = fec_get_n_pc(encoder->epmode, setup->n_pccw, channel_bytes);
503 : }
504 : /* reduce bandwith to 12kHz if bitrate is low */
505 0 : if (sub(encoder->frame_dms, 100) == 0 &&
506 0 : ((sub(setup->targetBytes, 40) < 0 && L_sub(encoder->fs, 48000) == 0) ||
507 0 : (sub(setup->targetBytes, 36) < 0 && L_sub(encoder->fs, 32000) == 0)))
508 : {
509 0 : encoder->bandwidth = L_min(12000, encoder->bandwidth_preset);
510 : }
511 : else
512 : {
513 : /* channel with highest index has lowest bitrate.
514 : For a second channel with lower targetBytes, bandwidth is overwritten */
515 0 : encoder->bandwidth = encoder->bandwidth_preset;
516 : }
517 :
518 : {
519 : Word16 tmp;
520 :
521 0 : SWITCH(encoder->frame_dms)
522 : {
523 0 : case 25: tmp = 1; BREAK;
524 0 : case 50: tmp = 2; BREAK;
525 0 : case 75: tmp = 3; BREAK;
526 0 : default : tmp = 4; BREAK;
527 : }
528 :
529 0 : encoder->bw_ctrl_cutoff_bin = L_mult0(Mpy_32_32_lc3plus(encoder->bandwidth, 10737419), tmp); /* bandwidth * frame_dms / 5000 */
530 : }
531 :
532 0 : encoder->bw_index = sub( Mpy_32_32_lc3plus(encoder->bandwidth, 536871), 1); /* (bandwidth / 4000 ) - 1 */
533 0 : switch (encoder->frame_dms)
534 : {
535 0 : case 25: max_bytes = MAX_NBYTES_025; break;
536 0 : case 50: max_bytes = MAX_NBYTES_050; break;
537 0 : case 75: max_bytes = MAX_NBYTES_075; BREAK;
538 0 : case 100: max_bytes = MAX_NBYTES_100; break;
539 : }
540 : #ifdef ENABLE_HR_MODE
541 0 : if (encoder->hrmode)
542 : {
543 0 : max_bytes = MAX_NBYTES_RED_HR;
544 : }
545 : #endif
546 0 : if (setup->targetBytes < MIN_NBYTES || setup->targetBytes > max_bytes)
547 : {
548 0 : return LC3PLUS_BITRATE_ERROR;
549 : }
550 :
551 0 : setup->total_bits = shl(setup->targetBytes, 3);
552 0 : setup->targetBitsInit =
553 0 : sub(setup->total_bits,
554 0 : add(encoder->envelope_bits,
555 0 : add(encoder->global_gain_bits, add(encoder->noise_fac_bits, encoder->BW_cutoff_bits))));
556 0 : setup->targetBitsInit = sub(setup->targetBitsInit, sub(17, norm_s(sub(encoder->yLen, 1))));
557 0 : if (setup->total_bits > 1280)
558 : {
559 0 : setup->targetBitsInit = sub(setup->targetBitsInit, 1);
560 : }
561 0 : if (setup->total_bits > 2560)
562 : {
563 0 : setup->targetBitsInit = sub(setup->targetBitsInit, 1);
564 : }
565 :
566 : #ifdef ENABLE_HR_MODE
567 0 : if (encoder->hrmode)
568 : {
569 0 : setup->targetBitsInit -= 1;
570 : }
571 : #endif
572 :
573 0 : setup->targetBitsAri = setup->total_bits;
574 :
575 0 : SWITCH (encoder->frame_dms)
576 : {
577 0 : case 25:
578 : /* 9830 = 2.4 * 2^12 */
579 0 : setup->ltpf_enable =
580 0 : sub(extract_l(L_shr(L_mult0(9830, setup->total_bits), 12)), add(560, DEPR_i_mult(80, encoder->fs_idx))) < 0;
581 0 : setup->enable_lpc_weighting = 0;
582 0 : BREAK;
583 0 : case 50:
584 0 : setup->ltpf_enable = sub(sub(DEPR_i_mult(setup->total_bits, 2), 160), add(560, DEPR_i_mult(80, encoder->fs_idx))) < 0;
585 0 : setup->enable_lpc_weighting = setup->total_bits < 240;
586 0 : BREAK;
587 0 : case 75:
588 0 : setup->ltpf_enable = sub(L_shr(L_mult0(10923, setup->total_bits), 13), add(560, DEPR_i_mult(80, encoder->fs_idx))) < 0;
589 0 : setup->enable_lpc_weighting = setup->total_bits < 360;
590 0 : BREAK;
591 0 : case 100:
592 0 : setup->enable_lpc_weighting = setup->total_bits < 480;
593 0 : setup->ltpf_enable = sub(setup->total_bits, add(560, DEPR_i_mult(80, encoder->fs_idx))) < 0;
594 0 : BREAK;
595 : }
596 :
597 0 : setup->quantizedGainOff =
598 0 : -(s_min(115, setup->total_bits / (10 * (encoder->fs_idx + 1))) + 105 + 5 * (encoder->fs_idx + 1));
599 :
600 : #ifdef ENABLE_HR_MODE
601 0 : if (encoder->hrmode && encoder->fs_idx == 5)
602 : {
603 0 : setup->quantizedGainOff = MAX(setup->quantizedGainOff, -181);
604 : }
605 : #endif
606 :
607 : #ifdef ENABLE_HR_MODE
608 0 : if (encoder->frame_dms == 100 &&
609 0 : ((encoder->fs_in >= 44100 && setup->targetBytes >= 100) ||
610 0 : (encoder->fs_in == 32000 && setup->targetBytes >= 81))
611 0 : && setup->targetBytes < 340
612 0 : && (encoder->hrmode == 0))
613 : #else
614 : if (encoder->frame_dms == 100 &&
615 : ((encoder->fs_in >= 44100 && setup->targetBytes >= 100) ||
616 : (encoder->fs_in == 32000 && setup->targetBytes >= 81))
617 : && setup->targetBytes < 340
618 : )
619 : #endif
620 : {
621 0 : setup->attack_handling = 1;
622 : }
623 0 : else if (encoder->frame_dms == 75 && ((encoder->fs_in >= 44100 && setup->targetBytes >= 75) ||
624 0 : (encoder->fs_in == 32000 && setup->targetBytes >= 61)) && setup->targetBytes < 150
625 : #ifdef ENABLE_HR_MODE
626 0 : && encoder->hrmode == 0
627 : #endif
628 : )
629 : {
630 0 : setup->attack_handling = 1;
631 : }
632 : else
633 : {
634 : /* reset attack detector for bitrate switching */
635 0 : setup->attack_handling = 0;
636 0 : setup->attdec_filter_mem[0] = 0;
637 0 : setup->attdec_filter_mem[1] = 0;
638 0 : setup->attdec_detected = 0;
639 0 : setup->attdec_position = 0;
640 0 : setup->attdec_acc_energy = 0;
641 0 : setup->attdec_scaling = 0;
642 : }
643 :
644 : #ifdef ENABLE_HR_MODE
645 0 : if (encoder->hrmode)
646 : {
647 0 : setup->ltpf_enable = 0;
648 : }
649 : #endif
650 0 : encoder->sns_damping = SNS_DAMPING;
651 :
652 : #ifdef ENABLE_HR_MODE
653 0 : IF (encoder->hrmode)
654 : {
655 0 : encoder->sns_damping = SNS_DAMPING_HRMODE;
656 0 : IF (encoder->fs_idx >= 4)
657 : {
658 0 : IF ((encoder->frame_dms == 100) & (setup->total_bits > 4400))
659 : {
660 0 : encoder->sns_damping = SNS_DAMPING_HRMODE_UB_10MS;
661 : }
662 0 : IF ((encoder->frame_dms == 75) & (setup->total_bits > 3300))
663 : {
664 0 : encoder->sns_damping = SNS_DAMPING_HRMODE_UB_7_5MS;
665 : }
666 0 : IF ((encoder->frame_dms == 50) & (setup->total_bits > 2300))
667 : {
668 0 : encoder->sns_damping = SNS_DAMPING_HRMODE_UB_5MS;
669 : }
670 0 : IF ((encoder->frame_dms == 25) & (setup->total_bits > 1150))
671 : {
672 0 : encoder->sns_damping = SNS_DAMPING_HRMODE_UB_2_5MS;
673 : }
674 : }
675 : }
676 :
677 0 : if (encoder->hrmode && encoder->fs_idx >= 4)
678 0 : {
679 0 : int real_rate = setup->targetBytes * 8 * 10000 / encoder->frame_dms;
680 0 : setup->regBits = real_rate / 12500;
681 :
682 0 : if (encoder->fs_idx == 5)
683 : {
684 0 : if (encoder->frame_dms == 100)
685 : {
686 0 : setup->regBits += 2;
687 : }
688 0 : if (encoder->frame_dms == 75)
689 : {
690 0 : setup->regBits +=1;
691 : }
692 0 : if (encoder->frame_dms == 25)
693 : {
694 0 : setup->regBits -= 6;
695 : }
696 : }
697 : else
698 : {
699 0 : if (encoder->frame_dms == 25)
700 : {
701 0 : setup->regBits -= 6;
702 : }
703 0 : else if (encoder->frame_dms == 50)
704 : {
705 0 : setup->regBits += 0;
706 : }
707 0 : if (encoder->frame_dms == 75)
708 : {
709 0 : setup->regBits +=2;
710 : }
711 0 : if (encoder->frame_dms == 100)
712 : {
713 0 : setup->regBits += 5;
714 : }
715 : }
716 :
717 :
718 0 : if (setup->regBits < 6)
719 : {
720 0 : setup->regBits = 6;
721 : }
722 0 : if (setup->regBits > 23)
723 : {
724 0 : setup->regBits = 23;
725 : }
726 : }
727 : else
728 : {
729 0 : setup->regBits = -1;
730 : }
731 : #endif
732 : }
733 :
734 0 : encoder->bitrate = bitrate;
735 :
736 0 : return LC3PLUS_OK;
737 : }
738 :
|
