pinebuds/services/bt_app/app_media_player.cpp

/***************************************************************************
 *
 * 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 <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "cmsis.h"
#include "cmsis_os.h"
#include "app_bt_trace.h"
#include "tgt_hardware.h"

#ifdef WL_DET
#include "app_mic_alg.h"
#endif

#ifdef MEDIA_PLAYER_SUPPORT

#include "hal_uart.h"
#include "hal_timer.h"
#include "audioflinger.h"
#include "lockcqueue.h"
#include "hal_cmu.h"
#include "analog.h"
#include "app_bt_stream.h"
#include "app_overlay.h"
#include "app_audio.h"
#include "app_utils.h"

#include "res_audio_data.h"
#include "res_audio_data_cn.h"
#include "resources.h"
#include "app_media_player.h"
#include "res_audio_ring.h"
#include "audio_prompt_sbc.h"
#include "app_bt.h"
#include "besbt.h"

#include "cqueue.h"
#include "btapp.h"
#include "app_bt_media_manager.h"
#ifdef VOICE_DATAPATH
#include "app_voicepath.h"
#include "app_ai_if.h"
#endif

#if defined(AUDIO_ANC_FB_MC_MEDIA) && defined(ANC_APP) && !defined(__AUDIO_RESAMPLE__)
#include"anc_process.h"
#include "hal_codec.h"
#endif

#ifdef __THIRDPARTY
#include "app_thirdparty.h"
#endif
#if defined(IBRT)
#include "app_tws_ibrt.h"
#include "app_ibrt_if.h"
#include "app_ibrt_voice_report.h"
#endif
#ifdef __INTERACTION__
uint8_t g_findme_fadein_vol = TGT_VOLUME_LEVEL_0;
#endif
static char need_init_decoder = 1;
static btif_sbc_decoder_t *media_sbc_decoder = NULL;

#define SBC_TEMP_BUFFER_SIZE 64
#define SBC_QUEUE_SIZE (SBC_TEMP_BUFFER_SIZE*16)
CQueue media_sbc_queue;

static float * media_sbc_eq_band_gain = NULL;

#ifdef __BT_ANC__
#define APP_AUDIO_PLAYBACK_BUFF_SIZE        (1024*3)
#else
#define APP_AUDIO_PLAYBACK_BUFF_SIZE        (1024*4)
#endif

#if defined(AUDIO_ANC_FB_MC_MEDIA) && defined(ANC_APP) && !defined(__AUDIO_RESAMPLE__)
static enum AUD_BITS_T sample_size_play_bt;
static enum AUD_SAMPRATE_T sample_rate_play_bt;
static uint32_t data_size_play_bt;

static uint8_t *playback_buf_bt;
static uint32_t playback_size_bt;
static int32_t playback_samplerate_ratio_bt;

static uint8_t *playback_buf_mc;
static uint32_t playback_size_mc;
static enum AUD_CHANNEL_NUM_T  playback_ch_num_bt;
#endif



#define  SBC_FRAME_LEN  64 //0x5c   /* pcm 512 bytes*/
static U8* g_app_audio_data = NULL;
static uint32_t g_app_audio_length = 0;
static uint32_t g_app_audio_read = 0;

static uint32_t g_play_continue_mark = 0;

static uint8_t app_play_sbc_stop_proc_cnt = 0;

static uint16_t g_prompt_chnlsel = PROMOT_ID_BIT_MASK_CHNLSEl_ALL;

//for continue play

#define MAX_SOUND_NUMBER 10

typedef struct tMediaSoundMap
{
    U8* data;  //total files
    uint32_t fsize; //file index

}_tMediaSoundMap;

const tMediaSoundMap*  media_sound_map;

const tMediaSoundMap media_sound_map_cn[MAX_SOUND_NUMBER] =
{
    {(U8*)CN_SOUND_ZERO,    sizeof(CN_SOUND_ZERO) },
    {(U8*)CN_SOUND_ONE,    sizeof(CN_SOUND_ONE) },
    {(U8*)CN_SOUND_TWO,     sizeof(CN_SOUND_TWO) },
    {(U8*)CN_SOUND_THREE,     sizeof(CN_SOUND_THREE) },
    {(U8*)CN_SOUND_FOUR,     sizeof(CN_SOUND_FOUR) },
    {(U8*)CN_SOUND_FIVE,     sizeof(CN_SOUND_FIVE) },
    {(U8*)CN_SOUND_SIX,     sizeof(CN_SOUND_SIX) },
    {(U8*)CN_SOUND_SEVEN,     sizeof(CN_SOUND_SEVEN) },
    {(U8*)CN_SOUND_EIGHT,     sizeof(CN_SOUND_EIGHT) },
    {(U8*)CN_SOUND_NINE,    sizeof(CN_SOUND_NINE) },
};

const tMediaSoundMap media_sound_map_en[MAX_SOUND_NUMBER] =
{
    {(U8*)EN_SOUND_ZERO,    EN_SOUND_ZERO_len },
    {(U8*)EN_SOUND_ONE,    EN_SOUND_ONE_len },
    {(U8*)EN_SOUND_TWO,     EN_SOUND_TWO_len },
    {(U8*)EN_SOUND_THREE,     EN_SOUND_THREE_len },
    {(U8*)EN_SOUND_FOUR,     EN_SOUND_FOUR_len },
    {(U8*)EN_SOUND_FIVE,     EN_SOUND_FIVE_len },
    {(U8*)EN_SOUND_SIX,     EN_SOUND_SIX_len },
    {(U8*)EN_SOUND_SEVEN,     EN_SOUND_SEVEN_len },
    {(U8*)EN_SOUND_EIGHT,     EN_SOUND_EIGHT_len },
    {(U8*)EN_SOUND_NINE,    EN_SOUND_NINE_len },
};

const uint8_t BT_MUTE[] = {
#include "res/SOUND_MUTE.txt"
};

char Media_player_number[MAX_PHB_NUMBER];

typedef struct tPlayContContext
{
    uint32_t g_play_continue_total; //total files
    uint32_t g_play_continue_n; //file index

    uint32_t g_play_continue_fread; //per file have readed

    U8 g_play_continue_array[MAX_PHB_NUMBER];

}_tPlayContContext;

tPlayContContext pCont_context;

APP_AUDIO_STATUS MSG_PLAYBACK_STATUS;
APP_AUDIO_STATUS*  ptr_msg_playback = &MSG_PLAYBACK_STATUS;

static int g_language = MEDIA_DEFAULT_LANGUAGE;
#ifdef AUDIO_LINEIN
static enum AUD_SAMPRATE_T app_play_audio_sample_rate = AUD_SAMPRATE_16000;
#endif

#define PREFIX_AUDIO(name)  ((g_language==MEDIA_DEFAULT_LANGUAGE) ? EN_##name : CN_##name)

#define PROMPT_MIX_PROPERTY_PTR_FROM_ENTRY_INDEX(index)  \
    ((PROMPT_MIX_PROPERTY_T *)((uintptr_t)__mixprompt_property_table_start + \
    (index)*sizeof(PROMPT_MIX_PROPERTY_T)))

