#ifndef VOICE_DATAPATH
/***************************************************************************
 *
 * Copyright 2015-2019 BES.
 * All rights reserved. All unpublished rights reserved.
 *
 * No part of this work may be used or reproduced in any form or by any
 * means, or stored in a database or retrieval system, without prior written
 * permission of BES.
 *
 * Use of this work is governed by a license granted by BES.
 * This work contains confidential and proprietary information of
 * BES. which is protected by copyright, trade secret,
 * trademark and other intellectual property rights.
 *
 ****************************************************************************/
#include "voice_sbc.h"
#include "hal_trace.h"

static VOICE_SBC_CONFIG_T voice_sbc_config = {
    VOICE_SBC_CHANNEL_COUNT,   VOICE_SBC_CHANNEL_MODE, VOICE_SBC_BIT_POOL,
    VOICE_SBC_SIZE_PER_SAMPLE, VOICE_SBC_SAMPLE_RATE,  VOICE_SBC_NUM_BLOCKS,
    VOICE_SBC_NUM_SUB_BANDS,   VOICE_SBC_MSBC_FLAG,    VOICE_SBC_ALLOC_METHOD,
};

static int voice_sbc_init_encoder(void);

static btif_sbc_encoder_t voice_sbc_encoder;
static btif_sbc_decoder_t voice_sbc_decoder;
static uint32_t voice_sbc_frame_len = 0;

static float voice_sbc_eq_band_gain[8] = {1, 1, 1, 1, 1, 1, 1, 1};

static int voice_sbc_init_encoder(void) {
  btif_sbc_init_encoder(&voice_sbc_encoder);
  voice_sbc_encoder.streamInfo.numChannels = voice_sbc_config.channelCnt;
  voice_sbc_encoder.streamInfo.channelMode = voice_sbc_config.channelMode;
  voice_sbc_encoder.streamInfo.bitPool = voice_sbc_config.bitPool;
  voice_sbc_encoder.streamInfo.sampleFreq = voice_sbc_config.sampleRate;
  voice_sbc_encoder.streamInfo.allocMethod = voice_sbc_config.allocMethod;
  voice_sbc_encoder.streamInfo.numBlocks = voice_sbc_config.numBlocks;
  voice_sbc_encoder.streamInfo.numSubBands = voice_sbc_config.numSubBands;
  voice_sbc_encoder.streamInfo.mSbcFlag = voice_sbc_config.mSbcFlag;

  voice_sbc_frame_len = btif_sbc_frame_len(&(voice_sbc_encoder.streamInfo));

  TRACE(1, "frame len is %d", voice_sbc_frame_len);
  return 0;
}

static int voice_sbc_init_decoder(void) {
  btif_sbc_init_decoder(&voice_sbc_decoder);
  voice_sbc_decoder.streamInfo.numChannels = voice_sbc_config.channelCnt;
  voice_sbc_decoder.streamInfo.channelMode = voice_sbc_config.channelMode;
  voice_sbc_decoder.streamInfo.bitPool = voice_sbc_config.bitPool;
  voice_sbc_decoder.streamInfo.sampleFreq = voice_sbc_config.sampleRate;
  voice_sbc_decoder.streamInfo.allocMethod = voice_sbc_config.allocMethod;
  voice_sbc_decoder.streamInfo.numBlocks = voice_sbc_config.numBlocks;
  voice_sbc_decoder.streamInfo.numSubBands = voice_sbc_config.numSubBands;
  voice_sbc_decoder.streamInfo.mSbcFlag = voice_sbc_config.mSbcFlag;
  return 0;
}

uint32_t voice_sbc_get_frame_len(void) { return voice_sbc_frame_len; }

