/***************************************************************************
 *
 * 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 A2DP_CP_ACCEL

#include "a2dp_decoder_cp.h"
#include "a2dp_decoder_internal.h"
#include "cp_accel.h"
#include "hal_location.h"
#include "hal_timer.h"
#include "hal_trace.h"
#include "heap_api.h"
#include "norflash_api.h"

#define CP_IN_FRAME_CNT 100
#define CP_OUT_FRAME_CNT 3

#define CP_IN_CACHE_SIZE (1024 * 10)

#if defined(A2DP_LHDC_V3)
#define CP_HEAP_SIZE (1024 * 64)
#else
#define CP_HEAP_SIZE (1024 * 32)
#endif

enum CP_DEC_STATE_T {
  CP_DEC_STATE_IDLE,
  CP_DEC_STATE_WORKING,
  CP_DEC_STATE_DONE,
  CP_DEC_STATE_INIT_DONE,
};

struct CP_IN_FRAME_INFO_T {
  uint32_t pos;
  uint32_t len;
};

struct CP_OUT_FRAME_INFO_T {
  enum CP_DEC_STATE_T state;
  uint32_t pos;
  uint32_t len;
};

static CP_BSS_LOC uint32_t cp_heap_buf[CP_HEAP_SIZE / 4];
static CP_BSS_LOC heap_handle_t cp_heap;

static CP_BSS_LOC uint16_t cp_in_widx;
static CP_BSS_LOC uint16_t cp_in_ridx;

static CP_BSS_LOC uint8_t cp_out_widx;
static CP_BSS_LOC uint8_t cp_out_ridx;

static CP_BSS_LOC struct CP_IN_FRAME_INFO_T *in_frames;
static CP_BSS_LOC struct CP_OUT_FRAME_INFO_T *out_frames;

static CP_BSS_LOC uint8_t *cp_in_cache;
static CP_BSS_LOC uint8_t *cp_out_cache;

static CP_BSS_LOC bool reset_frames;

#ifdef A2DP_TRACE_CP_DEC_TIME
static CP_BSS_LOC uint32_t cp_last_dec_time;
#endif

static uint8_t max_buffer_frames = 2;
static bool mcu_dec_inited;
static A2DP_CP_DECODE_T decode_frame;
static enum CP_PROC_DELAY_T proc_delay;

static bool cp_need_reset;

CP_TEXT_SRAM_LOC
unsigned int set_cp_reset_flag(uint8_t evt) {
  cp_need_reset = true;
  return 0;
}

bool is_cp_need_reset(void) {
  bool ret = cp_need_reset;
  cp_need_reset = false;
  return ret;
}

bool is_cp_init_done(void) { return cp_accel_init_done(); }

CP_TEXT_SRAM_LOC
static void reset_frame_info(void) {
  uint32_t idle_cnt;
  int i;

  if (proc_delay == CP_PROC_DELAY_0_FRAME) {
    idle_cnt = CP_OUT_FRAME_CNT;
  } else if (proc_delay == CP_PROC_DELAY_1_FRAME) {
    idle_cnt = CP_OUT_FRAME_CNT - 1;
  } else {
    idle_cnt = CP_OUT_FRAME_CNT - 2;
  }

  for (i = 0; i < CP_OUT_FRAME_CNT; i++) {
    if (i < idle_cnt) {
      out_frames[i].state = CP_DEC_STATE_IDLE;
    } else {
      out_frames[i].state = CP_DEC_STATE_INIT_DONE;
    }
  }

  cp_in_widx = 0;
  cp_in_ridx = 0;
  cp_out_widx = 0;
  cp_out_ridx = idle_cnt;

  reset_frames = false;
}

CP_TEXT_SRAM_LOC
static unsigned int cp_a2dp_main(uint8_t event) {
  int ret;
#ifdef A2DP_TRACE_CP_DEC_TIME
  uint32_t stime;
  uint32_t etime;
#endif

  if (!mcu_dec_inited) {
    return 0;
  }

  if (decode_frame) {
    do {
#ifdef A2DP_TRACE_CP_DEC_TIME
      stime = hal_fast_sys_timer_get();
#endif

      ret = decode_frame();

#ifdef A2DP_TRACE_CP_DEC_TIME
      etime = hal_fast_sys_timer_get();
      TRACE_A2DP_DECODER_I("cp_decode: %5u us in %5u us",
                           FAST_TICKS_TO_US(etime - stime),
                           FAST_TICKS_TO_US(etime - cp_last_dec_time));
      cp_last_dec_time = etime;
#endif
    } while (ret == 0);
  }

  if (reset_frames) {
    reset_frame_info();
#ifdef A2DP_TRACE_CP_ACCEL
    TRACE_A2DP_DECODER_I("%s: Reset frames", __func__);
#endif
  }

  return 0;
}

static struct cp_task_desc TASK_DESC_A2DP = {
    CP_ACCEL_STATE_CLOSED, cp_a2dp_main, NULL, NULL, set_cp_reset_flag};
int a2dp_cp_init(A2DP_CP_DECODE_T decode_func, enum CP_PROC_DELAY_T delay) {
  if (delay >= CP_PROC_DELAY_QTY) {
    return 1;
  }
  mcu_dec_inited = false;
  decode_frame = decode_func;
  proc_delay = delay;
#ifdef A2DP_TRACE_CP_DEC_TIME
  cp_last_dec_time = hal_fast_sys_timer_get();
#endif

  norflash_api_flush_disable(NORFLASH_API_USER_CP,
                             (uint32_t)cp_accel_init_done);
  cp_accel_open(CP_TASK_A2DP_DECODE, &TASK_DESC_A2DP);
  while (cp_accel_init_done() == false) {
    hal_sys_timer_delay_us(100);
  }
  norflash_api_flush_enable(NORFLASH_API_USER_CP);
  return 0;
}
int a2dp_cp_deinit(void) {
  cp_accel_close(CP_TASK_A2DP_DECODE);

  return 0;
}

SRAM_TEXT_LOC
int a2dp_cp_decoder_init(uint32_t out_frame_len, uint8_t max_frames) {
  uint32_t i;
  max_buffer_frames = max_frames;
  if (!mcu_dec_inited) {
#ifdef A2DP_TRACE_CP_ACCEL
    TRACE_A2DP_DECODER_I("%s: Decoder init", __func__);
#endif
    if (cp_accel_init_done() == false) {
      TRACE_A2DP_DECODER_I("%s: CP ACCEL not init yet", __func__);
      return 6;
    }

    cp_heap = heap_register(cp_heap_buf, sizeof(cp_heap_buf));
    if (cp_heap == NULL) {
      return 1;
    }

    in_frames = heap_malloc(cp_heap, sizeof(in_frames[0]) * CP_IN_FRAME_CNT);
    if (in_frames == NULL) {
      return 2;
    }

    out_frames = heap_malloc(cp_heap, sizeof(out_frames[0]) * CP_OUT_FRAME_CNT);
    if (out_frames == NULL) {
      return 3;
    }

    cp_in_cache = heap_malloc(cp_heap, CP_IN_CACHE_SIZE);
    if (cp_in_cache == NULL) {
      return 4;
    }

    cp_out_cache = heap_malloc(cp_heap, out_frame_len * CP_OUT_FRAME_CNT);
    if (cp_out_cache == NULL) {
      return 5;
    }

    for (i = 0; i < CP_OUT_FRAME_CNT; i++) {
      out_frames[i].pos = out_frame_len * i;
      out_frames[i].len = out_frame_len;
    }
    reset_frame_info();

    mcu_dec_inited = true;
  }

  return 0;
}

CP_TEXT_SRAM_LOC
static uint32_t get_in_frame_cnt(uint32_t in_widx, uint32_t in_ridx) {
  uint32_t cnt;

  if (in_widx >= in_ridx) {
    cnt = in_widx - in_ridx;
  } else {
    cnt = CP_IN_FRAME_CNT - in_ridx + in_widx;
  }

  return cnt;
}

uint32_t get_in_cp_frame_cnt(void) {
  return get_in_frame_cnt(cp_in_widx, cp_in_ridx);
}

uint32_t get_in_cp_frame_delay(void) { return proc_delay; }

SRAM_TEXT_LOC
static uint32_t get_in_frame_free_cnt(uint32_t in_widx, uint32_t in_ridx) {
  uint32_t free_cnt;

  if (in_widx >= in_ridx) {
    free_cnt = CP_IN_FRAME_CNT - in_widx + in_ridx;
  } else {
    free_cnt = in_ridx - in_widx;
  }
  free_cnt -= 1;

  return free_cnt;
}

SRAM_TEXT_LOC
int a2dp_cp_put_in_frame(const void *buf1, uint32_t len1, const void *buf2,
                         uint32_t len2) {
  uint16_t free_cnt;
  uint16_t in_widx;
  uint16_t in_ridx;
  uint16_t prev_in_widx;
  uint32_t free_len;
  uint32_t in_wpos;
  uint32_t in_rpos;
  uint32_t aligned_len;

  if (reset_frames) {
    return -1;
  }

  in_widx = cp_in_widx;
  in_ridx = cp_in_ridx;

  if (max_buffer_frames < get_in_cp_frame_cnt()) {
    return 1;
  }

  free_cnt = get_in_frame_free_cnt(in_widx, in_ridx);
  if (free_cnt == 0) {
    return 1;
  }

  if (in_widx == in_ridx) {
    in_wpos = 0;
    in_rpos = 0;
  } else {
    if (in_widx == 0) {
      prev_in_widx = CP_IN_FRAME_CNT - 1;
    } else {
      prev_in_widx = in_widx - 1;
    }
    in_wpos = in_frames[prev_in_widx].pos + in_frames[prev_in_widx].len;
    if (in_wpos >= CP_IN_CACHE_SIZE) {
      in_wpos -= CP_IN_CACHE_SIZE;
    }
    in_rpos = in_frames[in_ridx].pos;
  }

  // Align to word boundary
  in_wpos = (in_wpos + 3) & ~3;
  if (in_wpos >= CP_IN_CACHE_SIZE) {
    in_wpos -= CP_IN_CACHE_SIZE;
  }
  aligned_len = (len1 + len2 + 3) & ~3;

  if (in_wpos >= in_rpos) {
    free_len = CP_IN_CACHE_SIZE - in_wpos;
    if (in_rpos == 0) {
      free_len -= 1;
    }
    if (free_len < aligned_len) {
      free_len = (in_rpos > 0) ? (in_rpos - 1) : 0;
      if (free_len < aligned_len) {
        return 2;
      }
      in_wpos = 0;
    }
  } else {
    free_len = in_rpos - in_wpos - 1;
    if (free_len < aligned_len) {
      return 3;
    }
  }

  in_frames[in_widx].pos = in_wpos;
  in_frames[in_widx].len = len1 + len2;

  if (len1) {
    memcpy(&cp_in_cache[in_wpos], buf1, len1);
    in_wpos += len1;
  }
  if (len2) {
    memcpy(&cp_in_cache[in_wpos], buf2, len2);
    in_wpos += len2;
  }

  in_widx += 1;
  if (in_widx >= CP_IN_FRAME_CNT) {
    in_widx -= CP_IN_FRAME_CNT;
  }
  cp_in_widx = in_widx;

  return 0;
}

CP_TEXT_SRAM_LOC
int a2dp_cp_get_in_frame(void **p_buf, uint32_t *p_len) {
  uint16_t in_widx;
  uint16_t in_ridx;
  uint32_t in_rpos;

  if (reset_frames) {
    return -1;
  }

  in_widx = cp_in_widx;
  in_ridx = cp_in_ridx;

  if (in_widx == in_ridx) {
    return 1;
  }

  in_rpos = in_frames[in_ridx].pos;

  if (p_buf) {
    *p_buf = &cp_in_cache[in_rpos];
  }
  if (p_len) {
    *p_len = in_frames[in_ridx].len;
  }

  return 0;
}

CP_TEXT_SRAM_LOC
int a2dp_cp_consume_in_frame(void) {
  uint16_t in_widx;
  uint16_t in_ridx;

  if (reset_frames) {
    return 0;
  }

  in_widx = cp_in_widx;
  in_ridx = cp_in_ridx;

  if (in_widx == in_ridx) {
    return 1;
  }

  in_ridx += 1;
  if (in_ridx >= CP_IN_FRAME_CNT) {
    in_ridx -= CP_IN_FRAME_CNT;
  }
  cp_in_ridx = in_ridx;

  return 0;
}

CP_TEXT_SRAM_LOC
uint32_t a2dp_cp_get_in_frame_index(void) { return cp_in_ridx; }

SRAM_TEXT_LOC
uint32_t a2dp_cp_get_in_frame_cnt_by_index(uint32_t ridx) {
  return get_in_frame_cnt(cp_in_widx, ridx);
}

SRAM_TEXT_LOC
void a2dp_cp_reset_frame(void) {
#ifdef A2DP_TRACE_CP_ACCEL
  TRACE_A2DP_DECODER_I("%s: Reset frames", __func__);
#endif

  reset_frames = true;

  // Notify CP to work again
  cp_accel_send_event_mcu2cp(1);
}

SRAM_TEXT_LOC
bool a2dp_cp_get_frame_reset_status(void) { return reset_frames; }

CP_TEXT_SRAM_LOC
enum CP_EMPTY_OUT_FRM_T a2dp_cp_get_emtpy_out_frame(void **p_buf,
                                                    uint32_t *p_len) {
  enum CP_EMPTY_OUT_FRM_T ret;
  uint8_t out_widx;
  uint32_t out_wpos;
  enum CP_DEC_STATE_T state;

  if (reset_frames) {
    return CP_EMPTY_OUT_FRM_ERR;
  }

  out_widx = cp_out_widx;
  state = out_frames[out_widx].state;

  if (state != CP_DEC_STATE_IDLE && state != CP_DEC_STATE_WORKING) {
    return CP_EMPTY_OUT_FRM_ERR;
  }

  if (state == CP_DEC_STATE_WORKING) {
    ret = CP_EMPTY_OUT_FRM_WORKING;
  } else {
    out_frames[out_widx].state = CP_DEC_STATE_WORKING;
    ret = CP_EMPTY_OUT_FRM_OK;
  }

  out_wpos = out_frames[out_widx].pos;

  if (p_buf) {
    *p_buf = &cp_out_cache[out_wpos];
  }
  if (p_len) {
    *p_len = out_frames[out_widx].len;
  }

  return ret;
}

CP_TEXT_SRAM_LOC
int a2dp_cp_consume_emtpy_out_frame(void) {
  uint8_t out_widx;

  if (reset_frames) {
    return 0;
  }

  out_widx = cp_out_widx;

  if (out_frames[out_widx].state != CP_DEC_STATE_WORKING) {
    return 1;
  }

  out_frames[out_widx].state = CP_DEC_STATE_DONE;

#ifdef A2DP_TRACE_CP_ACCEL
  TRACE_A2DP_DECODER_I("AD2P-CP out frame W[%d]", out_widx);
#endif

  out_widx += 1;
  if (out_widx >= CP_OUT_FRAME_CNT) {
    out_widx -= CP_OUT_FRAME_CNT;
  }
  cp_out_widx = out_widx;

  return 0;
}

SRAM_TEXT_LOC
int a2dp_cp_get_full_out_frame(void **p_buf, uint32_t *p_len) {
  uint8_t out_ridx;
  uint32_t out_rpos;
  enum CP_DEC_STATE_T state;

  if (reset_frames) {
    return -1;
  }

  out_ridx = cp_out_ridx;
  state = out_frames[out_ridx].state;

  if (state != CP_DEC_STATE_DONE && state != CP_DEC_STATE_INIT_DONE) {
    // Notify CP to work again
    cp_accel_send_event_mcu2cp(
        CP_BUILD_ID(CP_TASK_A2DP_DECODE, CP_EVENT_A2DP_DECODE));
    if (state == CP_DEC_STATE_WORKING) {
      return CP_EMPTY_OUT_FRM_WORKING;
    } else {
      return (10 + state);
    }
  }

  out_rpos = out_frames[out_ridx].pos;

  if (state == CP_DEC_STATE_DONE) {
    if (p_buf) {
      *p_buf = &cp_out_cache[out_rpos];
    }
    if (p_len) {
      *p_len = out_frames[out_ridx].len;
    }
  } else {
    if (p_buf) {
      *p_buf = NULL;
    }
    if (p_len) {
      *p_len = 0;
    }
  }

  return 0;
}

SRAM_TEXT_LOC
int a2dp_cp_consume_full_out_frame(void) {
  uint8_t out_ridx;
  enum CP_DEC_STATE_T state;

  if (reset_frames) {
    return 0;
  }

  out_ridx = cp_out_ridx;
  state = out_frames[out_ridx].state;

  if (state != CP_DEC_STATE_DONE && state != CP_DEC_STATE_INIT_DONE) {
    return 1;
  }

#ifdef A2DP_TRACE_CP_ACCEL
  TRACE_A2DP_DECODER_I("AD2P-CP out frame R[%d]", out_ridx);
#endif

  out_frames[out_ridx].state = CP_DEC_STATE_IDLE;

  out_ridx += 1;
  if (out_ridx >= CP_OUT_FRAME_CNT) {
    out_ridx -= CP_OUT_FRAME_CNT;
  }
  cp_out_ridx = out_ridx;

  // Notify CP to work again
  cp_accel_send_event_mcu2cp(
      CP_BUILD_ID(CP_TASK_A2DP_DECODE, CP_EVENT_A2DP_DECODE));

  return 0;
}

#endif