int media_audio_init(void)
{
    const float EQLevel[25] = {
        0.0630957,  0.0794328, 0.1,       0.1258925, 0.1584893,
        0.1995262,  0.2511886, 0.3162278, 0.398107 , 0.5011872,
        0.6309573,  0.794328 , 1,         1.258925 , 1.584893 ,
        1.995262 ,  2.5118864, 3.1622776, 3.9810717, 5.011872 ,
        6.309573 ,  7.943282 , 10       , 12.589254, 15.848932
    };//-12~12
    uint8_t *buff = NULL;
    uint8_t i;

    app_audio_mempool_get_buff((uint8_t **)&media_sbc_eq_band_gain, CFG_HW_AUD_EQ_NUM_BANDS*sizeof(float));

    for (i=0; i<CFG_HW_AUD_EQ_NUM_BANDS; i++){
        media_sbc_eq_band_gain[i] = EQLevel[12];
    }

    app_audio_mempool_get_buff(&buff, SBC_QUEUE_SIZE);
    memset(buff, 0, SBC_QUEUE_SIZE);

    LOCK_APP_AUDIO_QUEUE();
    APP_AUDIO_InitCQueue(&media_sbc_queue, SBC_QUEUE_SIZE, buff);
    UNLOCK_APP_AUDIO_QUEUE();

    app_audio_mempool_get_buff((uint8_t **)&media_sbc_decoder, sizeof(btif_sbc_decoder_t) + 4);

    need_init_decoder = 1;

    app_play_sbc_stop_proc_cnt = 0;

    return 0;
}
static int decode_sbc_frame(unsigned char *pcm_buffer, unsigned int pcm_len)
{
    uint8_t underflow = 0;

    int r = 0;
    unsigned char *e1 = NULL, *e2 = NULL;
    unsigned int len1 = 0, len2 = 0;

    static btif_sbc_pcm_data_t pcm_data;
    bt_status_t ret = BT_STS_SUCCESS;
    unsigned short byte_decode = 0;

    pcm_data.data = (unsigned char*)pcm_buffer;

    LOCK_APP_AUDIO_QUEUE();
again:
    if(need_init_decoder) {
        pcm_data.data = (unsigned char*)pcm_buffer;
        pcm_data.dataLen = 0;
        btif_sbc_init_decoder(media_sbc_decoder);
    }

get_again:
    len1 = len2 = 0;
    r = APP_AUDIO_PeekCQueue(&media_sbc_queue, SBC_TEMP_BUFFER_SIZE, &e1, &len1, &e2, &len2);

    if(r == CQ_ERR) {
            need_init_decoder = 1;
            underflow = 1;
            r = pcm_data.dataLen;
            TRACE_MEDIA_PLAYESTREAM_I("[DECODE_SBC][END]");
            goto exit;
    }
    if (!len1){
        TRACE_MEDIA_PLAYESTREAM_I("[DECODE_SBC][LOOP] len1 underflow %d/%d\n", len1, len2);
        goto get_again;
    }

    ret = btif_sbc_decode_frames(media_sbc_decoder, (unsigned char *)e1,
                                len1, &byte_decode,
                                &pcm_data, pcm_len,
                                media_sbc_eq_band_gain);

    if(ret == BT_STS_CONTINUE) {
        need_init_decoder = 0;
        APP_AUDIO_DeCQueue(&media_sbc_queue, 0, len1);
        goto again;

        /* back again */
    }
    else if(ret == BT_STS_SUCCESS) {
        need_init_decoder = 0;
        r = pcm_data.dataLen;
        pcm_data.dataLen = 0;

        APP_AUDIO_DeCQueue(&media_sbc_queue, 0, byte_decode);

        //TRACE_MEDIA_PLAYESTREAM_I("p %d\n", pcm_data.sampleFreq);

        /* leave */
    }
    else if(ret == BT_STS_FAILED) {
        need_init_decoder = 1;
        r = pcm_data.dataLen;
        TRACE_MEDIA_PLAYESTREAM_E("[DECODE_SBC] err\n");

        APP_AUDIO_DeCQueue(&media_sbc_queue, 0, byte_decode);

        /* leave */
    }
    else if(ret == BT_STS_NO_RESOURCES) {
        need_init_decoder = 0;

        TRACE_MEDIA_PLAYESTREAM_I("[DECODE_SBC] no\n");

        /* leav */
        r = 0;
    }

exit:
    if (underflow){
        TRACE_MEDIA_PLAYESTREAM_I("[DECODE_SBC][END] len:%d\n ", pcm_len);
    }
    UNLOCK_APP_AUDIO_QUEUE();
    return r;
}

static int store_sbc_buffer(unsigned char *buf, unsigned int len)
{
    int nRet;

    LOCK_APP_AUDIO_QUEUE();
    nRet = APP_AUDIO_EnCQueue(&media_sbc_queue, buf, len);
    UNLOCK_APP_AUDIO_QUEUE();

    return nRet;
}

#if defined(IBRT)

#define PENDING_SYNC_PROMPT_BUFFER_CNT  8
// cleared when tws is disconnected
static uint16_t pendingSyncPromptId[PENDING_SYNC_PROMPT_BUFFER_CNT];
static uint8_t pending_sync_prompt_in_index = 0;
static uint8_t pending_sync_prompt_out_index = 0;
static uint8_t pending_sync_prompt_cnt = 0;

void app_tws_sync_prompt_manager_reset(void)
{
    pending_sync_prompt_in_index = 0;
    pending_sync_prompt_out_index = 0;
    pending_sync_prompt_cnt = 0;
}

void app_tws_sync_prompt_check(void)
{
    if (0 == pending_sync_prompt_cnt)
    {
        app_bt_active_mode_clear(ACTIVE_MODE_KEEPER_SYNC_VOICE_PROMPT, UPDATE_ACTIVE_MODE_FOR_ALL_LINKS);
    }

    if (IBRT_ACTIVE_MODE != app_ibrt_if_get_bt_ctrl_ctx()->tws_mode)
    {
        return;
    }

    bool isPlayPendingPrompt = false;
    uint16_t promptIdToPlay = 0;

    uint32_t lock = int_lock_global();
    if (pending_sync_prompt_cnt > 0)
    {
        isPlayPendingPrompt = true;
        promptIdToPlay = pendingSyncPromptId[pending_sync_prompt_out_index];
        pending_sync_prompt_out_index++;
        if (PENDING_SYNC_PROMPT_BUFFER_CNT == pending_sync_prompt_out_index)
        {
            pending_sync_prompt_out_index = 0;
        }
        pending_sync_prompt_cnt--;
    }
    int_unlock_global(lock);

    if (isPlayPendingPrompt)
    {
        TRACE_MEDIA_PLAYESTREAM_I("[POP_PENDING_PROMPT] 0x%x to play", promptIdToPlay);
        app_audio_manager_sendrequest(APP_BT_STREAM_MANAGER_START,
            BT_STREAM_MEDIA, 0, promptIdToPlay);
    }
}
#endif

void trigger_media_play(AUD_ID_ENUM id, uint8_t device_id, uint16_t aud_pram)
{
    uint16_t convertedId = (uint8_t)id;
    convertedId |= aud_pram;
    app_audio_manager_sendrequest(APP_BT_STREAM_MANAGER_START,BT_STREAM_MEDIA,device_id,convertedId);
}
void trigger_media_stop(AUD_ID_ENUM id, uint8_t device_id)
{
    /* Only the stop loop mode is supported */
    if (id == AUDIO_ID_FIND_MY_BUDS)
        app_play_sbc_stop_proc_cnt = 1;
}

uint32_t media_playAudioSideSelect(AUD_ID_ENUM id,uint8_t device_id, uint16_t side_select)
{
    trigger_media_play(id, device_id, PROMOT_ID_BIT_MASK_MERGING|side_select);
    return 0;
}


uint32_t media_PlayAudio(AUD_ID_ENUM id,uint8_t device_id)
{
    trigger_media_play(id, device_id, PROMOT_ID_BIT_MASK_MERGING|PROMOT_ID_BIT_MASK_CHNLSEl_ALL);
    return 0;
}

void media_PlayAudio_standalone(AUD_ID_ENUM id, uint8_t device_id)
{
    trigger_media_play(id, device_id, false);
}

void media_PlayAudio_locally(AUD_ID_ENUM id, uint8_t device_id)
{
    trigger_media_play(id, device_id, PROMOT_ID_BIT_MASK_MERGING|PROMOT_ID_BIT_MASK_CHNLSEl_ALL);
}

