| #include "kal_public_api.h" |
| #include "kal_general_types.h" |
| #include "sync_data.h" |
| |
| #include "kal_trace.h" |
| #include "l1sp_trc.h" |
| |
| #include "l1audio.h" |
| #include "am.h" |
| //#include "speech_def.h" |
| //#include "afe_def.h" // for output device setting |
| //#include "sp_drv.h" |
| |
| #include "sal_exp.h" |
| #include "bgSnd.h" |
| |
| //#define DSP_BGS_UP_DOWN_INT_SEPERATE |
| |
| |
| #define BGSND_BUFFER_LEN_NB (160) //unit is sample (16bit) |
| #define BGSND_BUFFER_LEN_WB (320) //unit is sample (16bit) |
| #define BGSND_BUFFER_LEN_SWB (640) //unit is sample (16bit) |
| #define BGSND_BUFFER_LEN_FB (960) //unit is sample (16bit) |
| |
| #define BGSND_BUFFER_LEN (BGSND_BUFFER_LEN_SWB) |
| |
| #define MAX_NUM_BGSND_PROCESS (2) |
| |
| |
| //================= DSP BGSND INTERFACE ==================== |
| |
| typedef enum { |
| DSP_BGSND_STATE_IDLE = 0, |
| DSP_BGSND_STATE_RUN, |
| DSP_BGSND_STATE_STOPPING, |
| }DSP_BGSND_STATE_TYPE; |
| |
| typedef struct{ |
| DSP_BGSND_STATE_TYPE state; |
| |
| bool fSph[MAX_NUM_BGSND_PROCESS]; |
| uint16 gain[MAX_NUM_BGSND_PROCESS]; |
| |
| void (*Ext_Hisr[MAX_NUM_BGSND_PROCESS])(void); |
| }DSP_BKGSND_T; |
| |
| DSP_BKGSND_T DSP_BGSnd; |
| |
| //================= Extended BGSND INTERFACE ==================== |
| #define MAX_SIZE_EXT_BGSND_SRC (2) // AP bkgsnd + VoLTE UL bkgsnd |
| #define EXT_BGSND_BUF_PTR_DIFF (2) |
| #define EXT_BGSND_SRC_BUF_SIZE ((BGSND_BUFFER_LEN) * 2 + EXT_BGSND_BUF_PTR_DIFF) //buffering 2 frames |
| |
| |
| #define MAX_LEVEL_EXT_BGSND_GAIN (7) |
| |
| typedef struct{ |
| EXT_SRC_STATE_TYPE state[MAX_NUM_BGSND_PROCESS]; |
| void (*offHdr)();//(int id); //TODO Trigger MED to close DSP bgsnd |
| void (*Hdr[MAX_NUM_BGSND_PROCESS])(void); // under HISR |
| uint16 dspLastSample[MAX_NUM_BGSND_PROCESS]; |
| |
| uint32 len_WriteSrcBuffer_this_time; |
| //event handling |
| //void (*EventHandler)(void); |
| //void *event_data; |
| |
| //gain handling |
| bool fSph[MAX_NUM_BGSND_PROCESS]; |
| uint16 gain[MAX_NUM_BGSND_PROCESS]; |
| |
| //buffer handling |
| uint32 bufSize[MAX_NUM_BGSND_PROCESS], bufRead[MAX_NUM_BGSND_PROCESS], bufWrite[MAX_NUM_BGSND_PROCESS]; |
| uint32 bufDataCount[MAX_NUM_BGSND_PROCESS]; |
| uint16 buffer[MAX_NUM_BGSND_PROCESS][EXT_BGSND_SRC_BUF_SIZE]; |
| |
| }EXT_BGSND_SRC_T; |
| |
| typedef struct{ |
| bool is_used[MAX_SIZE_EXT_BGSND_SRC]; |
| bool is_send_event[MAX_SIZE_EXT_BGSND_SRC]; |
| EXT_BGSND_SRC_T src[MAX_SIZE_EXT_BGSND_SRC]; |
| uint16 num_src_used; |
| |
| uint16 buffer[MAX_NUM_BGSND_PROCESS][BGSND_BUFFER_LEN]; //accumulate all sources multiplied by gains into this buffer |
| |
| uint16 aud_id; |
| bool skip_hisr; |
| kal_spinlockid bgs_spinlockID; |
| }EXT_BGSND_T; |
| |
| static EXT_BGSND_T Ext_BGSnd; |
| |
| void EXT_BGSND_Hisr(BGSND_PROCESS_TYPE type); |
| |
| /* |
| int has_ul = 0; |
| int has_dl = 0; |
| int ul_data[320], dl_data[320];*/ |
| |
| |
| static void DSP_BGSND_INIT() |
| { |
| MD_TRC_DSP_BGSND_INIT_ENTER(); |
| memset(&DSP_BGSnd, 0, sizeof(DSP_BKGSND_T)); |
| //has_ul = has_dl = 0; |
| MD_TRC_DSP_BGSND_INIT_LEAVE(); |
| } |
| |
| static void DSP_BGSND_ConfigMixer(kal_bool bSPHFlag, kal_int8 SNDGain, BGSND_PROCESS_TYPE type) |
| { |
| MD_TRC_DSP_BGSND_CONFIGMIXER_ENTER(); |
| MD_TRC_DSP_BGSND_CONFIGMIXER_BGSND_PROCESS_TYPE(type, bSPHFlag, SNDGain); |
| |
| ASSERT(SNDGain>=0 && SNDGain<=7); |
| if( SNDGain == 0) |
| DSP_BGSnd.gain[type] = 0; |
| else { |
| DSP_BGSnd.gain[type] = (kal_int16)(32767 >> (7 - SNDGain)); |
| } |
| DSP_BGSnd.fSph[type] = bSPHFlag; |
| MD_TRC_DSP_BGSND_CONFIGMIXER_LEAVE(); |
| } |
| |
| static void DSP_BGSND_UpdateMixer() // private |
| { |
| MD_TRC_DSP_BGSND_UPDATEMIXER_ENTER(); |
| if ( AM_IsSpeechOn() || AM_IsVoIPOn()) { |
| SAL_Bgsnd_Config(DSP_BGSnd.gain[BGSND_UL_PROCESS], DSP_BGSnd.gain[BGSND_DL_PROCESS], DSP_BGSnd.fSph[BGSND_UL_PROCESS], DSP_BGSnd.fSph[BGSND_DL_PROCESS]); |
| } else { |
| //When enable BT, spe_setSpeechMode() will do Speech Off and Speech On. This function may run between Off and ON, so do not use ASSERT(). |
| //ASSERT(false); |
| SAL_Bgsnd_Config(DSP_BGSnd.gain[BGSND_UL_PROCESS], DSP_BGSnd.gain[BGSND_DL_PROCESS], 0, 0); |
| } |
| MD_TRC_DSP_BGSND_UPDATEMIXER_LEAVE(); |
| } |
| |
| |
| void DSP_BGSND_Stop(void) |
| { |
| MD_TRC_DSP_BGSND_STOP_ENTER(); |
| DSP_BGSnd.state = DSP_BGSND_STATE_STOPPING; |
| { //turn off DSP BGSND |
| uint32 I; |
| if(SAL_Bgsnd_IsRunning()) |
| SAL_Bgsnd_SetFinal(); |
| for ( I = 0; ; I++ ) { |
| if ( SAL_Bgsnd_IsIdle()) /* DSP returns to idle state */ |
| break; |
| ASSERT_REBOOT( I < 20 ); |
| kal_sleep_task( AUD_1TICK(2) ); |
| } |
| |
| AM_SND_PlaybackOff( true ); |
| } |
| |
| #ifdef DSP_BGS_UP_DOWN_INT_SEPERATE |
| L1Audio_UnhookHisrHandler(D2C_SOUND_EFFECT_INT_ID_DL); |
| L1Audio_UnhookHisrHandler(D2C_SOUND_EFFECT_INT_ID_UL); |
| #else |
| L1Audio_UnhookHisrHandler(D2C_SOUND_EFFECT_INT_ID_DL); |
| #endif |
| DSP_BGSnd.state = DSP_BGSND_STATE_IDLE; |
| MD_TRC_DSP_BGSND_STOP_LEAVE(); |
| } |
| |
| |
| /* |
| static kal_uint16 tempMicData[320] |
| // = { 0x4808,0x85, 0x156,0, 0x4,0, 0x146,0x9000, |
| = { |
| 0xfff4,0x5a7a, 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a79, |
| 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a7a, 0x7fff, 0x5a8a, |
| 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a79, 0x7fff, 0x5a8a, 0x000d, 0xa587, |
| 0x8001, 0xa575, 0xfff4, 0x5a7a, 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa575, |
| 0xfff4, 0x5a79, 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a78, |
| 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa576, 0xfff3, 0x5a79, 0x7fff, 0x5a8b, |
| 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a79, 0x7fff, 0x5a8a, 0x000c, 0xa588, |
| 0x8001, 0xa576, 0xfff4, 0x5a79, 0x7fff, 0x5a8b, 0x000d, 0xa587, 0x8001, 0xa575, |
| |
| 0xfff4,0x5a7a, 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a79, |
| 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a7a, 0x7fff, 0x5a8a, |
| 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a79, 0x7fff, 0x5a8a, 0x000d, 0xa587, |
| 0x8001, 0xa575, 0xfff4, 0x5a7a, 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa575, |
| 0xfff4, 0x5a79, 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a78, |
| 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa576, 0xfff3, 0x5a79, 0x7fff, 0x5a8b, |
| 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a79, 0x7fff, 0x5a8a, 0x000c, 0xa588, |
| 0x8001, 0xa576, 0xfff4, 0x5a79, 0x7fff, 0x5a8b, 0x000d, 0xa587, 0x8001, 0xa575, |
| |
| 0xfff4,0x5a7a, 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a79, |
| 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a7a, 0x7fff, 0x5a8a, |
| 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a79, 0x7fff, 0x5a8a, 0x000d, 0xa587, |
| 0x8001, 0xa575, 0xfff4, 0x5a7a, 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa575, |
| 0xfff4, 0x5a79, 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a78, |
| 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa576, 0xfff3, 0x5a79, 0x7fff, 0x5a8b, |
| 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a79, 0x7fff, 0x5a8a, 0x000c, 0xa588, |
| 0x8001, 0xa576, 0xfff4, 0x5a79, 0x7fff, 0x5a8b, 0x000d, 0xa587, 0x8001, 0xa575, |
| |
| 0xfff4,0x5a7a, 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a79, |
| 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a7a, 0x7fff, 0x5a8a, |
| 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a79, 0x7fff, 0x5a8a, 0x000d, 0xa587, |
| 0x8001, 0xa575, 0xfff4, 0x5a7a, 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa575, |
| 0xfff4, 0x5a79, 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a78, |
| 0x7fff, 0x5a8a, 0x000d, 0xa587, 0x8001, 0xa576, 0xfff3, 0x5a79, 0x7fff, 0x5a8b, |
| 0x000d, 0xa587, 0x8001, 0xa575, 0xfff4, 0x5a79, 0x7fff, 0x5a8a, 0x000c, 0xa588, |
| 0x8001, 0xa576, 0xfff4, 0x5a79, 0x7fff, 0x5a8b, 0x000d, 0xa587, 0x8001, 0xa575 |
| |
| };*/ |
| |
| |
| void DSP_BGSND_Hisr(void * param) |
| { |
| int i; |
| uint16 *src_buf; |
| volatile uint16 *dst_buf; |
| |
| BGSND_PROCESS_TYPE type = (BGSND_PROCESS_TYPE) param; |
| |
| MD_TRC_DSP_BGSND_HISR_ENTER(); |
| |
| MD_TRC_DSP_BGSND_HISR_BGSND_PROCESS_TYPE(type, DSP_BGSnd.state); |
| |
| ASSERT( type == BGSND_DL_PROCESS || type == BGSND_UL_PROCESS ); |
| |
| if ((DSP_BGSND_STATE_RUN != DSP_BGSnd.state)){ |
| return; |
| } |
| |
| if(!SAL_Bgsnd_IsRunning()) |
| return; |
| |
| DSP_BGSnd.Ext_Hisr[type](); |
| src_buf = Ext_BGSnd.buffer[type]; |
| |
| dst_buf = src_buf; |
| //set up the DSP address and pointers |
| switch(type){ |
| case BGSND_DL_PROCESS: |
| //dst_buf_len = SAL_Bgsnd_GetDataLen_DL(); |
| dst_buf = SAL_Bgsnd_GetBuf_DL(); |
| break; |
| case BGSND_UL_PROCESS: |
| //dst_buf_len = SAL_Bgsnd_GetDataLen_UL(); |
| dst_buf = SAL_Bgsnd_GetBuf_UL(); |
| break; |
| } |
| |
| for(i=0; i<BGSND_BUFFER_LEN_SWB; i++){ |
| //*dst_buf++ = *src_buf++; |
| dst_buf[i] = src_buf[i]; |
| } |
| Data_Sync_Barrier(); |
| |
| MD_TRC_DSP_BGSND_HISR_LEAVE(); |
| } |
| #if !defined(DSP_BGS_UP_DOWN_INT_SEPERATE) |
| void DSP_BGSND_Shared_Hisr_DL_UL(void * param) |
| { |
| MD_TRC_DSP_BGSND_SHARED_HISR_DL_UL_ENTER(); |
| DSP_BGSND_Hisr((void * )BGSND_UL_PROCESS); |
| DSP_BGSND_Hisr((void * )BGSND_DL_PROCESS); |
| MD_TRC_DSP_BGSND_SHARED_HISR_DL_UL_LEAVE(); |
| } |
| #endif |
| |
| static void DSP_BGSND_Start(void (*Ext_DLHisr)(void), |
| void (*Ext_ULHisr)(void)) |
| { |
| MD_TRC_DSP_BGSND_START_ENTER(); |
| ASSERT(AM_IsSpeechOn() || AM_IsVoIPOn()); |
| |
| DSP_BGSnd.Ext_Hisr[BGSND_DL_PROCESS] = Ext_DLHisr; |
| DSP_BGSnd.Ext_Hisr[BGSND_UL_PROCESS] = Ext_ULHisr; |
| |
| #ifdef DSP_BGS_UP_DOWN_INT_SEPERATE |
| L1Audio_HookHisrHandler(D2C_SOUND_EFFECT_INT_ID_DL, DSP_BGSND_Hisr, (void *)BGSND_DL_PROCESS); |
| L1Audio_HookHisrHandler(D2C_SOUND_EFFECT_INT_ID_UL, DSP_BGSND_Hisr, (void *)BGSND_UL_PROCESS); |
| #else |
| L1Audio_HookHisrHandler(D2C_SOUND_EFFECT_INT_ID_DL, DSP_BGSND_Shared_Hisr_DL_UL, 0); |
| #endif |
| |
| // gain setting and update |
| // Although these settings are allowed to modify during run time, |
| // extended bgsnd should be fixed because the changes of volume from |
| // each sources are calculated in MCU side. |
| DSP_BGSND_ConfigMixer(KAL_TRUE, 7, BGSND_UL_PROCESS); |
| DSP_BGSND_ConfigMixer(KAL_TRUE, 7, BGSND_DL_PROCESS); |
| |
| DSP_BGSND_UpdateMixer(); |
| { //turn on DSP BGSND |
| uint32 I; |
| AM_SND_PlaybackOn(); |
| SAL_Bgsnd_SetInit(); |
| for( I = 0; ; I++ ) { |
| if(SAL_Bgsnd_IsRunning()) |
| break; |
| ASSERT_REBOOT( I < 20 ); |
| kal_sleep_task( AUD_1TICK(2) ); |
| } |
| } |
| |
| DSP_BGSnd.state = DSP_BGSND_STATE_RUN; |
| MD_TRC_DSP_BGSND_START_LEAVE(); |
| } |
| /*=============== Ext BGSND interface ========= */ |
| |
| uint32 EXT_BGSND_init() |
| { |
| MD_TRC_EXT_BGSND_INIT_ENTER(); |
| DSP_BGSND_INIT(); |
| memset((void *)&Ext_BGSnd, 0, sizeof(EXT_BGSND_T)); |
| // get audio ID |
| Ext_BGSnd.aud_id = L1Audio_GetAudioID(); |
| Ext_BGSnd.skip_hisr = 0; |
| Ext_BGSnd.bgs_spinlockID = kal_create_spinlock("bgs_spinlock"); |
| MD_TRC_EXT_BGSND_INIT_LEAVE(); |
| // L1Audio_SetEventHandler( Ext_BGSnd.aud_id, (L1Audio_EventHandler) EXT_BGSND_EventHandler ); |
| return 0; |
| } |
| |
| void EXT_BGSND_DLHisr(void); |
| void EXT_BGSND_ULHisr(void); |
| |
| |
| uint32 EXT_BGSND_Start(void (*offHdr)(void), |
| void (*DLHisr)(void), //move data from src -> ext |
| void (*ULHisr)(void), //move data from src -> ext |
| kal_int8 DLSNDGain, |
| kal_int8 ULSNDGain /*, |
| void (*EventHandler)(void)*/) |
| { |
| int i, j; |
| |
| Ext_BGSnd.skip_hisr = 0; |
| MD_TRC_EXT_BGSND_START_ENTER(); |
| |
| ASSERT(!(NULL==DLHisr && NULL==ULHisr)); |
| ASSERT(NULL!=offHdr); //without this, we cannot stop DSP BGSND |
| |
| for(i=0; i<MAX_SIZE_EXT_BGSND_SRC; i++){ |
| MD_TRC_EXT_BGSND_START_DEBUG1(i); |
| if(!Ext_BGSnd.is_used[i]){ |
| MD_TRC_EXT_BGSND_START_DEBUG2(i); |
| EXT_BGSND_SRC_T *pSrc = &Ext_BGSnd.src[i]; |
| memset(pSrc, 0, sizeof(EXT_BGSND_SRC_T)); |
| |
| pSrc->Hdr[BGSND_DL_PROCESS] = DLHisr; |
| pSrc->Hdr[BGSND_UL_PROCESS] = ULHisr; |
| pSrc->offHdr = offHdr; |
| for(j=0; j<MAX_NUM_BGSND_PROCESS; j++){//TODO temp solution |
| |
| pSrc->state[j] = EXT_SRC_STATE_RUN; |
| //pSrc->fSph[j] = true; //TODO |
| //pSrc->gain[j] = 7; //TODO |
| |
| // buffer reset |
| memset(pSrc->buffer[j], 0, sizeof(kal_uint16)*EXT_BGSND_SRC_BUF_SIZE); |
| pSrc->bufSize[j] = EXT_BGSND_SRC_BUF_SIZE; |
| pSrc->bufRead[j] = 0; |
| pSrc->bufWrite[j] = EXT_BGSND_BUF_PTR_DIFF; |
| pSrc->bufDataCount[j] = 0; |
| } |
| if(AM_IsSpeechOn() || AM_IsVoIPOn()){ |
| EXT_BGSND_ConfigMixer(i, true, DLSNDGain, BGSND_DL_PROCESS); |
| EXT_BGSND_ConfigMixer(i, true, ULSNDGain, BGSND_UL_PROCESS); |
| }else{ |
| EXT_BGSND_ConfigMixer(i, false, DLSNDGain, BGSND_DL_PROCESS); |
| EXT_BGSND_ConfigMixer(i, false, ULSNDGain, BGSND_UL_PROCESS); |
| } |
| Ext_BGSnd.is_used[i] = true; |
| if( 0 == Ext_BGSnd.num_src_used++){ |
| MD_TRC_EXT_BGSND_START_SELECTED_SRC(i, Ext_BGSnd.num_src_used); |
| // lock DSP for sherif writing. |
| L1Audio_SetFlag( Ext_BGSnd.aud_id ); // REIMIND: Before Locking SleepMode, to access DSP sherrif tasks much time. So access DSP must be after SetFlag1 |
| DSP_BGSND_Start(EXT_BGSND_DLHisr, EXT_BGSND_ULHisr); |
| } |
| MD_TRC_EXT_BGSND_START_DEBUG3(i); |
| break; |
| } |
| MD_TRC_EXT_BGSND_START_DEBUG4(i); |
| } |
| MD_TRC_EXT_BGSND_START_DEBUG5(i); |
| ASSERT(i < MAX_SIZE_EXT_BGSND_SRC); |
| |
| MD_TRC_EXT_BGSND_START_LEAVE(); |
| return i; |
| } |
| |
| void EXT_BGSND_Flush(uint32 id) //under MED Task, triggered by the AP message, BGSND_OFF |
| { //flush buffer first, and then close it ; HISR will consume the buffer until it is empty. |
| int j; |
| MD_TRC_EXT_BGSND_FLUSH_ENTER(); |
| ASSERT(Ext_BGSnd.is_used[id]); |
| |
| EXT_BGSND_SRC_T *pSrc = &Ext_BGSnd.src[id]; |
| MD_TRC_EXT_BGSND_FLUSH_ID(id); |
| |
| for(j=0; j<MAX_NUM_BGSND_PROCESS; j++){ |
| if(EXT_SRC_STATE_RUN == pSrc->state[j]){ |
| pSrc->state[j] = EXT_SRC_STATE_FLUSHING; |
| }else{//prevent double entry to the procedure of flushing |
| MD_TRC_EXT_BGSND_FLUSH_STATE(pSrc->state[j]); |
| } |
| } |
| MD_TRC_EXT_BGSND_FLUSH_LEAVE(); |
| } |
| |
| // under MED Task, triggered by the EXT_HISR when UL/DL buffer flushes completely. |
| // Even if many src would like to close DSP BGSND, we don't think about the race condition since the request of closing is processed by MED's queue. |
| // Due to it may force close. so status check nees to remove. |
| void EXT_BGSND_Close(uint32 id) |
| { |
| MD_TRC_EXT_BGSND_CLOSE_ENTER(); |
| ASSERT(Ext_BGSnd.is_used[id]); |
| EXT_BGSND_SRC_T *pSrc = &Ext_BGSnd.src[id]; |
| |
| // ASSERT(EXT_SRC_STATE_FLUSHING_OVER==pSrc->state[BGSND_DL_PROCESS]); |
| // ASSERT(EXT_SRC_STATE_FLUSHING_OVER==pSrc->state[BGSND_UL_PROCESS]); |
| MD_TRC_EXT_BGSND_CLOSE_SELECTED_SRC(id, Ext_BGSnd.num_src_used); |
| |
| { //flush buffer first, and then close it // buffer reset |
| Ext_BGSnd.is_used[id] = false; // [IMPORTANT] HISR using the information to check BGS is under use or not. so put the line before clean all information. |
| Ext_BGSnd.num_src_used--; |
| } |
| |
| pSrc->state[BGSND_DL_PROCESS] = pSrc->state[BGSND_UL_PROCESS] = EXT_SRC_STATE_STOPPING; |
| |
| if( 0 == Ext_BGSnd.num_src_used){ |
| DSP_BGSND_Stop(); |
| L1Audio_ClearFlag( Ext_BGSnd.aud_id ); |
| |
| } |
| pSrc->state[BGSND_DL_PROCESS] = pSrc->state[BGSND_UL_PROCESS] = EXT_SRC_STATE_IDLE; |
| MD_TRC_EXT_BGSND_CLOSE_LEAVE(); |
| } |
| |
| void EXT_BGSND_DLHisr(void) |
| { |
| MD_TRC_EXT_BGSND_DLHISR_ENTER(); |
| EXT_BGSND_Hisr(BGSND_DL_PROCESS); |
| MD_TRC_EXT_BGSND_DLHISR_LEAVE(); |
| } |
| |
| void EXT_BGSND_ULHisr(void) |
| { |
| MD_TRC_EXT_BGSND_ULHISR_ENTER(); |
| EXT_BGSND_Hisr(BGSND_UL_PROCESS); |
| MD_TRC_EXT_BGSND_ULHISR_LEAVE(); |
| } |
| |
| /*static*/ int32 EXT_BGSND_GetDataCount(uint32 id, BGSND_PROCESS_TYPE type) |
| { |
| int32 count = 0; |
| MD_TRC_EXT_BGSND_GETDATACOUNT_ENTER(); |
| |
| ASSERT( type == BGSND_DL_PROCESS || type == BGSND_UL_PROCESS ); |
| EXT_BGSND_SRC_T *pSrc = &Ext_BGSnd.src[id]; |
| |
| count = pSrc->bufDataCount[type]; |
| /* for(j=0; j<MAX_BGSND_BUFFER_PROCESS_BIT; j++){ |
| if(type & (1<<j)){ |
| type = 1<<j; |
| if(pSrc->bufWrite[type]<pSrc->bufRead[type]){ |
| count = (pSrc->bufSize[type] - EXT_BGSND_BUF_PTR_DIFF)+pSrc->bufWrite[type] - pSrc->bufRead[type]; |
| } else { |
| count = pSrc->bufWrite[type] - pSrc->bufRead[type]; |
| } |
| } |
| } |
| |
| if( count > EXT_BGSND_BUF_PTR_DIFF) { |
| count -= EXT_BGSND_BUF_PTR_DIFF; |
| } else { |
| count = 0; |
| } |
| |
| if(count&1){ |
| count = count -1; |
| }*/ |
| MD_TRC_EXT_BGSND_GETDATACOUNT_COUNT(count); |
| MD_TRC_EXT_BGSND_GETDATACOUNT_LEAVE(); |
| return count; |
| } |
| |
| void EXT_BGSND_Hisr(BGSND_PROCESS_TYPE type) |
| { |
| int i; |
| if(Ext_BGSnd.skip_hisr){ |
| return; |
| } |
| |
| MD_TRC_EXT_BGSND_HISR_ENTER(); |
| MD_TRC_EXT_BGSND_HISR_BGSND_PROCESS_TYPE(type); |
| |
| //reset buffer data |
| if( BGSND_DL_PROCESS == type){// align DL timing |
| for(i=0; i<BGSND_BUFFER_LEN; i++){ // To do , reduce computation |
| Ext_BGSnd.buffer[BGSND_DL_PROCESS][i] = 0; |
| } |
| for(i=0; i<BGSND_BUFFER_LEN; i++){ |
| Ext_BGSnd.buffer[BGSND_UL_PROCESS][i] = 0; |
| } |
| } |
| DSP_BGSND_UpdateMixer(); |
| for(i=0; i<MAX_SIZE_EXT_BGSND_SRC; i++){ |
| EXT_BGSND_SRC_T *pSrc = &Ext_BGSnd.src[i]; |
| if(Ext_BGSnd.is_used[i]){ |
| MD_TRC_EXT_BGSND_HISR_SELECTED_SRC(i, pSrc->state[type]); |
| |
| //point 1 |
| if(pSrc->Hdr[type]){ // Point1 must be before point2 since it is expected that in pSrc->Hdr[type](), len_WriteSrcBuffer_this_time will be updated by EXT_BGSND_WriteSrcBuffer |
| pSrc->Hdr[type](); // Each Hdr should update buffer[BGSND_ L_PROCESS] by EXT_BGSND_Buf_Add |
| } |
| |
| //point 2 |
| if(EXT_SRC_STATE_FLUSHING == pSrc->state[type]){ // FLUSHING --> FLUSHING_OVER |
| //if(EXT_BGSND_GetDataCount(i, type) <= EXT_BGSND_BUF_PTR_DIFF){ |
| if( (0 == pSrc->len_WriteSrcBuffer_this_time) && (EXT_BGSND_GetDataCount(i, type) < BGSND_BUFFER_LEN) ){ |
| MD_TRC_EXT_BGSND_HISR_EXT_SRC_STATE_FLUSHING_OVER(i, type); |
| pSrc->state[type] = EXT_SRC_STATE_FLUSHING_OVER; |
| if(EXT_SRC_STATE_FLUSHING_OVER == pSrc->state[1-type]){ // 1-type is just for the opposite. DL <-> UL |
| MD_TRC_EXT_BGSND_HISR_ENTER_SRC_OFFHDR(i); |
| Ext_BGSnd.skip_hisr = 1; |
| pSrc->offHdr(); //FLUSHING_OVER --> STOPPING |
| MD_TRC_EXT_BGSND_HISR_LEAVE_SRC_OFFHDR(i); |
| MD_TRC_EXT_BGSND_HISR_FLUSH_SRC_OFFHDR_COMPLETELY(i); |
| }else{//wait DL's flushing |
| MD_TRC_EXT_BGSND_HISR_WAIT_SRC_HDR_TO_FLUSH_COMPLETELY(i); |
| } |
| }else{ |
| MD_TRC_EXT_BGSND_HISR_FLUSHING(i, type, EXT_BGSND_GetDataCount(i, type)); |
| } |
| }else{ |
| MD_TRC_EXT_BGSND_HISR_NOT_FLUSHING(i, type, pSrc->state[type]); |
| } |
| |
| |
| |
| }else{ |
| MD_TRC_EXT_BGSND_HISR_HDR_IS_NOT_USED(i); |
| } |
| pSrc->len_WriteSrcBuffer_this_time = 0; |
| } |
| MD_TRC_EXT_BGSND_HISR_LEAVE(); |
| } |
| |
| /* |
| void EXT_BGSND_Buf_Add(uint32 id, uint16* src_buf, int src_len, BGSND_PROCESS_TYPE type) // write into ext buffer |
| { |
| int i; |
| uint16 *dst_buf; |
| EXT_BGSND_SRC_T *pSrc; |
| |
| MD_TRC_BGSND_DSP_BGSND_BUF_ADD(id, src_len, type); |
| |
| ASSERT(Ext_BGSnd.is_used[id]); |
| pSrc = &Ext_BGSnd.src[id]; |
| |
| ASSERT( BGSND_BUFFER_LEN == src_len);//must be wb |
| ASSERT( type == BGSND_DL_PROCESS || type == BGSND_UL_PROCESS ); |
| |
| { // DL |
| dst_buf = Ext_BGSnd.buffer[type]; |
| |
| for(i=0; i<src_len; i++){//accumulate DSP_DLBuffer |
| if( src_buf[i] < (0x1111111111111111 - dst_buf[i])){ //limiter |
| dst_buf[i] += src_buf[i]; |
| }else{ |
| MD_TRC_BKGSND_DSP_BUF_ADD_BUF(i, src_buf[i], i, dst_buf[i]); |
| } |
| } |
| } |
| }*/ |
| |
| /* |
| uint32 EXT_BGSND_SetEvent(uint32 id, void *data ) |
| { |
| ASSERT(Ext_BGSnd.is_used[id] && Ext_BGSnd.src[id].EventHandler); |
| is_send_event[id] = true; |
| Ext_BGSnd.src[i].event_data = data; |
| L1Audio_SetEvent(Ext_BGSnd.src.aud_id, NULL); |
| } |
| |
| void EXT_BGSND_EventHandler(void) |
| { |
| for(i=0; i<MAX_SIZE_EXT_BGSND_SRC; i++){//dispatch the event |
| if(Ext_BGSnd.is_send_event[i] && Ext_BGSnd.src[i].EventHandler){ |
| Ext_BGSnd.src[i].EventHandler(Ext_BGSnd.src[i].event_data); |
| Ext_BGSnd.is_send_event[i] = false; |
| } |
| } |
| } |
| */ |
| |
| void EXT_BGSND_WriteSrcBuffer(uint32 id, kal_uint8 *srcBuf, kal_int32 bufLen, BGSND_PROCESS_TYPE type) |
| { |
| int32 freeLen; |
| int32 srcBufLen = bufLen >> 1; // unit: 8bits -> 16bits |
| int32 currentRead; |
| EXT_BGSND_SRC_T *pSrc = &Ext_BGSnd.src[id]; |
| |
| MD_TRC_EXT_BGSND_WRITESRCBUFFER_ENTER(); |
| kal_take_spinlock(Ext_BGSnd.bgs_spinlockID, KAL_INFINITE_WAIT); |
| currentRead = pSrc->bufRead[type]; |
| |
| pSrc->len_WriteSrcBuffer_this_time = bufLen; |
| |
| if(currentRead > pSrc->bufWrite[type]) { // one segment |
| |
| freeLen = pSrc->bufSize[type] - pSrc->bufDataCount[type] - EXT_BGSND_BUF_PTR_DIFF; |
| |
| MD_TRC_L1SND_WRITE_DATA(1, id, type, srcBufLen, freeLen, pSrc->bufRead[type], pSrc->bufWrite[type]+srcBufLen); /* using write information which is after memory copy*/ |
| |
| ASSERT(srcBufLen <= freeLen); // unit is 2 byte |
| memcpy(pSrc->buffer[type]+pSrc->bufWrite[type], srcBuf, srcBufLen*sizeof(uint16)); |
| |
| pSrc->bufWrite[type] += srcBufLen; |
| pSrc->bufDataCount[type] += srcBufLen; |
| }else { // two segment |
| int32 segment; |
| kal_uint8 *p2SrcBuf; |
| |
| freeLen = pSrc->bufSize[type] - pSrc->bufDataCount[type] - EXT_BGSND_BUF_PTR_DIFF; |
| |
| MD_TRC_L1SND_WRITE_DATA(2, id, type, srcBufLen, freeLen, 0, 0); |
| ASSERT(srcBufLen <= freeLen); |
| |
| p2SrcBuf = srcBuf; |
| segment = pSrc->bufSize[type] - pSrc->bufWrite[type]; // bug |
| if(segment > srcBufLen){ |
| segment = srcBufLen; |
| } |
| |
| if(segment>0) { //first segment |
| memcpy(pSrc->buffer[type]+pSrc->bufWrite[type], p2SrcBuf, segment*sizeof(kal_uint16)); |
| //update pointer |
| p2SrcBuf = srcBuf + segment*sizeof(kal_uint16); |
| pSrc->bufWrite[type] += segment; |
| pSrc->bufDataCount[type] += segment; |
| if(pSrc->bufWrite[type]>=pSrc->bufSize[type]){ |
| pSrc->bufWrite[type] = 0; |
| } |
| MD_TRC_L1SND_WRITE_DATA(3, id, type, 0, 0, pSrc->bufRead[type], pSrc->bufWrite[type]); |
| |
| segment = srcBufLen - segment; |
| } |
| |
| if(segment>0) { //second segement |
| memcpy(pSrc->buffer[type], p2SrcBuf, segment*sizeof(kal_uint16)); |
| pSrc->bufWrite[type] = segment; |
| pSrc->bufDataCount[type] += segment; |
| |
| MD_TRC_L1SND_WRITE_DATA(4, id, type, 0, 0, pSrc->bufRead[type], pSrc->bufWrite[type]); |
| } |
| } |
| kal_give_spinlock(Ext_BGSnd.bgs_spinlockID); |
| MD_TRC_EXT_BGSND_WRITESRCBUFFER_LEAVE(); |
| } |
| |
| //from DL Src buffer -> DL ext buffer, multiplied by gain |
| //from UL Src buffer -> UL ext buffer |
| void EXT_BGSND_WriteExtBuffer(uint32 id, int gain, BGSND_PROCESS_TYPE type) // ToDo |
| { |
| volatile uint16 *toPtr; |
| int32 count, segment, i; |
| uint16 *dataPtr; |
| uint16 gainFactor; |
| MD_TRC_EXT_BGSND_WRITEEXTBUFFER_ENTER(); |
| MD_TRC_EXT_BGSND_WRITEEXTBUFFER_SELECTED_SRC(id, type); |
| ASSERT( type == BGSND_DL_PROCESS || type == BGSND_UL_PROCESS ); |
| kal_take_spinlock(Ext_BGSnd.bgs_spinlockID, KAL_INFINITE_WAIT); |
| EXT_BGSND_SRC_T *pSrc = &Ext_BGSnd.src[id]; |
| MD_TRC_EXT_BGSND_WRITEEXTBUFFER_FSPH(pSrc->fSph[type], pSrc->gain[type]); |
| |
| gainFactor = pSrc->gain[type]; |
| |
| count = EXT_BGSND_GetDataCount(id, type); |
| toPtr = Ext_BGSnd.buffer[type]; |
| |
| MD_TRC_EXT_BGSND_WRITEEXTBUFFER_COUNT(count); |
| |
| if (count > BGSND_BUFFER_LEN) |
| count = BGSND_BUFFER_LEN; |
| |
| |
| if(count > 0) { |
| /* First Segemnt */ |
| if(pSrc->bufWrite[type] < pSrc->bufRead[type]) { |
| segment = (pSrc->bufSize[type] - pSrc->bufRead[type]); |
| } else { |
| segment = (pSrc->bufWrite[type] - pSrc->bufRead[type]); |
| } |
| |
| if(segment&1){ // keep two sample alight |
| segment =segment - 1; |
| } |
| |
| if (segment > count) |
| segment = count; |
| |
| if (segment > 0) { |
| dataPtr = &(pSrc->buffer[type][pSrc->bufRead[type]]); |
| |
| if(pSrc->fSph[type] && MAX_LEVEL_EXT_BGSND_GAIN!=gainFactor){ |
| for (i=0; i<segment; i++) { |
| |
| kal_int16 x = (*dataPtr>>gainFactor); |
| kal_int16 y = (kal_int16)(*toPtr); |
| kal_int16 result = x + y; |
| |
| if (((x ^ y) >= 0) && (x ^ result) < 0) { |
| if (x < 0) |
| result = 0x8000; |
| else |
| result = 0x7FFF; |
| kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_WriteExtBuffer] Saturation1 %d %d", x, y); |
| |
| } |
| *toPtr = result; |
| toPtr++; |
| dataPtr++; |
| } |
| pSrc->dspLastSample[type] = *(toPtr-1); |
| }else{ |
| toPtr += segment; |
| dataPtr += segment; |
| |
| pSrc->dspLastSample[type] = 0; |
| } |
| |
| pSrc->bufRead[type] += segment; |
| pSrc->bufDataCount[type] -= segment; |
| if (pSrc->bufRead[type] >= pSrc->bufSize[type]) |
| pSrc->bufRead[type] = (pSrc->bufRead[type]-pSrc->bufSize[type]); |
| |
| MD_TRC_EXT_BGSND_WRITEEXTBUFFER_FILLED_TO_DSP(1, segment, pSrc->bufRead[type], pSrc->bufWrite[type]); |
| } |
| |
| segment = count - segment; |
| |
| if (segment > 0) { |
| dataPtr = &(pSrc->buffer[type][pSrc->bufRead[type]]); |
| if(pSrc->fSph[type] && MAX_LEVEL_EXT_BGSND_GAIN!=gainFactor){ |
| for (i=0; i<segment; i++) { |
| |
| kal_int16 x = (*dataPtr>>gainFactor); |
| kal_int16 y = (kal_int16)(*toPtr); |
| kal_int16 result = x + y; |
| |
| if (((x ^ y) >= 0) && ((x ^ result) < 0)) { |
| if (x < 0) |
| result = 0x8000; |
| else |
| result = 0x7FFF; |
| kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_WriteExtBuffer] Saturation2 %d, %d",x ,y); |
| |
| } |
| *toPtr = result; |
| toPtr++; |
| dataPtr++; |
| } |
| pSrc->dspLastSample[type] = *(dataPtr-1); |
| }else{ |
| toPtr += segment; |
| dataPtr += segment; |
| |
| pSrc->dspLastSample[type] = 0; |
| } |
| |
| pSrc->bufRead[type] += segment; |
| pSrc->bufDataCount[type] -= segment; |
| if (pSrc->bufRead[type] >= pSrc->bufSize[type]) |
| pSrc->bufRead[type] = (pSrc->bufRead[type]-pSrc->bufSize[type]); |
| |
| MD_TRC_EXT_BGSND_WRITEEXTBUFFER_FILLED_TO_DSP(2, segment, pSrc->bufRead[type], pSrc->bufWrite[type]); |
| } |
| } |
| |
| /* Put silence (last sample) if MCU buffer is empty */ |
| if (count > 0 && count < BGSND_BUFFER_LEN && EXT_SRC_STATE_RUN == pSrc->state[type]) { |
| kal_uint16 last_sample = pSrc->dspLastSample[type]; |
| // segment = dsp_buf_len - count; |
| segment = BGSND_BUFFER_LEN - count; |
| //for (i=0; i<segment; i++)) { |
| // *toPtr++ = last_sample; |
| //} |
| MD_TRC_EXT_BGSND_WRITEEXTBUFFER_FILLED_TO_DSP_WITH_LAST_SAMPLE(segment, last_sample); |
| if(pSrc->fSph[type] && MAX_LEVEL_EXT_BGSND_GAIN!=gainFactor){ |
| for (i=0; i<segment; i++) { |
| //*toPtr++ = *dataPtr++; |
| kal_int16 x = (last_sample>>gainFactor); |
| kal_int16 y = (kal_int16)(*toPtr); |
| kal_int16 result = x + y; |
| |
| if (((x ^ y) >= 0) && ((x ^ result) < 0)) { |
| if (x < 0) |
| result = 0x8000; |
| else |
| result = 0x7FFF; |
| kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_WriteExtBuffer] Saturation3 %d %d",x,y); |
| |
| } |
| |
| *toPtr = result; |
| toPtr++; |
| } |
| }else{ |
| toPtr += segment; |
| } |
| }//else{ //it means no data should be played, so we don't append to the size of a frame any more |
| // kal_trace( TRACE_FUNC, EXT_BGSND_WRITEEXTBUFFER_SKIP_TO_DSP, count, pSrc->state[type]); |
| //} |
| |
| /* { |
| //just for debugging |
| int i; |
| for(i=0; i<10; i++){ |
| MD_TRC_EXT_BGSND_WRITEEXTBUFFER( |
| Ext_BGSnd.buffer[type][0],Ext_BGSnd.buffer[type][1], |
| Ext_BGSnd.buffer[type][2],Ext_BGSnd.buffer[type][3], |
| Ext_BGSnd.buffer[type][4],Ext_BGSnd.buffer[type][5], |
| Ext_BGSnd.buffer[type][6],Ext_BGSnd.buffer[type][7], |
| Ext_BGSnd.buffer[type][8],Ext_BGSnd.buffer[type][9] |
| ); |
| |
| } |
| }*/ |
| kal_give_spinlock(Ext_BGSnd.bgs_spinlockID); |
| MD_TRC_EXT_BGSND_WRITEEXTBUFFER_LEAVE(); |
| } |
| |
| int32 EXT_BGSND_GetFreeSpace(uint32 id, BGSND_PROCESS_TYPE type) |
| { |
| |
| ASSERT( type == BGSND_DL_PROCESS || type == BGSND_UL_PROCESS ); |
| EXT_BGSND_SRC_T *pSrc = &Ext_BGSnd.src[id]; |
| |
| MD_TRC_EXT_BGSND_GETFREESPACE_ENTER(); |
| MD_TRC_EXT_BGSND_GETFREESPACE_INFO(pSrc->bufSize[type], pSrc->bufRead[type], pSrc->bufWrite[type]); |
| |
| |
| |
| MD_TRC_EXT_BGSND_GETFREESPACE_LEAVE(); |
| return (pSrc->bufSize[type] - EXT_BGSND_BUF_PTR_DIFF - pSrc->bufDataCount[type]); |
| } |
| |
| |
| void EXT_BGSND_ConfigMixer(int id, kal_bool bSPHFlag, kal_int8 SNDGain, BGSND_PROCESS_TYPE type) |
| { |
| EXT_BGSND_SRC_T *pSrc = &Ext_BGSnd.src[id]; |
| MD_TRC_EXT_BGSND_CONFIGMIXER_ENTER(); |
| ASSERT(SNDGain>=0 && SNDGain<=MAX_LEVEL_EXT_BGSND_GAIN); |
| MD_TRC_EXT_BGSND_CONFIGMIXER_BSPHFLAG(bSPHFlag, SNDGain); |
| pSrc->fSph[type] = bSPHFlag; |
| pSrc->gain[type] = MAX_LEVEL_EXT_BGSND_GAIN-SNDGain; |
| MD_TRC_EXT_BGSND_CONFIGMIXER_LEAVE(); |
| /* |
| SNDGain = 7 --> Volume >> 0 |
| SNDGain = 6 --> Volume >> 1 |
| SNDGain = 5 --> Volume >> 2 |
| |
| SNDGain = 0 --> Volume * 0 = 0 |
| */ |
| } |
| |
| |
| EXT_SRC_STATE_TYPE EXT_BGSND_GetStatus(int id, BGSND_PROCESS_TYPE enULDL) |
| { |
| ASSERT( id < MAX_SIZE_EXT_BGSND_SRC ); |
| ASSERT( enULDL < MAX_NUM_BGSND_PROCESS ); |
| return(Ext_BGSnd.src[id].state[enULDL]); |
| } |
| |
| |
| //================= Extended SPC BGSND INTERFACE ==================== |
| |
| |
| |
| |
| |