/*

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

}