void media_PlayAudio_standalone_locally(AUD_ID_ENUM id, uint8_t device_id)
{
    trigger_media_play(id, device_id, PROMOT_ID_BIT_MASK_CHNLSEl_ALL);
}

void media_PlayAudio_remotely(AUD_ID_ENUM id, uint8_t device_id)
{
    trigger_media_play(id, device_id, PROMOT_ID_BIT_MASK_MERGING|PROMOT_ID_BIT_MASK_CHNLSEl_ALL);
}

void media_PlayAudio_standalone_remotely(AUD_ID_ENUM id, uint8_t device_id)
{
    trigger_media_play(id, device_id, PROMOT_ID_BIT_MASK_CHNLSEl_ALL);
}

AUD_ID_ENUM media_GetCurrentPrompt(uint8_t device_id)
{
    AUD_ID_ENUM currentPromptId = AUD_ID_INVALID;
    if (app_bt_stream_isrun(APP_PLAY_BACK_AUDIO))
    {
        currentPromptId = app_get_current_standalone_promptId();
    }
#ifdef MIX_AUDIO_PROMPT_WITH_A2DP_MEDIA_ENABLED
    else if (audio_prompt_is_playing_ongoing())
    {
        currentPromptId = (AUD_ID_ENUM)audio_prompt_get_prompt_id();
    }
#endif
    return currentPromptId;
}

#define IsDigit(c) (((c)>='0')&&((c)<='9'))
void media_Set_IncomingNumber(const char* pNumber)
{
    char *p_num = Media_player_number;
    uint8_t cnt = 0;
    for(uint8_t idx = 0; idx < MAX_PHB_NUMBER; idx++) {
        if(*(pNumber + idx) == 0)
            break;

        if(IsDigit(*(pNumber + idx))) {
            *(p_num + cnt) = *(pNumber + idx);
            TRACE_MEDIA_PLAYESTREAM_I("[INCOMINGNUMBER] cnt %d ,p_num  %d", cnt, *(p_num + cnt));
            cnt ++;
        }
    }
}

PROMPT_MIX_PROPERTY_T* get_prompt_mix_property(uint16_t promptId)
{
    for (uint32_t index = 0;
         index < ((uint32_t)(uintptr_t)__mixprompt_property_table_end -
         (uint32_t)(uintptr_t)__mixprompt_property_table_start) / sizeof(PROMPT_MIX_PROPERTY_T);
         index++)
    {
        if (PROMPT_MIX_PROPERTY_PTR_FROM_ENTRY_INDEX(index)->promptId == promptId)
        {
            return PROMPT_MIX_PROPERTY_PTR_FROM_ENTRY_INDEX(index);
        }
    }

    return NULL;
}
/*
Reference information for how to pass
parameters into PROMPT_MIX_PROPERTY_TO_ADD:

PROMPT_MIX_PROPERTY_TO_ADD(
promptId,
volume_level_override,
coeff_for_mix_prompt_for_music,
coeff_for_mix_music_for_music,
coeff_for_mix_prompt_for_call,
coeff_for_mix_call_for_call)
*/
void media_runtime_audio_prompt_update(uint16_t id, uint8_t** ptr, uint32_t* len)
{
    switch (id)
    {
        case AUD_ID_POWER_ON:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)? (U8*)EN_SOUND_POWER_ON:  (U8*)CN_POWER_ON; //aud_get_reouce((AUD_ID_ENUM)id, &g_app_audio_length, &type);
            g_app_audio_length =  (g_language==MEDIA_DEFAULT_LANGUAGE)? EN_SOUND_POWER_ON_len: sizeof(CN_POWER_ON);
            break;
        case AUD_ID_POWER_OFF:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_POWER_OFF: (U8*)CN_POWER_OFF;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_POWER_OFF_len: sizeof(CN_POWER_OFF);
            break;
        case AUD_ID_BT_PAIR_ENABLE:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_PAIR_ENABLE: (U8*)CN_BT_PAIR_ENABLE;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_PAIR_ENABLE_len: sizeof(CN_BT_PAIR_ENABLE);
            break;
        case AUD_ID_BT_PAIRING:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)? (U8*)EN_SOUND_PAIRING: (U8*)CN_BT_PAIRING;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_PAIRING_len: sizeof(CN_BT_PAIRING);
            break;
        case AUD_ID_BT_PAIRING_SUC:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_PAIRING_SUCCESS: (U8*)CN_BT_PAIRING_SUCCESS;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_PAIRING_SUCCESS_len: sizeof(CN_BT_PAIRING_SUCCESS);
            break;
        case AUD_ID_BT_PAIRING_FAIL:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_PAIRING_FAIL: (U8*)CN_BT_PAIRING_FAIL;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_PAIRING_FAIL_len: sizeof(CN_BT_PAIRING_FAIL);
            break;
        case AUD_ID_BT_CALL_REFUSE:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_REFUSE: (U8*)CN_BT_REFUSE;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_REFUSE_len: sizeof(CN_BT_REFUSE);
            break;
        case AUD_ID_BT_CALL_OVER:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_OVER: (U8*)CN_BT_OVER;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_OVER_len: sizeof(CN_BT_OVER);
            break;
        case AUD_ID_BT_CALL_ANSWER:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_ANSWER: (U8*)CN_BT_ANSWER;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_ANSWER_len: sizeof(CN_BT_ANSWER);
            break;
        case AUD_ID_BT_CALL_HUNG_UP:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_HUNG_UP: (U8*)CN_BT_HUNG_UP;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_HUNG_UP_len: sizeof(CN_BT_HUNG_UP);
            break;
        case AUD_ID_BT_CALL_INCOMING_CALL:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_INCOMING_CALL: (U8*)CN_BT_INCOMING_CALL;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_INCOMING_CALL_len: sizeof(CN_BT_INCOMING_CALL);
            break;
        case AUD_ID_BT_CHARGE_PLEASE:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_CHARGE_PLEASE: (U8*)CN_CHARGE_PLEASE;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_CHARGE_PLEASE_len: sizeof(CN_CHARGE_PLEASE);
            break;
        case AUD_ID_BT_CHARGE_FINISH:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_CHARGE_FINISH: (U8*)CN_CHARGE_FINISH;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_CHARGE_FINISH_len: sizeof(CN_CHARGE_FINISH);
            break;
        case AUD_ID_BT_CONNECTED:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_CONNECTED: (U8*)CN_BT_CONNECTED;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_CONNECTED_len: sizeof(CN_BT_CONNECTED);
            break;
        case AUD_ID_BT_DIS_CONNECT:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_DIS_CONNECT: (U8*)CN_BT_DIS_CONNECT;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_DIS_CONNECT_len: sizeof(CN_BT_DIS_CONNECT);
            break;
        case AUD_ID_BT_WARNING:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_WARNING: (U8*)CN_BT_WARNING;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_WARNING_len: sizeof(CN_BT_WARNING);
            break;
        case AUDIO_ID_BT_ALEXA_START:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_ALEXA_START: (U8*)CN_BT_ALEXA_START;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_ALEXA_START_len: sizeof(CN_BT_ALEXA_START);
            break;
        case AUDIO_ID_BT_ALEXA_STOP:
        case AUDIO_ID_FIND_MY_BUDS:
        case AUDIO_ID_FIND_TILE:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_ALEXA_STOP: (U8*)CN_BT_ALEXA_STOP;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_ALEXA_STOP_len: sizeof(CN_BT_ALEXA_STOP);
            break;
        case AUDIO_ID_BT_GSOUND_MIC_OPEN:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_GSOUND_MIC_OPEN: (U8*)CN_BT_GSOUND_MIC_OPEN;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_GSOUND_MIC_OPEN_len: sizeof(CN_BT_GSOUND_MIC_OPEN);
            break;
        case AUDIO_ID_BT_GSOUND_MIC_CLOSE:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_GSOUND_MIC_CLOSE: (U8*)CN_BT_GSOUND_MIC_CLOSE;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_GSOUND_MIC_CLOSE_len: sizeof(CN_BT_GSOUND_MIC_CLOSE);
            break;
        case AUDIO_ID_BT_GSOUND_NC:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_GSOUND_NC: (U8*)CN_BT_GSOUND_NC;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_GSOUND_NC_len: sizeof(CN_BT_GSOUND_NC);
            break;
        case AUD_ID_LANGUAGE_SWITCH:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_LANGUAGE_SWITCH: (U8*)CN_LANGUAGE_SWITCH;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_LANGUAGE_SWITCH_len: sizeof(CN_LANGUAGE_SWITCH);
            break;
        case AUDIO_ID_BT_MUTE:
            g_app_audio_data = (U8*)BT_MUTE;
            g_app_audio_length = sizeof(BT_MUTE);
            break;
        case AUD_ID_NUM_0:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)? (U8*)EN_SOUND_ZERO:  (U8*)CN_SOUND_ZERO;
            g_app_audio_length =  (g_language==MEDIA_DEFAULT_LANGUAGE)? EN_SOUND_ZERO_len: sizeof(CN_SOUND_ZERO);
            break;
        case AUD_ID_NUM_1:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)? (U8*)EN_SOUND_ONE:  (U8*)CN_SOUND_ONE;
            g_app_audio_length =  (g_language==MEDIA_DEFAULT_LANGUAGE)? EN_SOUND_ONE_len: sizeof(CN_SOUND_ONE);
            break;
        case AUD_ID_NUM_2:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)? (U8*)EN_SOUND_TWO:  (U8*)CN_SOUND_TWO;
            g_app_audio_length =  (g_language==MEDIA_DEFAULT_LANGUAGE)? EN_SOUND_TWO_len: sizeof(CN_SOUND_TWO);
            break;
        case AUD_ID_NUM_3:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)? (U8*)EN_SOUND_THREE:  (U8*)CN_SOUND_THREE;
            g_app_audio_length =  (g_language==MEDIA_DEFAULT_LANGUAGE)? EN_SOUND_THREE_len: sizeof(CN_SOUND_THREE);
            break;
        case AUD_ID_NUM_4:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)? (U8*)EN_SOUND_FOUR:  (U8*)CN_SOUND_FOUR;
            g_app_audio_length =  (g_language==MEDIA_DEFAULT_LANGUAGE)? EN_SOUND_FOUR_len: sizeof(CN_SOUND_FOUR);
            break;
        case AUD_ID_NUM_5:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)? (U8*)EN_SOUND_FIVE:  (U8*)CN_SOUND_FIVE;
            g_app_audio_length =  (g_language==MEDIA_DEFAULT_LANGUAGE)? EN_SOUND_FIVE_len: sizeof(CN_SOUND_FIVE);
            break;
        case AUD_ID_NUM_6:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)? (U8*)EN_SOUND_SIX:  (U8*)CN_SOUND_SIX;
            g_app_audio_length =  (g_language==MEDIA_DEFAULT_LANGUAGE)? EN_SOUND_SIX_len: sizeof(CN_SOUND_SIX);
            break;
        case AUD_ID_NUM_7:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)? (U8*)EN_SOUND_SEVEN:  (U8*)CN_SOUND_SEVEN;
            g_app_audio_length =  (g_language==MEDIA_DEFAULT_LANGUAGE)? EN_SOUND_SEVEN_len: sizeof(CN_SOUND_SEVEN);
            break;
        case AUD_ID_NUM_8:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)? (U8*)EN_SOUND_EIGHT:  (U8*)CN_SOUND_EIGHT;
            g_app_audio_length =  (g_language==MEDIA_DEFAULT_LANGUAGE)? EN_SOUND_EIGHT_len: sizeof(CN_SOUND_EIGHT);
            break;
        case AUD_ID_NUM_9:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)? (U8*)EN_SOUND_NINE:  (U8*)CN_SOUND_NINE;
            g_app_audio_length =  (g_language==MEDIA_DEFAULT_LANGUAGE)? EN_SOUND_NINE_len: sizeof(CN_SOUND_NINE);
            break;
