Line data Source code
1 : /******************************************************************************************************
2 :
3 : (C) 2022-2025 IVAS codec Public Collaboration with portions copyright Dolby International AB, Ericsson AB,
4 : Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
5 : Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
6 : Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
7 : contributors to this repository. All Rights Reserved.
8 :
9 : This software is protected by copyright law and by international treaties.
10 : The IVAS codec Public Collaboration consisting of Dolby International AB, Ericsson AB,
11 : Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
12 : Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
13 : Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
14 : contributors to this repository retain full ownership rights in their respective contributions in
15 : the software. This notice grants no license of any kind, including but not limited to patent
16 : license, nor is any license granted by implication, estoppel or otherwise.
17 :
18 : Contributors are required to enter into the IVAS codec Public Collaboration agreement before making
19 : contributions.
20 :
21 : This software is provided "AS IS", without any express or implied warranties. The software is in the
22 : development stage. It is intended exclusively for experts who have experience with such software and
23 : solely for the purpose of inspection. All implied warranties of non-infringement, merchantability
24 : and fitness for a particular purpose are hereby disclaimed and excluded.
25 :
26 : Any dispute, controversy or claim arising under or in relation to providing this software shall be
27 : submitted to and settled by the final, binding jurisdiction of the courts of Munich, Germany in
28 : accordance with the laws of the Federal Republic of Germany excluding its conflict of law rules and
29 : the United Nations Convention on Contracts on the International Sales of Goods.
30 :
31 : *******************************************************************************************************/
32 :
33 : #include "options.h"
34 : #include <stdlib.h>
35 : #include "ivas_cnst.h"
36 : #include "ivas_prot.h"
37 : #include "prot.h"
38 : #include "ivas_rom_com.h"
39 : #include <math.h>
40 : #ifdef DEBUGGING
41 : #include "debug.h"
42 : #endif
43 :
44 : /*---------------------------------------------------------------
45 : * Local constants
46 : *---------------------------------------------------------------*/
47 :
48 : #define GAMMA_ISM_LOW_IMP 0.8f
49 : #define GAMMA_ISM_MEDIUM_IMP 1.2f
50 : #define GAMMA_ISM_HIGH_IMP 1.4f
51 :
52 : #define GAMMA_ISM_LOW_IMP2 0.9f
53 : #define GAMMA_ISM_MEDIUM_IMP2 1.2f
54 : #define GAMMA_ISM_HIGH_IMP2 1.35f
55 :
56 : #define GAMMA_ISM_LOW_IMP3 0.85f
57 : #define GAMMA_ISM_MEDIUM_IMP3 1.15f
58 : #define GAMMA_ISM_HIGH_IMP3 1.3f
59 :
60 : #define GAMMA_ISM_LOW_IMP4 0.8f
61 : #define GAMMA_ISM_MEDIUM_IMP4 1.0f
62 : #define GAMMA_ISM_HIGH_IMP4 1.2f
63 :
64 : #define PAN_MAX_DEG 30.0f
65 : #define ONE_OVER_PAN_STEP_DEG 10.0f
66 : #define SIN_LS_ANGLE 0.5f /* sinf( 30.0f * PI_OVER_180 ) */
67 :
68 :
69 : /*---------------------------------------------------------------
70 : * ivas_omasa_ism_mode_select()
71 : *
72 : * selects the ISM mode base on IVAS total bit-rate and
73 : * the number of objects in the combined ISM MASA format mode
74 : * ---------------------------------------------------------------*/
75 :
76 : /*! r : ISM format mode */
77 168814 : ISM_MODE ivas_omasa_ism_mode_select(
78 : const int32_t ivas_total_brate, /* i : IVAS total bitrate */
79 : const int16_t nchan_ism /* i : number of input ISM's */
80 : )
81 : {
82 168814 : ISM_MODE ism_mode = ISM_MODE_NONE;
83 :
84 168814 : switch ( nchan_ism )
85 : {
86 37528 : case 1:
87 37528 : if ( ivas_total_brate >= IVAS_24k4 )
88 : {
89 35581 : ism_mode = ISM_MASA_MODE_DISC;
90 : }
91 : else
92 : {
93 1947 : ism_mode = ISM_MODE_NONE;
94 : }
95 37528 : break;
96 15480 : case 2:
97 15480 : if ( ivas_total_brate >= IVAS_48k )
98 : {
99 8522 : ism_mode = ISM_MASA_MODE_DISC;
100 : }
101 6958 : else if ( ivas_total_brate >= IVAS_32k )
102 : {
103 5506 : ism_mode = ISM_MASA_MODE_PARAM_ONE_OBJ;
104 : }
105 : else
106 : {
107 1452 : ism_mode = ISM_MODE_NONE;
108 : }
109 15480 : break;
110 31624 : case 3:
111 31624 : if ( ivas_total_brate >= IVAS_96k )
112 : {
113 8813 : ism_mode = ISM_MASA_MODE_DISC;
114 : }
115 22811 : else if ( ivas_total_brate >= IVAS_64k )
116 : {
117 5742 : ism_mode = ISM_MASA_MODE_PARAM_ONE_OBJ;
118 : }
119 17069 : else if ( ivas_total_brate >= IVAS_32k )
120 : {
121 13897 : ism_mode = ISM_MASA_MODE_MASA_ONE_OBJ;
122 : }
123 : else
124 : {
125 3172 : ism_mode = ISM_MODE_NONE;
126 : }
127 31624 : break;
128 84182 : case 4:
129 84182 : if ( ivas_total_brate >= IVAS_128k )
130 : {
131 28374 : ism_mode = ISM_MASA_MODE_DISC;
132 : }
133 55808 : else if ( ivas_total_brate >= IVAS_64k )
134 : {
135 24095 : ism_mode = ISM_MASA_MODE_PARAM_ONE_OBJ;
136 : }
137 31713 : else if ( ivas_total_brate >= IVAS_32k )
138 : {
139 26998 : ism_mode = ISM_MASA_MODE_MASA_ONE_OBJ;
140 : }
141 : else
142 : {
143 4715 : ism_mode = ISM_MODE_NONE;
144 : }
145 84182 : break;
146 : }
147 :
148 168814 : return ism_mode;
149 : }
150 :
151 :
152 : /*---------------------------------------------------------------
153 : * ivas_set_omasa_TC()
154 : *
155 : * set number of transport channels in OMASA format
156 : * ---------------------------------------------------------------*/
157 :
158 12734 : void ivas_set_omasa_TC(
159 : const ISM_MODE ism_mode, /* i : ISM mode */
160 : const int16_t nchan_ism, /* i : number of input ISMs */
161 : int16_t *nSCE, /* o : number of SCEs */
162 : int16_t *nCPE /* o : number of CPEs */
163 : )
164 : {
165 12734 : switch ( ism_mode )
166 : {
167 5570 : case ISM_MASA_MODE_MASA_ONE_OBJ:
168 : case ISM_MASA_MODE_PARAM_ONE_OBJ:
169 5570 : *nCPE = 1;
170 5570 : *nSCE = 1;
171 5570 : break;
172 3594 : case ISM_MASA_MODE_DISC:
173 3594 : *nCPE = 1;
174 3594 : *nSCE = nchan_ism;
175 3594 : break;
176 3570 : case ISM_MODE_NONE:
177 3570 : *nCPE = 1;
178 3570 : *nSCE = 0;
179 3570 : break;
180 0 : default:
181 0 : break;
182 : }
183 :
184 12734 : return;
185 : }
186 :
187 :
188 : /*---------------------------------------------------------------
189 : * ivas_interformat_brate()
190 : *
191 : * Bit-budget distribution in case of combined-format coding
192 : * ---------------------------------------------------------------*/
193 :
194 : /*! r: adjusted bitrate */
195 156979 : int32_t ivas_interformat_brate(
196 : const ISM_MODE ism_mode, /* i : ISM mode */
197 : const int16_t nchan_ism, /* i : number of ISM channels */
198 : const int32_t element_brate, /* i : element bitrate */
199 : const int16_t ism_imp, /* i : ISM importance flag */
200 : const int16_t limit_flag /* i : flag to limit the bitrate increase */
201 : )
202 : {
203 : int32_t element_brate_out;
204 : int16_t nBits, limit_low, limit_high;
205 :
206 156979 : nBits = (int16_t) ( element_brate / FRAMES_PER_SEC );
207 :
208 156979 : if ( ism_imp == ISM_INACTIVE_IMP )
209 : {
210 687 : nBits = BITS_ISM_INACTIVE;
211 : }
212 : else
213 : {
214 156292 : if ( ism_mode == ISM_MASA_MODE_DISC && ( ( nchan_ism == 4 && element_brate == 24000 ) || ( nchan_ism == 3 && element_brate <= 24000 ) || ( nchan_ism == 2 && element_brate <= 11000 ) ) ) /* for border case in DISC mode */
215 : {
216 11712 : if ( limit_flag == 1 && ( ( nchan_ism == 4 && element_brate == 24000 ) || ( nchan_ism == 3 && element_brate == 20000 ) || ( nchan_ism == 2 && element_brate <= 11000 ) ) )
217 : {
218 6406 : return element_brate;
219 : }
220 :
221 5306 : if ( ism_imp == ISM_LOW_IMP )
222 : {
223 2176 : nBits = (int16_t) ( nBits * GAMMA_ISM_LOW_IMP4 );
224 : }
225 3130 : else if ( ism_imp == ISM_MEDIUM_IMP )
226 : {
227 1289 : nBits = (int16_t) ( nBits * GAMMA_ISM_MEDIUM_IMP4 );
228 1289 : if ( limit_flag == -1 )
229 : {
230 0 : nBits = (int16_t) ( nBits * GAMMA_ISM_HIGH_IMP4 );
231 : }
232 : }
233 : else /* ISM_HIGH_IMP */
234 : {
235 1841 : nBits = (int16_t) ( nBits * GAMMA_ISM_HIGH_IMP4 );
236 1841 : if ( limit_flag == -1 )
237 : {
238 0 : nBits = (int16_t) ( nBits * GAMMA_ISM_HIGH_IMP4 );
239 : }
240 : }
241 : }
242 144580 : else if ( ism_mode == ISM_MASA_MODE_PARAM_ONE_OBJ ||
243 97109 : ( ism_mode == ISM_MASA_MODE_DISC && element_brate == 9600 ) /* this condition corresponds to the ivas_total_brate = 24400 and 1 object */
244 : )
245 : {
246 24921 : if ( ism_mode == ISM_MASA_MODE_PARAM_ONE_OBJ && element_brate == IVAS_13k2 )
247 : {
248 4996 : if ( ism_imp == ISM_LOW_IMP )
249 : {
250 678 : nBits = (int16_t) ( nBits * GAMMA_ISM_LOW_IMP3 );
251 : }
252 4318 : else if ( ism_imp == ISM_MEDIUM_IMP )
253 : {
254 1238 : nBits = (int16_t) ( nBits * GAMMA_ISM_MEDIUM_IMP3 );
255 : }
256 : else /* ISM_HIGH_IMP */
257 : {
258 3080 : nBits = (int16_t) ( nBits * GAMMA_ISM_HIGH_IMP4 );
259 : }
260 : }
261 : else
262 : {
263 19925 : if ( ism_imp == ISM_LOW_IMP )
264 : {
265 1354 : nBits = (int16_t) ( nBits * GAMMA_ISM_LOW_IMP3 );
266 : }
267 18571 : else if ( ism_imp == ISM_MEDIUM_IMP )
268 : {
269 6719 : nBits = (int16_t) ( nBits * GAMMA_ISM_MEDIUM_IMP3 );
270 : }
271 : else /* ISM_HIGH_IMP */
272 : {
273 11852 : nBits = (int16_t) ( nBits * GAMMA_ISM_HIGH_IMP3 );
274 : }
275 : }
276 : }
277 119659 : else if ( ism_mode == ISM_MASA_MODE_MASA_ONE_OBJ && element_brate == 16000 )
278 : {
279 8987 : if ( ism_imp == ISM_LOW_IMP )
280 : {
281 1020 : nBits = (int16_t) ( nBits * GAMMA_ISM_LOW_IMP );
282 : }
283 7967 : else if ( ism_imp == ISM_MEDIUM_IMP )
284 : {
285 3296 : nBits = (int16_t) ( nBits * GAMMA_ISM_MEDIUM_IMP );
286 : }
287 : else /* ISM_HIGH_IMP */
288 : {
289 4671 : nBits = (int16_t) ( nBits * GAMMA_ISM_HIGH_IMP3 );
290 : }
291 : }
292 : else
293 : {
294 110672 : if ( ism_imp == ISM_LOW_IMP )
295 : {
296 17346 : nBits = (int16_t) ( nBits * GAMMA_ISM_LOW_IMP );
297 : }
298 93326 : else if ( ism_imp == ISM_MEDIUM_IMP )
299 : {
300 28698 : nBits = (int16_t) ( nBits * GAMMA_ISM_MEDIUM_IMP );
301 : }
302 : else /* ISM_HIGH_IMP */
303 : {
304 64628 : nBits = (int16_t) ( nBits * GAMMA_ISM_HIGH_IMP );
305 : }
306 : }
307 : }
308 :
309 150573 : limit_low = MIN_BRATE_SWB_BWE / FRAMES_PER_SEC;
310 150573 : if ( ism_imp == ISM_INACTIVE_IMP )
311 : {
312 687 : limit_low = BITS_ISM_INACTIVE;
313 : }
314 149886 : else if ( element_brate >= SCE_CORE_16k_LOW_LIMIT )
315 : {
316 109808 : limit_low = SCE_CORE_16k_LOW_LIMIT / FRAMES_PER_SEC;
317 : }
318 :
319 150573 : limit_high = IVAS_512k / FRAMES_PER_SEC;
320 150573 : if ( element_brate < SCE_CORE_16k_LOW_LIMIT )
321 : {
322 40598 : limit_high = ACELP_12k8_HIGH_LIMIT / FRAMES_PER_SEC;
323 : }
324 :
325 150573 : nBits = check_bounds_s( nBits, limit_low, limit_high );
326 :
327 150573 : element_brate_out = nBits * FRAMES_PER_SEC;
328 :
329 150573 : return element_brate_out;
330 : }
331 :
332 :
333 : /*---------------------------------------------------------------
334 : * ivas_combined_format_brate_sanity()
335 : *
336 : * Sanity check in combined format coding
337 : * ---------------------------------------------------------------*/
338 :
339 4389 : void ivas_combined_format_brate_sanity(
340 : const int32_t element_brate, /* i : element bitrate */
341 : const int16_t core, /* i : core */
342 : const int32_t total_brate, /* i : total bitrate */
343 : int32_t *core_brate, /* i/o: core bitrate */
344 : int16_t *inactive_coder_type_flag, /* o : inactive coder_type flag */
345 : int16_t *diff_nBits /* o : number of differential bits */
346 : )
347 : {
348 : int16_t limit_high, nBits;
349 : int32_t brate_diff;
350 :
351 4389 : brate_diff = total_brate - *core_brate;
352 :
353 : /* sanity check: at lowest IVAS bit-rates and one ISM channel coded by
354 : low-rate core-coder mode, it can happen that the CPE (MASA) bit-budget
355 : for ACELP core-coding @12.8 kHz is too high */
356 :
357 4389 : if ( element_brate < ACELP_12k8_HIGH_LIMIT )
358 : {
359 1911 : limit_high = ACELP_12k8_HIGH_LIMIT / FRAMES_PER_SEC;
360 1911 : nBits = (int16_t) ( *core_brate / FRAMES_PER_SEC );
361 :
362 1911 : *diff_nBits = nBits - limit_high;
363 1911 : if ( *diff_nBits > 0 )
364 : {
365 21 : if ( core == TCX_20_CORE || core == TCX_10_CORE )
366 : {
367 0 : *diff_nBits = 0;
368 : }
369 : else /* ACELP core */
370 : {
371 21 : *core_brate -= ( *diff_nBits * FRAMES_PER_SEC );
372 : }
373 : }
374 : }
375 :
376 : /*-----------------------------------------------------------------*
377 : * set inactive coder_type flag in ACELP core
378 : *-----------------------------------------------------------------*/
379 :
380 4389 : if ( core == ACELP_CORE )
381 : {
382 2680 : *inactive_coder_type_flag = 0; /* AVQ by default */
383 2680 : if ( *core_brate + brate_diff <= MAX_GSC_INACTIVE_BRATE )
384 : {
385 1599 : *inactive_coder_type_flag = 1; /* GSC */
386 : }
387 : }
388 :
389 4389 : return;
390 : }
391 :
392 :
393 : /*---------------------------------------------------------------
394 : * bits_index_ism_ratio()
395 : *
396 : *
397 : * ---------------------------------------------------------------*/
398 :
399 : /*!r : number of bits for ISM ratio index */
400 16168 : int16_t bits_index_ism_ratio(
401 : const int16_t nchan_ism /* i : number of objects */
402 : )
403 : {
404 : int16_t bits_index;
405 :
406 16168 : bits_index = 0;
407 16168 : if ( nchan_ism == 2 )
408 : {
409 2537 : bits_index = 3;
410 : }
411 13631 : else if ( nchan_ism == 3 )
412 : {
413 2413 : bits_index = 6;
414 : }
415 11218 : else if ( nchan_ism == 4 )
416 : {
417 11218 : bits_index = 7;
418 : }
419 : else
420 : {
421 0 : assert( ( nchan_ism >= 2 && nchan_ism <= 4 ) && "Wrong number of objects for MASA_ISM." );
422 : }
423 :
424 16168 : return bits_index;
425 : }
426 :
427 :
428 : /*---------------------------------------------------------------
429 : * calculate_nbits_meta()
430 : *
431 : *
432 : * ---------------------------------------------------------------*/
433 :
434 18703 : void calculate_nbits_meta(
435 : const int16_t nchan_ism,
436 : float q_energy_ratio_ism[MAX_PARAM_SPATIAL_SUBFRAMES][MASA_FREQUENCY_BANDS][MAX_NUM_OBJECTS],
437 : float masa_to_total_energy_ratio[MAX_PARAM_SPATIAL_SUBFRAMES][MASA_FREQUENCY_BANDS],
438 : const int16_t numSf,
439 : const int16_t numCodingBands,
440 : int16_t *bits_ism,
441 : const int16_t idx_sep_obj,
442 : const int16_t ism_imp )
443 : {
444 : int16_t sf, band, obj;
445 : float priority[MAX_NUM_OBJECTS], max_p;
446 :
447 18703 : if ( nchan_ism > 1 )
448 : {
449 18703 : set_f( priority, 0.0f, nchan_ism );
450 69974 : for ( sf = 0; sf < numSf; sf++ )
451 : {
452 338569 : for ( band = 0; band < numCodingBands; band++ )
453 : {
454 1357658 : for ( obj = 0; obj < nchan_ism; obj++ )
455 : {
456 1070360 : priority[obj] = max( priority[obj], ( q_energy_ratio_ism[sf][band][obj] * ( 1 - masa_to_total_energy_ratio[sf][band] ) ) );
457 : }
458 : }
459 : }
460 : }
461 : else
462 : {
463 0 : priority[0] = 1;
464 : }
465 :
466 : /* decide parameters for ISM metadata quantization */
467 18703 : maximum( priority, nchan_ism, &max_p );
468 84234 : for ( obj = 0; obj < nchan_ism; obj++ )
469 : {
470 65531 : if ( obj == idx_sep_obj )
471 : {
472 18703 : if ( ism_imp == 3 )
473 : {
474 11244 : priority[obj] = 1;
475 : }
476 7459 : else if ( ism_imp == 2 )
477 : {
478 5996 : priority[obj] = ( 1 + max_p ) * 0.5f;
479 : }
480 : else
481 : {
482 1463 : priority[obj] = max_p;
483 : }
484 : }
485 65531 : bits_ism[obj] = bits_direction_masa[0] - (int16_t) ( ( 1 - ( (int16_t) ( priority[obj] * 1000.0f ) ) * 0.001f ) * 6 );
486 : }
487 :
488 18703 : return;
489 : }
490 :
491 :
492 : /*---------------------------------------------------------------
493 : * ivas_get_stereo_panning_gains()
494 : *
495 : *
496 : *---------------------------------------------------------------*/
497 :
498 206506 : void ivas_get_stereo_panning_gains(
499 : const float aziDeg,
500 : const float eleDeg,
501 : float panningGains[2] )
502 : {
503 : float aziPlusEle, aziMinusEle, y;
504 :
505 : /* use identity sin(A+B) + sin(A−B) = 2 sinA cosB */
506 206506 : aziPlusEle = aziDeg + eleDeg;
507 206506 : aziMinusEle = aziDeg - eleDeg;
508 :
509 : /* wrap into -180..+180 */
510 220949 : while ( aziPlusEle > 180.0f )
511 : {
512 14443 : aziPlusEle -= 360.0f;
513 : }
514 213370 : while ( aziPlusEle < -180.0f )
515 : {
516 6864 : aziPlusEle += 360.0f;
517 : }
518 220021 : while ( aziMinusEle > 180.0f )
519 : {
520 13515 : aziMinusEle -= 360.0f;
521 : }
522 213741 : while ( aziMinusEle < -180.0f )
523 : {
524 7235 : aziMinusEle += 360.0f;
525 : }
526 :
527 : /* compute Y-coordinate corresponding to the azimuth and elevation: y = sin(azi) * cos(ele) = (sin(azi+ele) + sin(azi-ele)) / 2 */
528 206506 : y = ( sinf( aziPlusEle * PI_OVER_180 ) + sinf( aziMinusEle * PI_OVER_180 ) ) * 0.5f;
529 :
530 206506 : if ( y >= SIN_LS_ANGLE )
531 : { /* Left side */
532 43583 : panningGains[0] = 1.0f;
533 43583 : panningGains[1] = 0.0f;
534 : }
535 162923 : else if ( y <= -SIN_LS_ANGLE )
536 : { /* Right side */
537 44318 : panningGains[0] = 0.0f;
538 44318 : panningGains[1] = 1.0f;
539 : }
540 : else /* Tangent panning law */
541 : {
542 : /* from sin(angle) to index assuming range -30..+30 degrees with 0.1-degree spacing */
543 : float angleDeg, pos;
544 : int16_t idx;
545 :
546 : /* Convert azi and ele to an azi value of the cone of confusion */
547 118605 : angleDeg = asinf( y ) * _180_OVER_PI;
548 118605 : angleDeg = fmaxf( fminf( angleDeg, PAN_MAX_DEG ), -PAN_MAX_DEG );
549 :
550 : /* compute the panning gains from the mapped azimuth using a look-up table */
551 118605 : pos = ( angleDeg + PAN_MAX_DEG ) * ONE_OVER_PAN_STEP_DEG; /* ideal floating index */
552 118605 : idx = (int16_t) roundf( pos );
553 :
554 118605 : idx = max( 0, min( idx, OMASA_PAN_TBL_LEN - 1 ) );
555 :
556 118605 : panningGains[0] = ivas_tan_panning_gain_tbl[idx];
557 118605 : panningGains[1] = ivas_tan_panning_gain_tbl[OMASA_PAN_TBL_LEN - 1 - idx];
558 : }
559 :
560 206506 : return;
561 : }
562 :
563 :
564 : /*---------------------------------------------------------------
565 : * calculate_brate_limit_flag()
566 : *
567 : *
568 : *---------------------------------------------------------------*/
569 :
570 : /*! r: limitation flag */
571 53217 : int16_t calculate_brate_limit_flag(
572 : const int16_t ism_imp[], /* i : ISM importance flags */
573 : const int16_t nchan_ism /* i : number of objects */
574 : )
575 : {
576 : int16_t n;
577 : int16_t brate_limit_flag;
578 : int16_t nzeros;
579 :
580 53217 : brate_limit_flag = 0;
581 53217 : nzeros = 0;
582 170031 : for ( n = 0; n < nchan_ism; n++ )
583 : {
584 116814 : brate_limit_flag += ism_imp[n];
585 116814 : if ( ism_imp[n] == 0 )
586 : {
587 376 : nzeros++;
588 : }
589 : }
590 :
591 53217 : if ( brate_limit_flag >= (int16_t) ( nchan_ism * 2.5f ) )
592 : {
593 40451 : brate_limit_flag = 1;
594 : }
595 : else
596 : {
597 12766 : if ( nzeros / (float) nchan_ism >= 0.5f )
598 : {
599 209 : brate_limit_flag = -1; /* there is no limitation, on the contrary */
600 : }
601 : }
602 :
603 53217 : return brate_limit_flag;
604 : }
|
