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 <stdint.h>
34 : #include "options.h"
35 : #include "cnst.h"
36 : #include "wmc_auto.h"
37 : #include "prot_fx.h"
38 : #include "ivas_prot_fx.h"
39 :
40 : /*-----------------------------------------------------------------------------------------*
41 : * Local constants
42 : *-----------------------------------------------------------------------------------------*/
43 :
44 : #define BAND_SMOOTH_REST_START_IDX ( 2 )
45 : #define ONEeN20_Q97 0x5E728433 // 1e-20 in Q97 1.584.563.251
46 :
47 :
48 : /*-----------------------------------------------------------------------------------------*
49 : * Function ivas_calculate_update_factor_fx()
50 : *
51 : * To calculate the update factor
52 : *-----------------------------------------------------------------------------------------*/
53 :
54 40260 : static Word32 ivas_calculate_update_factor_fx( // o: Q22
55 : Word32 *p_bin_to_band, // i: Q22
56 : Word16 active_bins )
57 : {
58 40260 : Word32 update_factor_temp = 0;
59 40260 : move32();
60 : Word16 k;
61 :
62 901120 : FOR( k = 0; k < active_bins; k++ )
63 : {
64 860860 : update_factor_temp = L_add( update_factor_temp, p_bin_to_band[k] ); // Q22
65 : }
66 :
67 40260 : return update_factor_temp; // Q22
68 : }
69 :
70 :
71 : /*-----------------------------------------------------------------------------------------*
72 : * Function ivas_calculate_smoothning_factor_fx()
73 : *
74 : * To calculate the Smoothning factor
75 : *-----------------------------------------------------------------------------------------*/
76 :
77 40260 : static void ivas_calculate_smoothning_factor_fx(
78 : Word32 *Smoothing_factor, // o: Q31
79 : Word32 update_factor, // i: Q22
80 : const Word16 min_pool_size,
81 : const Word32 max_update_rate,
82 : const COV_SMOOTHING_TYPE smooth_mode,
83 : const Word32 ivas_total_brate,
84 : Word16 j )
85 : {
86 40260 : Word32 smooth_fact, L_tmp = 0;
87 40260 : Word16 tmp, exp_diff = 0;
88 40260 : move32();
89 40260 : move16();
90 :
91 40260 : tmp = BASOP_Util_Divide3232_Scale( update_factor, L_shl( L_deposit_l( min_pool_size ), Q22 ), &exp_diff ); // Q(31 - exp_diff)
92 40260 : *Smoothing_factor = L_shl_sat( L_deposit_h( tmp ), exp_diff ); // Q31
93 40260 : move32();
94 :
95 :
96 40260 : IF( NE_32( smooth_mode, COV_SMOOTH_MC ) )
97 : {
98 39108 : IF( LT_32( ivas_total_brate, IVAS_24k4 ) )
99 : {
100 7704 : smooth_fact = (Word32) ( ONE_IN_Q30 ); // 0.5 in Q31
101 7704 : move32();
102 : }
103 : ELSE
104 : {
105 31404 : smooth_fact = (Word32) ( 1610612735 ); // 0.75 in Q31
106 31404 : move32();
107 : }
108 :
109 39108 : L_tmp = Mpy_32_16_1( smooth_fact, add( j, 1 ) ); // (Q31 , Q0) -> Q16
110 39108 : *Smoothing_factor = Mpy_32_32( *Smoothing_factor, L_tmp ); // (Q31, Q16) -> Q16
111 39108 : move32();
112 39108 : *Smoothing_factor = L_shl_sat( *Smoothing_factor, Q15 ); // Q31
113 39108 : move32();
114 : }
115 :
116 40260 : IF( GT_32( *Smoothing_factor, max_update_rate ) ) // Q31
117 : {
118 20950 : *Smoothing_factor = max_update_rate; // Q31
119 20950 : move32();
120 : }
121 :
122 40260 : return;
123 : }
124 :
125 :
126 : /*-----------------------------------------------------------------------------------------*
127 : * Function ivas_set_up_cov_smoothing_fx()
128 : *
129 : * Setup for covariance smoothing
130 : *-----------------------------------------------------------------------------------------*/
131 :
132 3368 : static void ivas_set_up_cov_smoothing_fx(
133 : ivas_cov_smooth_state_t *hCovState,
134 : ivas_filterbank_t *pFb,
135 : const Word32 max_update_rate, // i: Q31
136 : const Word16 min_pool_size,
137 : const COV_SMOOTHING_TYPE smooth_mode, /* i : flag multichannel vs SPAR */
138 : const Word32 ivas_total_brate )
139 : {
140 : Word16 j;
141 : Word32 update_factor;
142 :
143 3368 : IF( EQ_32( smooth_mode, COV_SMOOTH_MC ) )
144 : {
145 1248 : FOR( j = 0; j < pFb->filterbank_num_bands; j++ )
146 : {
147 1152 : Word16 active_bins = pFb->fb_bin_to_band.pFb_active_bins_per_band[j];
148 1152 : move16();
149 1152 : update_factor = ivas_calculate_update_factor_fx( pFb->fb_bin_to_band.pFb_bin_to_band_fx[j], active_bins ); // Q22
150 1152 : ivas_calculate_smoothning_factor_fx( &hCovState->pSmoothing_factor_fx[j], update_factor, min_pool_size, max_update_rate, smooth_mode, ivas_total_brate, j );
151 : }
152 : }
153 : ELSE
154 : {
155 42380 : FOR( j = 0; j < pFb->filterbank_num_bands; j++ )
156 : {
157 39108 : Word32 *p_bin_to_band = pFb->fb_bin_to_band.pp_short_stride_bin_to_band_fx[j]; // Q22
158 39108 : Word16 active_bins = pFb->fb_bin_to_band.p_short_stride_num_bins_per_band[j];
159 39108 : move16();
160 39108 : update_factor = ivas_calculate_update_factor_fx( p_bin_to_band, active_bins ); // Q22
161 39108 : ivas_calculate_smoothning_factor_fx( &hCovState->pSmoothing_factor_fx[j], update_factor, min_pool_size, max_update_rate, smooth_mode, ivas_total_brate, j );
162 : }
163 : }
164 :
165 3368 : hCovState->prior_bank_idx = -1;
166 3368 : move16();
167 :
168 3368 : return;
169 : }
170 :
171 :
172 : /*-------------------------------------------------------------------------
173 : * ivas_spar_covar_smooth_enc_open_fx()
174 : *
175 : * Allocate and initialize SPAR Covar. smoothing handle
176 : *------------------------------------------------------------------------*/
177 :
178 3368 : ivas_error ivas_spar_covar_smooth_enc_open_fx(
179 : ivas_cov_smooth_state_t **hCovState_out, /* i/o: SPAR Covar. smoothing handle */
180 : const ivas_cov_smooth_cfg_t *cov_smooth_cfg, /* i : SPAR config. handle */
181 : ivas_filterbank_t *pFb, /* i/o: FB handle */
182 : const Word16 nchan_inp, /* i : number of input channels */
183 : const COV_SMOOTHING_TYPE smooth_mode, /* i : Smooth covariance for SPAR or MC */
184 : const Word32 ivas_total_brate /* i : IVAS total bitrate */
185 : )
186 : {
187 : ivas_cov_smooth_state_t *hCovState;
188 : Word16 i, j;
189 :
190 3368 : IF( ( hCovState = (ivas_cov_smooth_state_t *) malloc( sizeof( ivas_cov_smooth_state_t ) ) ) == NULL )
191 : {
192 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR COV encoder" );
193 : }
194 :
195 3368 : IF( ( hCovState->pSmoothing_factor_fx = (Word32 *) malloc( sizeof( Word32 ) * cov_smooth_cfg->max_bands ) ) == NULL )
196 : {
197 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR COV encoder" );
198 : }
199 :
200 19094 : FOR( i = 0; i < nchan_inp; i++ )
201 : {
202 99972 : FOR( j = 0; j < nchan_inp; j++ )
203 : {
204 84246 : IF( ( hCovState->pPrior_cov_real_fx[i][j] = (Word32 *) malloc( sizeof( Word32 ) * cov_smooth_cfg->max_bands ) ) == NULL )
205 : {
206 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR COV encoder Fixed" );
207 : }
208 84246 : set_zero_fx( hCovState->pPrior_cov_real_fx[i][j], cov_smooth_cfg->max_bands );
209 84246 : IF( ( hCovState->q_cov_real_per_band[i][j] = (Word16 *) malloc( sizeof( Word16 ) * cov_smooth_cfg->max_bands ) ) == NULL )
210 : {
211 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR COV encoder Fixed" );
212 : }
213 84246 : set16_fx( hCovState->q_cov_real_per_band[i][j], Q31, cov_smooth_cfg->max_bands );
214 84246 : IF( ( hCovState->q_prior_cov_real_per_band[i][j] = (Word16 *) malloc( sizeof( Word16 ) * cov_smooth_cfg->max_bands ) ) == NULL )
215 : {
216 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR COV encoder Fixed" );
217 : }
218 84246 : set16_fx( hCovState->q_prior_cov_real_per_band[i][j], Q31, cov_smooth_cfg->max_bands );
219 : }
220 : }
221 :
222 3368 : ivas_set_up_cov_smoothing_fx( hCovState, pFb, cov_smooth_cfg->max_update_rate_fx, cov_smooth_cfg->min_pool_size, smooth_mode, ivas_total_brate );
223 :
224 3368 : *hCovState_out = hCovState;
225 :
226 3368 : return IVAS_ERR_OK;
227 : }
228 :
229 : /*-------------------------------------------------------------------------
230 : * ivas_spar_covar_smooth_enc_close_fx()
231 : *
232 : * Deallocate SPAR Covar. smoothing handle
233 : *------------------------------------------------------------------------*/
234 :
235 3368 : void ivas_spar_covar_smooth_enc_close_fx(
236 : ivas_cov_smooth_state_t **hCovState_out, /* i/o: SPAR Covar. smoothing handle */
237 : const Word16 nchan_inp /* i : number of input channels */
238 : )
239 : {
240 : ivas_cov_smooth_state_t *hCovState;
241 : Word16 i, j;
242 :
243 3368 : hCovState = *hCovState_out;
244 :
245 3368 : IF( hCovState != NULL )
246 : {
247 3368 : free( hCovState->pSmoothing_factor_fx );
248 3368 : hCovState->pSmoothing_factor_fx = NULL;
249 :
250 19094 : FOR( i = 0; i < nchan_inp; i++ )
251 : {
252 99972 : FOR( j = 0; j < nchan_inp; j++ )
253 : {
254 84246 : free( hCovState->pPrior_cov_real_fx[i][j] );
255 84246 : hCovState->pPrior_cov_real_fx[i][j] = NULL;
256 84246 : free( hCovState->q_cov_real_per_band[i][j] );
257 84246 : hCovState->q_cov_real_per_band[i][j] = NULL;
258 84246 : free( hCovState->q_prior_cov_real_per_band[i][j] );
259 84246 : hCovState->q_prior_cov_real_per_band[i][j] = NULL;
260 : }
261 : }
262 :
263 3368 : free( hCovState );
264 3368 : hCovState_out = NULL;
265 : }
266 :
267 3368 : return;
268 : }
269 :
270 : /*-----------------------------------------------------------------------------------------*
271 : * Function ivas_compute_smooth_cov_fx()
272 : *
273 : * Compute smooth covariance real/imag.
274 : *-----------------------------------------------------------------------------------------*/
275 166680 : static void ivas_compute_smooth_cov_fx(
276 : ivas_cov_smooth_state_t *hCovState,
277 : ivas_filterbank_t *pFb,
278 : Word32 *pCov_buf[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH], // i/o: Q(q_cov[i][j])
279 : Word32 *pPrior_cov_buf[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH], // i: hCovState->q_cov_real_per_band[i][j][k]
280 : const Word32 fac, // i: ONEeN20_Q97 (1e-20 in Q97)
281 : const Word16 start_band,
282 : const Word16 end_band,
283 : const Word16 num_ch,
284 : const Word16 transient_det[2],
285 : Word16 *q_cov[IVAS_SPAR_MAX_CH] )
286 : {
287 : Word16 i, j, k;
288 166680 : Word16 prev_idx = hCovState->prior_bank_idx;
289 166680 : Word32 factor = 0, L_tmp0, L_tmp1;
290 :
291 166680 : const Word16 q_fac = 97;
292 166680 : const Word16 fac_e = sub( Q31, q_fac );
293 :
294 : Word16 cov_buf_e;
295 :
296 : Word16 sm_b;
297 : Word16 non_sm_b_idx;
298 :
299 166680 : sm_b = BAND_SMOOTH_REST_START_IDX;
300 166680 : move16();
301 166680 : move16();
302 166680 : move32();
303 :
304 166680 : assert( end_band <= pFb->filterbank_num_bands );
305 166680 : test();
306 166680 : IF( EQ_16( prev_idx, -1 ) || EQ_16( transient_det[1], 1 ) )
307 : {
308 42790 : FOR( i = 0; i < num_ch; i++ )
309 : {
310 213298 : FOR( j = 0; j < num_ch; j++ )
311 : {
312 178423 : set16_fx( hCovState->q_cov_real_per_band[i][j], q_cov[i][j], sub( end_band, start_band ) ); // assign q_cov[i][j] to hCovState->q_cov_real_per_band[i][j][k]
313 : }
314 : }
315 42790 : FOR( i = 0; i < num_ch; i++ )
316 : {
317 447667 : FOR( k = start_band; k < end_band; k++ )
318 : {
319 : /* ref: pCov_buf[i][i][k] += ( hCovState->pSmoothing_factor[k] * fac ); */
320 412792 : pCov_buf[i][i][k] = BASOP_Util_Add_Mant32Exp( pCov_buf[i][i][k], sub( Q31, q_cov[i][i] ), Mpy_32_32( hCovState->pSmoothing_factor_fx[k], fac ), fac_e, &cov_buf_e );
321 412792 : move32();
322 412792 : hCovState->q_cov_real_per_band[i][i][k] = sub( Q31, cov_buf_e );
323 412792 : move16();
324 : }
325 : }
326 : }
327 158765 : ELSE IF( EQ_16( transient_det[0], 1 ) )
328 : {
329 10281 : non_sm_b_idx = s_min( sm_b, end_band );
330 57302 : FOR( i = 0; i < num_ch; i++ )
331 : {
332 290698 : FOR( j = 0; j < num_ch; j++ )
333 : {
334 243677 : IF( EQ_16( i, j ) )
335 : {
336 47021 : factor = fac; // Q97
337 47021 : move32();
338 : }
339 : ELSE
340 : {
341 196656 : factor = 0; // Q97
342 196656 : move32();
343 : }
344 :
345 731031 : FOR( k = start_band; k < non_sm_b_idx; k++ )
346 : {
347 : /* ref: pCov_buf[i][j][k] = pPrior_cov_buf[i][j][k] + ( hCovState->pSmoothing_factor[k] * ( pCov_buf[i][j][k] - pPrior_cov_buf[i][j][k] + factor ) ); */
348 : /* mod: pCov_buf[i][j][k] = pCov_buf[i][j][k] * hCovState->pSmoothing_factor[k] +
349 : pPrior_cov_buf[i][j][k] * (1.0 - hCovState->pSmoothing_factor[k]) +
350 : factor * hCovState->pSmoothing_factor[k] ); */
351 487354 : L_tmp0 = Mpy_32_32( hCovState->pSmoothing_factor_fx[k], pCov_buf[i][j][k] ); // q_tmp0: q_cov[i][j] // (Q31, q_cov[i][j]) -> q_cov[i][j]
352 487354 : L_tmp1 = Mpy_32_32( L_sub( ONE_IN_Q31, hCovState->pSmoothing_factor_fx[k] ), pPrior_cov_buf[i][j][k] ); // q_tmp1: hCovState->q_prior_cov_real_per_band[i][j][k]
353 487354 : L_tmp0 = BASOP_Util_Add_Mant32Exp( L_tmp0, sub( Q31, q_cov[i][j] ), L_tmp1, sub( Q31, hCovState->q_prior_cov_real_per_band[i][j][k] ), &cov_buf_e );
354 487354 : pCov_buf[i][j][k] = BASOP_Util_Add_Mant32Exp( L_tmp0, cov_buf_e, Mpy_32_32( hCovState->pSmoothing_factor_fx[k], factor ), fac_e, &cov_buf_e );
355 487354 : move32();
356 487354 : hCovState->q_cov_real_per_band[i][j][k] = sub( Q31, cov_buf_e ); // Q of pCov_buf[i][j][k]
357 487354 : move16();
358 : }
359 2656495 : FOR( ; k < end_band; k++ )
360 : {
361 2412818 : hCovState->q_cov_real_per_band[i][j][k] = q_cov[i][j];
362 2412818 : move16();
363 : }
364 : }
365 : }
366 57302 : FOR( i = 0; i < num_ch; i++ )
367 : {
368 511543 : FOR( k = non_sm_b_idx; k < end_band; k++ )
369 : {
370 : /* ref: pCov_buf[i][i][k] += ( hCovState->pSmoothing_factor[k] * fac ); */
371 464522 : pCov_buf[i][i][k] = BASOP_Util_Add_Mant32Exp( pCov_buf[i][i][k], sub( Q31, q_cov[i][i] ), Mpy_32_32( hCovState->pSmoothing_factor_fx[k], fac ), fac_e, &cov_buf_e );
372 464522 : move32();
373 464522 : hCovState->q_cov_real_per_band[i][i][k] = sub( Q31, cov_buf_e ); // Q of pCov_buf[i][i][k]
374 464522 : move16();
375 : }
376 : }
377 : }
378 148484 : ELSE IF( prev_idx == 0 )
379 : {
380 823892 : FOR( i = 0; i < num_ch; i++ )
381 : {
382 4226952 : FOR( j = 0; j < num_ch; j++ )
383 : {
384 3551544 : IF( EQ_16( i, j ) )
385 : {
386 675408 : factor = fac; // Q97
387 675408 : move32();
388 : }
389 : ELSE
390 : {
391 2876136 : factor = 0; // Q97
392 2876136 : move32();
393 : }
394 :
395 45775456 : FOR( k = start_band; k < end_band; k++ )
396 : {
397 : /* ref: pCov_buf[i][j][k] = pPrior_cov_buf[i][j][k] + ( hCovState->pSmoothing_factor[k] * ( pCov_buf[i][j][k] - pPrior_cov_buf[i][j][k] + factor ) ); */
398 : /* mod: pCov_buf[i][j][k] = pCov_buf[i][j][k] * hCovState->pSmoothing_factor[k] +
399 : pPrior_cov_buf[i][j][k] * (1.0 - hCovState->pSmoothing_factor[k]) +
400 : factor * hCovState->pSmoothing_factor[k] ); */
401 42223912 : L_tmp0 = Mpy_32_32( hCovState->pSmoothing_factor_fx[k], pCov_buf[i][j][k] ); // q_tmp0: q_cov[i][j] // (Q31, q_cov[i][j]) -> q_cov[i][j]
402 42223912 : L_tmp1 = Mpy_32_32( L_sub( ONE_IN_Q31, hCovState->pSmoothing_factor_fx[k] ), pPrior_cov_buf[i][j][k] ); // q_tmp1: hCovState->q_prior_cov_real_per_band[i][j][k]
403 42223912 : L_tmp0 = BASOP_Util_Add_Mant32Exp( L_tmp0, sub( Q31, q_cov[i][j] ), L_tmp1, sub( Q31, hCovState->q_prior_cov_real_per_band[i][j][k] ), &cov_buf_e );
404 42223912 : pCov_buf[i][j][k] = BASOP_Util_Add_Mant32Exp( L_tmp0, cov_buf_e, Mpy_32_32( hCovState->pSmoothing_factor_fx[k], factor ), fac_e, &cov_buf_e );
405 42223912 : move32();
406 42223912 : hCovState->q_cov_real_per_band[i][j][k] = sub( Q31, cov_buf_e ); // Q of pCov_buf[i][j][k]
407 42223912 : move16();
408 : }
409 : }
410 : }
411 : }
412 :
413 166680 : return;
414 : }
415 :
416 :
417 : /*-----------------------------------------------------------------------------------------*
418 : * Function ivas_cov_smooth_process_fx()
419 : *
420 : * Covariance smoothing process
421 : *-----------------------------------------------------------------------------------------*/
422 :
423 166680 : void ivas_cov_smooth_process_fx(
424 : ivas_cov_smooth_state_t *hCovState, /* i/o: Covariance state handle */
425 : Word32 *cov_real[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH], // Q(hCovState->q_cov_real_per_band[i][j][k])
426 : ivas_filterbank_t *pFb, /* i/o: FB handle */
427 : const Word16 start_band,
428 : const Word16 end_band,
429 : const Word16 num_ch,
430 : const Word16 transient_det[2],
431 : Word16 *q_cov[IVAS_SPAR_MAX_CH] )
432 : {
433 : Word16 i, j, k;
434 166680 : Word16 num_bands = sub( end_band, start_band );
435 :
436 166680 : ivas_compute_smooth_cov_fx( hCovState, pFb, cov_real, hCovState->pPrior_cov_real_fx, ONEeN20_Q97, start_band, end_band, num_ch, transient_det, q_cov );
437 :
438 923984 : FOR( i = 0; i < num_ch; i++ )
439 : {
440 4730948 : FOR( j = 0; j < num_ch; j++ )
441 : {
442 3973644 : Copy32( &cov_real[i][j][start_band], &hCovState->pPrior_cov_real_fx[i][j][start_band], num_bands ); // Q of hCovState->pPrior_cov_real_fx[i][j][start_band + k] will be hCovState->q_cov_real_per_band[i][j][start_band + k]
443 51214940 : FOR( k = 0; k < num_bands; k++ )
444 : {
445 47241296 : hCovState->q_prior_cov_real_per_band[i][j][start_band + k] = hCovState->q_cov_real_per_band[i][j][start_band + k];
446 47241296 : move16();
447 : }
448 : }
449 : }
450 :
451 166680 : hCovState->prior_bank_idx = 0;
452 166680 : move16();
453 :
454 166680 : return;
455 : }
|
