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