| /* |
| * Copyright (C) 2013 - 2016 Sony Corporation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "ldacBT_internal.h" |
| |
| |
| |
| enum { |
| /* 2-DH5 */ |
| LDACBT_2DH5_02, LDACBT_2DH5_03, LDACBT_2DH5_04, LDACBT_2DH5_05, |
| LDACBT_2DH5_06, LDACBT_2DH5_07, LDACBT_2DH5_08, LDACBT_2DH5_09, LDACBT_2DH5_10, |
| LDACBT_2DH5_11, LDACBT_2DH5_12, LDACBT_2DH5_13, LDACBT_2DH5_14, |
| }; |
| |
| #define LDACBT_NO_DEF_ -1 |
| DECLFUNC const LDACBT_EQMID_PROPERTY tbl_ldacbt_eqmid_property[] = { |
| /* kbps, ID , label, ID for 2DH5 */ |
| /* 990 */ { LDACBT_EQMID_HQ, "HQ" , LDACBT_2DH5_02 }, |
| /* 660 */ { LDACBT_EQMID_SQ, "SQ" , LDACBT_2DH5_03 }, |
| /* 492 */ { LDACBT_EQMID_Q0, "Q0" , LDACBT_2DH5_04 }, |
| /* 396 */ { LDACBT_EQMID_Q1, "Q1" , LDACBT_2DH5_05 }, |
| /* 330 */ { LDACBT_EQMID_MQ, "MQ" , LDACBT_2DH5_06 }, |
| /* 282 */ { LDACBT_EQMID_Q2, "Q2" , LDACBT_2DH5_07 }, |
| /* 246 */ { LDACBT_EQMID_Q3, "Q3" , LDACBT_2DH5_08 }, |
| /* 216 */ { LDACBT_EQMID_Q4, "Q4" , LDACBT_2DH5_09 }, |
| /* 198 */ { LDACBT_EQMID_Q5, "Q5" , LDACBT_2DH5_10 }, |
| /* 180 */ { LDACBT_EQMID_Q6, "Q6" , LDACBT_2DH5_11 }, |
| /* 162 */ { LDACBT_EQMID_Q7, "Q7" , LDACBT_2DH5_12 }, |
| /* 150 */ { LDACBT_EQMID_Q8, "Q8" , LDACBT_2DH5_13 }, |
| /* 138 */ { LDACBT_EQMID_END, "Q9" , LDACBT_2DH5_14 }, |
| }; |
| |
| /* LDAC config table |
| * - NFRM/PCKT must be less than 16. |
| */ |
| DECLFUNC const LDACBT_CONFIG tbl_ldacbt_config[] = { |
| /* |
| * index , NFRM , LDAC , FRM |
| * , ---- , FRM , LEN |
| * , PCKT , LEN , /CH |
| * , , [byte], [byte] |
| */ |
| { LDACBT_2DH5_02, 2, 330, 165}, |
| { LDACBT_2DH5_03, 3, 220, 110}, |
| { LDACBT_2DH5_04, 4, 164, 82}, |
| { LDACBT_2DH5_05, 5, 132, 66}, |
| { LDACBT_2DH5_06, 6, 110, 55}, |
| { LDACBT_2DH5_07, 7, 94, 47}, |
| { LDACBT_2DH5_08, 8, 82, 41}, |
| { LDACBT_2DH5_09, 9, 72, 36}, |
| { LDACBT_2DH5_10, 10, 66, 33}, |
| { LDACBT_2DH5_11, 11, 60, 30}, |
| { LDACBT_2DH5_12, 12, 54, 27}, |
| { LDACBT_2DH5_13, 13, 50, 25}, |
| { LDACBT_2DH5_14, 14, 46, 23}, |
| }; |
| |
| |
| /* Clear LDAC handle parameters */ |
| DECLFUNC void ldacBT_param_clear(HANDLE_LDAC_BT hLdacBT) |
| { |
| int ich; |
| if( hLdacBT == NULL ) { return ; } |
| hLdacBT->proc_mode = LDACBT_PROCMODE_UNSET; |
| hLdacBT->error_code = LDACBT_ERR_NONE; |
| hLdacBT->error_code_api = LDACBT_ERR_NONE; |
| |
| hLdacBT->frm_samples = 0; |
| hLdacBT->sfid = UNSET; |
| hLdacBT->pcm.sf = UNSET; |
| hLdacBT->tx.mtu = UNSET; |
| hLdacBT->tx.tx_size = UNSET; |
| hLdacBT->tx.pkt_hdr_sz = UNSET; |
| hLdacBT->frmlen_tx = UNSET; |
| hLdacBT->tx.nfrm_in_pkt = UNSET; |
| hLdacBT->pcm.ch = 0; |
| hLdacBT->pcm.fmt = LDACBT_SMPL_FMT_S24; |
| hLdacBT->nshift = 0; |
| hLdacBT->frmlen = UNSET; |
| hLdacBT->frm_status = 0; |
| hLdacBT->bitrate = 0; |
| /* for alter frame length */ |
| hLdacBT->tgt_nfrm_in_pkt = UNSET; |
| hLdacBT->tgt_frmlen = UNSET; |
| hLdacBT->tgt_eqmid = UNSET; |
| hLdacBT->stat_alter_op = LDACBT_ALTER_OP__NON; |
| |
| hLdacBT->cm = UNSET; |
| hLdacBT->cci = UNSET; |
| hLdacBT->eqmid = UNSET; |
| hLdacBT->transport = UNSET; |
| |
| clear_data_ldac( hLdacBT->ldac_trns_frm_buf.buf, sizeof(hLdacBT->ldac_trns_frm_buf.buf)); |
| hLdacBT->ldac_trns_frm_buf.used = 0; |
| hLdacBT->ldac_trns_frm_buf.nfrm_in = 0; |
| |
| clear_data_ldac( hLdacBT->pcmring.buf, sizeof(hLdacBT->pcmring.buf)); |
| hLdacBT->pcmring.wp = 0; |
| hLdacBT->pcmring.rp = 0; |
| hLdacBT->pcmring.nsmpl = 0; |
| /* work buffer for I/O */ |
| for( ich = 0; ich < LDAC_PRCNCH; ich++ ){ |
| hLdacBT->ap_pcm[ich] = &hLdacBT->a_pcm[ ich * LDACBT_MAX_LSU * LDACBT_PCM_WLEN_MAX ]; |
| } |
| hLdacBT->pp_pcm = hLdacBT->ap_pcm; |
| clear_data_ldac( hLdacBT->a_pcm, LDAC_PRCNCH * LDACBT_MAX_LSU * LDACBT_PCM_WLEN_MAX ); |
| |
| } |
| |
| /* get ldaclib error code */ |
| DECLFUNC int ldacBT_check_ldaclib_error_code(HANDLE_LDAC_BT hLdacBT) |
| { |
| HANDLE_LDAC hData; |
| int error_code, internal_error_code; |
| |
| if( hLdacBT == NULL ){ return LDACBT_E_FAIL; } |
| if( (hData = hLdacBT->hLDAC) == NULL ){ return LDACBT_E_FAIL; } |
| |
| ldaclib_get_error_code(hData, &error_code); |
| |
| ldaclib_get_internal_error_code(hData, &internal_error_code); |
| |
| hLdacBT->error_code = error_code << 10 | internal_error_code; |
| |
| return LDACBT_S_OK; |
| } |
| |
| /* Assertions. */ |
| DECLFUNC int ldacBT_assert_cm( int cm ) |
| { |
| if( (cm != LDACBT_CHANNEL_MODE_STEREO ) |
| && (cm != LDACBT_CHANNEL_MODE_DUAL_CHANNEL ) |
| && (cm != LDACBT_CHANNEL_MODE_MONO ) |
| ){ |
| return LDACBT_ERR_ASSERT_CHANNEL_MODE; |
| } |
| return LDACBT_ERR_NONE; |
| } |
| UNUSED_ATTR DECLFUNC int ldacBT_assert_cci( int cci ) |
| { |
| if( (cci != LDAC_CCI_STEREO ) |
| && (cci != LDAC_CCI_DUAL_CHANNEL ) |
| && (cci != LDAC_CCI_MONO ) |
| ){ |
| return LDACBT_ERR_ASSERT_CHANNEL_CONFIG; |
| } |
| return LDACBT_ERR_NONE; |
| } |
| DECLFUNC int ldacBT_assert_sample_format( LDACBT_SMPL_FMT_T fmt ) |
| { |
| #ifndef _32BIT_FIXED_POINT |
| if( (fmt != LDACBT_SMPL_FMT_S16) |
| && (fmt != LDACBT_SMPL_FMT_S24) |
| && (fmt != LDACBT_SMPL_FMT_S32) |
| && (fmt != LDACBT_SMPL_FMT_F32) |
| ){ |
| #else /* _32BIT_FIXED_POINT */ |
| if( (fmt != LDACBT_SMPL_FMT_S16) |
| && (fmt != LDACBT_SMPL_FMT_S24) |
| && (fmt != LDACBT_SMPL_FMT_S32) |
| ){ |
| #endif /* _32BIT_FIXED_POINT */ |
| return LDACBT_ERR_ILL_SMPL_FORMAT; |
| } |
| return LDACBT_ERR_NONE; |
| } |
| DECLFUNC int ldacBT_assert_pcm_sampling_freq( int sampling_freq ) |
| { |
| if( (sampling_freq != 1*44100) && (sampling_freq != 1*48000) |
| && (sampling_freq != 2*44100) && (sampling_freq != 2*48000) |
| ){ |
| return LDACBT_ERR_ILL_SAMPLING_FREQ; |
| } |
| return LDACBT_ERR_NONE; |
| } |
| DECLFUNC int ldacBT_assert_mtu( int mtu ) |
| { |
| if( mtu < LDACBT_MTU_REQUIRED ){ |
| return LDACBT_ERR_ILL_MTU_SIZE; |
| } |
| return LDACBT_ERR_NONE; |
| } |
| DECLFUNC int ldacBT_assert_eqmid( int eqmid ) |
| { |
| if( (eqmid == LDACBT_EQMID_HQ) || (eqmid == LDACBT_EQMID_SQ) || (eqmid == LDACBT_EQMID_MQ)){ |
| return LDACBT_ERR_NONE; |
| } |
| |
| return LDACBT_ERR_ILL_EQMID; |
| } |
| |
| /* LDAC set Encode Quality Mode index core */ |
| DECLFUNC void ldacBT_set_eqmid_core( HANDLE_LDAC_BT hLdacBT, int eqmid ) |
| { |
| /* "eqmid" must be checked before calling this function. */ |
| /* just update tgt_eqmid */ |
| P_LDACBT_CONFIG pCfg; |
| pCfg = ldacBT_get_config( eqmid, hLdacBT->tx.pkt_type ); |
| hLdacBT->tgt_eqmid = eqmid; |
| hLdacBT->tgt_frmlen = hLdacBT->pcm.ch * pCfg->frmlen_1ch; |
| hLdacBT->tgt_frmlen -= LDACBT_FRMHDRBYTES; |
| hLdacBT->tgt_nfrm_in_pkt = pCfg->nfrm_in_pkt; |
| |
| } |
| |
| /* Split LR interleaved PCM into buffer that for LDAC encode. */ |
| DECLFUNC void ldacBT_prepare_pcm_encode( void *pbuff, char **ap_pcm, int nsmpl, int nch, |
| LDACBT_SMPL_FMT_T fmt ) |
| { |
| int i; |
| if( nch == 2 ){ |
| if( fmt == LDACBT_SMPL_FMT_S16 ){ |
| short *p_pcm_16 = (short *)pbuff; |
| short *p_lch_16 = (short *)ap_pcm[0]; |
| short *p_rch_16 = (short *)ap_pcm[1]; |
| for (i = 0; i < nsmpl; i++) { |
| *p_lch_16++ = p_pcm_16[0]; |
| *p_rch_16++ = p_pcm_16[1]; |
| p_pcm_16+=2; |
| } |
| } |
| else if( fmt == LDACBT_SMPL_FMT_S24 ){ |
| char *p_pcm_8 = (char *)pbuff; |
| char *p_lch_8 = (char *)ap_pcm[0]; |
| char *p_rch_8 = (char *)ap_pcm[1]; |
| #if __BYTE_ORDER == __LITTLE_ENDIAN |
| for (i = 0; i < nsmpl; i++) { |
| *p_lch_8++ = p_pcm_8[0]; |
| *p_lch_8++ = p_pcm_8[1]; |
| *p_lch_8++ = p_pcm_8[2]; |
| p_pcm_8+=3; |
| *p_rch_8++ = p_pcm_8[0]; |
| *p_rch_8++ = p_pcm_8[1]; |
| *p_rch_8++ = p_pcm_8[2]; |
| p_pcm_8+=3; |
| } |
| #else /* __BYTE_ORDER */ |
| #error unsupported byte order |
| #endif /* #if __BYTE_ORDER == __LITTLE_ENDIAN */ |
| } |
| else if ( fmt == LDACBT_SMPL_FMT_S32 ){ |
| char *p_pcm_8 = (char *)pbuff; |
| char *p_lch_8 = (char *)ap_pcm[0]; |
| char *p_rch_8 = (char *)ap_pcm[1]; |
| #if __BYTE_ORDER == __LITTLE_ENDIAN |
| for (i = 0; i < nsmpl; i++) { |
| *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]; |
| p_pcm_8+=4; |
| *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]; |
| p_pcm_8+=4; |
| } |
| #else /* __BYTE_ORDER */ |
| #error unsupported byte order |
| #endif /* #if __BYTE_ORDER == __LITTLE_ENDIAN */ |
| } |
| else if ( fmt == LDACBT_SMPL_FMT_F32 ){ |
| float *p_pcm = (float *)pbuff; |
| float *p_lch = (float *)ap_pcm[0]; |
| float *p_rch = (float *)ap_pcm[1]; |
| for (i = 0; i < nsmpl; i++) { |
| *p_lch++ = p_pcm[0]; |
| p_pcm++; |
| *p_rch++ = p_pcm[0]; |
| p_pcm++; |
| } |
| } |
| else{;} /* never be happend */ |
| } |
| else if( nch == 1 ){ |
| switch(fmt){ |
| case LDACBT_SMPL_FMT_S16: |
| copy_data_ldac( pbuff, ap_pcm[0], 2*nsmpl ); |
| break; |
| case LDACBT_SMPL_FMT_S24: |
| copy_data_ldac( pbuff, ap_pcm[0], 3*nsmpl ); |
| break; |
| case LDACBT_SMPL_FMT_S32: |
| case LDACBT_SMPL_FMT_F32: |
| copy_data_ldac( pbuff, ap_pcm[0], 4*nsmpl ); |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| |
| |
| /* update framelength */ |
| DECLFUNC int ldacBT_update_frmlen(HANDLE_LDAC_BT hLdacBT, int frmlen) |
| { |
| int status, sf, ch, fl, fl_per_ch; |
| int nbasebands, grad_mode, grad_qu_l, grad_qu_h, grad_ofst_l, grad_ofst_h, abc_flag; |
| LDACBT_TX_INFO *ptx; |
| LDAC_RESULT result; |
| status = LDACBT_E_FAIL; |
| |
| if( hLdacBT == NULL ){ |
| return LDACBT_E_FAIL; |
| } |
| sf = hLdacBT->pcm.sf; /* sampling frequency */ |
| ch = hLdacBT->pcm.ch; /* number of channels */ |
| ptx = &hLdacBT->tx; |
| |
| ldac_setup_AGAIN: |
| /* update LDAC parameters. */ |
| |
| |
| if( frmlen == UNSET ){ |
| goto ldac_setup_END; |
| } |
| |
| /* check & update frameLength */ |
| ldaclib_get_encode_frame_length( hLdacBT->hLDAC, &fl ); |
| if( fl == 0 ){ // This meens that the handle was not initialized yet. Shall not happen. |
| |
| goto ldac_setup_END; |
| } |
| else if( frmlen == fl ){ |
| /* No need to update frame length. Just update bitrate information. */ |
| status = LDACBT_S_OK; |
| hLdacBT->bitrate = ldacBT_frmlen_to_bitrate( fl, 1, sf, hLdacBT->frm_samples ); |
| goto ldac_setup_END; |
| } |
| |
| /* Time to update the frame_length. */ |
| /* Get ldac encoding information for frame_length. */ |
| fl_per_ch = (frmlen+LDACBT_FRMHDRBYTES) / ch; |
| result = ldaclib_get_encode_setting( fl_per_ch, hLdacBT->sfid, &nbasebands, |
| &grad_mode, &grad_qu_l, &grad_qu_h, &grad_ofst_l, &grad_ofst_h, &abc_flag); |
| if (LDAC_FAILED(result)) { |
| goto ldac_setup_END; |
| } |
| /* Set Encoding Information */ |
| result = ldaclib_set_encode_info( hLdacBT->hLDAC, nbasebands, grad_mode, |
| grad_qu_l, grad_qu_h, grad_ofst_l, grad_ofst_h, abc_flag); |
| if (LDAC_FAILED(result)) { |
| ldacBT_check_ldaclib_error_code(hLdacBT); |
| goto ldac_setup_END; |
| } |
| |
| if( !LDAC_SUCCEEDED(ldaclib_set_encode_frame_length( hLdacBT->hLDAC, frmlen ))){ |
| goto ldac_setup_END; |
| } |
| |
| /* Update parameters in handle. */ |
| hLdacBT->frmlen = frmlen; |
| hLdacBT->frmlen_tx = LDACBT_FRMHDRBYTES + frmlen; |
| ptx->nfrm_in_pkt = ptx->tx_size / hLdacBT->frmlen_tx; |
| if( ptx->nfrm_in_pkt > LDACBT_NFRM_TX_MAX ){ |
| ptx->nfrm_in_pkt = LDACBT_NFRM_TX_MAX; |
| } |
| else if( ptx->nfrm_in_pkt < 2 ){ |
| /* Not allowed 1frame/packet transportation for current version of LDAC A2DP */ |
| if( frmlen <= (ptx->tx_size / 2 - LDACBT_FRMHDRBYTES)){ |
| goto ldac_setup_END; |
| } |
| frmlen = ptx->tx_size / 2 - LDACBT_FRMHDRBYTES; |
| goto ldac_setup_AGAIN; |
| } |
| /* Update bitrate and EQMID. */ |
| hLdacBT->bitrate = ldacBT_frmlen_to_bitrate( frmlen, 1, sf, hLdacBT->frm_samples ); |
| hLdacBT->eqmid = ldacBT_get_eqmid_from_frmlen( frmlen, ch, hLdacBT->transport, ptx->pkt_type ); |
| if( hLdacBT->tgt_eqmid == UNSET){ |
| hLdacBT->eqmid = UNSET; |
| } |
| status = LDACBT_S_OK; |
| |
| ldac_setup_END: |
| return status; |
| } |
| |
| /* Get channel_config_index from channel_mode. |
| * The argument cm, channel_mode, must be checked by function ldacBT_assert_cm() before calling this |
| * function. |
| */ |
| DECLFUNC int ldacBT_cm_to_cci( int cm ) |
| { |
| if( cm == LDACBT_CHANNEL_MODE_STEREO ){ |
| return LDAC_CCI_STEREO; |
| } |
| else if( cm == LDACBT_CHANNEL_MODE_DUAL_CHANNEL ){ |
| return LDAC_CCI_DUAL_CHANNEL; |
| } |
| else/* if( cm == LDACBT_CHANNEL_MODE_MONO )*/{ |
| return LDAC_CCI_MONO; |
| } |
| } |
| |
| /* Get channel_mode from channel_config_index. |
| * The argument cci, channel_config_index, must be checked by the function ldacBT_assert_cci() before |
| * calling this function. |
| */ |
| UNUSED_ATTR DECLFUNC int ldacBT_cci_to_cm( int cci ) |
| { |
| if( cci == LDAC_CCI_STEREO ){ |
| return LDACBT_CHANNEL_MODE_STEREO; |
| } |
| else if( cci == LDAC_CCI_DUAL_CHANNEL ){ |
| return LDACBT_CHANNEL_MODE_DUAL_CHANNEL; |
| } |
| else/* if( cci == LDAC_CCI_MONO )*/{ |
| return LDACBT_CHANNEL_MODE_MONO; |
| } |
| } |
| |
| /* Get bitrate from frame length */ |
| DECLFUNC int ldacBT_frmlen_to_bitrate( int frmlen, int flgFrmHdr, int sf, int frame_samples ) |
| { |
| int bitrate; |
| if( (frmlen == UNSET) || (flgFrmHdr == UNSET) || (sf == UNSET) || (frame_samples == UNSET) ){ |
| return LDACBT_E_FAIL; |
| } |
| if( flgFrmHdr ){ |
| frmlen += LDACBT_FRMHDRBYTES; |
| } |
| bitrate = frmlen * sf / frame_samples / (1000 / 8); |
| return bitrate; |
| } |
| |
| /* Get Encode Quality Mode index property */ |
| DECLFUNC P_LDACBT_EQMID_PROPERTY ldacBT_get_eqmid_conv_tbl ( int eqmid ) |
| { |
| int i, tbl_size; |
| P_LDACBT_EQMID_PROPERTY pEqmIdProp; |
| |
| pEqmIdProp = (P_LDACBT_EQMID_PROPERTY)tbl_ldacbt_eqmid_property; |
| tbl_size = (int)(sizeof(tbl_ldacbt_eqmid_property)/sizeof(tbl_ldacbt_eqmid_property[0])); |
| /* Search current eqmid */ |
| for( i = 0; i < tbl_size; ++i, ++pEqmIdProp ){ |
| if( pEqmIdProp->eqmid == eqmid ){ |
| return pEqmIdProp; |
| } |
| } |
| return NULL; |
| } |
| |
| /* Get altered Encode Quality Mode index */ |
| DECLFUNC int ldacBT_get_altered_eqmid ( HANDLE_LDAC_BT hLdacBT, int priority ) |
| { |
| int i, eqmid_0, eqmid_1, eqmid_new, tbl_size; |
| if( priority == 0 ){ return LDACBT_E_FAIL; } |
| switch( hLdacBT->tx.pkt_type ){ |
| case _2_DH5: |
| break; |
| default: |
| return LDACBT_E_FAIL; |
| } |
| tbl_size = (int)(sizeof(tbl_ldacbt_eqmid_property)/sizeof(tbl_ldacbt_eqmid_property[0])); |
| /* Search target eqmid */ |
| for( i = 0; i < tbl_size; ++i ){ |
| if( tbl_ldacbt_eqmid_property[i].eqmid == hLdacBT->tgt_eqmid ){ |
| break; |
| } |
| } |
| eqmid_0 = i; |
| eqmid_1 = eqmid_0 - priority; |
| if( eqmid_1 < 0 ){ return LDACBT_E_FAIL; } |
| if( eqmid_1 >= tbl_size ){ return LDACBT_E_FAIL; } |
| |
| eqmid_new = tbl_ldacbt_eqmid_property[eqmid_1].eqmid; |
| for( i = 0; i < tbl_size; ++i ){ |
| if( tbl_ldacbt_eqmid_property[i].eqmid == LDACBT_LIMIT_ALTER_EQMID_PRIORITY ){ |
| break; |
| } |
| } |
| if( eqmid_1 > i ){ return LDACBT_E_FAIL; } |
| return eqmid_new; |
| |
| } |
| |
| /* Get LDAC bitrate info from Encode Quality Mode Index */ |
| DECLFUNC P_LDACBT_CONFIG ldacBT_get_config( int ldac_bt_mode, int pkt_type ) |
| { |
| int i, tbl_size, ldac_mode_id; |
| P_LDACBT_EQMID_PROPERTY pEqmIdProp; |
| P_LDACBT_CONFIG pCfg; |
| |
| if( (pEqmIdProp = ldacBT_get_eqmid_conv_tbl( ldac_bt_mode )) == NULL ){ |
| return NULL; |
| } |
| |
| if( pkt_type == _2_DH5 ){ ldac_mode_id = pEqmIdProp->id_for_2DH5;} |
| else{ |
| return NULL; |
| } |
| |
| pCfg = (P_LDACBT_CONFIG)tbl_ldacbt_config; |
| tbl_size = (int)(sizeof(tbl_ldacbt_config)/sizeof(tbl_ldacbt_config[0])); |
| for( i = 0; i < tbl_size; ++i, ++pCfg ){ |
| if( ldac_mode_id == pCfg->id ){ |
| return pCfg; |
| } |
| } |
| return NULL; /* not found */ |
| } |
| |
| /* Get Encode Quality Mode Index from framelength */ |
| DECLFUNC int ldacBT_get_eqmid_from_frmlen( int frmlen, int nch, int flgFrmHdr, int pktType ) |
| { |
| int i, n, eqmid; |
| P_LDACBT_CONFIG pCfg; |
| |
| if( flgFrmHdr ){ |
| frmlen += LDACBT_FRMHDRBYTES; |
| } |
| if( nch > 0 ){ |
| frmlen /= nch; |
| } |
| |
| eqmid = LDACBT_EQMID_END; |
| n = (int)(sizeof(tbl_ldacbt_eqmid_property)/sizeof(tbl_ldacbt_eqmid_property[0])); |
| for( i = 0; i < n; ++i ){ |
| if( (pCfg = ldacBT_get_config( tbl_ldacbt_eqmid_property[i].eqmid, pktType )) != NULL ){ |
| if( frmlen >= pCfg->frmlen_1ch){ |
| eqmid = tbl_ldacbt_eqmid_property[i].eqmid; |
| break; |
| } |
| } |
| } |
| return eqmid; |
| } |
| |
