xref: /aosp_15_r20/external/libldac/src/ldacBT_api.c (revision aef9bcd9217ad2365ebc8e70efaf94b64e04df14)

/*
 * 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;
}