1 /*
2 * Copyright (C) 2013 - 2016 Sony Corporation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "ldacBT_internal.h"
18
19
20
21 enum {
22 /* 2-DH5 */
23 LDACBT_2DH5_02, LDACBT_2DH5_03, LDACBT_2DH5_04, LDACBT_2DH5_05,
24 LDACBT_2DH5_06, LDACBT_2DH5_07, LDACBT_2DH5_08, LDACBT_2DH5_09, LDACBT_2DH5_10,
25 LDACBT_2DH5_11, LDACBT_2DH5_12, LDACBT_2DH5_13, LDACBT_2DH5_14,
26 };
27
28 #define LDACBT_NO_DEF_ -1
29 DECLFUNC const LDACBT_EQMID_PROPERTY tbl_ldacbt_eqmid_property[] = {
30 /* kbps, ID , label, ID for 2DH5 */
31 /* 990 */ { LDACBT_EQMID_HQ, "HQ" , LDACBT_2DH5_02 },
32 /* 660 */ { LDACBT_EQMID_SQ, "SQ" , LDACBT_2DH5_03 },
33 /* 492 */ { LDACBT_EQMID_Q0, "Q0" , LDACBT_2DH5_04 },
34 /* 396 */ { LDACBT_EQMID_Q1, "Q1" , LDACBT_2DH5_05 },
35 /* 330 */ { LDACBT_EQMID_MQ, "MQ" , LDACBT_2DH5_06 },
36 /* 282 */ { LDACBT_EQMID_Q2, "Q2" , LDACBT_2DH5_07 },
37 /* 246 */ { LDACBT_EQMID_Q3, "Q3" , LDACBT_2DH5_08 },
38 /* 216 */ { LDACBT_EQMID_Q4, "Q4" , LDACBT_2DH5_09 },
39 /* 198 */ { LDACBT_EQMID_Q5, "Q5" , LDACBT_2DH5_10 },
40 /* 180 */ { LDACBT_EQMID_Q6, "Q6" , LDACBT_2DH5_11 },
41 /* 162 */ { LDACBT_EQMID_Q7, "Q7" , LDACBT_2DH5_12 },
42 /* 150 */ { LDACBT_EQMID_Q8, "Q8" , LDACBT_2DH5_13 },
43 /* 138 */ { LDACBT_EQMID_END, "Q9" , LDACBT_2DH5_14 },
44 };
45
46 /* LDAC config table
47 * - NFRM/PCKT must be less than 16.
48 */
49 DECLFUNC const LDACBT_CONFIG tbl_ldacbt_config[] = {
50 /*
51 * index , NFRM , LDAC , FRM
52 * , ---- , FRM , LEN
53 * , PCKT , LEN , /CH
54 * , , [byte], [byte]
55 */
56 { LDACBT_2DH5_02, 2, 330, 165},
57 { LDACBT_2DH5_03, 3, 220, 110},
58 { LDACBT_2DH5_04, 4, 164, 82},
59 { LDACBT_2DH5_05, 5, 132, 66},
60 { LDACBT_2DH5_06, 6, 110, 55},
61 { LDACBT_2DH5_07, 7, 94, 47},
62 { LDACBT_2DH5_08, 8, 82, 41},
63 { LDACBT_2DH5_09, 9, 72, 36},
64 { LDACBT_2DH5_10, 10, 66, 33},
65 { LDACBT_2DH5_11, 11, 60, 30},
66 { LDACBT_2DH5_12, 12, 54, 27},
67 { LDACBT_2DH5_13, 13, 50, 25},
68 { LDACBT_2DH5_14, 14, 46, 23},
69 };
70
71
72 /* Clear LDAC handle parameters */
ldacBT_param_clear(HANDLE_LDAC_BT hLdacBT)73 DECLFUNC void ldacBT_param_clear(HANDLE_LDAC_BT hLdacBT)
74 {
75 int ich;
76 if( hLdacBT == NULL ) { return ; }
77 hLdacBT->proc_mode = LDACBT_PROCMODE_UNSET;
78 hLdacBT->error_code = LDACBT_ERR_NONE;
79 hLdacBT->error_code_api = LDACBT_ERR_NONE;
80
81 hLdacBT->frm_samples = 0;
82 hLdacBT->sfid = UNSET;
83 hLdacBT->pcm.sf = UNSET;
84 hLdacBT->tx.mtu = UNSET;
85 hLdacBT->tx.tx_size = UNSET;
86 hLdacBT->tx.pkt_hdr_sz = UNSET;
87 hLdacBT->frmlen_tx = UNSET;
88 hLdacBT->tx.nfrm_in_pkt = UNSET;
89 hLdacBT->pcm.ch = 0;
90 hLdacBT->pcm.fmt = LDACBT_SMPL_FMT_S24;
91 hLdacBT->nshift = 0;
92 hLdacBT->frmlen = UNSET;
93 hLdacBT->frm_status = 0;
94 hLdacBT->bitrate = 0;
95 /* for alter frame length */
96 hLdacBT->tgt_nfrm_in_pkt = UNSET;
97 hLdacBT->tgt_frmlen = UNSET;
98 hLdacBT->tgt_eqmid = UNSET;
99 hLdacBT->stat_alter_op = LDACBT_ALTER_OP__NON;
100
101 hLdacBT->cm = UNSET;
102 hLdacBT->cci = UNSET;
103 hLdacBT->eqmid = UNSET;
104 hLdacBT->transport = UNSET;
105
106 clear_data_ldac( hLdacBT->ldac_trns_frm_buf.buf, sizeof(hLdacBT->ldac_trns_frm_buf.buf));
107 hLdacBT->ldac_trns_frm_buf.used = 0;
108 hLdacBT->ldac_trns_frm_buf.nfrm_in = 0;
109
110 clear_data_ldac( hLdacBT->pcmring.buf, sizeof(hLdacBT->pcmring.buf));
111 hLdacBT->pcmring.wp = 0;
112 hLdacBT->pcmring.rp = 0;
113 hLdacBT->pcmring.nsmpl = 0;
114 /* work buffer for I/O */
115 for( ich = 0; ich < LDAC_PRCNCH; ich++ ){
116 hLdacBT->ap_pcm[ich] = &hLdacBT->a_pcm[ ich * LDACBT_MAX_LSU * LDACBT_PCM_WLEN_MAX ];
117 }
118 hLdacBT->pp_pcm = hLdacBT->ap_pcm;
119 clear_data_ldac( hLdacBT->a_pcm, LDAC_PRCNCH * LDACBT_MAX_LSU * LDACBT_PCM_WLEN_MAX );
120
121 }
122
123 /* get ldaclib error code */
ldacBT_check_ldaclib_error_code(HANDLE_LDAC_BT hLdacBT)124 DECLFUNC int ldacBT_check_ldaclib_error_code(HANDLE_LDAC_BT hLdacBT)
125 {
126 HANDLE_LDAC hData;
127 int error_code, internal_error_code;
128
129 if( hLdacBT == NULL ){ return LDACBT_E_FAIL; }
130 if( (hData = hLdacBT->hLDAC) == NULL ){ return LDACBT_E_FAIL; }
131
132 ldaclib_get_error_code(hData, &error_code);
133
134 ldaclib_get_internal_error_code(hData, &internal_error_code);
135
136 hLdacBT->error_code = error_code << 10 | internal_error_code;
137
138 return LDACBT_S_OK;
139 }
140
141 /* Assertions. */
ldacBT_assert_cm(int cm)142 DECLFUNC int ldacBT_assert_cm( int cm )
143 {
144 if( (cm != LDACBT_CHANNEL_MODE_STEREO )
145 && (cm != LDACBT_CHANNEL_MODE_DUAL_CHANNEL )
146 && (cm != LDACBT_CHANNEL_MODE_MONO )
147 ){
148 return LDACBT_ERR_ASSERT_CHANNEL_MODE;
149 }
150 return LDACBT_ERR_NONE;
151 }
ldacBT_assert_cci(int cci)152 UNUSED_ATTR DECLFUNC int ldacBT_assert_cci( int cci )
153 {
154 if( (cci != LDAC_CCI_STEREO )
155 && (cci != LDAC_CCI_DUAL_CHANNEL )
156 && (cci != LDAC_CCI_MONO )
157 ){
158 return LDACBT_ERR_ASSERT_CHANNEL_CONFIG;
159 }
160 return LDACBT_ERR_NONE;
161 }
ldacBT_assert_sample_format(LDACBT_SMPL_FMT_T fmt)162 DECLFUNC int ldacBT_assert_sample_format( LDACBT_SMPL_FMT_T fmt )
163 {
164 #ifndef _32BIT_FIXED_POINT
165 if( (fmt != LDACBT_SMPL_FMT_S16)
166 && (fmt != LDACBT_SMPL_FMT_S24)
167 && (fmt != LDACBT_SMPL_FMT_S32)
168 && (fmt != LDACBT_SMPL_FMT_F32)
169 ){
170 #else /* _32BIT_FIXED_POINT */
171 if( (fmt != LDACBT_SMPL_FMT_S16)
172 && (fmt != LDACBT_SMPL_FMT_S24)
173 && (fmt != LDACBT_SMPL_FMT_S32)
174 ){
175 #endif /* _32BIT_FIXED_POINT */
176 return LDACBT_ERR_ILL_SMPL_FORMAT;
177 }
178 return LDACBT_ERR_NONE;
179 }
180 DECLFUNC int ldacBT_assert_pcm_sampling_freq( int sampling_freq )
181 {
182 if( (sampling_freq != 1*44100) && (sampling_freq != 1*48000)
183 && (sampling_freq != 2*44100) && (sampling_freq != 2*48000)
184 ){
185 return LDACBT_ERR_ILL_SAMPLING_FREQ;
186 }
187 return LDACBT_ERR_NONE;
188 }
189 DECLFUNC int ldacBT_assert_mtu( int mtu )
190 {
191 if( mtu < LDACBT_MTU_REQUIRED ){
192 return LDACBT_ERR_ILL_MTU_SIZE;
193 }
194 return LDACBT_ERR_NONE;
195 }
196 DECLFUNC int ldacBT_assert_eqmid( int eqmid )
197 {
198 if( (eqmid == LDACBT_EQMID_HQ) || (eqmid == LDACBT_EQMID_SQ) || (eqmid == LDACBT_EQMID_MQ)){
199 return LDACBT_ERR_NONE;
200 }
201
202 return LDACBT_ERR_ILL_EQMID;
203 }
204
205 /* LDAC set Encode Quality Mode index core */
206 DECLFUNC void ldacBT_set_eqmid_core( HANDLE_LDAC_BT hLdacBT, int eqmid )
207 {
208 /* "eqmid" must be checked before calling this function. */
209 /* just update tgt_eqmid */
210 P_LDACBT_CONFIG pCfg;
211 pCfg = ldacBT_get_config( eqmid, hLdacBT->tx.pkt_type );
212 hLdacBT->tgt_eqmid = eqmid;
213 hLdacBT->tgt_frmlen = hLdacBT->pcm.ch * pCfg->frmlen_1ch;
214 hLdacBT->tgt_frmlen -= LDACBT_FRMHDRBYTES;
215 hLdacBT->tgt_nfrm_in_pkt = pCfg->nfrm_in_pkt;
216
217 }
218
219 /* Split LR interleaved PCM into buffer that for LDAC encode. */
220 DECLFUNC void ldacBT_prepare_pcm_encode( void *pbuff, char **ap_pcm, int nsmpl, int nch,
221 LDACBT_SMPL_FMT_T fmt )
222 {
223 int i;
224 if( nch == 2 ){
225 if( fmt == LDACBT_SMPL_FMT_S16 ){
226 short *p_pcm_16 = (short *)pbuff;
227 short *p_lch_16 = (short *)ap_pcm[0];
228 short *p_rch_16 = (short *)ap_pcm[1];
229 for (i = 0; i < nsmpl; i++) {
230 *p_lch_16++ = p_pcm_16[0];
231 *p_rch_16++ = p_pcm_16[1];
232 p_pcm_16+=2;
233 }
234 }
235 else if( fmt == LDACBT_SMPL_FMT_S24 ){
236 char *p_pcm_8 = (char *)pbuff;
237 char *p_lch_8 = (char *)ap_pcm[0];
238 char *p_rch_8 = (char *)ap_pcm[1];
239 #if __BYTE_ORDER == __LITTLE_ENDIAN
240 for (i = 0; i < nsmpl; i++) {
241 *p_lch_8++ = p_pcm_8[0];
242 *p_lch_8++ = p_pcm_8[1];
243 *p_lch_8++ = p_pcm_8[2];
244 p_pcm_8+=3;
245 *p_rch_8++ = p_pcm_8[0];
246 *p_rch_8++ = p_pcm_8[1];
247 *p_rch_8++ = p_pcm_8[2];
248 p_pcm_8+=3;
249 }
250 #else /* __BYTE_ORDER */
251 #error unsupported byte order
252 #endif /* #if __BYTE_ORDER == __LITTLE_ENDIAN */
253 }
254 else if ( fmt == LDACBT_SMPL_FMT_S32 ){
255 char *p_pcm_8 = (char *)pbuff;
256 char *p_lch_8 = (char *)ap_pcm[0];
257 char *p_rch_8 = (char *)ap_pcm[1];
258 #if __BYTE_ORDER == __LITTLE_ENDIAN
259 for (i = 0; i < nsmpl; i++) {
260 *p_lch_8++ = p_pcm_8[0]; *p_lch_8++ = p_pcm_8[1]; *p_lch_8++ = p_pcm_8[2]; *p_lch_8++ = p_pcm_8[3];
261 p_pcm_8+=4;
262 *p_rch_8++ = p_pcm_8[0]; *p_rch_8++ = p_pcm_8[1]; *p_rch_8++ = p_pcm_8[2]; *p_rch_8++ = p_pcm_8[3];
263 p_pcm_8+=4;
264 }
265 #else /* __BYTE_ORDER */
266 #error unsupported byte order
267 #endif /* #if __BYTE_ORDER == __LITTLE_ENDIAN */
268 }
269 else if ( fmt == LDACBT_SMPL_FMT_F32 ){
270 float *p_pcm = (float *)pbuff;
271 float *p_lch = (float *)ap_pcm[0];
272 float *p_rch = (float *)ap_pcm[1];
273 for (i = 0; i < nsmpl; i++) {
274 *p_lch++ = p_pcm[0];
275 p_pcm++;
276 *p_rch++ = p_pcm[0];
277 p_pcm++;
278 }
279 }
280 else{;} /* never be happend */
281 }
282 else if( nch == 1 ){
283 switch(fmt){
284 case LDACBT_SMPL_FMT_S16:
285 copy_data_ldac( pbuff, ap_pcm[0], 2*nsmpl );
286 break;
287 case LDACBT_SMPL_FMT_S24:
288 copy_data_ldac( pbuff, ap_pcm[0], 3*nsmpl );
289 break;
290 case LDACBT_SMPL_FMT_S32:
291 case LDACBT_SMPL_FMT_F32:
292 copy_data_ldac( pbuff, ap_pcm[0], 4*nsmpl );
293 break;
294 default:
295 break;
296 }
297 }
298 }
299
300
301 /* update framelength */
302 DECLFUNC int ldacBT_update_frmlen(HANDLE_LDAC_BT hLdacBT, int frmlen)
303 {
304 int status, sf, ch, fl, fl_per_ch;
305 int nbasebands, grad_mode, grad_qu_l, grad_qu_h, grad_ofst_l, grad_ofst_h, abc_flag;
306 LDACBT_TX_INFO *ptx;
307 LDAC_RESULT result;
308 status = LDACBT_E_FAIL;
309
310 if( hLdacBT == NULL ){
311 return LDACBT_E_FAIL;
312 }
313 sf = hLdacBT->pcm.sf; /* sampling frequency */
314 ch = hLdacBT->pcm.ch; /* number of channels */
315 ptx = &hLdacBT->tx;
316
317 ldac_setup_AGAIN:
318 /* update LDAC parameters. */
319
320
321 if( frmlen == UNSET ){
322 goto ldac_setup_END;
323 }
324
325 /* check & update frameLength */
326 ldaclib_get_encode_frame_length( hLdacBT->hLDAC, &fl );
327 if( fl == 0 ){ // This meens that the handle was not initialized yet. Shall not happen.
328
329 goto ldac_setup_END;
330 }
331 else if( frmlen == fl ){
332 /* No need to update frame length. Just update bitrate information. */
333 status = LDACBT_S_OK;
334 hLdacBT->bitrate = ldacBT_frmlen_to_bitrate( fl, 1, sf, hLdacBT->frm_samples );
335 goto ldac_setup_END;
336 }
337
338 /* Time to update the frame_length. */
339 /* Get ldac encoding information for frame_length. */
340 fl_per_ch = (frmlen+LDACBT_FRMHDRBYTES) / ch;
341 result = ldaclib_get_encode_setting( fl_per_ch, hLdacBT->sfid, &nbasebands,
342 &grad_mode, &grad_qu_l, &grad_qu_h, &grad_ofst_l, &grad_ofst_h, &abc_flag);
343 if (LDAC_FAILED(result)) {
344 goto ldac_setup_END;
345 }
346 /* Set Encoding Information */
347 result = ldaclib_set_encode_info( hLdacBT->hLDAC, nbasebands, grad_mode,
348 grad_qu_l, grad_qu_h, grad_ofst_l, grad_ofst_h, abc_flag);
349 if (LDAC_FAILED(result)) {
350 ldacBT_check_ldaclib_error_code(hLdacBT);
351 goto ldac_setup_END;
352 }
353
354 if( !LDAC_SUCCEEDED(ldaclib_set_encode_frame_length( hLdacBT->hLDAC, frmlen ))){
355 goto ldac_setup_END;
356 }
357
358 /* Update parameters in handle. */
359 hLdacBT->frmlen = frmlen;
360 hLdacBT->frmlen_tx = LDACBT_FRMHDRBYTES + frmlen;
361 ptx->nfrm_in_pkt = ptx->tx_size / hLdacBT->frmlen_tx;
362 if( ptx->nfrm_in_pkt > LDACBT_NFRM_TX_MAX ){
363 ptx->nfrm_in_pkt = LDACBT_NFRM_TX_MAX;
364 }
365 else if( ptx->nfrm_in_pkt < 2 ){
366 /* Not allowed 1frame/packet transportation for current version of LDAC A2DP */
367 if( frmlen <= (ptx->tx_size / 2 - LDACBT_FRMHDRBYTES)){
368 goto ldac_setup_END;
369 }
370 frmlen = ptx->tx_size / 2 - LDACBT_FRMHDRBYTES;
371 goto ldac_setup_AGAIN;
372 }
373 /* Update bitrate and EQMID. */
374 hLdacBT->bitrate = ldacBT_frmlen_to_bitrate( frmlen, 1, sf, hLdacBT->frm_samples );
375 hLdacBT->eqmid = ldacBT_get_eqmid_from_frmlen( frmlen, ch, hLdacBT->transport, ptx->pkt_type );
376 if( hLdacBT->tgt_eqmid == UNSET){
377 hLdacBT->eqmid = UNSET;
378 }
379 status = LDACBT_S_OK;
380
381 ldac_setup_END:
382 return status;
383 }
384
385 /* Get channel_config_index from channel_mode.
386 * The argument cm, channel_mode, must be checked by function ldacBT_assert_cm() before calling this
387 * function.
388 */
389 DECLFUNC int ldacBT_cm_to_cci( int cm )
390 {
391 if( cm == LDACBT_CHANNEL_MODE_STEREO ){
392 return LDAC_CCI_STEREO;
393 }
394 else if( cm == LDACBT_CHANNEL_MODE_DUAL_CHANNEL ){
395 return LDAC_CCI_DUAL_CHANNEL;
396 }
397 else/* if( cm == LDACBT_CHANNEL_MODE_MONO )*/{
398 return LDAC_CCI_MONO;
399 }
400 }
401
402 /* Get channel_mode from channel_config_index.
403 * The argument cci, channel_config_index, must be checked by the function ldacBT_assert_cci() before
404 * calling this function.
405 */
406 UNUSED_ATTR DECLFUNC int ldacBT_cci_to_cm( int cci )
407 {
408 if( cci == LDAC_CCI_STEREO ){
409 return LDACBT_CHANNEL_MODE_STEREO;
410 }
411 else if( cci == LDAC_CCI_DUAL_CHANNEL ){
412 return LDACBT_CHANNEL_MODE_DUAL_CHANNEL;
413 }
414 else/* if( cci == LDAC_CCI_MONO )*/{
415 return LDACBT_CHANNEL_MODE_MONO;
416 }
417 }
418
419 /* Get bitrate from frame length */
420 DECLFUNC int ldacBT_frmlen_to_bitrate( int frmlen, int flgFrmHdr, int sf, int frame_samples )
421 {
422 int bitrate;
423 if( (frmlen == UNSET) || (flgFrmHdr == UNSET) || (sf == UNSET) || (frame_samples == UNSET) ){
424 return LDACBT_E_FAIL;
425 }
426 if( flgFrmHdr ){
427 frmlen += LDACBT_FRMHDRBYTES;
428 }
429 bitrate = frmlen * sf / frame_samples / (1000 / 8);
430 return bitrate;
431 }
432
433 /* Get Encode Quality Mode index property */
434 DECLFUNC P_LDACBT_EQMID_PROPERTY ldacBT_get_eqmid_conv_tbl ( int eqmid )
435 {
436 int i, tbl_size;
437 P_LDACBT_EQMID_PROPERTY pEqmIdProp;
438
439 pEqmIdProp = (P_LDACBT_EQMID_PROPERTY)tbl_ldacbt_eqmid_property;
440 tbl_size = (int)(sizeof(tbl_ldacbt_eqmid_property)/sizeof(tbl_ldacbt_eqmid_property[0]));
441 /* Search current eqmid */
442 for( i = 0; i < tbl_size; ++i, ++pEqmIdProp ){
443 if( pEqmIdProp->eqmid == eqmid ){
444 return pEqmIdProp;
445 }
446 }
447 return NULL;
448 }
449
450 /* Get altered Encode Quality Mode index */
451 DECLFUNC int ldacBT_get_altered_eqmid ( HANDLE_LDAC_BT hLdacBT, int priority )
452 {
453 int i, eqmid_0, eqmid_1, eqmid_new, tbl_size;
454 if( priority == 0 ){ return LDACBT_E_FAIL; }
455 switch( hLdacBT->tx.pkt_type ){
456 case _2_DH5:
457 break;
458 default:
459 return LDACBT_E_FAIL;
460 }
461 tbl_size = (int)(sizeof(tbl_ldacbt_eqmid_property)/sizeof(tbl_ldacbt_eqmid_property[0]));
462 /* Search target eqmid */
463 for( i = 0; i < tbl_size; ++i ){
464 if( tbl_ldacbt_eqmid_property[i].eqmid == hLdacBT->tgt_eqmid ){
465 break;
466 }
467 }
468 eqmid_0 = i;
469 eqmid_1 = eqmid_0 - priority;
470 if( eqmid_1 < 0 ){ return LDACBT_E_FAIL; }
471 if( eqmid_1 >= tbl_size ){ return LDACBT_E_FAIL; }
472
473 eqmid_new = tbl_ldacbt_eqmid_property[eqmid_1].eqmid;
474 for( i = 0; i < tbl_size; ++i ){
475 if( tbl_ldacbt_eqmid_property[i].eqmid == LDACBT_LIMIT_ALTER_EQMID_PRIORITY ){
476 break;
477 }
478 }
479 if( eqmid_1 > i ){ return LDACBT_E_FAIL; }
480 return eqmid_new;
481
482 }
483
484 /* Get LDAC bitrate info from Encode Quality Mode Index */
485 DECLFUNC P_LDACBT_CONFIG ldacBT_get_config( int ldac_bt_mode, int pkt_type )
486 {
487 int i, tbl_size, ldac_mode_id;
488 P_LDACBT_EQMID_PROPERTY pEqmIdProp;
489 P_LDACBT_CONFIG pCfg;
490
491 if( (pEqmIdProp = ldacBT_get_eqmid_conv_tbl( ldac_bt_mode )) == NULL ){
492 return NULL;
493 }
494
495 if( pkt_type == _2_DH5 ){ ldac_mode_id = pEqmIdProp->id_for_2DH5;}
496 else{
497 return NULL;
498 }
499
500 pCfg = (P_LDACBT_CONFIG)tbl_ldacbt_config;
501 tbl_size = (int)(sizeof(tbl_ldacbt_config)/sizeof(tbl_ldacbt_config[0]));
502 for( i = 0; i < tbl_size; ++i, ++pCfg ){
503 if( ldac_mode_id == pCfg->id ){
504 return pCfg;
505 }
506 }
507 return NULL; /* not found */
508 }
509
510 /* Get Encode Quality Mode Index from framelength */
511 DECLFUNC int ldacBT_get_eqmid_from_frmlen( int frmlen, int nch, int flgFrmHdr, int pktType )
512 {
513 int i, n, eqmid;
514 P_LDACBT_CONFIG pCfg;
515
516 if( flgFrmHdr ){
517 frmlen += LDACBT_FRMHDRBYTES;
518 }
519 if( nch > 0 ){
520 frmlen /= nch;
521 }
522
523 eqmid = LDACBT_EQMID_END;
524 n = (int)(sizeof(tbl_ldacbt_eqmid_property)/sizeof(tbl_ldacbt_eqmid_property[0]));
525 for( i = 0; i < n; ++i ){
526 if( (pCfg = ldacBT_get_config( tbl_ldacbt_eqmid_property[i].eqmid, pktType )) != NULL ){
527 if( frmlen >= pCfg->frmlen_1ch){
528 eqmid = tbl_ldacbt_eqmid_property[i].eqmid;
529 break;
530 }
531 }
532 }
533 return eqmid;
534 }
535
536