#ifdef __BT_WARNING_TONE_MERGE_INTO_STREAM_SBC__
        case AUD_ID_RING_WARNING:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)? (U8*)RES_AUD_RING_SAMPRATE_16000:  (U8*)RES_AUD_RING_SAMPRATE_16000;
            g_app_audio_length =  (g_language==MEDIA_DEFAULT_LANGUAGE)? sizeof(RES_AUD_RING_SAMPRATE_16000): sizeof(RES_AUD_RING_SAMPRATE_16000);
            break;
#endif
#ifdef __INTERACTION__
        case AUD_ID_BT_FINDME:
            g_app_audio_data = (g_language==MEDIA_DEFAULT_LANGUAGE)?(U8*)EN_SOUND_FINDME: (U8*)CN_BT_FINDME;
            g_app_audio_length = (g_language==MEDIA_DEFAULT_LANGUAGE)?EN_SOUND_FINDME_len: sizeof(CN_BT_FINDME);
            break;
#endif
	case AUDIO_ID_BT_DUDU:
            g_app_audio_data = (U8*)EN_DUDU;
            g_app_audio_length =  EN_DUDU_len;
            break;
		case AUDIO_ID_BT_DU:
            g_app_audio_data = (U8*)EN_DUDU;
            g_app_audio_length =  EN_DUDU_len;
            break;
        default:
            g_app_audio_length = 0;
            break;
        }

      *ptr = g_app_audio_data;
      *len = g_app_audio_length;
}

void media_Play_init_audio(uint16_t aud_id)
{

    if (aud_id == AUD_ID_BT_CALL_INCOMING_NUMBER)
    {
          g_play_continue_mark = 1; 

        if (g_language == MEDIA_DEFAULT_LANGUAGE)
            media_sound_map = media_sound_map_en;
        else
            media_sound_map = media_sound_map_cn;

        memset(&pCont_context, 0x0, sizeof(pCont_context)); 
        
        pCont_context.g_play_continue_total =  strlen((const char*)Media_player_number);

        for (uint32_t i=0;( i<pCont_context.g_play_continue_total) && (i< MAX_PHB_NUMBER); i++)
        {
        pCont_context.g_play_continue_array[i] = Media_player_number[i] - '0';

        TRACE_MEDIA_PLAYESTREAM_I("[INIT_AUDIO] array[%d] = %d, total =%d",i,  pCont_context.g_play_continue_array[i], pCont_context.g_play_continue_total);

        }
    }   else{
        g_app_audio_read = 0;
        g_play_continue_mark = 0;
            
        media_runtime_audio_prompt_update(aud_id, &g_app_audio_data, &g_app_audio_length);
    }   
}
uint32_t app_play_sbc_more_data_fadeout(int16_t *buf, uint32_t len)
{
    uint32_t i;
    uint32_t j = 0;

    for (i = len; i > 0; i--){
        *(buf+j) = *(buf+j)*i/len;
        j++;
    }

    return len;
}

static uint32_t need_fadein_len = 0;
static uint32_t need_fadein_len_processed = 0;

int app_play_sbc_more_data_fadein_config(uint32_t len)
{
    TRACE_MEDIA_PLAYESTREAM_I("[FADEIN] config l:%d", len);
    need_fadein_len = len;
    need_fadein_len_processed = 0;
    return 0;
}
uint32_t app_play_sbc_more_data_fadein(int16_t *buf, uint32_t len)
{
    uint32_t i;
    uint32_t j = 0;
    uint32_t base;
    uint32_t dest;

    base = need_fadein_len_processed;
    dest = need_fadein_len_processed + len < need_fadein_len ?
           need_fadein_len_processed + len :
           need_fadein_len_processed;

    if (base >= dest){
//        TRACE_MEDIA_PLAYESTREAM_I("skip fadein");
        return len;
    }
//    TRACE_MEDIA_PLAYESTREAM_I("fadein l:%d base:%d dest:%d", len, base, dest);
//    DUMP16("%5d ", buf, 20);
//    DUMP16("%5d ", buf+len-19, 20);

    for (i = base; i < dest; i++){
        *(buf+j) = *(buf+j)*i/need_fadein_len;
        j++;
    }

    need_fadein_len_processed += j;
//    DUMP16("%05d ", buf, 20);
//    DUMP16("%5d ", buf+len-19, 20);
    return len;
}

