/***************************************************************************
 *
 * 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.
 *
 ****************************************************************************/
#ifdef SPEECH_LIB

#include "hal_aud.h"
#include "hal_trace.h"
#include "spectrum_fix.h"
#include "speech_memory.h"

#define AUDIO_SPECTRUM_FRAME_SIZE (256)

struct AudioSpectrum {
  SpectrumFixState *state;
  enum AUD_BITS_T bits;
  int16_t *frame;
  int16_t *data;
};

static AudioSpectrum audio_spectrum;

extern const SpectrumFixConfig audio_spectrum_cfg;

void audio_spectrum_open(int sample_rate, enum AUD_BITS_T sample_bits) {
  uint8_t *speech_buf = NULL;
  int speech_buf_size = 1024 * 5;

  syspool_get_buff((uint8_t **)&(audio_spectrum.frame),
                   AUDIO_SPECTRUM_FRAME_SIZE * sizeof(int16_t));
  syspool_get_buff((uint8_t **)&(audio_spectrum.data),
                   audio_spectrum_cfg.freq_num * sizeof(int16_t));
  syspool_get_buff(&speech_buf, speech_buf_size);
  speech_heap_init(speech_buf, speech_buf_size);

  audio_spectrum.state = spectrum_fix_init(
      sample_rate, AUDIO_SPECTRUM_FRAME_SIZE, &audio_spectrum_cfg);
  audio_spectrum.bits = sample_bits;
}

void audio_spectrum_close(void) {
  spectrum_fix_destroy(audio_spectrum.state);

  size_t total = 0, used = 0, max_used = 0;
  speech_memory_info(&total, &used, &max_used);
  TRACE(3, "SPEECH MALLOC MEM: total - %d, used - %d, max_used - %d.", total,
        used, max_used);
  ASSERT(used == 0, "[%s] used != 0", __func__);
}

static inline int16_t convertTo16Bit(int16_t x) { return x; }

static inline int16_t convertTo16Bit(int32_t x) { return (x >> 8); }

// convert stream to 16bit mono stream
template <typename DataType>
static void convertToMono16Bit(int16_t *out, DataType *in, int frame_size) {
  for (int i = 0; i < frame_size; i++) {
    out[i] = convertTo16Bit(in[i * 2]) / 2 + convertTo16Bit(in[i * 2 + 1]) / 2;
  }
}

template <typename DataType>
void audio_spectrum_run_impl(const uint8_t *buf, int len) {
  int frame_size = len / sizeof(DataType);
  DataType *pBuf = (DataType *)buf;

  ASSERT(frame_size % (2 * AUDIO_SPECTRUM_FRAME_SIZE) == 0,
         "[%s] only support N*%d frame size", __FUNCTION__,
         AUDIO_SPECTRUM_FRAME_SIZE);

  int audio_spectrum_block_cnt = frame_size / 2 / AUDIO_SPECTRUM_FRAME_SIZE;

  for (int i = 0; i < audio_spectrum_block_cnt; i++) {
    // stereo to mono, 24bit to 16bit
    convertToMono16Bit(audio_spectrum.frame,
                       pBuf + i * AUDIO_SPECTRUM_FRAME_SIZE * 2,
                       AUDIO_SPECTRUM_FRAME_SIZE);

    // TRACE(0,"pcm:");
    // DUMP16("0x%x, ", audio_spectrum.frame, 8);

    spectrum_fix_analysis(audio_spectrum.state, audio_spectrum.frame);
    if (i == 0) {
      spectrum_fix_process(audio_spectrum.state, audio_spectrum.data,
                           audio_spectrum_cfg.freq_num);
      // TRACE(1,"spectrum: %d", sizeof(DataType));
      // DUMP16("0x%x, ", audio_spectrum.data, audio_spectrum_cfg.freq_num);
    }
  }
}

void audio_spectrum_run(const uint8_t *buf, int len) {
  if (audio_spectrum.bits == AUD_BITS_16)
    audio_spectrum_run_impl<int16_t>(buf, len);
  else if (audio_spectrum.bits == AUD_BITS_24)
    audio_spectrum_run_impl<int32_t>(buf, len);
  else
    TRACE(1, "[%s] warning not suitable callback available", __func__);
}

#endif