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 : #ifdef DEBUGGING
36 : #include "debug.h"
37 : #endif
38 : #include "prot.h"
39 : #include "ivas_prot.h"
40 : #include "ivas_rom_com.h"
41 : #include "math.h"
42 : #include "wmc_auto.h"
43 :
44 :
45 : /*------------------------------------------------------------------------------------------*
46 : * Local constants
47 : *------------------------------------------------------------------------------------------*/
48 :
49 : /* Delay handling of LFE: overall_lfe_delay = max(11.5, BLOCK_OFFSET_MS); */
50 : #define BLOCK_OFFSET_MS 12
51 :
52 :
53 : /*-----------------------------------------------------------------------------------------*
54 : * Function ivas_lfe_dec_delay_adjust()
55 : *
56 : * Adjusts the input to be passed to filtering block taking into consideration
57 : * LFE delay calculated during initialization time
58 : *-----------------------------------------------------------------------------------------*/
59 :
60 1234634 : static void ivas_lfe_dec_delay_adjust(
61 : LFE_DEC_HANDLE hLFE,
62 : float *pInbuf,
63 : float output_lfe_ch[] )
64 : {
65 : int16_t i, diff, loop_counter;
66 : int16_t fade_len, dct_len, zero_pad_len;
67 : float tmp_buffer[L_FRAME48k];
68 :
69 1234634 : diff = hLFE->lfe_prior_buf_len - hLFE->pWindow_state->fade_len;
70 1234634 : loop_counter = diff < 0 ? 0 : diff;
71 1234634 : fade_len = hLFE->pWindow_state->fade_len;
72 1234634 : dct_len = hLFE->pWindow_state->dct_len;
73 1234634 : zero_pad_len = hLFE->pWindow_state->zero_pad_len;
74 :
75 1234634 : for ( i = 0; i < loop_counter; i++ )
76 : {
77 0 : tmp_buffer[i] = hLFE->prior_out_buffer[i];
78 : }
79 :
80 411752906 : for ( i = 0; i < fade_len; i++ )
81 : {
82 410518272 : tmp_buffer[i + loop_counter] = hLFE->prior_out_buffer[i + loop_counter] + pInbuf[i];
83 : }
84 1234634 : loop_counter += fade_len;
85 :
86 514382474 : for ( i = 0; i < fade_len + ( zero_pad_len << 1 ); i++ )
87 : {
88 513147840 : tmp_buffer[i + loop_counter] = pInbuf[i + fade_len];
89 : }
90 :
91 411752906 : for ( i = 0; i < hLFE->lfe_prior_buf_len; i++ )
92 : {
93 410518272 : hLFE->prior_out_buffer[i] = tmp_buffer[i + dct_len];
94 : }
95 :
96 514382474 : for ( i = 0; i < dct_len; i++ )
97 : {
98 513147840 : output_lfe_ch[i] = tmp_buffer[i];
99 : }
100 :
101 1234634 : return;
102 : }
103 :
104 :
105 : /*-----------------------------------------------------------------------------------------*
106 : * Function ivas_lfe_dec_windowing()
107 : *
108 : * LFE windowing block, input is passed through Fielder window
109 : *-----------------------------------------------------------------------------------------*/
110 :
111 1234634 : static void ivas_lfe_dec_windowing(
112 : LFE_DEC_HANDLE hLFE,
113 : float *pInbuf )
114 : {
115 : int16_t i;
116 : int16_t fade_len;
117 : int16_t zero_pad_len;
118 : const float *pWindow_coeffs;
119 :
120 1234634 : fade_len = hLFE->pWindow_state->fade_len;
121 1234634 : zero_pad_len = hLFE->pWindow_state->zero_pad_len;
122 1234634 : pWindow_coeffs = hLFE->pWindow_state->pWindow_coeffs;
123 :
124 411752906 : for ( i = 0; i < fade_len; i++ )
125 : {
126 410518272 : pInbuf[i] = pInbuf[zero_pad_len + i] * pWindow_coeffs[i];
127 : }
128 :
129 103864202 : for ( i = 0; i < zero_pad_len * 2; i++ )
130 : {
131 102629568 : pInbuf[fade_len + i] = pInbuf[zero_pad_len + fade_len + i];
132 : }
133 :
134 411752906 : for ( i = 0; i < fade_len; i++ )
135 : {
136 410518272 : pInbuf[zero_pad_len * 2 + fade_len + i] = pInbuf[zero_pad_len * 3 + fade_len + i] * pWindow_coeffs[fade_len - i - 1];
137 : }
138 :
139 1234634 : return;
140 : }
141 :
142 :
143 : /*-----------------------------------------------------------------------------------------*
144 : * Function ivas_lfe_dec_dequant()
145 : *
146 : * LDE de-quatization block, calls arithmetic deccoding block inside
147 : *-----------------------------------------------------------------------------------------*/
148 :
149 598088 : static int16_t ivas_lfe_dec_dequant(
150 : LFE_DEC_HANDLE hLFE,
151 : Decoder_State *st0,
152 : float *pOut_buf,
153 : int16_t *num_dct_pass_bins )
154 : {
155 : int16_t shift_bits, i;
156 : int16_t quant_strategy;
157 : int16_t coding_strategy;
158 : int16_t base2_bit_size;
159 : int16_t lfe_bits;
160 : int16_t all_zeros_dct;
161 : int16_t min_shift_bits;
162 : int16_t shift;
163 : int16_t sign_bits[IVAS_LFE_MAX_NUM_DCT_COEFFS];
164 : int16_t abs_values[IVAS_LFE_MAX_NUM_DCT_COEFFS];
165 : int16_t values[IVAS_LFE_MAX_NUM_DCT_COEFFS];
166 : int16_t num_dct_coeffs, num_groups;
167 :
168 598088 : all_zeros_dct = get_next_indice( st0, 1 );
169 598088 : lfe_bits = st0->next_bit_pos;
170 598088 : shift_bits = IVAS_LFE_SHIFT_BITS;
171 598088 : min_shift_bits = 0;
172 598088 : shift = 0;
173 :
174 598088 : if ( all_zeros_dct == 1 )
175 : {
176 5069570 : for ( i = 0; i < IVAS_LFE_MAX_NUM_DCT_COEFFS; i++ )
177 : {
178 4771360 : pOut_buf[i] = 0.0f;
179 : }
180 : }
181 : else
182 : {
183 : float two_pow_shift_by_4;
184 : Tastat as;
185 : int16_t iii, extra_bits_read;
186 :
187 299878 : extra_bits_read = 0;
188 299878 : quant_strategy = get_next_indice( st0, 1 );
189 299878 : *num_dct_pass_bins = ivas_lfe_num_dct_pass_bins_tbl[quant_strategy];
190 299878 : num_dct_coeffs = (int16_t) ( *num_dct_pass_bins * IVAS_LFE_NUM_COEFFS_IN_SUBGRP );
191 299878 : num_groups = ( num_dct_coeffs / ( 2 * IVAS_LFE_NUM_COEFFS_IN_SUBGRP ) );
192 299878 : min_shift_bits = ivas_lfe_min_shift_tbl[quant_strategy];
193 299878 : shift = get_next_indice( st0, shift_bits ) + min_shift_bits * IVAS_LFE_SHIFTS_PER_DOUBLE;
194 :
195 5097926 : for ( i = 0; i < num_dct_coeffs; i++ )
196 : {
197 4798048 : sign_bits[i] = get_next_indice( st0, 1 );
198 : }
199 :
200 299878 : coding_strategy = get_next_indice( st0, 1 );
201 :
202 299878 : if ( coding_strategy )
203 : {
204 6135 : for ( iii = 0; iii < num_groups; iii++ )
205 : {
206 4908 : base2_bit_size = hLFE->lfe_dec_indices_coeffs_tbl[quant_strategy][iii];
207 24540 : for ( i = 0; i < 4; i++ )
208 : {
209 19632 : abs_values[iii * 4 + i] = get_next_indice( st0, base2_bit_size );
210 : }
211 : }
212 : }
213 : else
214 : {
215 1493255 : for ( iii = 0; iii < num_groups; iii++ )
216 : {
217 1194604 : extra_bits_read = 0;
218 1194604 : ivas_ari_start_decoding_14bits_ext_1_lfe( st0, &as, &extra_bits_read );
219 :
220 5973020 : for ( i = 0; i < 4; i++ )
221 : {
222 4778416 : abs_values[iii * 4 + i] = ivas_ari_decode_14bits_bit_ext_1_lfe( st0, &as, hLFE->cum_freq_models[quant_strategy][iii], &extra_bits_read );
223 : }
224 1194604 : ivas_ari_done_decoding_14bits_ext_1_lfe( st0, extra_bits_read );
225 : }
226 : }
227 :
228 5097926 : for ( i = 0; i < num_dct_coeffs; i++ )
229 : {
230 4798048 : values[i] = abs_values[i];
231 4798048 : if ( sign_bits[i] > 0 )
232 : {
233 1414493 : values[i] = -abs_values[i] - 1;
234 : }
235 : }
236 :
237 299878 : two_pow_shift_by_4 = powf( 2, ( -shift / (float) IVAS_LFE_SHIFTS_PER_DOUBLE ) );
238 :
239 1499390 : for ( i = 0; i < num_groups; i++ )
240 : {
241 1199512 : pOut_buf[2 * i] = values[4 * i] * two_pow_shift_by_4;
242 1199512 : pOut_buf[2 * i + 1] = values[4 * i + 1] * two_pow_shift_by_4;
243 :
244 1199512 : pOut_buf[2 * i + *num_dct_pass_bins] = values[4 * i + 2] * two_pow_shift_by_4;
245 1199512 : pOut_buf[2 * i + *num_dct_pass_bins + 1] = values[4 * i + 3] * two_pow_shift_by_4;
246 : }
247 : }
248 :
249 598088 : lfe_bits = st0->next_bit_pos - lfe_bits;
250 :
251 598088 : return lfe_bits;
252 : }
253 :
254 :
255 : /*-------------------------------------------------------------------------
256 : * ivas_create_lfe_lpf_dec()
257 : *
258 : * Create, allocate and initialize IVAS decoder LFE low pass filter state handle
259 : *-------------------------------------------------------------------------*/
260 :
261 596 : static void ivas_create_lfe_lpf_dec(
262 : ivas_filters_process_state_t *hLfeLpf, /* o : LFE LPF handle */
263 : const int32_t input_Fs /* i : input sampling rate */
264 : )
265 : {
266 : const float *filt_coeff;
267 :
268 596 : ivas_lfe_lpf_select_filt_coeff( input_Fs, IVAS_FILTER_ORDER_4, &filt_coeff );
269 596 : ivas_filters_init( hLfeLpf, filt_coeff, IVAS_FILTER_ORDER_4 );
270 :
271 596 : return;
272 : }
273 :
274 :
275 : /*-----------------------------------------------------------------------------------------*
276 : * Function ivas_lfe_dec()
277 : *
278 : * LFE channel decoder
279 : *-----------------------------------------------------------------------------------------*/
280 :
281 617317 : void ivas_lfe_dec(
282 : LFE_DEC_HANDLE hLFE, /* i/o: LFE decoder handle */
283 : Decoder_State *st0, /* i/o: decoder state structure - for bitstream handling*/
284 : const int16_t output_frame, /* i : output frame length per channel */
285 : const int16_t bfi, /* i : BFI flag */
286 : float output_lfe_ch[] /* o : output LFE synthesis */
287 : )
288 : {
289 : int16_t num_dct_pass_bins;
290 : int16_t i, j, dct_len;
291 : float out[L_FRAME48k];
292 : float t_audio[L_FRAME48k];
293 : float lfe_dct[IVAS_LFE_MAX_NUM_DCT_COEFFS];
294 :
295 617317 : dct_len = hLFE->pWindow_state->dct_len;
296 617317 : num_dct_pass_bins = IVAS_LFE_MAX_NUM_DCT_PASS_BINS;
297 :
298 617317 : if ( bfi == 0 )
299 : {
300 598088 : ivas_lfe_dec_dequant( hLFE, st0, lfe_dct, &num_dct_pass_bins );
301 :
302 598088 : set_zero( t_audio, dct_len );
303 598088 : mvr2r( lfe_dct, t_audio, num_dct_pass_bins );
304 598088 : ivas_imdct( t_audio, out, dct_len );
305 598088 : ivas_lfe_dec_windowing( hLFE, out );
306 598088 : ivas_lfe_dec_delay_adjust( hLFE, out, output_lfe_ch );
307 :
308 598088 : set_zero( t_audio, dct_len );
309 598088 : mvr2r( &lfe_dct[num_dct_pass_bins], t_audio, num_dct_pass_bins );
310 :
311 598088 : ivas_imdct( t_audio, out, dct_len );
312 598088 : ivas_lfe_dec_windowing( hLFE, out );
313 598088 : ivas_lfe_dec_delay_adjust( hLFE, out, output_lfe_ch + dct_len );
314 :
315 598088 : mvr2r( hLFE->prevsynth_buf + L_FRAME_1k6, hLFE->prevsynth_buf, LFE_PLC_BUFLEN - L_FRAME_1k6 );
316 :
317 598088 : j = 0;
318 19736904 : for ( i = 0; i < L_FRAME_1k6; i++ )
319 : {
320 19138816 : hLFE->prevsynth_buf[i + LFE_PLC_BUFLEN - L_FRAME_1k6] = output_lfe_ch[j];
321 19138816 : j += output_frame / L_FRAME_1k6;
322 : }
323 :
324 598088 : hLFE->bfi_count = 0;
325 : }
326 : else
327 : {
328 : /* note: in BFI branch, buffer 't_audio' is in time-domain ('wtda' signal) */
329 19229 : hLFE->bfi_count++;
330 19229 : ivas_lfe_tdplc( hLFE, hLFE->prevsynth_buf, t_audio, output_frame );
331 :
332 19229 : ivas_itda( t_audio, out, dct_len );
333 19229 : ivas_lfe_dec_windowing( hLFE, out );
334 19229 : ivas_lfe_dec_delay_adjust( hLFE, out, output_lfe_ch );
335 :
336 19229 : ivas_itda( t_audio + dct_len, out, dct_len );
337 19229 : ivas_lfe_dec_windowing( hLFE, out );
338 19229 : ivas_lfe_dec_delay_adjust( hLFE, out, output_lfe_ch + dct_len );
339 :
340 19229 : mvr2r( hLFE->prevsynth_buf + L_FRAME_1k6, hLFE->prevsynth_buf, LFE_PLC_BUFLEN - L_FRAME_1k6 );
341 :
342 19229 : j = 0;
343 634557 : for ( i = 0; i < L_FRAME_1k6; i++ )
344 : {
345 615328 : hLFE->prevsynth_buf[i + LFE_PLC_BUFLEN - L_FRAME_1k6] = output_lfe_ch[j];
346 615328 : j += output_frame / L_FRAME_1k6;
347 : }
348 : }
349 :
350 617317 : if ( hLFE->filter_state.order > 0 )
351 : {
352 : /* Low Pass Filter */
353 23795 : ivas_filter_process( &hLFE->filter_state, output_lfe_ch, output_frame );
354 : }
355 :
356 : /* add delay to make overall max(block_offset, 11.5) */
357 617317 : if ( hLFE->lfe_addl_delay > 0 )
358 : {
359 617317 : delay_signal( output_lfe_ch, output_frame, hLFE->lfe_delay_buf, hLFE->lfe_addl_delay );
360 : }
361 :
362 617317 : return;
363 : }
364 :
365 :
366 : /*-------------------------------------------------------------------------
367 : * ivas_create_lfe_dec()
368 : *
369 : * Create, allocate and initialize IVAS decoder LFE handle
370 : *-------------------------------------------------------------------------*/
371 :
372 9546 : ivas_error ivas_create_lfe_dec(
373 : LFE_DEC_HANDLE *hLFE_out, /* o : IVAS LFE decoder structure */
374 : const int32_t output_Fs, /* i : output sampling rate */
375 : const int32_t delay_ns /* i : additional LFE delay to sync other channel outputs */
376 : )
377 : {
378 : float low_pass_delay_dec_out, block_offset_s;
379 : int16_t filt_order, output_frame;
380 : LFE_DEC_HANDLE hLFE;
381 : float lfe_addl_delay_s;
382 : int16_t i, j;
383 : float lfe_block_delay_s;
384 :
385 9546 : low_pass_delay_dec_out = 0;
386 9546 : block_offset_s = 0;
387 :
388 9546 : output_frame = (int16_t) ( output_Fs / FRAMES_PER_SEC );
389 :
390 : /*-----------------------------------------------------------------*
391 : * Allocate LFE handle
392 : *-----------------------------------------------------------------*/
393 :
394 9546 : if ( ( hLFE = (LFE_DEC_HANDLE) malloc( sizeof( LFE_DEC_DATA ) ) ) == NULL )
395 : {
396 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for LFE\n" ) );
397 : }
398 :
399 : /*-----------------------------------------------------------------*
400 : * LFE Window: allocate and initialize
401 : *-----------------------------------------------------------------*/
402 :
403 9546 : if ( ( hLFE->pWindow_state = (LFE_WINDOW_HANDLE) malloc( sizeof( LFE_WINDOW_DATA ) ) ) == NULL )
404 : {
405 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for LFE window structure\n" ) );
406 : }
407 :
408 9546 : ivas_lfe_window_init( hLFE->pWindow_state, output_Fs, output_frame );
409 :
410 : /* Initialization for entropy coding */
411 9546 : hLFE->cum_freq_models[0][0] = ivas_str_lfe_freq_models.entropy_coder_model_fine_sg1;
412 9546 : hLFE->cum_freq_models[0][1] = ivas_str_lfe_freq_models.entropy_coder_model_fine_sg2;
413 9546 : hLFE->cum_freq_models[0][2] = ivas_str_lfe_freq_models.entropy_coder_model_fine_sg3;
414 9546 : hLFE->cum_freq_models[0][3] = ivas_str_lfe_freq_models.entropy_coder_model_fine_sg4;
415 9546 : hLFE->cum_freq_models[1][0] = ivas_str_lfe_freq_models.entropy_coder_model_coarse_sg1;
416 9546 : hLFE->cum_freq_models[1][1] = ivas_str_lfe_freq_models.entropy_coder_model_coarse_sg2;
417 9546 : hLFE->cum_freq_models[1][2] = ivas_str_lfe_freq_models.entropy_coder_model_coarse_sg3;
418 9546 : hLFE->cum_freq_models[1][3] = &ivas_str_lfe_freq_models.entropy_coder_model_coarse_sg4;
419 :
420 : /* delay calculation */
421 9546 : lfe_block_delay_s = ( IVAS_LFE_FADE_NS / 1000000000.f ) + ivas_lfe_lpf_delay[IVAS_FILTER_ORDER_4 - 3];
422 :
423 9546 : block_offset_s = BLOCK_OFFSET_MS * 0.001f;
424 9546 : filt_order = 0;
425 9546 : low_pass_delay_dec_out = 0;
426 9546 : if ( ( delay_ns / 1000000000.f ) > ivas_lfe_lpf_delay[IVAS_FILTER_ORDER_4 - 3] )
427 : {
428 596 : filt_order = 4;
429 596 : low_pass_delay_dec_out = ivas_lfe_lpf_delay[IVAS_FILTER_ORDER_4 - 3];
430 596 : ivas_create_lfe_lpf_dec( &( hLFE->filter_state ), output_Fs );
431 : }
432 :
433 9546 : hLFE->filter_state.order = filt_order;
434 9546 : lfe_block_delay_s = lfe_block_delay_s + low_pass_delay_dec_out;
435 9546 : hLFE->lfe_prior_buf_len = NS2SA( output_Fs, IVAS_LFE_FADE_NS );
436 :
437 9546 : hLFE->bfi_count = 0;
438 9546 : block_offset_s += delay_ns / 1000000000.f;
439 9546 : lfe_addl_delay_s = block_offset_s - lfe_block_delay_s;
440 :
441 9546 : lfe_addl_delay_s = max( 0.0f, lfe_addl_delay_s );
442 9546 : hLFE->lfe_addl_delay = (int16_t) ( lfe_addl_delay_s * output_Fs );
443 9546 : hLFE->delay_ns = delay_ns;
444 :
445 9546 : if ( hLFE->lfe_addl_delay > 0 )
446 : {
447 9546 : if ( ( hLFE->lfe_delay_buf = (float *) malloc( hLFE->lfe_addl_delay * sizeof( float ) ) ) == NULL )
448 : {
449 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for LFE additional delay buffer\n" ) );
450 : }
451 9546 : set_zero( (float *) hLFE->lfe_delay_buf, hLFE->lfe_addl_delay );
452 : }
453 : else
454 : {
455 0 : hLFE->lfe_delay_buf = NULL;
456 : }
457 :
458 : /* Initialization base2 bits for each subgroup for no entropy coding */
459 28638 : for ( i = 0; i < IVAS_MAX_NUM_QUANT_STRATS; i++ )
460 : {
461 95460 : for ( j = 0; j < IVAS_MAX_NUM_DCT_COEF_GROUPS; j++ )
462 : {
463 76368 : hLFE->lfe_dec_indices_coeffs_tbl[i][j] =
464 76368 : (int16_t) ceilf( log2f( (float) ( ivas_lfe_num_ele_in_coder_models[i][j] + 1 ) ) );
465 : }
466 : }
467 :
468 9546 : *hLFE_out = hLFE;
469 :
470 9546 : return IVAS_ERR_OK;
471 : }
472 :
473 :
474 : /*-------------------------------------------------------------------------
475 : * ivas_lfe_dec_close()
476 : *
477 : * Destroy IVAS decoder LFE handle
478 : *-------------------------------------------------------------------------*/
479 :
480 97897 : void ivas_lfe_dec_close(
481 : LFE_DEC_HANDLE *hLFE /* i/o: LFE decoder handle */
482 : )
483 : {
484 97897 : if ( hLFE == NULL || *hLFE == NULL )
485 : {
486 88351 : return;
487 : }
488 :
489 9546 : free( ( *hLFE )->pWindow_state );
490 9546 : ( *hLFE )->pWindow_state = NULL;
491 :
492 9546 : if ( ( *hLFE )->lfe_delay_buf != NULL )
493 : {
494 9546 : free( ( *hLFE )->lfe_delay_buf );
495 9546 : ( *hLFE )->lfe_delay_buf = NULL;
496 : }
497 :
498 9546 : free( ( *hLFE ) );
499 9546 : ( *hLFE ) = NULL;
500 :
501 9546 : return;
502 : }
|