uint32_t app_play_single_sbc_more_data(uint8_t *buf, uint32_t len)
{
    //int32_t stime, etime;
    //U16 byte_decode;
    uint32_t l = 0;

     //TRACE_MEDIA_PLAYESTREAM_I("app_play_sbc_more_data : %d, %d", g_app_audio_read, g_app_audio_length);

    if (g_app_audio_read < g_app_audio_length){
        unsigned int available_len = 0;
        unsigned int store_len = 0;

        available_len = AvailableOfCQueue(&media_sbc_queue);
        store_len = (g_app_audio_length - g_app_audio_read) > available_len ? available_len :(g_app_audio_length - g_app_audio_read);
        store_sbc_buffer((unsigned char *)(g_app_audio_data + g_app_audio_read), store_len);
        g_app_audio_read += store_len;
    }


        l = decode_sbc_frame(buf, len);

        if (l != len)
        {
            g_app_audio_read = g_app_audio_length;
            //af_stream_stop(AUD_STREAM_PLAYBACK);
            //af_stream_close(AUD_STREAM_PLAYBACK);
            TRACE_MEDIA_PLAYESTREAM_I("[SINGLE_SBC_MORE_DATA][END] length:%d len:%d l:%d", g_app_audio_length, len, l);
        }

    return l;
}


/* play continue sound */
uint32_t app_play_continue_sbc_more_data(uint8_t *buf, uint32_t len)
{

    uint32_t l, n, fsize = 0;

    U8*  pdata =NULL;

// store data
    unsigned int available_len = 0;
    unsigned int store_len = 0;

    if (pCont_context.g_play_continue_n < pCont_context.g_play_continue_total){
        do {
            n = pCont_context.g_play_continue_n;
            pdata = media_sound_map[pCont_context.g_play_continue_array[n]].data;
            fsize = media_sound_map[pCont_context.g_play_continue_array[n]].fsize;

            available_len = AvailableOfCQueue(&media_sbc_queue);
            if (!available_len)
                break;

            store_len = (fsize - pCont_context.g_play_continue_fread) > available_len ? available_len :(fsize - pCont_context.g_play_continue_fread);
            store_sbc_buffer((unsigned char *)(pdata + pCont_context.g_play_continue_fread), store_len);
            pCont_context.g_play_continue_fread += store_len;
            if (pCont_context.g_play_continue_fread == fsize){
                pCont_context.g_play_continue_n++;
                pCont_context.g_play_continue_fread = 0;
            }
        }while(pCont_context.g_play_continue_n < pCont_context.g_play_continue_total);
    }

    l = decode_sbc_frame(buf, len);

    if (l !=len){
        TRACE_MEDIA_PLAYESTREAM_I("[CONTINUE_SBC_MORE_DATA][END]");
    }

    return l;
}

uint32_t app_play_sbc_channel_select(int16_t *dst_buf, int16_t *src_buf, uint32_t src_len)
{
#if defined(IBRT)
    if (IS_PROMPT_CHNLSEl_ALL(g_prompt_chnlsel) || app_ibrt_voice_report_is_me(PROMPT_CHNLSEl_FROM_ID_VALUE(g_prompt_chnlsel)))
    {
        // Copy from tail so that it works even if dst_buf == src_buf
        for (int i = (int)(src_len - 1); i >= 0; i--)
        {
            dst_buf[i*2 + 0] = dst_buf[i*2 + 1] = src_buf[i];
        }
    }
    else
    {
        // Copy from tail so that it works even if dst_buf == src_buf
        for (int i = (int)(src_len - 1); i >= 0; i--)
        {
            dst_buf[i*2 + 0] = dst_buf[i*2 + 1] = 0;
        }
    }
#else
    if (IS_PROMPT_CHNLSEl_ALL(g_prompt_chnlsel))
    {
        // Copy from tail so that it works even if dst_buf == src_buf
        for (int i = (int)(src_len - 1); i >= 0; i--)
        {
            dst_buf[i*2 + 0] = dst_buf[i*2 + 1] = src_buf[i];
        }
    }
    else if (IS_PROMPT_CHNLSEl_LCHNL(g_prompt_chnlsel))
    {
        // Copy from tail so that it works even if dst_buf == src_buf
        for (int i = (int)(src_len - 1); i >= 0; i--)
        {
            dst_buf[i*2 + 0] = src_buf[i];
            dst_buf[i*2 + 1] = 0;
        }
    }
    else if (IS_PROMPT_CHNLSEl_RCHNL(g_prompt_chnlsel))
    {
        // Copy from tail so that it works even if dst_buf == src_buf
        for (int i = (int)(src_len - 1); i >= 0; i--)
        {
            dst_buf[i*2 + 0] = 0;
            dst_buf[i*2 + 1] = src_buf[i];
        }
    }
    else
    {
        // Copy from tail so that it works even if dst_buf == src_buf
        for (int i = (int)(src_len - 1); i >= 0; i--)
        {
            dst_buf[i*2 + 0] = dst_buf[i*2 + 1] = 0;
        }
    }
#endif
    return 0;
}

#ifdef __BT_ANC__
extern uint8_t bt_sco_samplerate_ratio ;
extern void us_fir_init (void);
extern U32 us_fir_run (short* src_buf, short* dst_buf, U32 in_samp_num);
#endif

uint32_t g_cache_buff_sz = 0;

static int16_t *app_play_sbc_cache = NULL;
uint32_t app_play_sbc_more_data(uint8_t *buf, uint32_t len)
{
#if defined(IBRT)
    app_ibrt_voice_report_trigger_checker();
#endif

#ifdef VOICE_DATAPATH
    if (app_voicepath_get_stream_pending_state(VOICEPATH_STREAMING))
    {
        af_stream_start(AUD_STREAM_ID_0, AUD_STREAM_CAPTURE);
    #ifdef MIX_MIC_DURING_MUSIC
        app_voicepath_enable_hw_sidetone(0, HW_SIDE_TONE_MAX_ATTENUATION_COEF);
    #endif
        app_voicepath_set_stream_state(VOICEPATH_STREAMING, true);
        app_voicepath_set_pending_started_stream(VOICEPATH_STREAMING, false);
    }
#endif
    uint32_t l = 0;

    memset(buf, 0, len);

#if defined(MEDIA_PLAY_24BIT)
    len /= 2;
#endif

#ifdef __BT_ANC__
    uint32_t dec_len = len/bt_sco_samplerate_ratio;
#endif

    if(app_play_sbc_cache)
        memset(app_play_sbc_cache, 0, g_cache_buff_sz);

    if (app_play_sbc_stop_proc_cnt) {
        if (app_play_sbc_stop_proc_cnt == 1) {
            app_play_sbc_stop_proc_cnt = 2;
        } else if (app_play_sbc_stop_proc_cnt == 2) {
            app_play_sbc_stop_proc_cnt = 3;

            // For 8K sample rate data, it takes about 4ms (or 12ms if h/w resample in use) from codec to DAC PA.
            // The playback stream should be stopped after the last data arrives at DAC PA, otherwise there
            // might be some pop sound.
            app_play_audio_stop();
        }
    } else {
        if (app_play_sbc_cache) {
#ifdef __BT_ANC__
            len = dec_len;
#endif
            if (g_play_continue_mark) {
                l = app_play_continue_sbc_more_data((uint8_t *)app_play_sbc_cache, len/2);
            } else {
                l = app_play_single_sbc_more_data((uint8_t *)app_play_sbc_cache, len/2);
            }
            if (l != len / 2) {
#ifdef __BT_ANC__
                len = dec_len*3;
#endif
                memset(app_play_sbc_cache+l, 0, len/2-l);
                app_play_sbc_stop_proc_cnt = 1;
            }
#ifdef __BT_ANC__
            len = dec_len*3;
            l = l*3;
            us_fir_run((short*)app_play_sbc_cache, (short*)buf, dec_len/2/2);
            app_play_sbc_channel_select((int16_t*)buf, (int16_t*)buf, len/2/2);
#else
            app_play_sbc_channel_select((int16_t *)buf, app_play_sbc_cache, len/2/2);
#endif

#if defined(MEDIA_PLAY_24BIT)
            int32_t *buf32 = (int32_t *)buf;
            int16_t *buf16 = (int16_t *)buf;

            for (int16_t i = len/2 - 1; i >= 0; i--) {
                buf32[i] = ((int32_t)buf16[i] << 8);
            }
            len *= 2;
#endif
        } else {
#if defined(MEDIA_PLAY_24BIT)
            len *= 2;
#endif
            memset(buf, 0, len);
        }
    }

    return l;
}