uint32_t voice_sbc_encode(uint8_t *input, uint32_t inputBytes,
                          uint32_t *purchasedBytes, uint8_t *output,
                          uint8_t isReset) {
  if (isReset) {
    voice_sbc_init_encoder();
  }

  btif_sbc_pcm_data_t PcmEncData;
  uint16_t outputSbcBytes, bytes_encoded;

  PcmEncData.numChannels = voice_sbc_encoder.streamInfo.numChannels;
  PcmEncData.sampleFreq = voice_sbc_encoder.streamInfo.sampleFreq;

  if (voice_sbc_encoder.streamInfo.mSbcFlag) {
    uint16_t outputOffset = 0;
    uint16_t oneChunkOutput = 0;
    uint16_t oneChunkConsumed;
    bytes_encoded = 0;

    for (uint32_t index = 0; index < inputBytes;
         index += (uint32_t)VOICE_SBC_PCM_DATA_SIZE_PER_FRAME) {
      PcmEncData.data = input + index;
      PcmEncData.dataLen = VOICE_SBC_PCM_DATA_SIZE_PER_FRAME;
      // output[outputOffset++] = 0xAD;
      // output[outputOffset++] = 0x02;
      btif_sbc_encode_frames(&voice_sbc_encoder, &PcmEncData, &oneChunkConsumed,
                             &output[outputOffset], &oneChunkOutput, 0xFFFF);
      outputOffset += oneChunkOutput;
      // output[outputOffset++] = 0x00;

      bytes_encoded += oneChunkConsumed;
    }

    outputSbcBytes = outputOffset;
  } else {
    PcmEncData.data = input;
    PcmEncData.dataLen = inputBytes;

    btif_sbc_encode_frames(&voice_sbc_encoder, &PcmEncData, &bytes_encoded,
                           output, &outputSbcBytes, 0xFFFF);
  }

  TRACE(2, "Encode %d bytes PCM data into %d bytes SBC data.", inputBytes,
        outputSbcBytes);
  TRACE(1, "Consumed PCM data %d bytes", bytes_encoded);

  *purchasedBytes = bytes_encoded;

  return outputSbcBytes;
}

uint32_t voice_sbc_decode(uint8_t *pcm_buffer, CQueue *encodedDataQueue,
                          uint32_t expectedOutputSize, uint8_t isReset) {
  if (isReset) {
    voice_sbc_init_decoder();
  }
  int r = 0;
  unsigned char *e1 = NULL, *e2 = NULL;
  unsigned int len1 = 0, len2 = 0;
  uint32_t sbcDataBytesToDecode;
  unsigned int pcm_offset = 0;
  uint16_t byte_decode;
  int8_t ret;
  btif_sbc_pcm_data_t voice_PcmDecData;

get_again:
  voice_PcmDecData.data = pcm_buffer + pcm_offset;
  voice_PcmDecData.dataLen = 0;

  if (LengthOfCQueue(encodedDataQueue) >
      VOICE_SBC_ENCODED_DATA_SIZE_PER_FRAME) {
    sbcDataBytesToDecode = VOICE_SBC_ENCODED_DATA_SIZE_PER_FRAME;
  } else {
    sbcDataBytesToDecode = LengthOfCQueue(encodedDataQueue);
  }

  len1 = len2 = 0;
  r = PeekCQueue(encodedDataQueue, sbcDataBytesToDecode, &e1, &len1, &e2,
                 &len2);
  if ((r == CQ_ERR) || (0 == len1)) {
    goto exit;
  }

  ret = btif_sbc_decode_frames(&voice_sbc_decoder, (unsigned char *)e1, len1,
                               &byte_decode, &voice_PcmDecData,
                               expectedOutputSize - pcm_offset,
                               voice_sbc_eq_band_gain);

  TRACE(4, "len1 %d byte_decode %d expectedOutputSize %d pcm_offset %d", len1,
        byte_decode, expectedOutputSize, pcm_offset);
  TRACE(1, "voice_PcmDecData.dataLen %d", voice_PcmDecData.dataLen);

  DeCQueue(encodedDataQueue, 0, byte_decode);

  pcm_offset += voice_PcmDecData.dataLen;

  if (expectedOutputSize == pcm_offset) {
    goto exit;
  }

  if ((ret == BT_STS_SDP_CONT_STATE) || (ret == BT_STS_SUCCESS)) {
    goto get_again;
  }

exit:
  TRACE(1, "Get pcm data size %d", pcm_offset);
  return pcm_offset;
}

int voice_sbc_init(VOICE_SBC_CONFIG_T *pConfig) {
  voice_sbc_config = *pConfig;
  return 0;
}

#endif