| /* |
| * Copyright (C) 2013 - 2017 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" |
| |
| |
| /* Get LDAC library version */ |
| #define LDACBT_LIB_VER_MAJOR 2 |
| #define LDACBT_LIB_VER_MINOR 0 |
| #define LDACBT_LIB_VER_BRANCH 2 |
| LDACBT_API int ldacBT_get_version( void ) |
| { |
| return ((LDACBT_LIB_VER_MAJOR)<<16)|((LDACBT_LIB_VER_MINOR)<<8)|(LDACBT_LIB_VER_BRANCH); |
| } |
| |
| /* Get LDAC handle */ |
| LDACBT_API HANDLE_LDAC_BT ldacBT_get_handle( void ) |
| { |
| HANDLE_LDAC_BT hLdacBT; |
| hLdacBT = (HANDLE_LDAC_BT)malloc( sizeof(STRUCT_LDACBT_HANDLE) ); |
| if( hLdacBT == NULL ){ return NULL; } |
| |
| /* Get ldaclib Handler */ |
| if( (hLdacBT->hLDAC = ldaclib_get_handle()) == NULL ){ |
| ldacBT_free_handle( hLdacBT ); |
| return NULL; |
| } |
| |
| ldacBT_param_clear( hLdacBT ); |
| return hLdacBT; |
| } |
| |
| /* Free LDAC handle */ |
| LDACBT_API void ldacBT_free_handle( HANDLE_LDAC_BT hLdacBT ) |
| { |
| if( hLdacBT == NULL ){ return; } |
| |
| if( hLdacBT->hLDAC != NULL ){ |
| /* close ldaclib handle */ |
| if( hLdacBT->proc_mode == LDACBT_PROCMODE_ENCODE ){ |
| ldaclib_free_encode( hLdacBT->hLDAC ); |
| } |
| /* free ldaclib handle */ |
| ldaclib_free_handle( hLdacBT->hLDAC ); |
| hLdacBT->hLDAC = NULL; |
| } |
| /* free ldacbt handle */ |
| free( hLdacBT ); |
| } |
| |
| /* Close LDAC handle */ |
| LDACBT_API void ldacBT_close_handle( HANDLE_LDAC_BT hLdacBT ) |
| { |
| if( hLdacBT == NULL ){ return; } |
| |
| if( hLdacBT->hLDAC != NULL ){ |
| /* close ldaclib handle */ |
| if( hLdacBT->proc_mode == LDACBT_PROCMODE_ENCODE ){ |
| ldaclib_free_encode( hLdacBT->hLDAC ); |
| } |
| /* clear error code */ |
| ldaclib_clear_error_code(hLdacBT->hLDAC); |
| ldaclib_clear_internal_error_code(hLdacBT->hLDAC); |
| } |
| /* clear ldacbt handle */ |
| ldacBT_param_clear( hLdacBT ); |
| } |
| |
| |
| /* Get ERROR CODE */ |
| LDACBT_API int ldacBT_get_error_code( HANDLE_LDAC_BT hLdacBT ) |
| { |
| int error_code; |
| if( hLdacBT == NULL ){return LDACBT_ERR_FATAL_HANDLE<<10;} |
| ldacBT_check_ldaclib_error_code( hLdacBT ); |
| if( hLdacBT->error_code_api == LDACBT_GET_LDACLIB_ERROR_CODE ){ |
| error_code = LDACBT_ERR_FATAL << 20 | hLdacBT->error_code; |
| }else if( hLdacBT->error_code_api != LDACBT_ERR_NONE ){ |
| error_code = hLdacBT->error_code_api << 20 | hLdacBT->error_code; |
| }else{ |
| error_code = hLdacBT->error_code_api << 20; |
| } |
| return error_code; |
| } |
| |
| |
| /* Get Configured Sampling frequency */ |
| LDACBT_API int ldacBT_get_sampling_freq( HANDLE_LDAC_BT hLdacBT ) |
| { |
| if( hLdacBT == NULL ){ |
| return LDACBT_E_FAIL; |
| } |
| if( hLdacBT->proc_mode != LDACBT_PROCMODE_ENCODE ) |
| { |
| hLdacBT->error_code_api = LDACBT_ERR_HANDLE_NOT_INIT; |
| return LDACBT_E_FAIL; |
| } |
| return hLdacBT->pcm.sf; |
| } |
| |
| /* Get bitrate */ |
| LDACBT_API int ldacBT_get_bitrate( HANDLE_LDAC_BT hLdacBT ) |
| { |
| if( hLdacBT == NULL ){ |
| return LDACBT_E_FAIL; |
| } |
| if( hLdacBT->proc_mode != LDACBT_PROCMODE_ENCODE ) |
| { |
| hLdacBT->error_code_api = LDACBT_ERR_HANDLE_NOT_INIT; |
| return LDACBT_E_FAIL; |
| } |
| return hLdacBT->bitrate; |
| } |
| |
| /* Init LDAC handle for ENCODE */ |
| LDACBT_API int ldacBT_init_handle_encode( HANDLE_LDAC_BT hLdacBT, int mtu, int eqmid, |
| int cm, LDACBT_SMPL_FMT_T fmt, int sf ) |
| { |
| LDAC_RESULT result; |
| int sfid, frame_samples, cci; |
| int nbasebands, grad_mode, grad_qu_l, grad_qu_h, grad_ofst_l, grad_ofst_h, abc_flag; |
| P_LDACBT_CONFIG pCfg; |
| const int a_cci_nch[] = { 1, 2, 2 }; |
| |
| /* check arguments */ |
| if( hLdacBT == NULL ){ return LDACBT_E_FAIL; } |
| if( (hLdacBT->error_code_api = ldacBT_assert_mtu( mtu )) != LDACBT_ERR_NONE ){ |
| return LDACBT_E_FAIL; |
| } |
| if( (hLdacBT->error_code_api = ldacBT_assert_eqmid( eqmid )) != LDACBT_ERR_NONE ){ |
| return LDACBT_E_FAIL; |
| } |
| if( (hLdacBT->error_code_api = ldacBT_assert_cm( cm )) != LDACBT_ERR_NONE ){ |
| return LDACBT_E_FAIL; |
| } |
| if( (hLdacBT->error_code_api = ldacBT_assert_sample_format( fmt )) != LDACBT_ERR_NONE ){ |
| return LDACBT_E_FAIL; |
| } |
| if( (hLdacBT->error_code_api = ldacBT_assert_pcm_sampling_freq( sf )) != LDACBT_ERR_NONE ){ |
| return LDACBT_E_FAIL; |
| } |
| |
| ldacBT_close_handle( hLdacBT ); |
| |
| /* initialize handle for encode processing */ |
| hLdacBT->proc_mode = LDACBT_PROCMODE_ENCODE; |
| hLdacBT->flg_encode_flushed = FALSE; |
| |
| /* transport setting */ |
| /* The ldac frame header is REQUIRED for A2DP streaming. */ |
| hLdacBT->transport = TRUE; |
| hLdacBT->tx.mtu = mtu; |
| hLdacBT->tx.pkt_hdr_sz = LDACBT_TX_HEADER_SIZE; |
| hLdacBT->tx.tx_size = LDACBT_MTU_REQUIRED; |
| hLdacBT->tx.pkt_type = _2_DH5; |
| /* - BT TRANS HEADER etc */ |
| hLdacBT->tx.tx_size -= hLdacBT->tx.pkt_hdr_sz; |
| if( hLdacBT->tx.tx_size > (hLdacBT->tx.mtu - hLdacBT->tx.pkt_hdr_sz) ){ |
| /* never happen, mtu must be larger than LDACBT_MTU_REQUIRED(2DH5) */ |
| hLdacBT->tx.tx_size = (hLdacBT->tx.mtu - hLdacBT->tx.pkt_hdr_sz); |
| } |
| |
| /* channel configration */ |
| cci = ldacBT_cm_to_cci(cm); |
| hLdacBT->cm = cm; |
| hLdacBT->cci = cci; |
| /* input pcm configuration */ |
| hLdacBT->pcm.ch = a_cci_nch[cci]; |
| hLdacBT->pcm.sf = sf; |
| hLdacBT->pcm.fmt = fmt; |
| switch(hLdacBT->pcm.fmt){ |
| case LDACBT_SMPL_FMT_S16: |
| hLdacBT->pcm.wl = 2; |
| break; |
| case LDACBT_SMPL_FMT_S24: |
| hLdacBT->pcm.wl = 3; |
| break; |
| case LDACBT_SMPL_FMT_S32: |
| case LDACBT_SMPL_FMT_F32: |
| hLdacBT->pcm.wl = 4; |
| break; |
| default: |
| // must be rejected by ldacBT_assert_sample_format() |
| hLdacBT->pcm.wl = 4; |
| break; |
| } |
| |
| /* initilize ldac encode */ |
| /* Get sampling frequency index */ |
| result = ldaclib_get_sampling_rate_index( hLdacBT->pcm.sf, &sfid ); |
| if( LDAC_FAILED ( result ) ){ |
| hLdacBT->error_code_api = LDACBT_ERR_ILL_SAMPLING_FREQ; |
| return LDACBT_E_FAIL; |
| } |
| hLdacBT->sfid = sfid; |
| |
| /* Get number of frame samples */ |
| result = ldaclib_get_frame_samples(sfid, &frame_samples); |
| if (LDAC_FAILED(result)) { |
| hLdacBT->error_code_api = LDACBT_ERR_ILL_SAMPLING_FREQ; |
| return LDACBT_E_FAIL; |
| } |
| hLdacBT->frm_samples = frame_samples; |
| |
| |
| /* Set Parameters by Encode Quality Mode Index */ |
| hLdacBT->eqmid = eqmid; |
| /* get frame_length of EQMID */ |
| pCfg = ldacBT_get_config( hLdacBT->eqmid, hLdacBT->tx.pkt_type ); |
| /* set frame_length */ |
| hLdacBT->frmlen_tx = hLdacBT->pcm.ch * pCfg->frmlen_1ch; |
| hLdacBT->frmlen = hLdacBT->frmlen_tx; |
| if (hLdacBT->transport) { |
| /* Adjust frame_length for Transport Header Data */ |
| hLdacBT->frmlen -= LDACBT_FRMHDRBYTES; |
| } |
| |
| /* Calculate how many LDAC frames fit into payload packet */ |
| hLdacBT->tx.nfrm_in_pkt = hLdacBT->tx.tx_size / hLdacBT->frmlen_tx; |
| |
| |
| /* Get ldac encode setting */ |
| result = ldaclib_get_encode_setting( pCfg->frmlen_1ch, sfid, &nbasebands, &grad_mode, |
| &grad_qu_l, &grad_qu_h, &grad_ofst_l, &grad_ofst_h, &abc_flag); |
| if (LDAC_FAILED(result)) { |
| hLdacBT->error_code_api = LDACBT_ERR_ILL_PARAM; |
| return LDACBT_E_FAIL; |
| } |
| |
| /* Set Configuration Information */ |
| result = ldaclib_set_config_info( hLdacBT->hLDAC, hLdacBT->sfid, hLdacBT->cci, |
| hLdacBT->frmlen, hLdacBT->frm_status); |
| if (LDAC_FAILED(result)) { |
| hLdacBT->error_code_api = LDACBT_GET_LDACLIB_ERROR_CODE; |
| return LDACBT_E_FAIL; |
| } |
| else if (result != LDAC_S_OK) { |
| hLdacBT->error_code_api = LDACBT_GET_LDACLIB_ERROR_CODE; |
| } |
| |
| /* 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)) { |
| hLdacBT->error_code_api = LDACBT_GET_LDACLIB_ERROR_CODE; |
| return LDACBT_E_FAIL; |
| } |
| else if (result != LDAC_S_OK) { |
| hLdacBT->error_code_api = LDACBT_GET_LDACLIB_ERROR_CODE; |
| } |
| |
| /* Initialize ldaclib for Encoding */ |
| result = ldaclib_init_encode(hLdacBT->hLDAC); |
| if (LDAC_FAILED(result)) { |
| hLdacBT->error_code_api = LDACBT_GET_LDACLIB_ERROR_CODE; |
| return LDACBT_E_FAIL; |
| } |
| else if (result != LDAC_S_OK) { |
| hLdacBT->error_code_api = LDACBT_GET_LDACLIB_ERROR_CODE; |
| } |
| |
| /* reset target eqmid as current setting */ |
| hLdacBT->tgt_eqmid = hLdacBT->eqmid; |
| hLdacBT->tgt_nfrm_in_pkt = hLdacBT->tx.nfrm_in_pkt; |
| hLdacBT->tgt_frmlen = hLdacBT->frmlen; |
| hLdacBT->stat_alter_op = LDACBT_ALTER_OP__NON; |
| |
| /* get bitrate */ |
| hLdacBT->bitrate = ldacBT_frmlen_to_bitrate( hLdacBT->frmlen, hLdacBT->transport, |
| hLdacBT->pcm.sf, hLdacBT->frm_samples ); |
| |
| return (hLdacBT->error_code_api==LDACBT_ERR_NONE?LDACBT_S_OK:LDACBT_E_FAIL); |
| } |
| |
| /* Set Encode Quality Mode index */ |
| LDACBT_API int ldacBT_set_eqmid( HANDLE_LDAC_BT hLdacBT, int eqmid ) |
| { |
| if( hLdacBT == NULL ){ |
| return LDACBT_E_FAIL; |
| } |
| if( hLdacBT->proc_mode != LDACBT_PROCMODE_ENCODE ){ |
| hLdacBT->error_code_api = LDACBT_ERR_HANDLE_NOT_INIT; |
| return LDACBT_E_FAIL; |
| } |
| |
| if( (hLdacBT->error_code_api = ldacBT_assert_eqmid( eqmid )) != LDACBT_ERR_NONE ){ |
| return LDACBT_E_FAIL; /* fatal */ |
| } |
| ldacBT_set_eqmid_core( hLdacBT, eqmid ); |
| |
| return LDACBT_S_OK; |
| } |
| |
| /* Get Encode Quality Mode index */ |
| LDACBT_API int ldacBT_get_eqmid( HANDLE_LDAC_BT hLdacBT ) |
| { |
| if( hLdacBT == NULL ){ |
| return LDACBT_E_FAIL; |
| } |
| if( hLdacBT->proc_mode != LDACBT_PROCMODE_ENCODE ){ |
| hLdacBT->error_code_api = LDACBT_ERR_HANDLE_NOT_INIT; |
| return LDACBT_E_FAIL; |
| } |
| return hLdacBT->tgt_eqmid; |
| } |
| |
| /* Alter encode quality mode index */ |
| LDACBT_API int ldacBT_alter_eqmid_priority( HANDLE_LDAC_BT hLdacBT, int priority ) |
| { |
| int target_eqmid; |
| if( hLdacBT == NULL ){ return LDACBT_E_FAIL; } |
| if( hLdacBT->proc_mode != LDACBT_PROCMODE_ENCODE ){ |
| hLdacBT->error_code_api = LDACBT_ERR_HANDLE_NOT_INIT; |
| return LDACBT_E_FAIL; |
| } |
| if( (priority != LDACBT_EQMID_INC_QUALITY) && |
| (priority != LDACBT_EQMID_INC_CONNECTION ) |
| ){ |
| hLdacBT->error_code_api = LDACBT_ERR_ILL_PARAM; |
| return LDACBT_E_FAIL; |
| } |
| |
| target_eqmid = ldacBT_get_altered_eqmid( hLdacBT, priority); |
| if( target_eqmid < 0 ){ |
| hLdacBT->error_code_api = LDACBT_ERR_ALTER_EQMID_LIMITED; |
| return LDACBT_E_FAIL; |
| } |
| |
| ldacBT_set_eqmid_core( hLdacBT, target_eqmid ); |
| return LDACBT_S_OK; |
| } |
| |
| /* LDAC encode proccess */ |
| LDACBT_API int ldacBT_encode( HANDLE_LDAC_BT hLdacBT, void *p_pcm, int *pcm_used, |
| unsigned char *p_stream, int *stream_sz, int *frame_num ) |
| { |
| LDAC_RESULT result; |
| LDACBT_SMPL_FMT_T fmt; |
| LDACBT_TRANSPORT_FRM_BUF *ptfbuf; |
| LDACBT_PCM_RING_BUF *ppcmring; |
| P_LDACBT_CONFIG pCfg; |
| int frmlen, frmlen_wrote, frmlen_adj; |
| int frm_status, flg_Do_Encode; |
| int nFrmToPkt, ch, wl; |
| unsigned char *p_ldac_transport_frame; |
| unsigned char a_frm_header[LDACBT_FRMHDRBYTES + 2]; |
| if( hLdacBT == NULL ){ |
| return LDACBT_E_FAIL; |
| } |
| if( hLdacBT->hLDAC == NULL ){ |
| return LDACBT_E_FAIL; |
| } |
| if( hLdacBT->proc_mode != LDACBT_PROCMODE_ENCODE ){ |
| hLdacBT->error_code_api = LDACBT_ERR_HANDLE_NOT_INIT; |
| return LDACBT_E_FAIL; |
| } |
| /* Clear Error Codes */ |
| hLdacBT->error_code_api = LDACBT_ERR_NONE; |
| ldaclib_clear_error_code( hLdacBT->hLDAC ); |
| ldaclib_clear_internal_error_code( hLdacBT->hLDAC ); |
| |
| if( ( pcm_used == NULL) || |
| ( p_stream == NULL ) || |
| ( stream_sz == NULL ) || |
| ( frame_num == NULL ) |
| ){ |
| hLdacBT->error_code_api = LDACBT_ERR_ILL_PARAM; |
| return LDACBT_E_FAIL; |
| } |
| /* reset parameters */ |
| *pcm_used = 0; |
| *stream_sz = 0; |
| *frame_num = 0; |
| flg_Do_Encode = 0; |
| fmt = hLdacBT->pcm.fmt; |
| ch = hLdacBT->pcm.ch; |
| wl = hLdacBT->pcm.wl; |
| ptfbuf = &hLdacBT->ldac_trns_frm_buf; |
| ppcmring = &hLdacBT->pcmring; |
| |
| /* update input pcm data */ |
| if( p_pcm != NULL ){ |
| int nByteCpy, sz; |
| nByteCpy = LDACBT_ENC_LSU * wl * ch; |
| sz = ppcmring->nsmpl * wl * ch + nByteCpy; |
| if( sz < LDACBT_ENC_PCM_BUF_SZ ){ |
| copy_data_ldac( p_pcm, ppcmring->buf + ppcmring->wp, nByteCpy ); |
| ppcmring->wp += nByteCpy; |
| if( ppcmring->wp >= LDACBT_ENC_PCM_BUF_SZ ){ |
| ppcmring->wp = 0; |
| } |
| ppcmring->nsmpl += LDACBT_ENC_LSU; |
| *pcm_used = nByteCpy; |
| }else{ |
| /* Not enough space to copy. |
| * This will happen when the last encode process failed. |
| */ |
| *pcm_used = 0; |
| } |
| |
| if( ppcmring->nsmpl >= hLdacBT->frm_samples ) |
| { |
| flg_Do_Encode = 1; |
| } |
| }else{ |
| if (hLdacBT->flg_encode_flushed != TRUE){ |
| flg_Do_Encode = 1; |
| } |
| } |
| |
| if( !flg_Do_Encode ){ |
| /* nothing to do */ |
| return LDACBT_S_OK; |
| } |
| |
| /* update frame_length if needed */ |
| if( (hLdacBT->tgt_eqmid != UNSET) && (hLdacBT->tgt_eqmid != hLdacBT->eqmid) ){ |
| if( ptfbuf->nfrm_in == 0 ){ |
| ldacBT_update_frmlen( hLdacBT, hLdacBT->tgt_frmlen ); |
| hLdacBT->stat_alter_op = LDACBT_ALTER_OP__NON; |
| } |
| else if( hLdacBT->tgt_nfrm_in_pkt > hLdacBT->tx.nfrm_in_pkt ){ |
| /* for better connectivity, apply ASAP */ |
| if( !hLdacBT->stat_alter_op ){ |
| nFrmToPkt = hLdacBT->tgt_nfrm_in_pkt - ptfbuf->nfrm_in; |
| if( nFrmToPkt > 0 ){ |
| pCfg = ldacBT_get_config(LDACBT_EQMID_END, hLdacBT->tx.pkt_type); |
| if( pCfg != NULL ){ |
| do{ |
| frmlen_adj = (hLdacBT->tx.tx_size - ptfbuf->used) / nFrmToPkt; |
| if( frmlen_adj > hLdacBT->tgt_frmlen ) { |
| frmlen_adj = hLdacBT->tgt_frmlen; |
| } |
| frmlen_adj -= LDACBT_FRMHDRBYTES; |
| if( frmlen_adj >= pCfg->frmlen ){ |
| if( ldacBT_update_frmlen( hLdacBT, frmlen_adj ) == LDACBT_S_OK ){ |
| hLdacBT->stat_alter_op = LDACBT_ALTER_OP__ACTIVE; |
| break; |
| } |
| } |
| }while( --nFrmToPkt > 0 ); |
| } |
| if( !hLdacBT->stat_alter_op ){ |
| /* force to flash streams */ |
| hLdacBT->stat_alter_op = LDACBT_ALTER_OP__FLASH; |
| } |
| } |
| } |
| } |
| else{ |
| /* wait the condition ptfbuf->nfrm_in == 0 for apply new frame_length */ |
| hLdacBT->stat_alter_op = LDACBT_ALTER_OP__STANDBY; |
| } |
| |
| } |
| else if( hLdacBT->tgt_frmlen != hLdacBT->frmlen ){ |
| if( ptfbuf->nfrm_in == 0 ){ |
| ldacBT_update_frmlen( hLdacBT, hLdacBT->tgt_frmlen ); |
| hLdacBT->stat_alter_op = LDACBT_ALTER_OP__NON; |
| }else{ |
| if( hLdacBT->tgt_nfrm_in_pkt == hLdacBT->tx.nfrm_in_pkt ){ |
| ldacBT_update_frmlen( hLdacBT, hLdacBT->tgt_frmlen ); |
| hLdacBT->stat_alter_op = LDACBT_ALTER_OP__NON; |
| }else{ |
| if( hLdacBT->tgt_nfrm_in_pkt > hLdacBT->tx.nfrm_in_pkt ){ |
| /* for better connectivity, apply ASAP */ |
| if( !hLdacBT->stat_alter_op ){ |
| nFrmToPkt = hLdacBT->tgt_nfrm_in_pkt - ptfbuf->nfrm_in; |
| if( nFrmToPkt > 0 ){ |
| frmlen_adj = (hLdacBT->tx.tx_size - ptfbuf->used) / nFrmToPkt; |
| if( frmlen_adj > hLdacBT->tgt_frmlen ) { |
| frmlen_adj = hLdacBT->tgt_frmlen; |
| } |
| if( ldacBT_update_frmlen( hLdacBT, frmlen_adj ) == LDACBT_S_OK ){ |
| hLdacBT->stat_alter_op = LDACBT_ALTER_OP__ACTIVE; |
| } |
| if( !hLdacBT->stat_alter_op ){ |
| /* flash streams */ |
| hLdacBT->stat_alter_op = LDACBT_ALTER_OP__FLASH; |
| } |
| } |
| } |
| }else{ |
| /* wait the condition ptfbuf->nfrm_in == 0 for apply new frame_length */ |
| hLdacBT->stat_alter_op = LDACBT_ALTER_OP__STANDBY; |
| } |
| } |
| } |
| } |
| |
| /* check write space for encoded data */ |
| ldaclib_get_encode_frame_length( hLdacBT->hLDAC, &frmlen ); |
| |
| if( (( ptfbuf->used + frmlen + LDACBT_FRMHDRBYTES) > hLdacBT->tx.tx_size) || |
| (hLdacBT->stat_alter_op == LDACBT_ALTER_OP__FLASH) || /* need to flash streams? */ |
| (( ptfbuf->used + frmlen + LDACBT_FRMHDRBYTES) >= LDACBT_ENC_STREAM_BUF_SZ ) |
| ) |
| { |
| copy_data_ldac( ptfbuf->buf, p_stream, ptfbuf->used ); |
| *stream_sz = ptfbuf->used; |
| *frame_num = ptfbuf->nfrm_in; |
| clear_data_ldac( ptfbuf->buf, sizeof(char)*LDACBT_ENC_STREAM_BUF_SZ); |
| ptfbuf->used = 0; |
| ptfbuf->nfrm_in = 0; |
| if( hLdacBT->stat_alter_op != LDACBT_ALTER_OP__NON ){ |
| /* update frame length */ |
| ldacBT_update_frmlen( hLdacBT, hLdacBT->tgt_frmlen ); |
| hLdacBT->stat_alter_op = LDACBT_ALTER_OP__NON; |
| } |
| } |
| p_ldac_transport_frame = ptfbuf->buf + ptfbuf->used; |
| |
| /* Encode Frame */ |
| if( ppcmring->nsmpl > 0 ){ |
| char *p_pcm_ring_r; |
| int nsmpl_to_clr; |
| nsmpl_to_clr = hLdacBT->frm_samples - ppcmring->nsmpl; |
| if( nsmpl_to_clr > 0 ){ |
| int pos, nBytesToZero; |
| pos = ppcmring->rp + ppcmring->nsmpl * wl * ch; |
| nBytesToZero = nsmpl_to_clr * wl * ch; |
| while( nBytesToZero > 0 ){ |
| int clearBytes; |
| clearBytes = nBytesToZero; |
| if ( pos + clearBytes >= LDACBT_ENC_PCM_BUF_SZ ){ |
| clearBytes = (LDACBT_ENC_PCM_BUF_SZ - pos); |
| } |
| clear_data_ldac( ppcmring->buf + pos, clearBytes); |
| nBytesToZero -= clearBytes; |
| if( (pos += clearBytes) >= LDACBT_ENC_PCM_BUF_SZ ){ |
| pos = 0; |
| } |
| } |
| } |
| p_pcm_ring_r = ppcmring->buf + ppcmring->rp; |
| ldacBT_prepare_pcm_encode( p_pcm_ring_r, hLdacBT->pp_pcm, hLdacBT->frm_samples, ch, fmt ); |
| result = ldaclib_encode(hLdacBT->hLDAC, hLdacBT->pp_pcm, (LDAC_SMPL_FMT_T)fmt, |
| p_ldac_transport_frame+LDACBT_FRMHDRBYTES, &frmlen_wrote); |
| if( !LDAC_FAILED(result) ){ |
| ppcmring->rp += hLdacBT->frm_samples * wl * ch; |
| ppcmring->nsmpl -= hLdacBT->frm_samples; |
| if( ppcmring->rp >= LDACBT_ENC_PCM_BUF_SZ ){ ppcmring->rp = 0; } |
| if( ppcmring->nsmpl < 0 ){ ppcmring->nsmpl = 0; } |
| } |
| }else{ |
| result = ldaclib_flush_encode(hLdacBT->hLDAC, (LDAC_SMPL_FMT_T)fmt, |
| p_ldac_transport_frame+LDACBT_FRMHDRBYTES, &frmlen_wrote); |
| hLdacBT->flg_encode_flushed = TRUE; |
| } |
| |
| if( LDAC_FAILED(result) ){ |
| hLdacBT->error_code_api = LDACBT_GET_LDACLIB_ERROR_CODE; |
| return LDACBT_E_FAIL; |
| } |
| else if( result != LDAC_S_OK ){ |
| hLdacBT->error_code_api = LDACBT_GET_LDACLIB_ERROR_CODE; |
| } |
| |
| if( frmlen_wrote > 0 ){ |
| if( hLdacBT->transport == TRUE ){ |
| /* Set Frame Header Data */ |
| clear_data_ldac( a_frm_header, LDACBT_FRMHDRBYTES+2 ); |
| /* Get Frame Header Information */ |
| result = ldaclib_get_config_info(hLdacBT->hLDAC, &hLdacBT->sfid, &hLdacBT->cci, |
| &frmlen, &frm_status); |
| if( LDAC_FAILED(result) ){ |
| hLdacBT->error_code_api = LDACBT_GET_LDACLIB_ERROR_CODE; |
| return LDACBT_E_FAIL; |
| } |
| else if (result != LDAC_S_OK) { |
| hLdacBT->error_code_api = LDACBT_GET_LDACLIB_ERROR_CODE; |
| } |
| |
| /* Set Frame Header */ |
| result = ldaclib_set_frame_header(hLdacBT->hLDAC, a_frm_header, hLdacBT->sfid, |
| hLdacBT->cci, frmlen, frm_status); |
| if( LDAC_FAILED(result) ){ |
| hLdacBT->error_code_api = LDACBT_GET_LDACLIB_ERROR_CODE; |
| return LDACBT_E_FAIL; |
| } |
| else if (result != LDAC_S_OK) { |
| hLdacBT->error_code_api = LDACBT_GET_LDACLIB_ERROR_CODE; |
| } |
| copy_data_ldac( a_frm_header, p_ldac_transport_frame, LDACBT_FRMHDRBYTES ); |
| frmlen_wrote += LDACBT_FRMHDRBYTES; |
| } |
| ptfbuf->used += frmlen_wrote; |
| ptfbuf->nfrm_in ++; |
| } |
| |
| /* check for next frame buffer status */ |
| if( *stream_sz == 0 ){ |
| if( (( ptfbuf->used + frmlen_wrote) > hLdacBT->tx.tx_size) || |
| ( ptfbuf->nfrm_in >= LDACBT_NFRM_TX_MAX ) || |
| (( ptfbuf->used + frmlen_wrote) >= LDACBT_ENC_STREAM_BUF_SZ ) || |
| ( p_pcm == NULL ) /* flush encode */ |
| ) |
| { |
| copy_data_ldac( ptfbuf->buf, p_stream, ptfbuf->used ); |
| *stream_sz = ptfbuf->used; |
| *frame_num = ptfbuf->nfrm_in; |
| clear_data_ldac( ptfbuf->buf, sizeof(char)*LDACBT_ENC_STREAM_BUF_SZ); |
| ptfbuf->used = 0; |
| ptfbuf->nfrm_in = 0; |
| if( hLdacBT->stat_alter_op != LDACBT_ALTER_OP__NON ){ |
| ldacBT_update_frmlen( hLdacBT, hLdacBT->tgt_frmlen ); |
| hLdacBT->stat_alter_op = LDACBT_ALTER_OP__NON; |
| } |
| } |
| } |
| |
| return LDACBT_S_OK; |
| } |