#ifdef AUDIO_LINEIN
static uint8_t app_play_lineinmode_merge = 0;
static uint8_t app_play_lineinmode_mode = 0;

inline static void app_play_audio_lineinmode_mono_merge(int16_t *aud_buf_mono, int16_t *ring_buf_mono, uint32_t aud_buf_len)
{
    uint32_t i = 0;
    for (i = 0; i < aud_buf_len; i++) {
        aud_buf_mono[i] = (aud_buf_mono[i]>>1) + (ring_buf_mono[i]>>1);
    }
}

inline static void app_play_audio_lineinmode_stereo_merge(int16_t *aud_buf_stereo, int16_t *ring_buf_mono, uint32_t aud_buf_len)
{
    uint32_t aud_buf_stereo_offset = 0;
    uint32_t ring_buf_mono_offset = 0;
    for (aud_buf_stereo_offset = 0; aud_buf_stereo_offset < aud_buf_len; ) {
        aud_buf_stereo[aud_buf_stereo_offset] = aud_buf_stereo[aud_buf_stereo_offset] + (ring_buf_mono[ring_buf_mono_offset]>>1);
        aud_buf_stereo_offset++;
        aud_buf_stereo[aud_buf_stereo_offset] = aud_buf_stereo[aud_buf_stereo_offset] + (ring_buf_mono[ring_buf_mono_offset]>>1);
        aud_buf_stereo_offset++;
        ring_buf_mono_offset++;
    }
}

uint32_t app_play_audio_lineinmode_more_data(uint8_t *buf, uint32_t len)
{
    uint32_t l = 0;
    if (app_play_lineinmode_merge && app_play_sbc_cache){
        TRACE(1,"line in mode:%d ", len);
        if (app_play_lineinmode_mode == 1){
            if (g_play_continue_mark){
                l = app_play_continue_sbc_more_data((uint8_t *)app_play_sbc_cache, len);
            }else{
                l = app_play_single_sbc_more_data((uint8_t *)app_play_sbc_cache, len);
            }
            if (l != len){
                memset(app_play_sbc_cache+l, 0, len-l);
                app_play_lineinmode_merge = 0;
            }
            app_play_audio_lineinmode_mono_merge((int16_t *)buf, (int16_t *)app_play_sbc_cache, len/2);
        }else if (app_play_lineinmode_mode == 2){
            if (g_play_continue_mark){
                l = app_play_continue_sbc_more_data((uint8_t *)app_play_sbc_cache, len/2);
            }else{
                l = app_play_single_sbc_more_data((uint8_t *)app_play_sbc_cache, len/2);
            }
            if (l != len/2){
                memset(app_play_sbc_cache+l, 0, len/2-l);
                app_play_lineinmode_merge = 0;
            }
            app_play_audio_lineinmode_stereo_merge((int16_t *)buf, (int16_t *)app_play_sbc_cache, len/2);
        }
    }

    return l;
}

int app_play_audio_lineinmode_init(uint8_t mode, uint32_t buff_len)
{
    TRACE(1,"lapp_play_audio_lineinmode_init:%d ", buff_len);
    app_play_lineinmode_mode = mode;
    app_audio_mempool_get_buff((uint8_t **)&app_play_sbc_cache, buff_len);
    media_audio_init();
    return 0;
}

int app_play_audio_lineinmode_start(APP_AUDIO_STATUS* status)
{
    if (app_play_audio_sample_rate == AUD_SAMPRATE_44100){
        LOCK_APP_AUDIO_QUEUE();
        APP_AUDIO_DeCQueue(&media_sbc_queue, 0, APP_AUDIO_LengthOfCQueue(&media_sbc_queue));
        UNLOCK_APP_AUDIO_QUEUE();
        app_play_lineinmode_merge = 1;
        need_init_decoder = 1;
        media_Play_init_audio(status->aud_id);
    }
    return 0;
}

int app_play_audio_lineinmode_stop(APP_AUDIO_STATUS* status)
{
    app_play_lineinmode_merge = 0;
    return 0;
}
#endif


#if defined(AUDIO_ANC_FB_MC_MEDIA) && defined(ANC_APP) && !defined(__AUDIO_RESAMPLE__)
#define DELAY_SAMPLE_MC (33*2)     //  2:ch
static int32_t delay_buf_media[DELAY_SAMPLE_MC];
static uint32_t audio_mc_data_playback_media(uint8_t *buf, uint32_t mc_len_bytes)
{
   uint32_t begin_time;
   //uint32_t end_time;
   begin_time = hal_sys_timer_get();
   TRACE_MEDIA_PLAYESTREAM_I("[PLAYBACK_MEDIA][MC] %d",begin_time);

   float left_gain;
   float right_gain;
   int32_t playback_len_bytes,mc_len_bytes_8;
   int32_t i,j,k;
   int delay_sample;

   mc_len_bytes_8=mc_len_bytes/8;

   hal_codec_get_dac_gain(&left_gain,&right_gain);

   //TRACE_MEDIA_PLAYESTREAM_I("playback_samplerate_ratio:  %d",playback_samplerate_ratio);

  // TRACE_MEDIA_PLAYESTREAM_I("left_gain:  %d",(int)(left_gain*(1<<12)));
  // TRACE_MEDIA_PLAYESTREAM_I("right_gain: %d",(int)(right_gain*(1<<12)));

   playback_len_bytes=mc_len_bytes/playback_samplerate_ratio_bt;

    if (sample_size_play_bt == AUD_BITS_16)
    {
        int16_t *sour_p=(int16_t *)(playback_buf_bt+playback_size_bt/2);
        int16_t *mid_p=(int16_t *)(buf);
        int16_t *mid_p_8=(int16_t *)(buf+mc_len_bytes-mc_len_bytes_8);
        int16_t *dest_p=(int16_t *)buf;

        if(buf == playback_buf_mc)
        {
            sour_p=(int16_t *)playback_buf_bt;
        }

        delay_sample=DELAY_SAMPLE_MC;

        for(i=0,j=0;i<delay_sample;i=i+2)
        {
            mid_p[j++]=delay_buf_media[i];
            mid_p[j++]=delay_buf_media[i+1];
        }

        for(i=0;i<playback_len_bytes/2-delay_sample;i=i+2)
        {
            mid_p[j++]=sour_p[i];
            mid_p[j++]=sour_p[i+1];
        }

        for(j=0;i<playback_len_bytes/2;i=i+2)
        {
            delay_buf_media[j++]=sour_p[i];
            delay_buf_media[j++]=sour_p[i+1];
        }

        if(playback_samplerate_ratio_bt<=8)
        {
            for(i=0,j=0;i<playback_len_bytes/2;i=i+2*(8/playback_samplerate_ratio_bt))
            {
                mid_p_8[j++]=mid_p[i];
                mid_p_8[j++]=mid_p[i+1];
            }
        }
        else
        {
            for(i=0,j=0;i<playback_len_bytes/2;i=i+2)
            {
                for(k=0;k<playback_samplerate_ratio_bt/8;k++)
                {
                    mid_p_8[j++]=mid_p[i];
                    mid_p_8[j++]=mid_p[i+1];
                }
            }
        }

        anc_mc_run_stereo((uint8_t *)mid_p_8,mc_len_bytes_8,left_gain,right_gain,AUD_BITS_16);

        for(i=0,j=0;i<(mc_len_bytes_8)/2;i=i+2)
        {
            for(k=0;k<8;k++)
            {
                dest_p[j++]=mid_p_8[i];
                dest_p[j++]=mid_p_8[i+1];
            }
        }


    }
    else if (sample_size_play_bt == AUD_BITS_24)
    {
        int32_t *sour_p=(int32_t *)(playback_buf_bt+playback_size_bt/2);
        int32_t *mid_p=(int32_t *)(buf);
        int32_t *mid_p_8=(int32_t *)(buf+mc_len_bytes-mc_len_bytes_8);
        int32_t *dest_p=(int32_t *)buf;

        if(buf == (playback_buf_mc))
        {
            sour_p=(int32_t *)playback_buf_bt;
        }

        delay_sample=DELAY_SAMPLE_MC;

        for(i=0,j=0;i<delay_sample;i=i+2)
        {
            mid_p[j++]=delay_buf_media[i];
            mid_p[j++]=delay_buf_media[i+1];

        }

         for(i=0;i<playback_len_bytes/4-delay_sample;i=i+2)
        {
            mid_p[j++]=sour_p[i];
            mid_p[j++]=sour_p[i+1];
        }

         for(j=0;i<playback_len_bytes/4;i=i+2)
        {
            delay_buf_media[j++]=sour_p[i];
            delay_buf_media[j++]=sour_p[i+1];
        }

        if(playback_samplerate_ratio_bt<=8)
        {
            for(i=0,j=0;i<playback_len_bytes/4;i=i+2*(8/playback_samplerate_ratio_bt))
            {
                mid_p_8[j++]=mid_p[i];
                mid_p_8[j++]=mid_p[i+1];
            }
        }
        else
        {
            for(i=0,j=0;i<playback_len_bytes/4;i=i+2)
            {
                for(k=0;k<playback_samplerate_ratio_bt/8;k++)
                {
                    mid_p_8[j++]=mid_p[i];
                    mid_p_8[j++]=mid_p[i+1];
                }
            }
        }

        anc_mc_run_stereo((uint8_t *)mid_p_8,mc_len_bytes_8,left_gain,right_gain,AUD_BITS_24);

        for(i=0,j=0;i<(mc_len_bytes_8)/4;i=i+2)
        {
            for(k=0;k<8;k++)
            {
                dest_p[j++]=mid_p_8[i];
                dest_p[j++]=mid_p_8[i+1];
            }
        }

    }

  //  end_time = hal_sys_timer_get();

 //   TRACE_MEDIA_PLAYESTREAM_I("%s:run time: %d", __FUNCTION__, end_time-begin_time);

    return 0;
}
#endif

void app_audio_playback_done(void)
{
#if defined(IBRT)
    app_tws_sync_prompt_check();
#endif
}

int app_play_audio_stop(void)
{
    TRACE_MEDIA_PLAYESTREAM_I("[STOP]");
    
    app_audio_sendrequest(APP_PLAY_BACK_AUDIO, (uint8_t)APP_BT_SETTING_CLOSE, 0);
    return 0;
}


uint32_t g_active_aud_id = MAX_RECORD_NUM;

int app_play_audio_set_aud_id(uint32_t aud_id)
{
    g_active_aud_id = aud_id;
    return 0;
}

int app_play_audio_get_aud_id(void)
{
    return g_active_aud_id;
}

void app_play_audio_set_lang(int L)
{
    g_language = L;
}

int app_play_audio_get_lang()
{
    return g_language;
}
extern struct BT_DEVICE_T  app_bt_device;
int app_play_audio_onoff(bool onoff, APP_AUDIO_STATUS* status)
{
    static bool isRun =  false;

    struct AF_STREAM_CONFIG_T stream_cfg;
    uint8_t* bt_audio_buff = NULL;
    uint16_t bytes_parsed = 0;
    enum AUD_SAMPRATE_T sample_rate POSSIBLY_UNUSED = AUD_SAMPRATE_16000;
    uint16_t aud_id = 0;
    uint16_t aud_pram = 0;

    TRACE_MEDIA_PLAYESTREAM_I("[MEDIA_ONOFF] %s, to %s it",
        isRun?"Running":"Idle", onoff?"start":"stop");


    if (isRun == onoff)
    {
        return 0;
    }
    if (onoff ) {

#ifdef WL_DET
    app_mic_alg_audioloop(false,APP_SYSFREQ_78M);
#endif

#if defined(__AI_VOICE__)||defined(BISTO_ENABLED)
        app_ai_if_inform_music_or_prompt_status(true, AUD_SAMPRATE_16000);
        app_ai_if_pre_music_or_prompt_check();
#endif

#if defined(__THIRDPARTY)
         app_thirdparty_specific_lib_event_handle(THIRDPARTY_FUNC_NO1,THIRDPARTY_STOP);
#endif
        aud_id = PROMPT_ID_FROM_ID_VALUE(status->aud_id);
        aud_pram = PROMPT_PRAM_FROM_ID_VALUE(status->aud_id);
        g_prompt_chnlsel = PROMPT_CHNLSEl_FROM_ID_VALUE(aud_pram);
        TRACE_MEDIA_PLAYESTREAM_I("[MEDIA_ONOFF] aud_id:%04x %s aud_pram:%04x chnlsel:%d", status->aud_id, aud_id2str(aud_id), aud_pram, g_prompt_chnlsel);

        media_Play_init_audio(aud_id);
        app_play_audio_set_aud_id(aud_id);
        if (!g_app_audio_length){
            app_audio_sendrequest(APP_PLAY_BACK_AUDIO, (uint8_t)APP_BT_SETTING_CLOSE, 0);
            return 0;
        }

#if defined(AUDIO_ANC_FB_MC_MEDIA) && defined(ANC_APP) && !defined(__AUDIO_RESAMPLE__)
        app_sysfreq_req(APP_SYSFREQ_USER_APP_0, APP_SYSFREQ_104M);
#else
        app_sysfreq_req(APP_SYSFREQ_USER_APP_0, APP_SYSFREQ_52M);
#endif
        af_set_priority(AF_USER_AUDIO, osPriorityHigh);
        app_audio_mempool_init_with_specific_size(APP_AUDIO_BUFFER_SIZE);
        media_audio_init();

#if (defined(APP_LINEIN_A2DP_SOURCE)||defined(APP_I2S_A2DP_SOURCE))&&defined(ENHANCED_STACK)
        if(app_bt_device.src_or_snk == BT_DEVICE_SRC)
        {
            app_a2dp_source_init();
        }
#endif

        btif_sbc_init_decoder(media_sbc_decoder);
        btif_sbc_decode_frames(media_sbc_decoder,
                               g_app_audio_data, g_app_audio_length,
                               &bytes_parsed,
                               NULL, 0,
                               NULL);
        switch (media_sbc_decoder->streamInfo.sampleFreq)
        {
            case BTIF_SBC_CHNL_SAMPLE_FREQ_16:
                sample_rate = AUD_SAMPRATE_16000;
                break;
            case BTIF_SBC_CHNL_SAMPLE_FREQ_32:
                sample_rate = AUD_SAMPRATE_32000;
                break;
            case BTIF_SBC_CHNL_SAMPLE_FREQ_44_1:
                sample_rate = AUD_SAMPRATE_44100;
                break;
            case BTIF_SBC_CHNL_SAMPLE_FREQ_48:
                sample_rate = AUD_SAMPRATE_48000;
                break;
            default:
                sample_rate = AUD_SAMPRATE_16000;
                break;
        }

#ifdef PLAYBACK_USE_I2S
        hal_cmu_audio_resample_disable();
#endif

        memset(&stream_cfg, 0, sizeof(stream_cfg));

#if defined(MEDIA_PLAY_24BIT)
        stream_cfg.bits = AUD_BITS_24;
#else
        stream_cfg.bits = AUD_BITS_16;
#endif
        stream_cfg.channel_num = AUD_CHANNEL_NUM_2;
#ifdef __BT_ANC__
        stream_cfg.sample_rate =  AUD_SAMPRATE_48000 ;
#else
        stream_cfg.sample_rate =  AUD_SAMPRATE_16000;
#endif
#ifdef PLAYBACK_USE_I2S
        stream_cfg.device = AUD_STREAM_USE_I2S0_MASTER;
        stream_cfg.io_path = AUD_IO_PATH_NULL;
#else
        stream_cfg.device = AUD_STREAM_USE_INT_CODEC;
        stream_cfg.io_path = AUD_OUTPUT_PATH_SPEAKER;
#endif
#ifdef __INTERACTION__
        if(aud_id == AUD_ID_BT_FINDME)
        {
            stream_cfg.vol = g_findme_fadein_vol;
        }
        else
#endif
        {
            stream_cfg.vol = TGT_VOLUME_LEVEL_WARNINGTONE;
        }
        stream_cfg.handler = app_play_sbc_more_data;

        stream_cfg.data_size = APP_AUDIO_PLAYBACK_BUFF_SIZE;

#if defined(MEDIA_PLAY_24BIT)
        stream_cfg.data_size *= 2;
#endif

        g_cache_buff_sz = stream_cfg.data_size/2/2 ;

        app_audio_mempool_get_buff((uint8_t **)&app_play_sbc_cache, g_cache_buff_sz);
        app_audio_mempool_get_buff(&bt_audio_buff, stream_cfg.data_size);
        stream_cfg.data_ptr = BT_AUDIO_CACHE_2_UNCACHE(bt_audio_buff);

#ifdef __BT_ANC__
        bt_sco_samplerate_ratio = 3;
        us_fir_init();
#endif

#if defined(AUDIO_ANC_FB_MC_MEDIA) && defined(ANC_APP) && !defined(__AUDIO_RESAMPLE__)
        sample_size_play_bt=stream_cfg.bits;
        sample_rate_play_bt=stream_cfg.sample_rate;
        data_size_play_bt=stream_cfg.data_size;
        playback_buf_bt=stream_cfg.data_ptr;
        playback_size_bt=stream_cfg.data_size;
#ifdef __BT_ANC__
        playback_samplerate_ratio_bt=8;
#else
        playback_samplerate_ratio_bt=8*3;
#endif
        playback_ch_num_bt=stream_cfg.channel_num;
#endif
        af_stream_open(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK, &stream_cfg);

#if defined(AUDIO_ANC_FB_MC_MEDIA) && defined(ANC_APP) && !defined(__AUDIO_RESAMPLE__)
        stream_cfg.bits = sample_size_play_bt;
        stream_cfg.channel_num = playback_ch_num_bt;
        stream_cfg.sample_rate = sample_rate_play_bt;
        stream_cfg.device = AUD_STREAM_USE_MC;
        stream_cfg.vol = 0;
        stream_cfg.handler = audio_mc_data_playback_media;
        stream_cfg.io_path = AUD_OUTPUT_PATH_SPEAKER;

        app_audio_mempool_get_buff(&bt_audio_buff, data_size_play_bt*playback_samplerate_ratio_bt);
        stream_cfg.data_ptr = BT_AUDIO_CACHE_2_UNCACHE(bt_audio_buff);
        stream_cfg.data_size = data_size_play_bt*playback_samplerate_ratio_bt;

        playback_buf_mc=stream_cfg.data_ptr;
        playback_size_mc=stream_cfg.data_size;

        anc_mc_run_init(hal_codec_anc_convert_rate(sample_rate_play_bt));
        af_stream_open(AUD_STREAM_ID_2, AUD_STREAM_PLAYBACK, &stream_cfg);
#endif

#if !(defined(__AUDIO_RESAMPLE__) && defined(SW_PLAYBACK_RESAMPLE))
        af_codec_tune(AUD_STREAM_NUM, 0);
#endif

#if defined(IBRT)
        app_ibrt_voice_report_trigger_init(aud_id, aud_pram);
#endif
        af_stream_start(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK);

#if defined(AUDIO_ANC_FB_MC_MEDIA) && defined(ANC_APP) && !defined(__AUDIO_RESAMPLE__)
        af_stream_start(AUD_STREAM_ID_2, AUD_STREAM_PLAYBACK);
#endif


    } else {

#ifdef VOICE_DATAPATH
        app_voicepath_set_stream_state(AUDIO_OUTPUT_STREAMING, false);
        app_voicepath_set_pending_started_stream(AUDIO_OUTPUT_STREAMING, false);
#endif
#if !(defined(__AUDIO_RESAMPLE__) && defined(SW_PLAYBACK_RESAMPLE))
        af_codec_tune(AUD_STREAM_PLAYBACK, 0);
#endif

        af_stream_stop(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK);
        af_stream_close(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK);

#if defined(AUDIO_ANC_FB_MC_MEDIA) && defined(ANC_APP) && !defined(__AUDIO_RESAMPLE__)
        af_stream_stop(AUD_STREAM_ID_2, AUD_STREAM_PLAYBACK);
        af_stream_close(AUD_STREAM_ID_2, AUD_STREAM_PLAYBACK);
#endif
#if defined(IBRT)
        app_ibrt_voice_report_trigger_deinit();
#ifdef MIX_AUDIO_PROMPT_WITH_A2DP_MEDIA_ENABLED
        audio_prompt_stop_playing();
#endif
#endif
#ifdef PLAYBACK_USE_I2S
        hal_cmu_audio_resample_enable();
#endif

        app_play_sbc_cache = NULL;
        g_cache_buff_sz = 0;
        g_prompt_chnlsel = PROMOT_ID_BIT_MASK_CHNLSEl_ALL;
        app_play_audio_set_aud_id(MAX_RECORD_NUM);
        af_set_priority(AF_USER_AUDIO, osPriorityAboveNormal);
        app_sysfreq_req(APP_SYSFREQ_USER_APP_0, APP_SYSFREQ_32K);

        app_audio_playback_done();
#if defined(__THIRDPARTY)
         app_thirdparty_specific_lib_event_handle(THIRDPARTY_FUNC_NO1,THIRDPARTY_START);
#endif

#ifdef WL_DET
        app_mic_alg_audioloop(true,APP_SYSFREQ_78M);
#endif
    }
    isRun = onoff;

    return 0;
}

static void app_stop_local_prompt_playing(void)
{
    app_audio_sendrequest(APP_PLAY_BACK_AUDIO, APP_BT_SETTING_CLOSE, 0);
#ifdef MIX_AUDIO_PROMPT_WITH_A2DP_MEDIA_ENABLED
    audio_prompt_stop_playing();
#endif
}

void app_stop_both_prompt_playing(void)
{
    app_stop_local_prompt_playing();
    app_tws_stop_peer_prompt();
}

void app_tws_cmd_stop_prompt_handler(uint8_t* ptrParam, uint16_t paramLen)
{
    TRACE_MEDIA_PLAYESTREAM_I("[STOP_PROMPT_HANDLER]");
    app_stop_local_prompt_playing();
}
#endif