[Feature]Upload Modem source code
Change-Id: Id4294f30faced84d3e6fd6d5e61e1111bf287a37
diff --git a/mcu/driver/audio/src/v1/spc_drv.c b/mcu/driver/audio/src/v1/spc_drv.c
new file mode 100644
index 0000000..0097994
--- /dev/null
+++ b/mcu/driver/audio/src/v1/spc_drv.c
@@ -0,0 +1,6600 @@
+/*****************************************************************************
+* Copyright Statement:
+* --------------------
+* This software is protected by Copyright and the information contained
+* herein is confidential. The software may not be copied and the information
+* contained herein may not be used or disclosed except with the written
+* permission of MediaTek Inc. (C) 2005
+*
+* BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
+* THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
+* RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
+* AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
+* NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
+* SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
+* SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
+* THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
+* NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
+* SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
+*
+* BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
+* LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
+* AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
+* OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
+* MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
+*
+* THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
+* WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
+* LAWS PRINCIPLES. ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
+* RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
+* THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
+*
+*****************************************************************************/
+
+/*******************************************************************************
+ *
+ * Filename:
+ * ---------
+ * spc_drv.c
+ *
+ * Project:
+ * --------
+ * MAUI
+ *
+ * Description:
+ * ------------
+ * MD speech control
+ *
+ * Author:
+ * -------
+ *
+ *
+ *==============================================================================
+ * HISTORY
+ * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
+ *------------------------------------------------------------------------------
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+>>>> ORIGINAL //VMOLY/TRUNK/VMOLY/mcu/driver/audio/src/v1/spc_drv.c#11
+==== THEIRS //VMOLY/TRUNK/VMOLY/mcu/driver/audio/src/v1/spc_drv.c#12
+ * removed!
+ * removed!
+ * removed!
+==== YOURS //ws_thomas.chen_work1/VMOLY/TRUNK/VMOLY/mcu/driver/audio/src/v1/spc_drv.c
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+<<<<
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ *------------------------------------------------------------------------------
+ * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
+ *==============================================================================
+ *******************************************************************************/
+
+#include "kal_public_api.h"
+#include "kal_general_types.h"
+#include "stack_config.h"
+#include "reg_base.h"
+#include "kal_trace.h"
+#include "string.h"
+#include "fsal.h"
+#include "sp_cc.h"
+#include "event_info_utility.h" // for MODEM_WARNING_MESSAGE
+
+#include "audio_enum.h"
+#include "am.h"
+#include "afe.h"
+#include "media.h"
+#include "l1sp_trc.h"
+#include "audcoeff_default.h"
+#include "dcl.h"
+#include "extcodec.h"
+
+#if defined(__L5_SUPPORT__)
+
+#include "l1audio.h"
+
+#include "drv_sap.h"
+#include "l5_msgid.h"
+#endif
+
+
+#include "med_spcio.h"
+#include "audio_em_struct.h"
+// #include "aud_common_config.h" // for DEFAULT_SPEECH_COMMON_PARA. in customer folder
+
+
+#include "spc_drv.h" // including "sp_drv.h"
+#include "sp_enhance.h"
+#include "sp_daca.h"
+#include "pcm4way.h"
+// #include "pcmrec.h"
+#include "rawpcmrec.h"
+#include "bgSnd.h"
+#include "pcmRouter.h"
+#include "ctm_drv.h"
+#include "vm.h"
+#include "pcmMixer.h"
+#include "pcmMixer3.h"
+// #include "mml1_rf_global.h"
+
+#if defined(__CVSD_CODEC_SUPPORT__)
+#include "bt_sco_drv.h"
+#endif
+
+#include "sp_dsptone_drv.h"
+#include "sal_exp.h"
+
+// ----------------------------------------------------------------------------
+void Spc_AcousticLoopback(bool enable, kal_uint8 uParam, kal_uint8 extraParam);
+#if defined(_SPE_ENH_MD_PARSE_)
+uint16 spc_dynamicParameterParser_dispatcher(const kal_uint16 offset, const kal_uint16 length, SPC_MSG_FROM_T comeFrom,
+ kal_uint16 *procLen, kal_uint16 *newOffset);
+#endif
+void Spc_SpeechRouterOn(kal_bool enable);
+void Spc_SpeechOnForDaca( kal_uint8 RAT_Mode, kal_bool enable);
+void spc_SpeechOnForCallHold(kal_bool isGen);
+kal_bool spc_endApp(void);
+
+void spc_gain_UlMuteSet(kal_bool on, kal_bool byPassCheck);
+void spc_gain_DlMuteSet(kal_bool on, kal_bool byPassCheck);
+void spc_gain_UlEnhResultMuteSet(kal_bool on, kal_bool byPassCheck);
+void spc_gain_UlSourceMuteSet(kal_bool on, kal_bool byPassCheck);
+void spc_gain_DlMuteCodecSet(kal_bool on, kal_bool byPassCheck);
+void spc_gain_DlMuteSet_PrePcmMixer(kal_bool on, kal_bool byPassCheck);
+
+// ----------------------------------------------------------------------------
+
+#if defined(__ECALL_SUPPORT__)
+void aud_ecall_event_callback(eCall_Modem_Event event, void *param);
+#endif
+
+extern _PCMEX_T pcmEx;
+typedef enum {
+ SPC_APP_SPEECH_USAGE = 0,
+ SPC_APP_PCMNWAY_USAGE,
+ SPC_APP_OLD_RECORD_USAGE, // either "SPC_APP_RECORD_USAGE" or "SPC_APP_PCM_REC_USAGE & SPC_APP_VM_REC_USAGE" usage, remove from 93md
+ SPC_APP_BGSND_USAGE,
+
+ SPC_APP_CTM_USAGE,
+ SPC_APP_ACLOOPBACK_USAGE,
+
+ SPC_APP_OLD_PCM_REC_USAGE, // 6, add from MT6582 chip, remove from 93md
+ SPC_APP_VM_REC_USAGE,
+
+ SPC_APP_HOLD_USAGE, // cannot mix with other speech application
+ SPC_APP_HOSTED_USAGE,
+ SPC_APP_PCMROUTER_USAGE,
+
+ //We can't enable all record function, only following selections are acceptable:
+ //1. SPC_APP_OLD_RECORD_USAGE
+ //2. SPC_APP_OLD_PCM_REC_USAGE
+ //3. SPC_APP_OLD_PCM_REC_USAGE + SPC_APP_VM_REC_USAGE
+ //4. SPC_APP_RAW_PCM_REC_USAGE
+ //5. SPC_APP_RAW_PCM_REC_USAGE + SPC_APP_VM_REC_USAGE
+ SPC_APP_RAW_PCM_REC_USAGE, //11, add from MT6752 chip
+
+ SPC_APP_MERGE_SPH_USAGE, // 12
+ SPC_APP_MIXER_USAGE, // 13
+ SPC_APP_MIXER3_USAGE, // 14
+ SPC_APP_MAX = 16 // due to spcAppUsage is uint16. so only 16 application can existing.
+} MSG_SPC_APP_T;
+
+typedef enum{
+ SPC_EM_INIT_COMMON = 0,
+ SPC_EM_INIT_NB,
+ SPC_EM_INIT_WB,
+ SPC_EM_INIT_SWB,
+ SPC_EM_INIT_DMNR,
+ SPC_EM_INIT_LSPK_DMNR,
+ SPC_EM_INIT_IIR,
+
+ SPC_EM_INIT_MAX = 16 // due to spcEmInit is unit16, so only 16 em data message can existing.
+} SPC_EM_INIT_T;
+
+typedef struct _SPC_T_
+{
+ kal_uint16 spcGetEpofTimes;
+ kal_uint16 spcAppUsage; //Please reference MSG_SPC_APP_T for bit definition
+
+ kal_uint16 spcEmInit;
+
+ // DSP mute
+ kal_bool spcMuteUl;
+ kal_bool spcMuteDl;
+
+ kal_bool spcMuteUlEnhResult;
+ kal_bool spcMuteUlSource;
+
+ kal_uint16 spcRampAck;
+#if defined(__ECALL_SUPPORT__)
+ kal_uint8 eCall_LIB_Status; //0:disable ecall,1:only enable SDT,2:enable ecall
+ kal_uint8 eCall_Ctrl_Seq_Switch;
+#endif
+} _SPC_T;
+
+#if defined(__ECALL_SUPPORT__)
+typedef signed short int Int16; /* 16 bit signed variable */
+
+extern Int16 eCall_TX_CTRL_SEQ_State[800];
+extern Int16 eCall_TX_CTRL_SEQ_dlData[800];
+extern Int16 eCall_TX_CTRL_SEQ_dlMetric[800];
+extern Int16 eCall_RX_CTRL_SEQ_State[800];
+extern Int16 eCall_RX_CTRL_SEQ_dlData[800];
+extern Int16 eCall_RX_CTRL_SEQ_dlMetric[800];
+kal_uint8 eCall_Msd[140];
+// Speech Recognition Feature for Eu spec
+#endif
+
+typedef struct spcEMIParInfoStruct
+{
+ uint32 EMI_Offset;
+ uint32 EMI_Len;
+ uint32 Common_Offset;
+ uint32 Dbg_Info_Offset;
+
+} spcEMIParInfo;
+
+
+
+
+
+
+
+
+
+#if defined(_SPE_ENH_MD_PARSE_)
+typedef struct spcDynParHeaderStruct
+{
+ uint16 SphParserVer;
+ uint16 NumLayer;
+ uint16 NumEachLayer;
+ uint16 Param_Header_Layer1;
+ uint16 Param_Header_Layer2;
+ uint16 Param_Header_Layer3;
+ uint16 Param_Header_Layer4;
+ uint16 SphUnitMagiNum;
+} spcDynParHeader;
+
+
+typedef struct spcDynParNBDataStruct
+{
+ unsigned short speech_Mode_para[NUM_MODE_PARAS];
+ short speech_NB_FIR_IN_para[NUM_FIR_COEFFS];
+ short speech_NB_FIR_OUT_para[NUM_FIR_COEFFS];
+} spcDynParNBData;
+
+
+typedef struct spcDynParNBDataStruct_V10 // need remover later
+{
+ unsigned short speech_Mode_para[NUM_MODE_PARAS];
+ short speech_NB_FIR_IN_para[45];
+ short speech_NB_FIR_OUT_para[45];
+} spcDynParNBData_V10;
+
+
+
+typedef struct spcDynParNBIIRDataStruct
+{
+ short speech_NB_MIC1_IIR_para[NUM_MIC1_IIR_COEFFS];
+ short speech_NB_MIC2_IIR_para[NUM_MIC2_IIR_COEFFS];
+ short speech_NB_IIR_IN_para[NUM_IIR_COEFFS];
+ short speech_NB_IIR_OUT_para[NUM_IIR_COEFFS];
+} spcDynParNBIIRData;
+typedef struct spcDynParWBDataStruct
+{
+
+ unsigned short speech_Mode_para[NUM_MODE_PARAS];
+ short speech_WB_FIR_IN_para[NUM_WB_FIR_COEFFS];
+ short speech_WB_FIR_OUT_para[NUM_WB_FIR_COEFFS];
+} spcDynParWBData;
+typedef struct spcDynParWBIIRDataStruct
+{
+ short speech_WB_MIC1_IIR_para[NUM_MIC1_IIR_COEFFS];
+ short speech_WB_MIC2_IIR_para[NUM_MIC2_IIR_COEFFS];
+ short speech_WB_IIR_IN_para[NUM_IIR_COEFFS];
+ short speech_WB_IIR_OUT_para[NUM_IIR_COEFFS];
+
+} spcDynParWBIIRData;
+typedef struct spcDynParSWBDataStruct
+{
+
+ unsigned short speech_Mode_para[NUM_MODE_PARAS];
+ short speech_SWB_FIR_IN_para[NUM_SWB_FIR_COEFFS];
+ short speech_SWB_FIR_OUT_para[NUM_SWB_FIR_COEFFS];
+} spcDynParSWBData;
+typedef struct spcDynParSWBIIRDataStruct
+{
+ short speech_SWB_MIC1_IIR_para[NUM_MIC1_IIR_COEFFS];
+ short speech_SWB_MIC2_IIR_para[NUM_MIC2_IIR_COEFFS];
+ short speech_SWB_IIR_IN_para[NUM_IIR_COEFFS];
+ short speech_SWB_IIR_OUT_para[NUM_IIR_COEFFS];
+} spcDynParSWBIIRData;
+typedef struct spcMagiClarityDataStruct
+{
+ short MagiClarity_Para[32];
+} spcMagiClarityData;
+
+typedef struct spcCommonDataStruct
+{
+
+ unsigned short Common_Para[NUM_COMMON_PARAS];
+ unsigned short Debug_info_para[NUM_DEBUG_INFO];
+
+} spcCommonData;
+#endif
+
+typedef struct spcDynParEchoRefForUsbAudioStruct
+{
+
+ bool isEchoRefForUsbAudioOn;
+ short chip_delay_with_switch;
+ short mic_index; // bit wise definition ordered from main mic to reference mic. Only one bit is set!! bit 0: o17, bit 1: o18, bit 2: o23, bit 3: o24, bit 4: o25,
+
+} spcDynParEchoRefForUsbAudio_T;
+
+#if defined(_SPE_ENH_MD_PARSE_)
+short DMNR_NB_REC[NUM_DMNR_PARAM];
+short DMNR_NB_LoudSpk[NUM_DMNR_PARAM];
+short DMNR_WB_REC[NUM_WB_DMNR_PARAM];
+short DMNR_WB_LoudSpk[NUM_WB_DMNR_PARAM];
+short DMNR_SWB_REC[NUM_SWB_DMNR_PARAM];
+short DMNR_SWB_LoudSpk[NUM_SWB_DMNR_PARAM];
+//DMNR header
+#define Header_DMNR_NB_REC 0x0011
+#define Header_DMNR_NB_LSP 0x0012
+#define Header_DMNR_WB_REC 0x0021
+#define Header_DMNR_WB_LSP 0x0022
+#define Header_DMNR_SWB_REC 0x0031
+#define Header_DMNR_SWB_LSP 0x0032
+
+
+//define data header - voice band
+#define NB_Par 0x10
+#define WB_Par 0x20
+#define SWB_Par 0x30
+//define param header- voice band
+#define VoiceBand_NB (1 << 1)
+#define VoiceBand_WB (1 << 2)
+#define VoiceBand_SWB 0x04
+#define VoiceBand_FB 0x08
+
+
+
+//define data header -network
+
+#define GSM_NETWORK 0x01
+#define WCDMA_NETWORK 0x02
+#define CDMA_NETWORK 0x03
+#define VOLTE_NETWORK 0x04
+#define C2K_NETWORK 0x05
+#define DONT_CARE_NETWORK 0x0F
+
+
+unsigned short Temp_speech_NB_Mode_para[TOTAL_NETWORK_NUMBER][NUM_MODE_PARAS];
+short Temp_speech_NB_FIR_IN_para[TOTAL_NETWORK_NUMBER][NUM_FIR_COEFFS];
+short Temp_speech_NB_FIR_OUT_para[TOTAL_NETWORK_NUMBER][NUM_FIR_COEFFS];
+short Temp_speech_NB_IIR_IN_para[TOTAL_NETWORK_NUMBER][NUM_IIR_COEFFS];
+short Temp_speech_NB_IIR_OUT_para[TOTAL_NETWORK_NUMBER][NUM_IIR_COEFFS];
+short Temp_speech_NB_MIC1_IIR_para[TOTAL_NETWORK_NUMBER][NUM_MIC1_IIR_COEFFS];
+short Temp_speech_NB_MIC2_IIR_para[TOTAL_NETWORK_NUMBER][NUM_MIC2_IIR_COEFFS];
+
+unsigned short Temp_speech_WB_Mode_para[TOTAL_NETWORK_NUMBER][NUM_MODE_PARAS];
+short Temp_speech_WB_FIR_IN_para[TOTAL_NETWORK_NUMBER][NUM_WB_FIR_COEFFS];
+short Temp_speech_WB_FIR_OUT_para[TOTAL_NETWORK_NUMBER][NUM_WB_FIR_COEFFS];
+short Temp_speech_WB_IIR_IN_para[TOTAL_NETWORK_NUMBER][NUM_IIR_COEFFS];
+short Temp_speech_WB_IIR_OUT_para[TOTAL_NETWORK_NUMBER][NUM_IIR_COEFFS];
+short Temp_speech_WB_MIC1_IIR_para[TOTAL_NETWORK_NUMBER][NUM_MIC1_IIR_COEFFS];
+short Temp_speech_WB_MIC2_IIR_para[TOTAL_NETWORK_NUMBER][NUM_MIC2_IIR_COEFFS];
+
+unsigned short Temp_speech_SWB_Mode_para[TOTAL_NETWORK_NUMBER][NUM_MODE_PARAS];
+short Temp_speech_SWB_FIR_IN_para[TOTAL_NETWORK_NUMBER][NUM_SWB_FIR_COEFFS];
+short Temp_speech_SWB_FIR_OUT_para[TOTAL_NETWORK_NUMBER][NUM_SWB_FIR_COEFFS];
+short Temp_speech_SWB_IIR_IN_para[TOTAL_NETWORK_NUMBER][NUM_IIR_COEFFS];
+short Temp_speech_SWB_IIR_OUT_para[TOTAL_NETWORK_NUMBER][NUM_IIR_COEFFS];
+short Temp_speech_SWB_MIC1_IIR_para[TOTAL_NETWORK_NUMBER][NUM_MIC1_IIR_COEFFS];
+short Temp_speech_SWB_MIC2_IIR_para[TOTAL_NETWORK_NUMBER][NUM_MIC2_IIR_COEFFS];
+#endif
+extern const unsigned short Speech_Common_Para[12] ;
+extern const unsigned short Debug_Info_Para[16] ;
+
+
+
+
+
+
+// ----------------------------------------------------------------------------
+// Global Variable
+// ----------------------------------------------------------------------------
+
+static _SPC_T gSpc;
+
+__attribute__((aligned (4)))static kal_uint8 emDataBuf[4096];
+
+
+static uint16 gSpc_networkStatus = 0xFF;
+
+// ----------------------------------------------------------------------------
+// Macro function
+// ----------------------------------------------------------------------------
+
+#define IS_SPC_APP_USED(app) ((gSpc.spcAppUsage & (1 << (app))) != 0)
+#define SET_SPC_APP_USAGE(app) (gSpc.spcAppUsage |= (1 << (app)))
+#define CLR_SPC_APP_USAGE(app) (gSpc.spcAppUsage &= (~(1 << (app))))
+
+
+#define IS_SPC_EM_INIT(emPara) ((gSpc.spcEmInit& (1 << (emPara))) != 0)
+#define SET_SPC_EM_INIT(emPara) (gSpc.spcEmInit |= (1 << (emPara)))
+
+#define IS_SPC_RAMP_WAIT_ACK(point) ((gSpc.spcRampAck & (1 << (point))) != 0)
+#define SET_SPC_RAMP_WAIT_ACK(point) (gSpc.spcRampAck |= (1 << (point)))
+#define CLR_SPC_RAMP_WAIT_ACK(point) (gSpc.spcRampAck &= (~(1 << (point))))
+
+#define SPC_CODEC_INFO_STRCAT(dest, src) strncat((dest), (src), strlen((src)) < SPC_PROP_CODEC_LEN-strlen((dest)) ? strlen((src)) : SPC_PROP_CODEC_LEN-strlen((dest)))
+
+/*
+#if ((defined(MT6280) || defined(MT6290)) && (defined(__SMART_PHONE_MODEM__))) || defined(SPH_CHIP_BACK_PHONECALL_USE)
+// for super dongle project on data card chip, MD reset scenario is useless
+// So the protection is unnecessary and un-sync with AP side, so the request is always done
+#define IS_SPC_ID_SPEECH_CUSTOM_DATA_REQUEST_DONE (true)
+#else
+#define IS_SPC_ID_SPEECH_CUSTOM_DATA_REQUEST_DONE (IS_SPC_EM_INIT(SPC_EM_INIT_COMMON)) // using comm parameter data notify as EM data request ack
+#endif
+*/
+
+// ----------------------------------------------------------------------------
+// Internal Init Related
+// ----------------------------------------------------------------------------
+#if defined(_SPE_ENH_MD_PARSE_)
+// following constant inside ./custom/driver/common/aud_common.c
+extern const unsigned short Speech_Normal_Mode_Para[16];
+extern const unsigned short Speech_Earphone_Mode_Para[16];
+extern const unsigned short Speech_LoudSpk_Mode_Para[16];
+extern const unsigned short Speech_BT_Earphone_Mode_Para[16];
+extern const unsigned short Speech_BT_Cordless_Mode_Para[16];
+extern const unsigned short Speech_CARKIT_Mode_Para[16];
+extern const unsigned short Speech_AUX1_Mode_Para[16];
+extern const unsigned short Speech_AUX2_Mode_Para[16];
+extern const unsigned short WB_Speech_Normal_Mode_Para[16];
+extern const unsigned short WB_Speech_Earphone_Mode_Para[16];
+extern const unsigned short WB_Speech_LoudSpk_Mode_Para[16];
+extern const unsigned short WB_Speech_BT_Earphone_Mode_Para[16];
+extern const unsigned short WB_Speech_BT_Cordless_Mode_Para[16];
+extern const unsigned short WB_Speech_CARKIT_Mode_Para[16];
+extern const unsigned short WB_Speech_AUX1_Mode_Para[16];
+extern const unsigned short WB_Speech_AUX2_Mode_Para[16];
+
+
+extern const signed short WB_DMNR_Para[76];
+extern const signed short LSpk_WB_DMNR_Para[76];
+extern const signed short DMNR_Para[44];
+extern const signed short LSpk_DMNR_Para[44];
+
+
+
+/**
+
+*/
+extern const signed short Speech_All_Pass_IIR_Coeff[42] ;
+extern const signed short Sph_Mic1_IIR_In[20] ;
+extern const signed short Sph_Mic2_IIR_In[20] ;
+unsigned short default_speech_mode_para[TOTAL_NETWORK_NUMBER][NUM_MODE_PARAS];
+signed short default_Speech_Input_FIR_Coeff[TOTAL_NETWORK_NUMBER][NUM_FIR_COEFFS];
+signed short default_Speech_Output_FIR_Coeff[TOTAL_NETWORK_NUMBER][NUM_FIR_COEFFS];
+signed short default_Speech_Input_IIR_Coeff[TOTAL_NETWORK_NUMBER][NUM_IIR_COEFFS];
+signed short default_Speech_Output_IIR_Coeff[TOTAL_NETWORK_NUMBER][NUM_IIR_COEFFS];
+signed short default_Speech_MIC1_IIR_Coeff[TOTAL_NETWORK_NUMBER][NUM_MIC1_IIR_COEFFS];
+signed short default_Speech_MIC2_IIR_Coeff[TOTAL_NETWORK_NUMBER][NUM_MIC2_IIR_COEFFS];
+unsigned short default_WB_speech_mode_para[TOTAL_NETWORK_NUMBER][NUM_MODE_PARAS];
+signed short default_WB_Speech_Input_FIR_Coeff[TOTAL_NETWORK_NUMBER][NUM_WB_FIR_COEFFS];
+signed short default_WB_Speech_Output_FIR_Coeff[TOTAL_NETWORK_NUMBER][NUM_WB_FIR_COEFFS];
+signed short default_WB_Speech_Input_IIR_Coeff[TOTAL_NETWORK_NUMBER][NUM_IIR_COEFFS];
+signed short default_WB_Speech_Output_IIR_Coeff[TOTAL_NETWORK_NUMBER][NUM_IIR_COEFFS];
+signed short default_WB_Speech_MIC1_IIR_Coeff[TOTAL_NETWORK_NUMBER][NUM_MIC1_IIR_COEFFS];
+signed short default_WB_Speech_MIC2_IIR_Coeff[TOTAL_NETWORK_NUMBER][NUM_MIC2_IIR_COEFFS];
+unsigned short default_SWB_speech_mode_para[TOTAL_NETWORK_NUMBER][NUM_MODE_PARAS];
+signed short default_SWB_Speech_Input_FIR_Coeff[TOTAL_NETWORK_NUMBER][NUM_SWB_FIR_COEFFS];
+signed short default_SWB_Speech_Output_FIR_Coeff[TOTAL_NETWORK_NUMBER][NUM_SWB_FIR_COEFFS];
+signed short default_SWB_Speech_Input_IIR_Coeff[TOTAL_NETWORK_NUMBER][NUM_IIR_COEFFS];
+signed short default_SWB_Speech_Output_IIR_Coeff[TOTAL_NETWORK_NUMBER][NUM_IIR_COEFFS];
+signed short default_SWB_Speech_MIC1_IIR_Coeff[TOTAL_NETWORK_NUMBER][NUM_MIC1_IIR_COEFFS];
+signed short default_SWB_Speech_MIC2_IIR_Coeff[TOTAL_NETWORK_NUMBER][NUM_MIC2_IIR_COEFFS];
+#endif
+
+
+
+#if defined(_SPE_ENH_MD_PARSE_)
+
+void spc_EmInit(kal_bool isNeedBasic, kal_bool isNeedNb,kal_bool isNeedWb,kal_bool isNeedSWb, kal_bool isNeedDmnr, kal_bool isNeedLspkDmnr,kal_bool isNeedIIR)
+{
+ MD_TRC_SPC_EM_DEFAULT_INIT(isNeedBasic, isNeedNb,isNeedWb, isNeedSWb,isNeedDmnr, isNeedLspkDmnr,isNeedIIR);
+
+ // ====== parameters from EM =======
+ if(isNeedBasic){
+ // common parameter
+ uint16 commonP[] = DEFAULT_SPEECH_COMMON_PARA;
+ L1SP_LoadCommonSpeechPara(commonP);
+
+ }
+ if(isNeedNb){
+
+ // mode parameter , default use normal mode,GSM,NB
+ uint8 count;
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_speech_mode_para[count], Speech_Normal_Mode_Para, 16*sizeof(uint16)) ;
+ }
+ l1sp_setAllSpeechModePara((kal_uint16 *)default_speech_mode_para, TOTAL_NETWORK_NUMBER * NUM_MODE_PARAS);
+ // SPE_LoadSpeechPara(NULL, gSpe.sph_ModePara[0], NULL, NULL); // l1sp.sph_v_para no one use it.
+
+
+ // FIR , default use normal mode,GSM,NB
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_Speech_Input_FIR_Coeff[count], WB_Speech_Input_FIR_Coeff[0], NUM_FIR_COEFFS*sizeof(int16)) ;
+ }
+ l1sp_setAllSpeechFirCoeff_InputOnly((int16 *)default_Speech_Input_FIR_Coeff, TOTAL_NETWORK_NUMBER*NUM_FIR_COEFFS);
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_Speech_Output_FIR_Coeff[count], WB_Speech_Output_FIR_Coeff[0], NUM_FIR_COEFFS*sizeof(int16)) ;
+ }
+ l1sp_setAllSpeechFirCoeff_OutputOnly((int16 *)default_Speech_Output_FIR_Coeff, TOTAL_NETWORK_NUMBER*NUM_FIR_COEFFS);
+ //AM_WriteFirCoeffs( gSpe.sph_InFirCoeff[0], gSpe.sph_OutFirCoeff[0] );
+
+ }
+ if(isNeedWb){
+ // WB FIR
+
+ // in customer folder's Audcoeff.c
+ uint8 count;
+
+
+ // WB mode parameter , default use normal mode,GSM,NB
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_WB_speech_mode_para[count], WB_Speech_Normal_Mode_Para, 16*sizeof(uint16)) ;
+ }
+ l1sp_setAllWbSpeechModePara((kal_uint16* )default_WB_speech_mode_para, TOTAL_NETWORK_NUMBER * NUM_MODE_PARAS);
+ //SPE_LoadSpeechPara(NULL, NULL, NULL,gSpe.sph_WbModePara[0] );
+
+
+ extern const signed short WB_Speech_Input_FIR_Coeff[6][90];
+ extern const signed short WB_Speech_Output_FIR_Coeff[6][90];
+
+
+
+ // WB FIR , default use normal mode,GSM,NB
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_WB_Speech_Input_FIR_Coeff[count], WB_Speech_Input_FIR_Coeff[0], NUM_WB_FIR_COEFFS*sizeof(int16)) ;
+ }
+
+ l1sp_setAllWbSpeechFirCoeff_InputOnly((kal_int16 *)default_WB_Speech_Input_FIR_Coeff, TOTAL_NETWORK_NUMBER*NUM_WB_FIR_COEFFS);
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_WB_Speech_Output_FIR_Coeff[count], WB_Speech_Output_FIR_Coeff[0], NUM_WB_FIR_COEFFS*sizeof(int16)) ;
+ }
+ l1sp_setAllWbSpeechFirCoeff_OutputOnly((int16 *)default_WB_Speech_Output_FIR_Coeff, TOTAL_NETWORK_NUMBER*NUM_WB_FIR_COEFFS);
+ //AM_WriteWbFirCoeffs(gSpe.sph_WbInFirCoeff[0],gSpe.sph_WbOutFirCoeff[0]);
+ }
+ if(isNeedSWb){
+ // SWB FIR
+ // SWB mode parameter , default use normal mode,GSM,NB
+ uint8 count;
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_SWB_speech_mode_para[count], WB_Speech_Normal_Mode_Para, 16*sizeof(uint16)) ;
+ }
+ l1sp_setAllSWbSpeechModePara((kal_uint16* )default_SWB_speech_mode_para, TOTAL_NETWORK_NUMBER * NUM_MODE_PARAS);
+ //SPE_LoadSpeechPara(NULL, NULL, NULL,gSpe.sph_WbModePara[0] );
+
+
+ extern const signed short WB_Speech_Input_FIR_Coeff[6][90];
+ extern const signed short WB_Speech_Output_FIR_Coeff[6][90];
+
+
+
+ // WB FIR , default use normal mode,GSM,NB
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_SWB_Speech_Input_FIR_Coeff[count], WB_Speech_Input_FIR_Coeff[0], NUM_SWB_FIR_COEFFS*sizeof(int16)) ;
+ }
+ l1sp_setAllSWbSpeechFirCoeff_InputOnly((kal_int16 *)default_SWB_Speech_Input_FIR_Coeff, TOTAL_NETWORK_NUMBER*NUM_SWB_FIR_COEFFS);
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_SWB_Speech_Output_FIR_Coeff[count], WB_Speech_Output_FIR_Coeff[0], NUM_SWB_FIR_COEFFS*sizeof(int16)) ;
+ }
+ l1sp_setAllSWbSpeechFirCoeff_OutputOnly((int16 *)default_SWB_Speech_Output_FIR_Coeff, TOTAL_NETWORK_NUMBER*NUM_SWB_FIR_COEFFS);
+ //AM_WriteWbFirCoeffs(gSpe.sph_WbInFirCoeff[0],gSpe.sph_WbOutFirCoeff[0]);
+
+
+ }
+ if(isNeedIIR){
+ //IIR
+ uint8 count;
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_Speech_Input_IIR_Coeff[count], Speech_All_Pass_IIR_Coeff, NUM_IIR_COEFFS*sizeof(int16)) ;
+ }
+ l1sp_setAllSpeechIirCoeff_InputOnly((int16 *)default_Speech_Input_IIR_Coeff, TOTAL_NETWORK_NUMBER*NUM_IIR_COEFFS);
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_Speech_Output_IIR_Coeff[count], Speech_All_Pass_IIR_Coeff, NUM_IIR_COEFFS*sizeof(int16)) ;
+ }
+ l1sp_setAllSpeechIirCoeff_OutputOnly((int16 *)default_Speech_Output_IIR_Coeff, TOTAL_NETWORK_NUMBER*NUM_IIR_COEFFS);
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_Speech_MIC1_IIR_Coeff[count], Sph_Mic1_IIR_In, NUM_MIC1_IIR_COEFFS*sizeof(int16)) ;
+ }
+ l1sp_setAllSpeechMic1IirCoeff((int16 *)default_Speech_MIC1_IIR_Coeff, TOTAL_NETWORK_NUMBER*NUM_MIC1_IIR_COEFFS);
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_Speech_MIC2_IIR_Coeff[count], Sph_Mic2_IIR_In, NUM_MIC2_IIR_COEFFS*sizeof(int16)) ;
+ }
+ l1sp_setAllSpeechMic2IirCoeff((int16 *)default_Speech_MIC2_IIR_Coeff, TOTAL_NETWORK_NUMBER*NUM_MIC2_IIR_COEFFS);
+
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_WB_Speech_Input_IIR_Coeff[count], Speech_All_Pass_IIR_Coeff, NUM_IIR_COEFFS*sizeof(int16)) ;
+ }
+ l1sp_setAllWBSpeechIirCoeff_InputOnly((int16 *)default_WB_Speech_Input_IIR_Coeff, TOTAL_NETWORK_NUMBER*NUM_IIR_COEFFS);
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_WB_Speech_Output_IIR_Coeff[count], Speech_All_Pass_IIR_Coeff, NUM_IIR_COEFFS*sizeof(int16)) ;
+ }
+ l1sp_setAllWBSpeechIirCoeff_OutputOnly((int16 *)default_WB_Speech_Output_IIR_Coeff, TOTAL_NETWORK_NUMBER*NUM_IIR_COEFFS);
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_WB_Speech_MIC1_IIR_Coeff[count], Sph_Mic1_IIR_In, NUM_MIC1_IIR_COEFFS*sizeof(int16)) ;
+ }
+ l1sp_setAllWBSpeechMic1IirCoeff((int16 *)default_WB_Speech_MIC1_IIR_Coeff, TOTAL_NETWORK_NUMBER*NUM_MIC1_IIR_COEFFS);
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_WB_Speech_MIC2_IIR_Coeff[count], Sph_Mic2_IIR_In, NUM_MIC2_IIR_COEFFS*sizeof(int16)) ;
+ }
+ l1sp_setAllWBSpeechMic2IirCoeff((int16 *)default_WB_Speech_MIC2_IIR_Coeff, TOTAL_NETWORK_NUMBER*NUM_MIC2_IIR_COEFFS);
+
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_SWB_Speech_Input_IIR_Coeff[count], Speech_All_Pass_IIR_Coeff, NUM_IIR_COEFFS*sizeof(int16)) ;
+ }
+ l1sp_setAllSWBSpeechIirCoeff_InputOnly((int16 *)default_SWB_Speech_Input_IIR_Coeff, TOTAL_NETWORK_NUMBER*NUM_IIR_COEFFS);
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_SWB_Speech_Output_IIR_Coeff[count], Speech_All_Pass_IIR_Coeff, NUM_IIR_COEFFS*sizeof(int16)) ;
+ }
+ l1sp_setAllSWBSpeechIirCoeff_OutputOnly((int16 *)default_SWB_Speech_Output_IIR_Coeff, TOTAL_NETWORK_NUMBER*NUM_IIR_COEFFS);
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_SWB_Speech_MIC1_IIR_Coeff[count], Sph_Mic1_IIR_In, NUM_MIC1_IIR_COEFFS*sizeof(int16)) ;
+ }
+ l1sp_setAllSWBSpeechMic1IirCoeff((int16 *)default_SWB_Speech_MIC1_IIR_Coeff, TOTAL_NETWORK_NUMBER*NUM_MIC1_IIR_COEFFS);
+ for(count=0; count<TOTAL_NETWORK_NUMBER; count++)
+ {
+ memcpy(default_SWB_Speech_MIC2_IIR_Coeff[count], Sph_Mic2_IIR_In, NUM_MIC2_IIR_COEFFS*sizeof(int16)) ;
+ }
+ l1sp_setAllSWBSpeechMic2IirCoeff((int16 *)default_SWB_Speech_MIC2_IIR_Coeff, TOTAL_NETWORK_NUMBER*NUM_MIC2_IIR_COEFFS);
+
+ }
+
+ if(isNeedDmnr){
+ L1SP_SetWbDMNRPara(WB_DMNR_Para);
+ L1SP_SetDMNRPara(DMNR_Para);
+ }
+
+ if(isNeedLspkDmnr){ // load param when begin run
+ L1SP_SetLSpkWbDMNRPara(LSpk_WB_DMNR_Para);
+ L1SP_SetLSpkDMNRPara(LSpk_DMNR_Para);
+ }
+
+ // loading!!
+ // if(isNeedBasic || isNeedWb) {
+ // L1SP_LoadSpeechPara();
+ // }
+}
+
+#endif
+/**
+ @app: app to be enable
+ @return: check result, true for pass, false for fail
+*/
+bool spc_mainAppOnCheck(MSG_SPC_APP_T app)
+{
+ // other related check
+ if(SPC_APP_SPEECH_USAGE != app && SPC_APP_MERGE_SPH_USAGE != app) {
+ if(IS_SPC_APP_USED(SPC_APP_SPEECH_USAGE)) {
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR_CHECK(app, SPC_APP_SPEECH_USAGE, SPC_APP_SPEECH_USAGE, gSpc.spcAppUsage);
+
+ ASSERT(0);
+
+ return false;
+ }
+ }
+
+ if(SPC_APP_ACLOOPBACK_USAGE != app) {
+ if(IS_SPC_APP_USED(SPC_APP_ACLOOPBACK_USAGE)) {
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR_CHECK(app, SPC_APP_ACLOOPBACK_USAGE, SPC_APP_ACLOOPBACK_USAGE, gSpc.spcAppUsage);
+
+ ASSERT(0);
+
+ return false;
+ }
+ }
+
+
+
+ if(SPC_APP_HOLD_USAGE != app) {
+ if(IS_SPC_APP_USED(SPC_APP_HOLD_USAGE)) {
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR_CHECK(app, SPC_APP_HOLD_USAGE, SPC_APP_HOLD_USAGE, gSpc.spcAppUsage);
+
+ ASSERT(0);
+
+ return false;
+ }
+ }
+
+ if(SPC_APP_HOSTED_USAGE != app) {
+ if(IS_SPC_APP_USED(SPC_APP_HOSTED_USAGE)) {
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR_CHECK(app, SPC_APP_HOSTED_USAGE, SPC_APP_HOSTED_USAGE, gSpc.spcAppUsage);
+
+ ASSERT(0);
+
+ return false;
+ }
+ }
+
+ if(SPC_APP_PCMROUTER_USAGE != app) {
+ if(IS_SPC_APP_USED(SPC_APP_PCMROUTER_USAGE)) {
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR_CHECK(app, SPC_APP_PCMROUTER_USAGE, SPC_APP_PCMROUTER_USAGE, gSpc.spcAppUsage);
+
+ ASSERT(0);
+
+ return false;
+ }
+ }
+
+ if(SPC_APP_MERGE_SPH_USAGE != app && SPC_APP_SPEECH_USAGE != app) {
+ if(IS_SPC_APP_USED(SPC_APP_MERGE_SPH_USAGE)) {
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR_CHECK(app, SPC_APP_MERGE_SPH_USAGE, SPC_APP_MERGE_SPH_USAGE, gSpc.spcAppUsage);
+
+ ASSERT(0);
+
+ return false;
+ }
+ }
+
+ return true;
+}
+
+
+// ----------------------------------------------------------------------------
+// Codec Related
+// ----------------------------------------------------------------------------
+/*
+#define CODEC_INFO_PROP_CODEC "codec="
+#define CODEC_INFO_PROP_ISHDV "isHdV="
+#define CODEC_INFO_PROP_HDVOP "HDVOp="
+#define CODEC_INFO_PROP_SR "sr="
+#define CODEC_INFO_PROP_BR "br="
+#define CODEC_INFO_PROP_FS "fs="
+#define CODEC_INFO_PROP_RR "rr="
+#define CODEC_INFO_PROP_SEPERATER ";"
+
+
+#define CODEC_INFO_PROP_CODEC_VALUE_FR "FR"
+#define CODEC_INFO_PROP_CODEC_VALUE_HR "HR"
+#define CODEC_INFO_PROP_CODEC_VALUE_EFR "EFR"
+#define CODEC_INFO_PROP_CODEC_VALUE_AMR "AMR"
+#define CODEC_INFO_PROP_CODEC_VALUE_AWB "AWB"
+
+#define CODEC_INFO_PROP_ISHDV_VALUE_Y "Y"
+#define CODEC_INFO_PROP_ISHDV_VALUE_N "N"
+*/
+
+#define SPC_PROP_CODEC_LEN 92
+
+typedef struct {
+ char codecInfo[SPC_PROP_CODEC_LEN];
+ char codecOp[SPC_PROP_CODEC_LEN];
+} SPC_CODEC_INFO_STRUCT;
+
+static struct {
+ uint32 curSpeechMode;
+ uint16 curRateInSoCodec;
+ SPC_CODEC_INFO_STRUCT info;
+} gSpc_codec_info;
+
+void spc_codecInfoInit(void)
+{
+ gSpc_codec_info.curSpeechMode = 0xffffffff;
+ gSpc_codec_info.curRateInSoCodec = 0xffff;
+ memset(&(gSpc_codec_info.info), '\0', sizeof(SPC_CODEC_INFO_STRUCT));
+}
+
+void spc_sendCodecInfoNotify(void)
+{
+ spcBufInfo info;
+
+ info.syncWord = 0x1234;
+ info.type = AUD_CCCI_STRMBUF_TYPE_NW_CODEC_INFO;
+ info.length = sizeof(SPC_CODEC_INFO_STRUCT); // currently, fix the buffer size in WB
+
+ SpcIO_WriteDataToAp(&info, sizeof(spcBufInfo),
+ &(gSpc_codec_info.info), sizeof(SPC_CODEC_INFO_STRUCT), NULL, 0,
+ SPCIO_MSG_FROM_SPC_NW_CODEC_INFO_NOTIFY);
+ MD_TRC_SPC_CODEC_NOTIFY_TO_AP(gSpc_codec_info.info.codecInfo, gSpc_codec_info.info.codecOp);
+}
+
+void spc_codecInfoNotify(uint32 codec)
+{
+
+ MD_TRC_SPC_CODEC_NOTIFY_IN(gSpc_codec_info.curSpeechMode, codec);
+
+ if(false == IS_SPC_APP_USED(SPC_APP_SPEECH_USAGE)){
+ // just leave log and return
+ MD_TRC_SPC_APP_DATA_SEND_FAIL(SPC_APP_SPEECH_USAGE, SPC_APP_SPEECH_USAGE, 1);
+ return;
+ }
+
+ // if codec&rate did not change, just return
+ if(codec== gSpc_codec_info.curSpeechMode) {
+ return;
+ }
+
+ // prepare codec sending
+ memset(&(gSpc_codec_info.info), 0, sizeof(SPC_CODEC_INFO_STRUCT));
+
+ if(0 == codec) { // FR,
+
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=FR;sr=8k;");
+
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=N;");
+ } else if (1 == codec) {
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=HR;sr=8k;");
+
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=N;");
+ } else if (2 == codec) {
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=EFR;sr=8k;");
+
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=N;");
+ } else if ((codec >= 0x20 && codec<=0x28) ||(codec >= 0xD0 && codec <= 0xDF)) { // AWB, EVS-AWB
+ uint8 bitRate = (codec&0xF);
+ if(codec >= 0x20 && codec<=0x28) { // AWB
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=AWB;sr=16k;");
+ } else { //EVS-AWB
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=EVSAWB;sr=16k;");
+ }
+
+ // bit rate
+ if ( 0x0 == bitRate) { // 6.60
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=6.60;");
+ } else if ( 0x1 == bitRate) { // 8.85
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=8.85;");
+ } else if ( 0x2 == bitRate) { // 12.65
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=12.65;");
+ } else if ( 0x3 == bitRate) { // 14.25
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=14.25;");
+ } else if ( 0x4 == bitRate) { // 15.85
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=15.85;");
+ } else if ( 0x5 == bitRate) { // 18.25
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=18.25;");
+ } else if ( 0x6 == bitRate) { // 19.85
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=19.85;");
+ } else if ( 0x7 == bitRate) { // 23.05
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=23.05;");
+ } else if ( 0x8 == bitRate) { // 23.85
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=23.85;");
+ } else { // unkonw codec
+ MD_TRC_SPC_CODEC_NOTIFY_UNKNOW(codec, 0xffff, 1);
+ }
+
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=Y;");
+ } else if(codec >=3 && codec <= 0xA) { // from 3~0x1f, AMR
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=AMR;sr=8k;");
+
+ // bit rate
+ if (3 == codec) { // 12.2k
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=12.20;");
+ } else if (4 == codec) { // 10.2K
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=10.20;");
+ } else if (5 == codec) { // 7.95K
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=7.95;");
+ } else if (6 == codec) { // 7.4K
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=7.40;");
+ } else if (7 == codec) { // 6.7K
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=6.70;");
+ } else if (8 == codec) { // 5.9K
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=5.90;");
+ } else if (9 == codec) { // 5.15K
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=5.15;");
+ } else if (0xA == codec) { // 4.75K
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=4.75;");
+ } else { // unkonw codec
+ MD_TRC_SPC_CODEC_NOTIFY_UNKNOW(codec, 0xffff, 2);
+ }
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=N;");
+ }else if(codec >= 0x80 && codec <= 0xBF) { // EVS
+ uint8 bitRate = (codec&0xF);
+
+ if ( codec < 0x90 ) {
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=EVS;sr=8k;");
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=N;");
+ } else if ( codec < 0xA0 ) {
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=EVS;sr=16k;");
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=Y;");
+ } else if ( codec < 0xB0 ) {
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=EVS;sr=32k;");
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=Y;");
+ } else {
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=EVS;sr=48k;");
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=Y;");
+ }
+
+ // bit rate
+ if ( 0x0 == bitRate) { // 2.80
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=2.80;");
+ } else if ( 0x1 == bitRate) { // 7.20
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=7.20;");
+ } else if ( 0x2 == bitRate) { // 8.00
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=8.00;");
+ } else if ( 0x3 == bitRate) { // 9.60
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=9.60");
+ } else if ( 0x4 == bitRate) { // 13.20
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=13.20;");
+ } else if ( 0x5 == bitRate) { // 16.40
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=16.40;");
+ } else if ( 0x6 == bitRate) { // 24.40
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=24.40;");
+ } else if ( 0x7 == bitRate) { // 32.00
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=32.00;");
+ } else if ( 0x8 == bitRate) { // 48.00
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=48.00;");
+ } else if ( 0x9 == bitRate) { // 64.00
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=64.00;");
+ } else if ( 0xA == bitRate) { // 96.00
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=96.00;");
+ } else if ( 0xB == bitRate) { // 128.00
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "br=128.00;");
+ } else { // unkonw codec
+ MD_TRC_SPC_CODEC_NOTIFY_UNKNOW(codec, 0xffff, 3);
+ }
+
+ } else if ( 0x60 == codec ) { // g711
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=G711;sr=8k;");
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=N;");
+ } else if ( 0x61 == codec ) { // 722
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=G722;sr=16k;");
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=Y;");
+ } else if ( 0x62 == codec ) { // g732.1
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=G723_1;sr=8k;");
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=N;");
+ } else if ( 0x63 == codec ) { // g726
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=G726;sr=8k;");
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=N;");
+ } else if ( 0x64 == codec ) { // g729,
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=G729;sr=8k;");
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=N;");
+ } else if (codec >= 0x30 && codec <= 0x35) {
+
+ if( 0x30 == codec ) { // SAL_C2K_COD_QCELP8K
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=S01;");
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=N;");
+ } else if ( 0x31 == codec ) { // SAL_C2K_COD_QCELP13K
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=S017;");
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=N;");
+ } else if ( 0x32 == codec ) { // SAL_C2K_COD_EVRCA
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=S03;");
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=N;");
+ } else if ( 0x33 == codec ) { // SAL_C2K_COD_EVRCB
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=S068;");
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=N;");
+ } else if ( 0x34 == codec ) { // SAL_C2K_COD_EVRCNW_NB
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=S073;");
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=N;");
+ } else if ( 0x35 == codec ) { // SAL_C2K_COD_EVRCNW_WB
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "codec=S073;");
+ SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecOp, "OM=Y;");
+ }
+
+ gSpc_codec_info.curRateInSoCodec = 0xffff; // reset only when SO codec change.
+
+ }
+ else {
+ MD_TRC_SPC_CODEC_NOTIFY_UNKNOW(codec, 0xffff, 4);
+ }
+
+ // send to AP
+ spc_sendCodecInfoNotify();
+
+ // update codec
+ gSpc_codec_info.curSpeechMode = codec;
+
+}
+
+void spc_codecInfoNotify_soRateUpdate(uint16 newRate)
+{
+ if (gSpc_codec_info.curSpeechMode >= 0x30 && gSpc_codec_info.curSpeechMode <= 0x35) {
+
+ // if codec&rate did not change, just return
+ if(newRate == gSpc_codec_info.curRateInSoCodec) {
+ return;
+ }
+
+ switch(newRate){
+ case 0: SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "rr=0;"); break;
+ case 1: SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "rr=1;"); break;
+ case 2: SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "rr=2;"); break;
+ case 3: SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "rr=3;"); break;
+ case 4: SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "rr=4;"); break;
+ case 5: SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "rr=5;"); break;
+ case 6: SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "rr=6;"); break;
+ case 7: SPC_CODEC_INFO_STRCAT(gSpc_codec_info.info.codecInfo, "rr=7;"); break;
+ default: break;
+ }
+
+ gSpc_codec_info.curRateInSoCodec = newRate;
+
+ // send to AP
+ spc_sendCodecInfoNotify();
+ } else {
+ MD_TRC_SPC_CODEC_NOTIFY_UNKNOW(gSpc_codec_info.curSpeechMode, newRate, 5);
+ }
+}
+
+
+// ----------------------------------------------------------------------------
+// Phone Call Related
+// ----------------------------------------------------------------------------
+typedef enum {
+ SPH_ON_APPLICATION_NORMAL = 0,
+ SPH_ON_APPLICATION_VT_CALL,
+ SPH_ON_APPLICATION_LOOPBACK,
+ SPH_ON_APPLICATION_ROUTER,
+ SPH_ON_APPLICATION_DACA,
+ SPH_ON_APPLICATION_HOLD_CALL,
+ SPH_ON_APPLICATION_ENCRYPTION,
+}spc_sph_on_application_t;
+
+typedef enum {
+ SPH_ON_BTINFO_BT_OFF,
+ SPH_ON_BTINFO_BT_PCM, /* via Modem PCM hardware */
+ SPH_ON_BTINFO_BT_CVSD_MSBC, /* via software BT codec */
+ SPH_ON_BTINFO_BT_CVSD,
+ SPH_ON_BTINFO_BT_MSBC
+}spc_sph_on_bt_info_t;
+
+typedef enum {
+ SPH_ON_SAMPLE_RATE_08K = 0,
+ SPH_ON_SAMPLE_RATE_16K,
+ SPH_ON_SAMPLE_RATE_32K,
+ SPH_ON_SAMPLE_RATE_48K,
+ SPH_ON_SAMPLE_RATE_MAX
+}spc_sph_on_sample_rate_t;
+
+typedef enum {
+ SPH_ON_PARAM_VIA_PAYLOAD = 0, /* speech param is written in payload */
+ SPH_ON_PARAM_VIA_SHM /* speech param is written in share memory */
+}spc_sph_on_param_path_t;
+
+typedef enum {
+ SPH_ON_EXT_DEV_INFO_DEFULAT = 0,
+ SPH_ON_EXT_DEV_INFO_VIBRATION_RECEIVER, // vibration receiver (3-in-1)
+ SPH_ON_EXT_DEV_INFO_VIBRATION_SPEAKER, // speaker (2-in-1 or 3-in-1)
+ SPH_ON_EXT_DEV_INFO_SMARTPA_SPEAKER, // speaker with smart-PA which need echo reference path
+ SPH_ON_EXT_DEV_INFO_SMARTPA_VIBRATION_SPEAKER, // vibration speaker with smart-PA which need echo reference path
+ SPH_ON_EXT_DEV_INFO_USB_AUDIO, // usb audio device, which needs echo reference path
+ SPH_ON_EXT_DEV_INFO_EARPHONE, // earphone audio device
+}spc_sph_on_ext_dev_info_t;
+
+typedef enum {
+ SPH_ON_LOOPBACK_INFO_FLAG_DISABLE_BT_CODEC = (1<<0), // 1'b == BT Loopback with BT codec / 0'b == BT Loopback without BT Codec, only support when SPH_ON_BTINFO_BT_CVSD_MSBC
+ SPH_ON_LOOPBACK_INFO_FLAG_DELAY_SETTING = (1<<1), // delay setting for normal loopback, i.e. speech mode is not BT cases. 0==Use modem default delay value/ 1== use AP gives delay value in loopback_delay
+}spc_sph_on_loopback_info_flag;
+
+typedef struct {
+ kal_uint8 loopback_flag;
+ kal_uint8 loopback_delay; /* spc_sph_on_loopback_info_flag */
+}spc_sph_on_loopback_info_t;
+
+typedef enum {
+ SPH_ON_MUTE_BIT_UL = (1<<0),
+ SPH_ON_MUTE_BIT_DL = (1<<1),
+ SPH_ON_MUTE_BIT_UL_ENH_RESULT = (1<<2),
+ SPH_ON_MUTE_BIT_UL_SOURCE = (1<<3),
+ SPH_ON_MUTE_BIT_DL_CODEC = (1<<4),
+ SPH_ON_MUTE_BIT_DL_PRE_PCM_MIXER = (1<<5),
+}spc_sph_on_mute_bit;
+
+typedef struct {
+ kal_uint8 application; /* spc_sph_on_application_t */
+ kal_uint8 bt_info; /* spc_sph_on_bt_info_t */
+ kal_uint8 sample_rate_enum; /* spc_sph_on_sample_rate_t */
+ kal_uint8 opendsp_flag; /* 0: internal SPE, 1: OpenDSP */
+
+ kal_uint8 param_path; /* spc_sph_on_param_path_t */
+ kal_uint8 param_shm_valid; /* SPH_ON_PARAM_VIA_SHM only. 0: invalid, 1: valid */
+ kal_uint16 param_size; /* Max 65535 bytes */
+
+ kal_uint16 param_idx;
+ kal_uint16 ext_dev_info; /* spc_sph_on_ext_dev_info_t */
+
+ kal_uint8 loopback_flag;
+ kal_uint8 loopback_delay; /* spc_sph_on_loopback_info_flag */
+ kal_uint16 echo_ref_delay_ms; /* echo reference data delay, unit is ms */
+
+ kal_uint8 mic_delay_ms; /* UL0 data delay, unit is ms */
+ kal_uint8 mute_mask; /* bit-wise define in spc_sph_on_mute_bit. 0: unmute, 1: mute */
+ kal_uint16 enh_crtl_support;
+
+#if defined(_SPE_ENH_MD_PARSE_)
+ kal_uint8 reserve_at_32byte[12];
+ kal_uint8 reserve_at_48byte[16];
+ kal_uint8 reserve_at_64byte[16];
+#else
+
+ kal_uint32 param_usip_len; // 95MD support EMI par.
+
+ kal_uint32 param_usip_index; // 95MD support EMI par.
+ kal_uint16 common_param[12]; /* param for driver/scheduler */
+ kal_uint16 debug_info[16]; /* param for driver/scheduler */
+
+ kal_uint8 smartPA_config;
+
+#if defined(MT6890)
+ kal_uint8 dtmf_rm_support; /* 0: Disable DTMF removal, 1: Enable DTMF removal */
+ kal_uint8 reserve_at_128byte[42];
+#else
+ kal_uint8 reserve_at_128byte[43];
+#endif
+
+
+#endif
+
+
+
+} spc_sph_on_info_t; /* 64 bytes */
+
+static spc_sph_on_info_t gSpc_sphOnInfo;
+
+#define SPC_CUST_ENH 0
+#if SPC_CUST_ENH
+#define PROCESS_BLK_SIZE 320
+static uint16 gSpc_DV_PCM_UL1_BUF[PROCESS_BLK_SIZE];
+static uint16 gSpc_DV_PCM_UL2_BUF[PROCESS_BLK_SIZE];
+static uint16 gSpc_DV_PCM_IN_BUF[PROCESS_BLK_SIZE];
+static uint16 gSpc_DV_PCM_DL_BUF[PROCESS_BLK_SIZE];
+static uint16 gSpc_DV_PCM_OUT_BUF[PROCESS_BLK_SIZE];
+static uint16 DV_dl_audioid;
+static uint16 DV_ul_audioid;
+
+void DV_init(void)
+{
+ // Do DV initialize
+ return;
+}
+
+void DV_Release(void)
+{
+ // Do DV destroy
+}
+
+void DV_UL_process()
+{
+ // do speech enahncment for uplink
+ // gSpc_DV_PCM_IN_BUF = ulProcess(gSpc_DV_PCM_UL1_BUF, gSpc_DV_PCM_UL2_BUF);
+}
+
+void DV_DL_process()
+{
+ // do speech enahncment for downlink
+ // gSpc_DV_PCM_OUT_BUF = dlProcess(gSpc_DV_PCM_DL_BUF);
+ memcpy(gSpc_DV_PCM_OUT_BUF, gSpc_DV_PCM_DL_BUF, 640);
+
+ spc_customDump(320, gSpc_DV_PCM_OUT_BUF);
+}
+
+void DV_PCM4WAY_DL_HisrHdl()
+{
+
+ PCM4WAY_GetFromSD(gSpc_DV_PCM_DL_BUF);
+
+ PCM4WAY_PutToSpk(gSpc_DV_PCM_OUT_BUF);
+
+ L1Audio_SetEvent(DV_dl_audioid, NULL);
+
+}
+
+void DV_PCM4WAY_UL_HisrHdl()
+{
+
+
+ PcmEx_GetFromMic1(gSpc_DV_PCM_UL1_BUF);
+ PcmEx_GetFromMic2(gSpc_DV_PCM_UL2_BUF);
+
+
+
+ PCM4WAY_PutToSE(gSpc_DV_PCM_IN_BUF);
+
+ L1Audio_SetEvent(DV_ul_audioid, NULL);
+}
+#endif // SPC_CUST_ENH
+
+void Spc_SpeechOn( kal_uint8 RAT_Mode )
+{
+
+ if(false == spc_mainAppOnCheck(SPC_APP_SPEECH_USAGE))
+ return;
+
+ ASSERT(RAT_Mode <= RAT_3G324M_MODE);
+
+
+#if defined(_SPE_ENH_MD_PARSE_)
+ // checking speech useage parameter. if Not, use the default value.
+ spc_EmInit(!IS_SPC_EM_INIT(SPC_EM_INIT_COMMON),!IS_SPC_EM_INIT(SPC_EM_INIT_NB),
+ !IS_SPC_EM_INIT(SPC_EM_INIT_WB),!IS_SPC_EM_INIT(SPC_EM_INIT_SWB),
+ !IS_SPC_EM_INIT(SPC_EM_INIT_DMNR),
+ !IS_SPC_EM_INIT(SPC_EM_INIT_LSPK_DMNR),
+ !IS_SPC_EM_INIT(SPC_EM_INIT_IIR));
+#endif
+
+ // rate setting
+#if defined(__UMTS_RAT__)
+ if( RAT_Mode != RAT_3G324M_MODE )
+ RAT_Mode = RAT_3G_MODE; // Force initial 3G
+#else
+ RAT_Mode = RAT_2G_MODE;
+#endif
+
+ MD_TRC_SPC_SPEECH_ON(RAT_Mode);
+
+
+ // reset codec before speechOn.
+ spc_codecInfoInit();
+ gSpc_networkStatus = 0xFF;
+
+ L1SP_Speech_On( RAT_Mode );
+
+ SET_SPC_APP_USAGE(SPC_APP_SPEECH_USAGE);
+
+
+#if SPC_CUST_ENH
+ DV_init();
+ Del_PcmEx_Start(DV_PCM4WAY_DL_HisrHdl, NULL, //DV_PCM4WAY_UL_HisrHdl,
+ NULL, //USE_D2M_PATH + USE_M2D_PATH,
+ NULL, //USE_D2M_PATH + USE_M2D_PATH,
+ NULL, //USE_D2M_PATH + USE_M2D_PATH,
+ NULL, //USE_D2M_PATH + USE_M2D_PATH,
+ USE_D2M_PATH + USE_M2D_PATH + DATA_SELECT_AFTER_ENH);
+#endif
+}
+
+kal_uint16 Spc_SpeechOn_withData(kal_uint16 offset, kal_uint16 length, const SPC_MSG_FROM_T comeFrom)
+{
+ spcBufInfo header;
+ spc_sph_on_info_t info;
+ kal_uint16 totalProcLen = 0;
+ kal_bool check;
+
+#if defined(_SPE_ENH_DSP_PARSE_)
+ kal_uint32 EMI_Offset;
+ //unsigned short Common_Para[NUM_COMMON_PARAS];
+ //unsigned short Dbg_Para[16];
+#endif
+
+ memset(&info, 0, sizeof(spc_sph_on_info_t));
+ if(length == (sizeof(spcBufInfo) + sizeof(spc_sph_on_info_t))) {
+ SpcIO_GetDataFromAp_inOneTime(offset, length, sizeof(spcBufInfo), &header, &info, comeFrom);
+ } else if ((length < (sizeof(spcBufInfo) + sizeof(spc_sph_on_info_t))) && (length > sizeof(spcBufInfo))) {
+ SpcIO_GetDataFromAp_inOneTime(offset, length, sizeof(spcBufInfo), &header, &info, comeFrom);
+ MD_TRC_SPC_SPH_ON_MISMATCH_PAYLOAD_SIZE(length, sizeof(spcBufInfo), sizeof(spc_sph_on_info_t));
+ } else if (length > (sizeof(spcBufInfo) + sizeof(spc_sph_on_info_t))) {
+ SpcIO_GetDataFromAp_inOneTime(offset, (sizeof(spcBufInfo) + sizeof(spc_sph_on_info_t)), sizeof(spcBufInfo), &header, &info, comeFrom);
+ MD_TRC_SPC_SPH_ON_MISMATCH_PAYLOAD_SIZE(length, sizeof(spcBufInfo), sizeof(spc_sph_on_info_t));
+ }else {
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_MERGE_SPH_USAGE, SPC_APP_MERGE_SPH_USAGE, 2);
+ return totalProcLen;
+ }
+
+ check = (header.syncWord == 0xA2A2);
+ MODEM_WARNING_MESSAGE(check, "Spc_SpeechOn_withData: unknow syncWord");
+ if(!check)
+ goto leaveSphOn;
+ check = (header.type == AUD_CCCI_STRMBUF_TYPE_SPH_INFO);
+ MODEM_WARNING_MESSAGE(check, "Spc_SpeechOn_withData: unknow type");
+ if(!check)
+ goto leaveSphOn;
+ check = (header.length == (length - sizeof(spcBufInfo)));
+ MODEM_WARNING_MESSAGE(check, "Spc_SpeechOn_withData: unknow length");
+ if(!check)
+ goto leaveSphOn;
+
+ MD_TRC_SPC_SPEECH_ON_PAYLOAD(
+ info.application, info.bt_info, info.sample_rate_enum, info.opendsp_flag,
+ info.param_path, info.param_shm_valid, info.param_size, info.param_idx, info.ext_dev_info,
+ info.mute_mask);
+
+ if(false == spc_mainAppOnCheck(SPC_APP_MERGE_SPH_USAGE)) {
+ return info.param_size;
+ }
+
+ if(IS_SPC_APP_USED(SPC_APP_MERGE_SPH_USAGE)) {
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_MERGE_SPH_USAGE, SPC_APP_MERGE_SPH_USAGE, 1);
+ return info.param_size;
+ }
+
+ memcpy(&gSpc_sphOnInfo, &info, sizeof(spc_sph_on_info_t));
+
+ // set device
+ SP_SetDevicePath(info.bt_info, info.sample_rate_enum);
+ SP_SetExtraDevInfo(info.bt_info, info.ext_dev_info, info.smartPA_config, info.echo_ref_delay_ms, info.mic_delay_ms);
+ // Set Enh
+ L1SP_EnhancementCtrlSupport(info.enh_crtl_support);
+
+#if defined(MT6890)
+ MD_TRC_SPC_SPEECH_ON_DTMF_SUPPORT(info.dtmf_rm_support);
+ if (info.dtmf_rm_support == 0) {
+ SAL_DTMF_Removal_Ctrl(SAL_DTMF_REMOVAL_UL_PRE_EN, false);
+ } else {
+ SAL_DTMF_Removal_Ctrl(SAL_DTMF_REMOVAL_UL_PRE_EN, true);
+ }
+#endif
+
+#if defined(_SPE_ENH_MD_PARSE_)
+ if(SPH_ON_PARAM_VIA_SHM == info.param_path) {
+ if(1 == info.param_shm_valid) {
+ kal_uint16 procLen = 0;
+ kal_uint16 curOffset = info.param_idx;
+
+ while (totalProcLen < info.param_size ) {
+ kal_uint16 newOffset;
+ spc_dynamicParameterParser_dispatcher(curOffset, info.param_size-totalProcLen,
+ SPC_MSG_FROM_CCCI_STREAM_AND_SHM, &procLen, &newOffset);
+
+ totalProcLen += procLen;
+ curOffset = newOffset;
+ }
+ }
+ } else {
+ // Via stream. Not implement yet
+ kal_prompt_trace(MOD_L1SP, "SphO. param data from payload!!");
+ }
+
+#else // for _SPE_ENH_DSP_PARSE_
+
+ // mute position apply
+ spc_gain_UlMuteSet((info.mute_mask&SPH_ON_MUTE_BIT_UL)!=0, KAL_TRUE);
+ spc_gain_DlMuteSet((info.mute_mask&SPH_ON_MUTE_BIT_DL)!=0, KAL_TRUE);
+ // spc_gain_UlEnhResultMuteSet((info.mute_mask&SPH_ON_MUTE_BIT_UL_ENH_RESULT)!=0, KAL_TRUE);
+ spc_gain_UlSourceMuteSet((info.mute_mask&SPH_ON_MUTE_BIT_UL_SOURCE)!=0, KAL_TRUE);
+ spc_gain_DlMuteCodecSet((info.mute_mask&SPH_ON_MUTE_BIT_DL_CODEC)!=0, KAL_TRUE);
+ spc_gain_DlMuteSet_PrePcmMixer((info.mute_mask&SPH_ON_MUTE_BIT_DL_PRE_PCM_MIXER)!=0,KAL_TRUE);
+
+ MD_TRC_SPC_SPE_CHECK_EMI_COMMON_PAR(info.common_param[0], info.common_param[1], info.common_param[2], info.common_param[3], info.common_param[4], info.common_param[5], info.common_param[6], info.common_param[7], info.common_param[8], info.common_param[9], info.common_param[10], info.common_param[11]);
+ MD_TRC_SPC_SPE_CHECK_EMI_DBG_PAR(info.debug_info[0], info.debug_info[1], info.debug_info[2], info.debug_info[3], info.debug_info[4], info.debug_info[5], info.debug_info[6], info.debug_info[7], info.debug_info[8], info.debug_info[9], info.debug_info[10], info.debug_info[11]);
+ L1SP_LoadCommonSpeechPara((uint16 *) info.common_param);
+ L1Audio_SetDebugInfo((uint16 *) info.debug_info);
+ VMREC_ConfigEpl();
+ spc_dev_LoopbackPoint_DVT(info.debug_info[15]);
+
+
+ MD_TRC_SPC_SPE_CHECK_EMI_SPEECH_INFO(0,info.param_usip_index,info.param_usip_len,info.param_shm_valid, info.param_path);
+ EMI_Offset=0;
+ if(info.param_path == 2 && info.param_shm_valid ==1 )
+ {
+ EMI_Offset =( info.param_usip_index + EMI_SPE_PAR_OFFSET)/2 ;
+ //memcpy(Common_Para, (((unsigned short *)(SP_GetSphParamBufAddr())) +EMI_Offset+EMI_NEED_3K_0+ EMI_MD_COMMON_PAR_OFFSET), sizeof(unsigned short) * NUM_COMMON_PARAS);
+ //memcpy(Dbg_Para, (((unsigned short *)(SP_GetSphParamBufAddr())) + EMI_Offset +EMI_NEED_3K_0+EMI_MD_DBG_PAR_OFFSET), sizeof(unsigned short) * 16);
+ //kal_trace( TRACE_FUNC,SPC_SPE_CHECK_EMI_COMMON_PAR,Common_Para[0],Common_Para[1],Common_Para[2],Common_Para[3],Common_Para[4],Common_Para[5],Common_Para[6],Common_Para[7],Common_Para[8],Common_Para[9],Common_Para[10],Common_Para[11]);
+ //kal_trace( TRACE_FUNC,SPC_SPE_CHECK_EMI_DBG_PAR,Dbg_Para[0],Dbg_Para[1],Dbg_Para[2],Dbg_Para[3],Dbg_Para[4],Dbg_Para[5],Dbg_Para[6],Dbg_Para[7],Dbg_Para[8],Dbg_Para[9],Dbg_Para[10],Dbg_Para[11]);
+ //L1SP_LoadCommonSpeechPara(Common_Para);
+ //L1Audio_SetDebugInfo((uint16 *)Dbg_Para);
+ l1sp_SetParEMIInfo(EMI_Offset,info.param_usip_len);
+ SetSpeechEnhancement(true);
+
+ }else if (info.param_path == 2 && info.param_shm_valid ==2 ) //use previous par.
+ {
+ SetSpeechEnhancement(true);
+ }
+ else
+ {
+ // need use MD default par
+ l1sp_SetParEMIInfo(EMI_MD_DEFAULT_OFFSET,EMI_MD_DEFAULT_LEN);
+ // L1SP_LoadCommonSpeechPara((uint16 *)Speech_Common_Para);
+ // L1Audio_SetDebugInfo((uint16 *)Debug_Info_Para);
+ SetSpeechEnhancement(true);
+ }
+#endif
+
+ L1SP_SetOpenDSPFlag(info.opendsp_flag);
+ if(SPH_ON_APPLICATION_NORMAL == info.application) {
+ Spc_SpeechOn(RAT_3G_MODE);
+ } else if (SPH_ON_APPLICATION_VT_CALL == info.application) {
+ // phase out from ap side
+ Spc_SpeechOn(RAT_3G324M_MODE);
+ } else if (SPH_ON_APPLICATION_LOOPBACK == info.application) {
+ Spc_AcousticLoopback(true, info.loopback_flag, info.loopback_delay);
+ } else if (SPH_ON_APPLICATION_ROUTER == info.application) {
+ Spc_SpeechRouterOn(true);
+ } else if (SPH_ON_APPLICATION_DACA == info.application) {
+ Spc_SpeechOnForDaca(0, true);
+ } else if (SPH_ON_APPLICATION_HOLD_CALL == info.application) {
+ spc_SpeechOnForCallHold(true);
+ }
+
+ SET_SPC_APP_USAGE(SPC_APP_MERGE_SPH_USAGE);
+
+leaveSphOn:
+ return totalProcLen;
+}
+
+
+void Spc_SpeechOff( void )
+{
+ kal_bool isAppOn=false;
+
+ MD_TRC_SPC_SPEECH_OFF();
+
+ // check app status
+ isAppOn = spc_endApp();
+ MODEM_WARNING_MESSAGE((false==isAppOn), "Spc_SpeechOff: with app=%x", gSpc.spcAppUsage);
+ // ASSERT(0==IS_SPC_APP_USED(SPC_APP_RECORD_USAGE)); removed from 93md
+ // ASSERT(0==IS_SPC_APP_USED(SPC_APP_PCM_REC_USAGE)); removed from 93md
+
+ if(!IS_SPC_APP_USED(SPC_APP_SPEECH_USAGE)){
+ // just leave log and return
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_SPEECH_USAGE, SPC_APP_SPEECH_USAGE, 0);
+ return;
+ }
+
+#if SPC_CUST_ENH
+ PcmEx_Stop();
+ DV_Release();
+#endif
+
+
+ // close speech
+ L1SP_Speech_Off();
+ CLR_SPC_APP_USAGE(SPC_APP_SPEECH_USAGE);
+
+}
+
+void Spc_SpeechOff_Merge( void)
+{
+ if(IS_SPC_APP_USED(SPC_APP_MERGE_SPH_USAGE)) {
+ if(SPH_ON_APPLICATION_NORMAL == gSpc_sphOnInfo.application) {
+ Spc_SpeechOff();
+ } else if (SPH_ON_APPLICATION_VT_CALL == gSpc_sphOnInfo.application) {
+ Spc_SpeechOff();
+ } else if (SPH_ON_APPLICATION_LOOPBACK == gSpc_sphOnInfo.application) {
+ Spc_AcousticLoopback(false,0,0);
+ } else if (SPH_ON_APPLICATION_ROUTER == gSpc_sphOnInfo.application) {
+ Spc_SpeechRouterOn(false);
+ } else if (SPH_ON_APPLICATION_DACA == gSpc_sphOnInfo.application) {
+ Spc_SpeechOnForDaca(0, false);
+ } else if (SPH_ON_APPLICATION_HOLD_CALL == gSpc_sphOnInfo.application) {
+ spc_SpeechOnForCallHold(false);
+ }
+
+ CLR_SPC_APP_USAGE(SPC_APP_MERGE_SPH_USAGE);
+ } else {
+ Spc_SpeechOff();
+ }
+
+}
+
+// MSG_A2M_SPH_DEV_CHANGE
+kal_uint16 Spc_SpeechDeviceChange(kal_uint16 offset, kal_uint16 length, const SPC_MSG_FROM_T comeFrom)
+{
+ spcBufInfo header;
+ spc_sph_on_info_t info;
+ kal_uint16 totalProcLen = 0;
+ kal_bool check;
+
+#if defined(_SPE_ENH_DSP_PARSE_)//for 95,97
+ kal_uint32 EMI_Offset;
+ //unsigned short Common_Para[NUM_COMMON_PARAS];
+ //unsigned short Dbg_Para[16];
+#endif
+ memset(&info, 0, sizeof(spc_sph_on_info_t));
+ if(length == (sizeof(spcBufInfo) + sizeof(spc_sph_on_info_t))) {
+ SpcIO_GetDataFromAp_inOneTime(offset, length, sizeof(spcBufInfo), &header, &info, comeFrom);
+ } else if ((length < (sizeof(spcBufInfo) + sizeof(spc_sph_on_info_t))) && (length > sizeof(spcBufInfo))) {
+ SpcIO_GetDataFromAp_inOneTime(offset, length, sizeof(spcBufInfo), &header, &info, comeFrom);
+ MD_TRC_SPC_SPH_ON_MISMATCH_PAYLOAD_SIZE(length, sizeof(spcBufInfo), sizeof(spc_sph_on_info_t));
+ } else if (length > (sizeof(spcBufInfo) + sizeof(spc_sph_on_info_t))) {
+ SpcIO_GetDataFromAp_inOneTime(offset, (sizeof(spcBufInfo) + sizeof(spc_sph_on_info_t)), sizeof(spcBufInfo), &header, &info, comeFrom);
+ MD_TRC_SPC_SPH_ON_MISMATCH_PAYLOAD_SIZE(length, sizeof(spcBufInfo), sizeof(spc_sph_on_info_t));
+ }else {
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_MERGE_SPH_USAGE, SPC_APP_MERGE_SPH_USAGE, 3);
+ goto leaveDevChange;
+ }
+
+ check = (header.syncWord == 0xA2A2);
+ MODEM_WARNING_MESSAGE(check, "Spc_SpeechDeviceChange: unknow syncWord");
+ if(!check)
+ goto leaveDevChange;
+ check = (header.type == AUD_CCCI_STRMBUF_TYPE_SPH_INFO);
+ MODEM_WARNING_MESSAGE(check, "Spc_SpeechDeviceChange: unknow type");
+ if(!check)
+ goto leaveDevChange;
+ check = (header.length == (length - sizeof(spcBufInfo)));
+ MODEM_WARNING_MESSAGE(check, "Spc_SpeechDeviceChange: unknow length");
+ if(!check)
+ goto leaveDevChange;
+
+ MD_TRC_SPC_SPEECH_ON_PAYLOAD(
+ info.application, info.bt_info, info.sample_rate_enum, info.opendsp_flag,
+ info.param_path, info.param_shm_valid, info.param_size, info.param_idx, info.ext_dev_info,
+ info.mute_mask);
+
+ // set device
+ SP_SetDevicePath(info.bt_info, info.sample_rate_enum);
+ SP_SetExtraDevInfo(info.bt_info, info.ext_dev_info, info.smartPA_config, info.echo_ref_delay_ms, info.mic_delay_ms);
+ gSpc_sphOnInfo.sample_rate_enum = info.sample_rate_enum;
+ gSpc_sphOnInfo.bt_info = info.bt_info;
+ gSpc_sphOnInfo.ext_dev_info = info.ext_dev_info;
+ gSpc_sphOnInfo.echo_ref_delay_ms = info.echo_ref_delay_ms;
+ gSpc_sphOnInfo.mic_delay_ms = info.mic_delay_ms;
+
+
+
+
+#if defined(_SPE_ENH_MD_PARSE_)
+ // apply the parameter
+ if(SPH_ON_PARAM_VIA_SHM == info.param_path) {
+ if(1 == info.param_shm_valid) {
+ kal_uint16 procLen = 0;
+ kal_uint16 curOffset = info.param_idx;
+
+ while (totalProcLen < info.param_size ) {
+ kal_uint16 newOffset;
+ spc_dynamicParameterParser_dispatcher(curOffset, info.param_size-totalProcLen,
+ SPC_MSG_FROM_CCCI_STREAM_AND_SHM, &procLen, &newOffset);
+
+ totalProcLen += procLen;
+ curOffset = newOffset;
+ }
+ }
+ } else {
+ // Via stream. Not implement yet
+ kal_prompt_trace(MOD_L1SP, "DEV change. param data from payload!!");
+ }
+
+#else
+ MD_TRC_SPC_SPE_CHECK_EMI_COMMON_PAR(info.common_param[0], info.common_param[1], info.common_param[2], info.common_param[3], info.common_param[4], info.common_param[5], info.common_param[6], info.common_param[7], info.common_param[8], info.common_param[9], info.common_param[10], info.common_param[11]);
+ MD_TRC_SPC_SPE_CHECK_EMI_DBG_PAR(info.debug_info[0], info.debug_info[1], info.debug_info[2], info.debug_info[3], info.debug_info[4], info.debug_info[5], info.debug_info[6], info.debug_info[7], info.debug_info[8], info.debug_info[9], info.debug_info[10], info.debug_info[11]);
+ L1SP_LoadCommonSpeechPara((uint16 *) info.common_param);
+ L1Audio_SetDebugInfo((uint16 *) info.debug_info);
+ VMREC_ConfigEpl();
+ spc_dev_LoopbackPoint_DVT(info.debug_info[15]);
+
+ MD_TRC_SPC_SPE_CHECK_EMI_SPEECH_INFO(1,info.param_usip_index,info.param_usip_len,info.param_shm_valid, info.param_path);
+ EMI_Offset=0;
+ if(info.param_path == 2 && info.param_shm_valid ==1 )
+ {
+ EMI_Offset =( info.param_usip_index + EMI_SPE_PAR_OFFSET)/2 ;
+ //memcpy(Common_Para, (((unsigned short *)(SP_GetSphParamBufAddr())) +EMI_Offset+EMI_NEED_3K_0+ EMI_MD_COMMON_PAR_OFFSET), sizeof(unsigned short) * NUM_COMMON_PARAS);
+ //memcpy(Dbg_Para, (((unsigned short *)(SP_GetSphParamBufAddr())) + EMI_Offset +EMI_NEED_3K_0+EMI_MD_DBG_PAR_OFFSET), sizeof(unsigned short) * 16);
+ //kal_trace( TRACE_FUNC,SPC_SPE_CHECK_EMI_COMMON_PAR,Common_Para[0],Common_Para[1],Common_Para[2],Common_Para[3],Common_Para[4],Common_Para[5],Common_Para[6],Common_Para[7],Common_Para[8],Common_Para[9],Common_Para[10],Common_Para[11]);
+ //kal_trace( TRACE_FUNC,SPC_SPE_CHECK_EMI_DBG_PAR,Dbg_Para[0],Dbg_Para[1],Dbg_Para[2],Dbg_Para[3],Dbg_Para[4],Dbg_Para[5],Dbg_Para[6],Dbg_Para[7],Dbg_Para[8],Dbg_Para[9],Dbg_Para[10],Dbg_Para[11]);
+ //L1SP_LoadCommonSpeechPara((uint16 *)Common_Para);
+ //L1Audio_SetDebugInfo((uint16 *)Dbg_Para);
+ l1sp_SetParEMIInfo(EMI_Offset,info.param_usip_len);
+ SetSpeechEnhancement(true);
+
+ }else if (info.param_path == 2 && info.param_shm_valid ==2 ) //use previous par.
+ {
+
+ SetSpeechEnhancement(true);
+ }
+ else
+ {
+ // need use MD default par
+ l1sp_SetParEMIInfo(EMI_MD_DEFAULT_OFFSET,EMI_MD_DEFAULT_LEN);
+ // L1SP_LoadCommonSpeechPara((uint16 *)Speech_Common_Para);
+ //L1Audio_SetDebugInfo((uint16 *)Debug_Info_Para);
+ SetSpeechEnhancement(true);
+ }
+
+#endif
+
+leaveDevChange:
+ return totalProcLen;
+}
+
+
+void spc_DebugPrint(void)
+{
+ uint16 *m_para;
+
+ m_para = Sp_GetCommonSpeechPara(); // size NUM_COMMON_PARAS
+ MD_TRC_L1SP_COMMON_PARAM_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11]);
+
+#if defined(_SPE_ENH_MD_PARSE_)
+ m_para = Sp_GetSpeechPara(); // size NUM_MODE_PARAS
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+
+ m_para = Sp_GetWbSpeechPara(); // size NUM_MODE_PARAS
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+#endif
+}
+
+
+/**
+ MED(AUDL) task
+ codec: em_speech_info_SpeechCodecType. in "em_public_struct.h"
+*/
+void spc_notify_network_status(uint32 codec)
+{
+ uint16 tmp;
+ uint8 band = 0; // default 8k
+ uint32 RAT = AM_GetNetworkRate();
+ uint8 Network = 0xF;
+
+ if( (0x61 == codec ) || ((codec >= 0x20) && (codec <= 0x28))
+ || ((codec >= 0x90) && (codec <= 0x9F))
+ || ((codec >= 0xD0) && (codec <= 0xDF)) ){ // 16k
+ band = 1;
+
+ } else if((codec >= 0xA0) && (codec <= 0xAF)) { // 32k
+ band = 2;
+ } else if((codec >= 0xB0) && (codec <= 0xBF)) { // 48k
+ band = 3;
+ }
+
+ if(RAT == RAT_4G_MODE)
+ {
+ Network = NETWORK_VOLTE;
+ }
+ else if(RAT == RAT_3G_MODE)
+ {
+ Network = NETWORK_WCDMA_FDD;
+#if defined( __UMTS_RAT__ )
+ switch(L1SP_GetSIMStatus()){
+ case SP_3G_SIM_FDD_ACTIVE:
+ Network = NETWORK_WCDMA_FDD;
+ break;
+ case SP_3G_SIM_TDD_ACTIVE:
+ Network = NETWORK_WCDMA_TDD;
+ break;
+ default:
+ Network = NETWORK_WCDMA_FDD;
+ break;
+ }
+#endif
+ }
+ else if(RAT == RAT_2G_MODE)
+ {
+ Network = NETWORK_GSM;
+ }
+ else if(RAT == RAT_C2K_MODE)
+ {
+ Network = NETWORK_C2K;
+ }
+
+ tmp = (kal_uint16)((band) << 4 | (Network & 0xF) | ( 0x1 << 15 ));
+ // tmp = (kal_uint16)( (band << 3) | (RAT & 0x7));
+
+ if(gSpc_networkStatus != tmp){
+ MD_TRC_SPC_NOTIFY_NETWORK_STATUS_INFO(tmp, band, RAT);
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_NETWORK_STATUS_NOTIFY, (kal_uint16)tmp, 0);
+ MD_TRC_SPC_NOTIFY_NETWORK_STATUS(gSpc_networkStatus, tmp);
+ gSpc_networkStatus = tmp;
+ }else{
+ MD_TRC_SPC_NOTIFY_NETWORK_STATUS_SKIP(tmp);
+ }
+
+ spc_codecInfoNotify(codec);
+}
+
+//AUDIO task
+#include "em_audio_public_struct.h"
+void spc_send_network_status_notify(em_speech_info_SpeechCodecType codec)
+{
+ SpcIO_MsgQueuePut(SPC_ID_NETWORK_STATUS_NOTIFY, codec, 0, SPC_MSG_FROM_AUDHISR);
+}
+
+void spc_ReceiveNwCodecInfoReadDone(void)
+{
+ l1sp_send_codec_status_notify(AM_GetSpeechMode());
+}
+/**
+ @isGen: true for trun on, false for turn off
+*/
+void spc_SpeechOnForCallHold(kal_bool isGen)
+{
+
+
+ if(isGen){ // turn on
+
+ if(false == spc_mainAppOnCheck(SPC_APP_HOLD_USAGE))
+ return;
+
+ // turn on speech and mute
+
+ L1SP_Speech_On(RAT_3G_MODE);
+ SP_MuteUlFromDiffPos(true, SP_MIC_MUTE_POS_FROM_SPC);
+
+ SET_SPC_APP_USAGE(SPC_APP_HOLD_USAGE);
+ } else { // turn off
+
+ if(!IS_SPC_APP_USED(SPC_APP_HOLD_USAGE)) { // sid generation not in use
+ // just leave the log and return
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_HOLD_USAGE, SPC_APP_HOLD_USAGE, 0);
+ return;
+ }
+
+ // turn off
+ SP_MuteUlFromDiffPos(false, SP_MIC_MUTE_POS_FROM_SPC);
+ L1SP_Speech_Off();
+ CLR_SPC_APP_USAGE(SPC_APP_HOLD_USAGE);
+ }
+
+}
+
+// ----------------------------------------------------------------------------
+// Loopback
+// ----------------------------------------------------------------------------
+#define ACLOOPBACK_USING_P2W 1
+
+#define ACLOOPBACK_FRAME_BUF_NO (64) // REMIND: should be pow of 2
+#define ACLOOPBACK_NB_FRAME_SIZE (160)
+#define ACLOOPBACK_DELAY 12 // unit is 20ms
+
+#if ACLOOPBACK_USING_P2W
+static uint16 gSpc_acLoopback_PCM_BUF[ACLOOPBACK_FRAME_BUF_NO][ACLOOPBACK_NB_FRAME_SIZE];
+#else
+// static uint16 gSpc_acLoopback_PCM_UL_BUF[ACLOOPBACK_FRAME_BUF_NO][ACLOOPBACK_NB_FRAME_SIZE];
+static uint16 gSpc_acLoopback_PCM_UL_BUF[ACLOOPBACK_NB_FRAME_SIZE];
+static uint16 gSpc_acLoopback_PCM_DL_BUF[ACLOOPBACK_FRAME_BUF_NO][ACLOOPBACK_NB_FRAME_SIZE];
+#endif
+
+typedef struct
+{
+ uint32 delay;
+ uint8 isLoopback;
+
+#if ACLOOPBACK_USING_P2W
+ uint32 tmp_w;
+ uint32 tmp_r;
+#else
+ // uint32 UL_tmp_w;
+ // uint32 UL_tmp_r;
+ uint32 DL_tmp_w;
+ uint32 DL_tmp_r;
+#endif
+
+} _SPC_ACOUSTIC_LOOPBACK_T;
+
+static _SPC_ACOUSTIC_LOOPBACK_T gSpc_acLoopback;
+void spc_setAcLoopbackState(bool b)
+{
+ gSpc_acLoopback.isLoopback = b;
+}
+
+bool spc_isAcLoopback()
+{
+ return gSpc_acLoopback.isLoopback;
+}
+
+
+#if ACLOOPBACK_USING_P2W
+void AcousticLoopback_PCM2WAY_UL_HisrHdl()
+#else
+void AcousticLoopback_PCM4WAY_UL_HisrHdl()
+#endif
+{
+ kal_take_spinlock(pcmEx.PCMEXspinLockID, KAL_INFINITE_WAIT);
+#if ACLOOPBACK_USING_P2W
+
+ /* P2W */
+ if( (gSpc_acLoopback.tmp_w - gSpc_acLoopback.tmp_r) < ACLOOPBACK_FRAME_BUF_NO ){
+ PCM2WAY_GetFromMic((uint16*)gSpc_acLoopback_PCM_BUF[gSpc_acLoopback.tmp_w & (ACLOOPBACK_FRAME_BUF_NO - 1)]);
+ MD_TRC_SPC_AC_LOOPBACK_FROM_MIC(
+ gSpc_acLoopback_PCM_BUF[gSpc_acLoopback.tmp_w & (ACLOOPBACK_FRAME_BUF_NO - 1)][0],
+ gSpc_acLoopback_PCM_BUF[gSpc_acLoopback.tmp_w & (ACLOOPBACK_FRAME_BUF_NO - 1)][1],
+ gSpc_acLoopback_PCM_BUF[gSpc_acLoopback.tmp_w & (ACLOOPBACK_FRAME_BUF_NO - 1)][2],
+ gSpc_acLoopback_PCM_BUF[gSpc_acLoopback.tmp_w & (ACLOOPBACK_FRAME_BUF_NO - 1)][3]);
+ (gSpc_acLoopback.tmp_w)++;
+ }else{
+ MD_TRC_SPC_AC_LOOPBACK_SKIP_MIC();
+ }
+
+#else
+ /* P4W UL with delay
+ if( (gSpc_acLoopback.UL_tmp_w - gSpc_acLoopback.UL_tmp_r) < ACLOOPBACK_FRAME_BUF_NO ){
+ PCM4WAY_GetFromMic((uint16*)gSpc_acLoopback_PCM_UL_BUF[gSpc_acLoopback.UL_tmp_w & (ACLOOPBACK_FRAME_BUF_NO - 1)]);
+ MD_TRC_SPC_AC_LOOPBACK_FROM_MIC(
+ gSpc_acLoopback_PCM_UL_BUF[gSpc_acLoopback.UL_tmp_w & (ACLOOPBACK_FRAME_BUF_NO - 1)][0],
+ gSpc_acLoopback_PCM_UL_BUF[gSpc_acLoopback.UL_tmp_w & (ACLOOPBACK_FRAME_BUF_NO - 1)][1],
+ gSpc_acLoopback_PCM_UL_BUF[gSpc_acLoopback.UL_tmp_w & (ACLOOPBACK_FRAME_BUF_NO - 1)][2],
+ gSpc_acLoopback_PCM_UL_BUF[gSpc_acLoopback.UL_tmp_w & (ACLOOPBACK_FRAME_BUF_NO - 1)][3]);
+ (gSpc_acLoopback.UL_tmp_w)++;
+ }else{
+ MD_TRC_SPC_AC_LOOPBACK_SKIP_MIC();
+ }
+
+ if( (gSpc_acLoopback.UL_tmp_w - gSpc_acLoopback.UL_tmp_r) >= gSpc_acLoopback.delay ){
+ PCM4WAY_PutToSE(gSpc_acLoopback_PCM_UL_BUF[gSpc_acLoopback.UL_tmp_r & (ACLOOPBACK_FRAME_BUF_NO - 1)]);
+ MD_TRC_SPC_AC_LOOPBACK_TO_SE(
+ gSpc_acLoopback_PCM_UL_BUF[gSpc_acLoopback.UL_tmp_r & (ACLOOPBACK_FRAME_BUF_NO - 1)][0],
+ gSpc_acLoopback_PCM_UL_BUF[gSpc_acLoopback.UL_tmp_r & (ACLOOPBACK_FRAME_BUF_NO - 1)][1],
+ gSpc_acLoopback_PCM_UL_BUF[gSpc_acLoopback.UL_tmp_r & (ACLOOPBACK_FRAME_BUF_NO - 1)][2],
+ gSpc_acLoopback_PCM_UL_BUF[gSpc_acLoopback.UL_tmp_r & (ACLOOPBACK_FRAME_BUF_NO - 1)][3]);
+ (gSpc_acLoopback.UL_tmp_r)++;
+ }else{
+ MD_TRC_SPC_AC_LOOPBACK_FILL_SE();
+ PCM4WAY_FillSE(0);
+ }
+ */
+
+ // P4W UL without delay
+ PCM4WAY_GetFromMic(gSpc_acLoopback_PCM_UL_BUF);
+ MD_TRC_SPC_AC_LOOPBACK_FROM_MIC(
+ gSpc_acLoopback_PCM_UL_BUF[0],
+ gSpc_acLoopback_PCM_UL_BUF[1],
+ gSpc_acLoopback_PCM_UL_BUF[2],
+ gSpc_acLoopback_PCM_UL_BUF[3]);
+
+ PCM4WAY_PutToSE(gSpc_acLoopback_PCM_UL_BUF);
+ MD_TRC_SPC_AC_LOOPBACK_TO_SE(
+ gSpc_acLoopback_PCM_UL_BUF[0],
+ gSpc_acLoopback_PCM_UL_BUF[1],
+ gSpc_acLoopback_PCM_UL_BUF[2],
+ gSpc_acLoopback_PCM_UL_BUF[3]);
+
+#endif
+ kal_give_spinlock(pcmEx.PCMEXspinLockID);
+}
+
+#if ACLOOPBACK_USING_P2W
+void AcousticLoopback_PCM2WAY_DL_HisrHdl()
+#else
+void AcousticLoopback_PCM4WAY_DL_HisrHdl()
+#endif
+{
+ kal_take_spinlock(pcmEx.PCMEXspinLockID, KAL_INFINITE_WAIT);
+#if ACLOOPBACK_USING_P2W
+ /* P2W */
+ if( (gSpc_acLoopback.tmp_w - gSpc_acLoopback.tmp_r) >= gSpc_acLoopback.delay){
+ PCM2WAY_PutToSpk(gSpc_acLoopback_PCM_BUF[gSpc_acLoopback.tmp_r & (ACLOOPBACK_FRAME_BUF_NO - 1)]);
+ MD_TRC_SPC_AC_LOOPBACK_TO_SPK(
+ gSpc_acLoopback_PCM_BUF[gSpc_acLoopback.tmp_r & (ACLOOPBACK_FRAME_BUF_NO - 1)][0],
+ gSpc_acLoopback_PCM_BUF[gSpc_acLoopback.tmp_r & (ACLOOPBACK_FRAME_BUF_NO - 1)][1],
+ gSpc_acLoopback_PCM_BUF[gSpc_acLoopback.tmp_r & (ACLOOPBACK_FRAME_BUF_NO - 1)][2],
+ gSpc_acLoopback_PCM_BUF[gSpc_acLoopback.tmp_r & (ACLOOPBACK_FRAME_BUF_NO - 1)][3]);
+ (gSpc_acLoopback.tmp_r)++;
+ }else{
+ MD_TRC_SPC_AC_LOOPBACK_FILL_SPK();
+ PCM2WAY_FillSpk(0);
+ }
+
+ MD_TRC_SPC_AC_LOOPBACK_UL_DL_INDEX(
+ gSpc_acLoopback.tmp_w, gSpc_acLoopback.tmp_r, 0, 0);
+#else
+
+
+ if( (gSpc_acLoopback.DL_tmp_w - gSpc_acLoopback.DL_tmp_r) < ACLOOPBACK_FRAME_BUF_NO ){
+ PCM4WAY_GetFromSD((uint16*)gSpc_acLoopback_PCM_DL_BUF[gSpc_acLoopback.DL_tmp_w & (ACLOOPBACK_FRAME_BUF_NO - 1)]);
+ MD_TRC_SPC_AC_LOOPBACK_FROM_SD(
+ gSpc_acLoopback_PCM_DL_BUF[gSpc_acLoopback.DL_tmp_w & (ACLOOPBACK_FRAME_BUF_NO - 1)][0],
+ gSpc_acLoopback_PCM_DL_BUF[gSpc_acLoopback.DL_tmp_w & (ACLOOPBACK_FRAME_BUF_NO - 1)][1],
+ gSpc_acLoopback_PCM_DL_BUF[gSpc_acLoopback.DL_tmp_w & (ACLOOPBACK_FRAME_BUF_NO - 1)][2],
+ gSpc_acLoopback_PCM_DL_BUF[gSpc_acLoopback.DL_tmp_w & (ACLOOPBACK_FRAME_BUF_NO - 1)][3]);
+ (gSpc_acLoopback.DL_tmp_w)++;
+ }else{
+ MD_TRC_SPC_AC_LOOPBACK_SKIP_SD();
+ }
+
+
+
+ if( (gSpc_acLoopback.DL_tmp_w - gSpc_acLoopback.DL_tmp_r) >= gSpc_acLoopback.delay){
+ PCM4WAY_PutToSpk(gSpc_acLoopback_PCM_DL_BUF[gSpc_acLoopback.DL_tmp_r & (ACLOOPBACK_FRAME_BUF_NO - 1)]);
+
+ MD_TRC_SPC_AC_LOOPBACK_TO_SPK(
+ gSpc_acLoopback_PCM_DL_BUF[gSpc_acLoopback.DL_tmp_r & (ACLOOPBACK_FRAME_BUF_NO - 1)][0],
+ gSpc_acLoopback_PCM_DL_BUF[gSpc_acLoopback.DL_tmp_r & (ACLOOPBACK_FRAME_BUF_NO - 1)][1],
+ gSpc_acLoopback_PCM_DL_BUF[gSpc_acLoopback.DL_tmp_r & (ACLOOPBACK_FRAME_BUF_NO - 1)][2],
+ gSpc_acLoopback_PCM_DL_BUF[gSpc_acLoopback.DL_tmp_r & (ACLOOPBACK_FRAME_BUF_NO - 1)][3]);
+ (gSpc_acLoopback.DL_tmp_r)++;
+
+ }else{
+ MD_TRC_SPC_AC_LOOPBACK_FILL_SPK();
+
+ PCM4WAY_FillSpk(0);
+ }
+
+
+ MD_TRC_SPC_AC_LOOPBACK_UL_DL_INDEX(
+ /* gSpc_acLoopback.DL_tmp_w, gSpc_acLoopback.DL_tmp_r, gSpc_acLoopback.UL_tmp_w, gSpc_acLoopback.UL_tmp_r);*/
+ gSpc_acLoopback.DL_tmp_w, gSpc_acLoopback.DL_tmp_r, 0, 0);
+
+#endif
+ kal_give_spinlock(pcmEx.PCMEXspinLockID);
+
+}
+
+/**
+ @uParam: reference spc_sph_on_loopback_info_flag
+ Bit 0: Pre-condiftion is speech mode equals to SPH_MODE_BT_EARPHONE(3) or SPH_MODE_BT_CCARITE(5). 1== BT Loopback without BT codec / 0 == BT Loopback with BT Codec. Only support CVSD&MSBC
+ Bit 1: delay setting for normal loopback, i.e. speech mode is not BT cases. 0==Use modem default delay value/ 1== use AP gives delay value in msgId32 bit[0:7]
+ @extraParam:
+ Bit[7:0]: Delay time in uint8. Unit is 20ms. Take effect when msgId16 bit[2] == 1. For example: when bit[7:0] = 0xf, then the delay time is 15*20 == 300 ms.
+*/
+void Spc_AcousticLoopback(bool enable, kal_uint8 uParam, kal_uint8 extraParam)
+{
+ // kal_bool enable = uParam & 0x1; // bit(0): on/off bit(1): disable/enable BT SW codec
+
+ MD_TRC_SPC_AC_LOOPBACK_INFO(enable, uParam, extraParam);
+
+ if(enable){
+
+ if(false == spc_mainAppOnCheck(SPC_APP_ACLOOPBACK_USAGE)) // remind to skip EM check if necessary
+ return;
+
+ if(IS_SPC_APP_USED(SPC_APP_PCMNWAY_USAGE)){
+ // just leave log and return
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR_CHECK(SPC_APP_ACLOOPBACK_USAGE, SPC_APP_PCMNWAY_USAGE, SPC_APP_PCMNWAY_USAGE, gSpc.spcAppUsage);
+ return;
+ }
+
+ // special case for BT loopback
+#if defined(__CVSD_CODEC_SUPPORT__)
+
+ if( SP_GetDevInfo() == SPH_DEVINFO_BT_CVSD_MSBC
+ || SP_GetDevInfo() == SPH_DEVINFO_BT_CVSD
+ || SP_GetDevInfo() == SPH_DEVINFO_BT_MSBC)
+ { // for SW BT platform, BT loopback does not related to speech and DSP.
+
+ kal_uint8 voice8kMode = SP_GetDevSamplingRate();
+ if( (voice8kMode==0) || (voice8kMode==1) ) {
+
+ SET_SPC_APP_USAGE(SPC_APP_ACLOOPBACK_USAGE);
+ BT_SCO_Loopback_ON( (uParam&SPH_ON_LOOPBACK_INFO_FLAG_DISABLE_BT_CODEC) ,(voice8kMode == 1));
+ return; // REMIND!!!
+
+ } else {
+ MODEM_WARNING_MESSAGE((voice8kMode==0), "Spc_AcousticLoopback(bt): incorrect Voice8kMode, %d", voice8kMode);
+ MODEM_WARNING_MESSAGE((voice8kMode==1), "Spc_AcousticLoopback(bt): incorrect Voice8kMode, %d", voice8kMode);
+ return;
+ }
+ }
+#endif
+
+ // setup
+ gSpc_acLoopback.delay = ACLOOPBACK_DELAY;
+ if((uParam & SPH_ON_LOOPBACK_INFO_FLAG_DELAY_SETTING) !=0) { // using bit[1] for check delay
+ kal_uint8 givenDelay = (extraParam & 0xFF); //use msg32 bit [7:0] for delay setting
+ ASSERT(givenDelay<= ACLOOPBACK_FRAME_BUF_NO);
+ gSpc_acLoopback.delay = givenDelay;
+ }
+#if ACLOOPBACK_USING_P2W
+ gSpc_acLoopback.tmp_w = 0;
+ gSpc_acLoopback.tmp_r = 0;
+#else
+ // gSpc_acLoopback.UL_tmp_w = 0;
+ // gSpc_acLoopback.UL_tmp_r = 0;
+ gSpc_acLoopback.DL_tmp_w = 0;
+ gSpc_acLoopback.DL_tmp_r = 0;
+#endif
+
+ //clean memory
+#if ACLOOPBACK_USING_P2W
+ memset(gSpc_acLoopback_PCM_BUF, 0, sizeof(uint16)*ACLOOPBACK_FRAME_BUF_NO*ACLOOPBACK_NB_FRAME_SIZE);
+#else
+ // memset(gSpc_acLoopback_PCM_UL_BUF, 0, sizeof(uint16)*ACLOOPBACK_FRAME_BUF_NO*ACLOOPBACK_NB_FRAME_SIZE);
+ memset(gSpc_acLoopback_PCM_UL_BUF, 0, sizeof(uint16)*ACLOOPBACK_NB_FRAME_SIZE);
+ memset(gSpc_acLoopback_PCM_DL_BUF, 0, sizeof(uint16)*ACLOOPBACK_FRAME_BUF_NO*ACLOOPBACK_NB_FRAME_SIZE);
+#endif
+ spc_setAcLoopbackState(1);
+#if ACLOOPBACK_USING_P2W
+ /* P2W */
+ Idle_PcmEx_Start(AcousticLoopback_PCM2WAY_DL_HisrHdl, AcousticLoopback_PCM2WAY_UL_HisrHdl,
+ USE_D2M_PATH + DATA_SELECT_AFTER_ENH, // ul1
+ USE_D2M_PATH + DATA_SELECT_AFTER_ENH, // ul2
+ USE_D2M_PATH + DATA_SELECT_AFTER_ENH, // ul3
+ USE_D2M_PATH + DATA_SELECT_AFTER_ENH, // ul4
+ USE_M2D_PATH,
+ PCMEX_BAND_NB, PCMEX_IDLE_ENH_SETTING_WITH);
+#else
+ // enable
+ L1SP_Speech_On(RAT_2G_MODE);
+
+#if ACLOOPBACK_USING_ExtCodec
+ Extcodec_Set_Delay(gSpc_acLoopback.delay);
+ Extcodec_Call_Open();
+
+#else
+ L1SP_SpeechLoopBackEnable(KAL_TRUE); //dsp codec loopback
+
+ Del_PcmEx_Start(AcousticLoopback_PCM4WAY_DL_HisrHdl, AcousticLoopback_PCM4WAY_UL_HisrHdl,
+ USE_D2M_PATH + USE_M2D_PATH + DATA_SELECT_AFTER_ENH,
+ USE_D2M_PATH + USE_M2D_PATH + DATA_SELECT_AFTER_ENH,
+ USE_D2M_PATH + USE_M2D_PATH + DATA_SELECT_AFTER_ENH,
+ USE_D2M_PATH + USE_M2D_PATH + DATA_SELECT_AFTER_ENH,
+ USE_D2M_PATH + USE_M2D_PATH);
+#endif//ACLOOPBACK_USING_ExtCodec
+#endif//ACLOOPBACK_USING_P2W
+
+
+ SET_SPC_APP_USAGE(SPC_APP_ACLOOPBACK_USAGE);
+
+ } else {
+
+ if(!IS_SPC_APP_USED(SPC_APP_ACLOOPBACK_USAGE)){
+ // just leave log and return
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_ACLOOPBACK_USAGE, SPC_APP_ACLOOPBACK_USAGE, 0);
+ return;
+ }
+
+#if defined(__CVSD_CODEC_SUPPORT__)
+ if( BT_SCO_IS_SPEECH_ON() )
+ { // for SW BT platform, BT loopback does not related to speech and DSP.
+ BT_SCO_Loopback_OFF();
+ CLR_SPC_APP_USAGE(SPC_APP_ACLOOPBACK_USAGE);
+ return;
+ }
+#endif
+
+
+#if ACLOOPBACK_USING_P2W
+ /* P2W */
+ // SetSpeechEnhancement(false);
+ PcmEx_Stop();
+ /*mute after loopback*/
+
+ SP_MuteUlFromDiffPos(false, SP_MIC_MUTE_POS_FROM_ALL);
+ L1SP_MuteSpeaker(false);
+#else
+
+ // Extended_PCM4WAY_Stop(P4W_APP_TYPE_UNDER_CALL);
+#if ACLOOPBACK_USING_ExtCodec
+ Extcodec_Call_Close();
+#else
+ PcmEx_Stop();
+#endif//ACLOOPBACK_USING_ExtCodec
+
+
+ L1SP_SpeechLoopBackEnable(KAL_FALSE);
+ L1SP_Speech_Off();
+ spc_setAcLoopbackState(0);
+
+
+#endif//ACLOOPBACK_USING_P2W
+
+ CLR_SPC_APP_USAGE(SPC_APP_ACLOOPBACK_USAGE);
+
+ }
+
+ return;
+}
+
+// ----------------------------------------------------------------------------
+// Speech on for Hosted Dongle
+// ----------------------------------------------------------------------------
+#define SPC_DACA_SIZE 320 // 16*20 words, currently fix 16k
+#define SPC_DACA_SIZE_IN_BYTE 640
+
+typedef struct _SPC_DACA_T_{
+
+ kal_bool dacaIsMicBufWaiting;
+ kal_bool dacaIsSpkBufWaiting;
+
+}_SPC_DACA_T;
+
+static _SPC_DACA_T gSpc_Daca;
+static kal_uint16 gSpc_Daca_spkBuf[SPC_DACA_SIZE];
+static kal_uint16 gSpc_Daca_micBuf[SPC_DACA_SIZE];
+
+/**
+ MD -> AP, Run under AUDL/MED
+*/
+void spc_daca_sendDlData(void)
+{
+ kal_bool sendResult = KAL_TRUE;
+ spcBufInfo info;
+
+ if(!IS_SPC_APP_USED(SPC_APP_HOSTED_USAGE)){ // prevent data sending after DACA is off
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_HOSTED_USAGE, SPC_APP_HOSTED_USAGE, 3);
+ return;
+ }
+
+ info.syncWord = 0x2A2A;
+ info.type = AUD_CCCI_STRMBUF_TYPE_DACA_GetSpk;
+ info.length = SPC_DACA_SIZE_IN_BYTE; // currently, fix the buffer size in WB
+
+ sendResult = (SpcIO_WriteDataToAp(&info, sizeof(spcBufInfo),
+ gSpc_Daca_spkBuf, SPC_DACA_SIZE_IN_BYTE, NULL, 0,
+ SPCIO_MSG_FROM_SPC_DACA_DLDATA_NOTIFY));
+
+ if(KAL_TRUE != sendResult) {
+ //clean up the read waiting flag when send fail to prevent blocking.
+ gSpc_Daca.dacaIsSpkBufWaiting = KAL_FALSE;
+ MD_TRC_SPC_APP_DATA_SEND_FAIL(SPC_APP_HOSTED_USAGE, SPC_APP_HOSTED_USAGE, 0);
+ }
+}
+
+void spc_daca_sendDlDataDone(void)
+{
+
+ if(!IS_SPC_APP_USED(SPC_APP_HOSTED_USAGE)){
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_HOSTED_USAGE, SPC_APP_HOSTED_USAGE, 4);
+ return;
+ }
+ gSpc_Daca.dacaIsSpkBufWaiting = KAL_FALSE;
+}
+
+
+/**
+ MD -> AP, Run under AUDL/MED
+*/
+void spc_daca_requestUlData(void)
+{
+ kal_int32 sendResult;
+
+ if(!IS_SPC_APP_USED(SPC_APP_HOSTED_USAGE)){ // prevent data sending after DACA is off
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_HOSTED_USAGE, SPC_APP_HOSTED_USAGE, 5);
+ return;
+ }
+
+ sendResult = SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_DACA_ULDATA_REQUEST, SPC_DACA_SIZE, 0);
+
+ if(sendResult<0){ //clean waiting flag of speaker to prevent message blocking
+ gSpc_Daca.dacaIsMicBufWaiting = KAL_FALSE;
+ MD_TRC_SPC_APP_DATA_SEND_FAIL(SPC_APP_HOSTED_USAGE, SPC_APP_HOSTED_USAGE, 1);
+ }
+}
+
+void spc_daca_writeUlDataDone(kal_uint16 offset, kal_int16 length, SPC_MSG_FROM_T comeFrom)
+{
+
+ spcBufInfo info;
+ kal_uint16 curOffSet;
+ kal_bool check;
+
+ if(!IS_SPC_APP_USED(SPC_APP_HOSTED_USAGE)){
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_HOSTED_USAGE, SPC_APP_HOSTED_USAGE, 6);
+ return;
+ }
+
+ check = (length>=sizeof(spcBufInfo));
+ MODEM_WARNING_MESSAGE(check, "spc_daca_writeUlDataDone: length=%d small then sizeof(spcBufInfo)", length);
+ if(!check)
+ goto leaveDacaUlDone;
+ curOffSet = SpcIo_GetDataFromAp(offset, sizeof(spcBufInfo), &info, comeFrom);
+
+
+ //header checking
+ check = (info.syncWord == 0xA2A2);
+ MODEM_WARNING_MESSAGE(check, "spc_daca_writeUlDataDone: unknow syncWord");
+ if(!check)
+ goto leaveDacaUlDone;
+ check = (info.type == AUD_CCCI_STRMBUF_TYPE_DACA_FillMic);
+ MODEM_WARNING_MESSAGE(check, "spc_daca_writeUlDataDone: unknow type");
+ if(!check)
+ goto leaveDacaUlDone;
+ check = (info.length == (length - sizeof(spcBufInfo)));
+ MODEM_WARNING_MESSAGE(check, "spc_daca_writeUlDataDone: unknow length");
+ if(!check)
+ goto leaveDacaUlDone;
+
+ if(info.length >0){
+ check = (info.length == SPC_DACA_SIZE_IN_BYTE);
+ MODEM_WARNING_MESSAGE(check, "spc_daca_writeUlDataDone: info.length=%d", info.length);
+ if(!check)
+ goto leaveDacaUlDone;
+ SpcIo_GetDataFromAp(curOffSet, SPC_DACA_SIZE_IN_BYTE, gSpc_Daca_micBuf, comeFrom);
+ }
+
+leaveDacaUlDone:
+ gSpc_Daca.dacaIsMicBufWaiting = KAL_FALSE;
+}
+
+void spc_dacaDl_handler(void)
+{
+ if( gSpc_Daca.dacaIsSpkBufWaiting == KAL_TRUE){
+ MD_TRC_SPC_M2A_DROP(SPC_APP_HOSTED_USAGE, SPC_APP_HOSTED_USAGE, 0);
+ return;
+ }
+
+ // speaker buffer comes from SD
+ DACA_GetFromSD((uint16 *)gSpc_Daca_spkBuf);
+
+ // Transfer to AUDL
+ // Send notification
+ SpcIO_MsgQueuePut(SPC_ID_AUDIO_STRM_DACA_DL_DATA_NOTIFY, 0, 0, SPC_MSG_FROM_AUDHISR);
+
+ gSpc_Daca.dacaIsSpkBufWaiting = KAL_TRUE;
+
+}
+
+void spc_dacaUl_handler(void)
+{
+ if( gSpc_Daca.dacaIsMicBufWaiting == KAL_TRUE){
+ MD_TRC_SPC_M2A_DROP(SPC_APP_HOSTED_USAGE, SPC_APP_HOSTED_USAGE, 1);
+ return;
+ }
+
+ // mic buffer put to SE.
+ DACA_PutToSE((const uint16 *)gSpc_Daca_micBuf);
+
+
+ // Transfer to AUDL
+ // Send notification
+ SpcIO_MsgQueuePut(SPC_ID_AUDIO_STRM_DACA_UL_DATA_REQUEST, 0, 0, SPC_MSG_FROM_AUDHISR);
+
+ gSpc_Daca.dacaIsMicBufWaiting = KAL_TRUE;
+}
+
+/**
+ @RAT_Mode: 0 for 2G, 1 for 3G, 2 for 3G324
+ @enable: true for daca speech on, false for daca speech off
+*/
+void Spc_SpeechOnForDaca( kal_uint8 RAT_Mode, kal_bool enable)
+{
+ if(true == enable){ // speech on with DACA
+
+ if(false == spc_mainAppOnCheck(SPC_APP_HOSTED_USAGE)) {
+ return;
+ }
+
+
+ // disable speech enhancment, due to path is too long, enhancment is meaningless
+ L1SP_EnableSpeechEnhancement(false);
+
+ // clean up setting
+ gSpc_Daca.dacaIsSpkBufWaiting = KAL_FALSE;
+ gSpc_Daca.dacaIsMicBufWaiting = KAL_FALSE;
+
+ // turn on
+#if defined(__UMTS_RAT__) // rate setting
+ if( RAT_Mode != RAT_3G324M_MODE )
+ RAT_Mode = RAT_3G_MODE; // Force initial 3G
+#else
+ RAT_Mode = RAT_2G_MODE;
+#endif
+ MD_TRC_SPC_SPEECH_ON(RAT_Mode);
+ L1SP_Speech_On(RAT_Mode);
+ DACA_Start(spc_dacaDl_handler, spc_dacaUl_handler, DACA_APP_TYPE_ACTIVE_UL_DL_WB); // fix wb due to USB protocal
+
+ SET_SPC_APP_USAGE(SPC_APP_HOSTED_USAGE);
+
+ } else { // speech off with DACA
+
+ // status checking
+ if(!IS_SPC_APP_USED(SPC_APP_HOSTED_USAGE)){
+ // just leave log and return
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_HOSTED_USAGE, SPC_APP_HOSTED_USAGE, 1);
+ return;
+ }
+
+ // turn off
+ DACA_Stop(DACA_APP_TYPE_ACTIVE_UL_DL_WB);
+ L1SP_Speech_Off();
+
+ // speech enhancment back to normal
+ L1SP_EnableSpeechEnhancement(false);
+
+ CLR_SPC_APP_USAGE(SPC_APP_HOSTED_USAGE);
+ }
+}
+// ----------------------------------------------------------------------------
+// DSP PCM ROUTER
+// ----------------------------------------------------------------------------
+void Spc_SpeechRouterOn(kal_bool enable)
+{
+ if(enable) {
+
+ // status check
+ if(false == spc_mainAppOnCheck(SPC_APP_PCMROUTER_USAGE)){
+ return;
+ }
+
+ //set solution ver before application start.
+
+ // application enable
+ PcmRouterStart();
+ SET_SPC_APP_USAGE(SPC_APP_PCMROUTER_USAGE);
+
+ } else {
+
+ // status checking
+ if(!IS_SPC_APP_USED(SPC_APP_PCMROUTER_USAGE)) {
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_PCMROUTER_USAGE, SPC_APP_PCMROUTER_USAGE, 1);
+
+ return;
+ }
+
+
+ // application disable
+ PcmRouterStop();
+ CLR_SPC_APP_USAGE(SPC_APP_PCMROUTER_USAGE);
+
+ }
+}
+
+// ----------------------------------------------------------------------------
+// RECORD
+// ----------------------------------------------------------------------------
+#if 0
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+#endif
+
+typedef struct
+{
+ bool isRecordDataWaiting;
+
+} _SPC_VM_RECORD_T;
+
+typedef struct
+{
+ bool isRecordDataWaiting;
+} _SPC_RAW_PCM_RECORD_T;
+
+// static _SPC_PCM_RECORD_T gSpc_PcmRecord;
+static _SPC_VM_RECORD_T gSpc_VmRecord;
+static _SPC_RAW_PCM_RECORD_T gSpc_RawPcmRecord;
+// static SPC_REC_FORMAT gSpc_Record_format; // only use under record command containing vm/pcm
+/*
+static kal_uint8 tempMicDataCnt = 0;
+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 spc_RawPcmRec_sendDataDone(void)
+{
+ if(!IS_SPC_APP_USED(SPC_APP_RAW_PCM_REC_USAGE)){
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_RAW_PCM_REC_USAGE, SPC_APP_RAW_PCM_REC_USAGE, 1);
+ return;
+ }
+
+ gSpc_RawPcmRecord.isRecordDataWaiting = false;
+}
+
+
+/**
+ run under AUDL/MED, when process message "SPC_ID_AUDIO_STRM_RAWPCMREC_DATA_NOTIFY"
+*/
+void spc_record_sendRawPcmData(void)
+{
+ kal_uint32 add1, add2;
+ kal_uint16 len1, len2;
+ spcBufInfo info;
+ bool sendResult = true;
+
+ if( (!IS_SPC_APP_USED(SPC_APP_RAW_PCM_REC_USAGE)) ){ // prevent pcm data sending to AP after record off
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_RAW_PCM_REC_USAGE, SPC_APP_RAW_PCM_REC_USAGE, 4);
+ return;
+ }
+
+ RawPcmRec_GetMicDataBufs(&add1, &len1, &add2, &len2);
+
+ MD_TRC_RAWPCMREC_GET_DATA_BUFS(add1, len1, add2, len2);
+
+ // change the len to unit of byte
+ len1 <<=1;
+ len2 <<=1;
+
+ if(len1 == 0){
+ gSpc_RawPcmRecord.isRecordDataWaiting = false;
+ MD_TRC_RAWPCMREC_GET_EMPTY_DATA();
+ } else {
+ info.syncWord = 0x2A2A;
+ info.type = AUD_CCCI_STRMBUF_TYPE_RAW_PCM_TYPE;
+ info.length = len1 + len2;
+
+ sendResult = SpcIO_WriteDataToAp(&info, sizeof(spcBufInfo),
+ (void *)add1, len1, (void *)add2, len2,
+ SPCIO_MSG_FROM_SPC_RAW_PCM_REC_DATA_NOTIFY);
+
+ if(sendResult == false) {
+ gSpc_RawPcmRecord.isRecordDataWaiting = false;
+ MD_TRC_SPC_APP_DATA_SEND_FAIL(SPC_APP_RAW_PCM_REC_USAGE, SPC_APP_RAW_PCM_REC_USAGE, 0);
+ }
+ }
+}
+
+#if 0
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+#endif
+
+
+/**
+ Send notification to AUDL/MED, prepare to get the recording data
+*/
+void spc_RawPcmRec_handler(void)
+{
+ if( gSpc_RawPcmRecord.isRecordDataWaiting == true){
+ MD_TRC_SPC_M2A_DROP(SPC_APP_RAW_PCM_REC_USAGE, SPC_APP_RAW_PCM_REC_USAGE, 0);
+ return;
+ }
+
+ gSpc_RawPcmRecord.isRecordDataWaiting = true;
+ // Send notification to AUDL to begin data transfer
+ SpcIO_MsgQueuePut(SPC_ID_AUDIO_STRM_RAWPCMREC_DATA_NOTIFY, 0, 0, SPC_MSG_FROM_AUDHISR);
+
+
+ return;
+}
+
+void spc_RawPcmRec_On(kal_uint8 dlPosition)
+{
+ // RAW PCM Record
+ gSpc_RawPcmRecord.isRecordDataWaiting = false;
+
+ RAWPCMREC_Start(spc_RawPcmRec_handler, dlPosition);
+}
+
+void spc_RawPcmRec_Off(void)
+{
+ RAWPCMREC_Stop();
+}
+
+bool spc_RawPcmRec_getDataWaiting(void)
+{
+ return(gSpc_RawPcmRecord.isRecordDataWaiting);
+}
+
+
+void spc_vmRec_sendMicDataDone(void)
+{
+ if(!IS_SPC_APP_USED(SPC_APP_VM_REC_USAGE)){
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_VM_REC_USAGE, SPC_APP_VM_REC_USAGE, 1);
+ return;
+ }
+
+ gSpc_VmRecord.isRecordDataWaiting = false;
+}
+
+
+/**
+ run under AUDL/MED, when process message "SPC_ID_AUDIO_STRM_VMREC_DATA_NOTIFY"
+*/
+void spc_record_sendVmData(void)
+{
+
+ kal_uint32 add1, add2;
+ kal_uint16 len1, len2;
+ kal_uint16 totalLenInWord;
+ spcBufInfo info;
+ bool sendResult = true;
+
+ if(!IS_SPC_APP_USED(SPC_APP_VM_REC_USAGE)){ // prevent sening vm data to AP after record off
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_VM_REC_USAGE, SPC_APP_VM_REC_USAGE, 5);
+ return;
+ }
+
+ // get data, length is word!!
+ VmRec_GetReadBufs(&add1, &len1, &add2, &len2);
+ totalLenInWord = len1+len2;
+
+ MD_TRC_VM_SENDVMDATA_INFO(add1, len1, add2, len2);
+
+ // change the len to unit of byte
+ len1 <<= 1;
+ len2 <<= 1;
+
+ if(len1 == 0){
+ gSpc_VmRecord.isRecordDataWaiting = false;
+ MD_TRC_SPC_APP_DATA_SEND_FAIL(SPC_APP_VM_REC_USAGE, SPC_APP_VM_REC_USAGE, 1);
+
+ } else {
+ info.syncWord = 0x2A2A;
+ info.type = AUD_CCCI_STRMBUF_TYPE_VM_TYPE;
+ info.length = len1 + len2;
+
+ sendResult = SpcIO_WriteDataToAp(&info, sizeof(spcBufInfo),
+ (void *)add1, len1, (void *)add2, len2,
+ SPCIO_MSG_FROM_SPC_VM_REC_DATA_NOTIFY);
+
+ VmRec_ReadDataDone(totalLenInWord);
+
+ if(sendResult == false) {
+ gSpc_VmRecord.isRecordDataWaiting = false;
+ MD_TRC_SPC_APP_DATA_SEND_FAIL(SPC_APP_VM_REC_USAGE, SPC_APP_VM_REC_USAGE, 2);;
+ }
+ }
+}
+
+void spc_vmRec_handler(void)
+{
+ if( gSpc_VmRecord.isRecordDataWaiting == true){
+ MD_TRC_SPC_M2A_DROP(SPC_APP_VM_REC_USAGE, SPC_APP_VM_REC_USAGE, 1);
+ return;
+ }
+
+ gSpc_VmRecord.isRecordDataWaiting = true;
+
+ SpcIO_MsgQueuePut(SPC_ID_AUDIO_STRM_VMREC_DATA_NOTIFY, 0, 0, SPC_MSG_FROM_AUDHISR);
+
+ return;
+}
+
+void spc_vmRec_On(void)
+{
+ VMREC_Start(spc_vmRec_handler, false);
+
+ gSpc_VmRecord.isRecordDataWaiting = false;
+}
+
+void spc_vmRec_Off(void)
+{
+ gSpc_VmRecord.isRecordDataWaiting = true;
+
+ VMREC_Stop(false);
+}
+
+// ---- Entry Points and Checking -----
+
+/**
+ @return: true for pass checking, flase for fail checking
+*/
+bool spc_recordStartCheck(MSG_SPC_APP_T app)
+{
+/*
+ if(!IS_SPC_ID_SPEECH_CUSTOM_DATA_REQUEST_DONE){ // prevent record on before EM data sending
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(app, app, 0);
+ return false;
+ }
+*/
+ if(IS_SPC_APP_USED(SPC_APP_HOLD_USAGE)){ // under SID generation state, record function is not provided
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR_CHECK(app, SPC_APP_HOLD_USAGE, SPC_APP_HOLD_USAGE, gSpc.spcAppUsage);
+
+ ASSERT(0);
+
+ return false;
+ }
+
+ // system is under idle state, we do not provide record function.
+ if((!IS_SPC_APP_USED(SPC_APP_SPEECH_USAGE))
+ && (!IS_SPC_APP_USED(SPC_APP_ACLOOPBACK_USAGE))
+ && (!IS_SPC_APP_USED(SPC_APP_CTM_USAGE))
+ && (!IS_SPC_APP_USED(SPC_APP_HOSTED_USAGE))
+ && (!IS_SPC_APP_USED(SPC_APP_PCMROUTER_USAGE))
+ ){
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(app, app, 3);
+
+ // REMOVE
+ // ASSERT(0);
+
+ return false;
+ }
+
+ // defualt
+ return true;
+}
+
+
+/**
+ Open vm logging to AP side. This can concurrency with PCM record (spc_PcmRecordStart)
+*/
+void spc_VmRecordStart(void)
+{
+ if(true!= spc_recordStartCheck(SPC_APP_VM_REC_USAGE)){
+ return;
+ }
+
+ // prevent re-entry
+ if(IS_SPC_APP_USED(SPC_APP_VM_REC_USAGE)){
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_VM_REC_USAGE, SPC_APP_VM_REC_USAGE, 2);
+ return;
+ }
+
+ spc_vmRec_On();
+
+ SET_SPC_APP_USAGE(SPC_APP_VM_REC_USAGE);
+}
+
+/**
+ Pair with spc_VmRecordStart(), to close vm logging.
+*/
+void spc_VmRecordStop(void)
+{
+ if(!IS_SPC_APP_USED(SPC_APP_VM_REC_USAGE)){
+ // just leave log and return
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_VM_REC_USAGE, SPC_APP_VM_REC_USAGE, 1);
+ return;
+ }
+
+ spc_vmRec_Off();
+ CLR_SPC_APP_USAGE(SPC_APP_VM_REC_USAGE);
+}
+
+
+/**
+ Open RAW PCM record. This can concurrency with VM record (spc_VmRecordStart)
+ Only support speech on record!! (Speech on for daca is NOT support)
+*/
+void spc_RawPcmRecordStart(kal_uint8 dlPosition)
+{
+ if(true != spc_recordStartCheck(SPC_APP_RAW_PCM_REC_USAGE)){
+ return;
+ }
+
+ if(IS_SPC_APP_USED(SPC_APP_HOSTED_USAGE)) // PCM record is not allow on DACA
+ {
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_RAW_PCM_REC_USAGE, SPC_APP_RAW_PCM_REC_USAGE, 4);
+ ASSERT(0);
+ return;
+ }
+
+ // prevent re-entry
+ if(IS_SPC_APP_USED(SPC_APP_RAW_PCM_REC_USAGE)){
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_RAW_PCM_REC_USAGE, SPC_APP_RAW_PCM_REC_USAGE, 2);
+ return;
+ }
+
+#if 0
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+#endif
+
+ spc_RawPcmRec_On(dlPosition);
+ SET_SPC_APP_USAGE(SPC_APP_RAW_PCM_REC_USAGE);
+}
+
+
+void spc_RawPcmRecordStop(void)
+{
+ if(!IS_SPC_APP_USED(SPC_APP_RAW_PCM_REC_USAGE)){
+ // just leave log and return
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_RAW_PCM_REC_USAGE, SPC_APP_RAW_PCM_REC_USAGE, 0);
+ return;
+ }
+
+ spc_RawPcmRec_Off();
+ CLR_SPC_APP_USAGE(SPC_APP_RAW_PCM_REC_USAGE);
+}
+
+
+// ----------------------------------------------------------------------------
+// PCMNWAY
+// ----------------------------------------------------------------------------
+#define SPC_PCMNWAY_MAX_SIZE_OF_SE_BUF 960 // unit is 16bit(word)
+#define SPC_PCMNWAY_MAX_SIZE_OF_SPK_BUF 960 // unit is 16bit(word), max = 48*20 = 960
+#define SPC_PCMNWAY_MAX_SIZE_OF_MIC_BUF 1922 // unit is 16bit(word), max = 960*2 +2(agc use)
+#define SPC_PCMNWAY_MAX_SIZE_OF_SD_BUF 960 // unit is 16bit(word)
+
+
+#define SPC_PNW_MSG_BUFFER_SE 1 // Bit 0
+#define SPC_PNW_MSG_BUFFER_SPK 2 // Bit 1
+#define SPC_PNW_MSG_BUFFER_MIC 4 // Bit 2
+#define SPC_PNW_MSG_BUFFER_SD 8 // Bit 3
+
+#define SPC_PNW_MSG_BIT_BAND 4
+
+typedef enum
+{
+
+ SPC_PCMNWAY_APP_TYPE_NONE = 0,
+#if 0
+/* under construction !*/
+/* under construction !*/
+#endif
+
+ SPC_PCMNWAY_APP_TYPE_UNSET = 0xffff,
+} SPC_PCMNWAY_APP_TYPE_T;
+
+typedef enum {
+ SPC_PCMNWAY_FORMAT_P2W_NORMAL = 0,
+ SPC_PCMNWAY_FORMAT_P2W_VOIP,
+ SPC_PCMNWAY_FORMAT_P2W_CAL, //calibration
+ SPC_PCMNWAY_FORMAT_P2W_WB_CAL, //wb calibration
+ SPC_PCMNWAY_FORMAT_P2W_WB_NORMAL, //normal usage for WB p2w
+
+ SPC_PCMNWAY_FORMAT_UNSET = 0xffff,
+}SPC_PCMNWAY_Format;
+
+
+typedef struct _SPC_PCMNWAY_T_
+{
+ kal_uint8 pnwBufInfo; //ref to SPC_PNW_MSG_BUFFER_x
+ kal_uint8 pnwBand; //0: for narrow band, 1: for wide band
+ // kal_uint16 pnwAppType;
+
+ kal_bool pnwIsMicBufWaiting;
+ kal_bool pnwIsSpkBufWaiting;
+
+ kal_uint32 micBufSize; // unit is byte (8bit)
+ kal_uint32 spkBufSize; // unit is byte (8bit)
+ kal_uint32 seBufSize;
+ kal_uint32 sdBufSize;
+
+
+}_SPC_PCMNWAY_T;
+
+static _SPC_PCMNWAY_T gSpc_Pcmnway;
+static kal_uint16 gSpc_Pcmnway_seBuf[SPC_PCMNWAY_MAX_SIZE_OF_SE_BUF];
+static kal_uint16 gSpc_Pcmnway_spkBuf[SPC_PCMNWAY_MAX_SIZE_OF_SPK_BUF];
+static kal_uint16 gSpc_Pcmnway_micBuf[SPC_PCMNWAY_MAX_SIZE_OF_MIC_BUF];
+static kal_uint16 gSpc_Pcmnway_sdBuf[SPC_PCMNWAY_MAX_SIZE_OF_SD_BUF];
+
+/*
+__attribute__ ((section ("NONCACHEDZI"))) static kal_uint16 tempUlData[179]
+ // = { 0x4808,0x85, 0x156,0, 0x4,0, 0x146,0x9000,
+ = { 0,0, 0,0, 0,0, 0,0,
+ 1, 2, 3, 4, 5, 6, 7, 8,
+ 0x2A2A, 0x2, 0x140,
+ 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
+};
+*/
+
+/**
+ MD -> AP, Run under AUDL/MED
+*/
+void spc_pcmNWay_sendUlData(void)
+{
+ kal_bool sendResultMic = KAL_TRUE;
+ kal_bool sendResultSd = KAL_TRUE;
+ spcBufInfo info;
+
+ if(!IS_SPC_APP_USED(SPC_APP_PCMNWAY_USAGE)){ // prevent data sending after PCMNWAY is off
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_PCMNWAY_USAGE, SPC_APP_PCMNWAY_USAGE, 4);
+ return;
+ }
+
+ if (gSpc_Pcmnway.pnwBufInfo & SPC_PNW_MSG_BUFFER_MIC) {
+ info.syncWord = 0x2A2A;
+ info.type = AUD_CCCI_STRMBUF_TYPE_PCM_GetFromMic;
+#if 0 //defined(__ENABLE_SPEECH_DVT__)
+/* under construction !*/
+#else // defined(__ENABLE_SPEECH_DVT__)
+ info.length = gSpc_Pcmnway.micBufSize;
+#endif // defined(__ENABLE_SPEECH_DVT__)
+
+ // for debug
+ /*
+ sendResultMic = spcIO_sendDataViaCCCI(
+ SPCIO_CCCI_MSG_CONSTRCUT_DATA_CMD(MSG_M2A_DATA_NOTIFY_PNW_ULREAD, 326),
+ &(tempUlData[8]), 342);
+ */
+
+#if 0 //defined(__ENABLE_SPEECH_DVT__)
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+#endif // defined(__ENABLE_SPEECH_DVT__)
+ {
+ sendResultMic = (SpcIO_WriteDataToAp(&info, sizeof(spcBufInfo),
+ gSpc_Pcmnway_micBuf, gSpc_Pcmnway.micBufSize, NULL, 0,
+ SPCIO_MSG_FROM_SPC_PNW_ULDATA_NOTIFY));
+ }
+
+ }
+
+ if (gSpc_Pcmnway.pnwBufInfo & SPC_PNW_MSG_BUFFER_SD) {
+ info.syncWord = 0x2A2A;
+ info.type = AUD_CCCI_STRMBUF_TYPE_PCM_GetfromSD;
+ info.length = gSpc_Pcmnway.sdBufSize;
+
+ sendResultSd = (SpcIO_WriteDataToAp(&info, sizeof(spcBufInfo),
+ gSpc_Pcmnway_sdBuf, gSpc_Pcmnway.sdBufSize, NULL, 0,
+ SPCIO_MSG_FROM_SPC_PNW_ULDATA_NOTIFY));
+ }
+
+ if((KAL_TRUE != sendResultMic) || (KAL_TRUE != sendResultSd)) {
+ //clean up the read waiting flag when send fail to prevent blocking.
+ gSpc_Pcmnway.pnwIsMicBufWaiting = KAL_FALSE;
+ MD_TRC_SPC_APP_DATA_SEND_FAIL(SPC_APP_PCMNWAY_USAGE, SPC_APP_PCMNWAY_USAGE, 0);
+ }
+}
+
+void spc_pcmNWay_sendUlDataDone(void)
+{
+
+ if(!IS_SPC_APP_USED(SPC_APP_PCMNWAY_USAGE)){
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_PCMNWAY_USAGE, SPC_APP_PCMNWAY_USAGE, 1);
+ return;
+ }
+ gSpc_Pcmnway.pnwIsMicBufWaiting = KAL_FALSE;
+
+}
+
+/**
+ MD -> AP
+*/
+// void spc_pcmNWay_requestDlData(uint16 bufLength)
+void spc_pcmNWay_requestDlData(void)
+{
+ kal_int32 sendResult;
+
+ if(!IS_SPC_APP_USED(SPC_APP_PCMNWAY_USAGE)){ // prevent data sending after PCMNWAY is off
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_PCMNWAY_USAGE, SPC_APP_PCMNWAY_USAGE, 5);
+ return;
+ }
+
+#if 0 // defined(__ENABLE_SPEECH_DVT__)
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+#endif // defined(__ENABLE_SPEECH_DVT__)
+ {
+ sendResult = SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_PNW_DLDATA_REQUEST, gSpc_Pcmnway.spkBufSize, 0);
+ }
+ // SPCIO_CCCI_MSG_ORG_CONSTRCUT_CMD(MSG_M2A_DATA_REQUEST_PNW_DLDATA, gSpc_Pcmnway.spkBufSize));
+
+ if(sendResult<0){ //clean waiting flag of speaker to prevent message blocking
+ gSpc_Pcmnway.pnwIsSpkBufWaiting = KAL_FALSE;
+ MD_TRC_SPC_APP_DATA_SEND_FAIL(SPC_APP_PCMNWAY_USAGE, SPC_APP_PCMNWAY_USAGE, 1);
+ }
+}
+
+void spc_pcmNWay_writeDlDataDone(kal_uint16 offset, kal_int16 length, SPC_MSG_FROM_T comeFrom)
+{
+
+ spcBufInfo info;
+ kal_uint16 curOffSet;
+ kal_bool check;
+
+ if(!IS_SPC_APP_USED(SPC_APP_PCMNWAY_USAGE)){
+ MD_TRC_SPC_M2A_DROP(SPC_APP_PCMNWAY_USAGE, SPC_APP_PCMNWAY_USAGE, 5);
+ return;
+ }
+
+ check = (length>=sizeof(spcBufInfo));
+ MODEM_WARNING_MESSAGE(check, "spc_pcmNWay_writeDlDataDone: length=%d small then sizeof(spcBufInfo)", length);
+ if(!check)
+ goto leavePnwDlDone;
+ curOffSet = SpcIo_GetDataFromAp(offset, sizeof(spcBufInfo), &info, comeFrom);
+
+
+ //header checking
+ check = (info.syncWord == 0xA2A2);
+ MODEM_WARNING_MESSAGE(check, "spc_pcmNWay_writeDlDataDone: unknow syncWord");
+ if(!check)
+ goto leavePnwDlDone;
+ check = ( (info.type == AUD_CCCI_STRMBUF_TYPE_PCM_FillSE) || (info.type == AUD_CCCI_STRMBUF_TYPE_PCM_FillSpk) );
+ MODEM_WARNING_MESSAGE(check, "spc_pcmNWay_writeDlDataDone: unknow syncWord");
+ if(!check)
+ goto leavePnwDlDone;
+ check = (info.length == (length - sizeof(spcBufInfo)));
+ MODEM_WARNING_MESSAGE(check, "spc_pcmNWay_writeDlDataDone: unknow syncWord");
+ if(!check)
+ goto leavePnwDlDone;
+
+ if(info.length >0){
+ if (info.type == AUD_CCCI_STRMBUF_TYPE_PCM_FillSE) { //SE
+ check = (info.length == gSpc_Pcmnway.seBufSize);
+ MODEM_WARNING_MESSAGE(check, "spc_pcmNWay_writeDlDataDone: (se)info.length=%d", info.length);
+ if(!check)
+ goto leavePnwDlDone;
+ SpcIo_GetDataFromAp(curOffSet, gSpc_Pcmnway.seBufSize, gSpc_Pcmnway_seBuf, comeFrom);
+ } else { //SPK
+ check = (info.length == gSpc_Pcmnway.spkBufSize);
+ MODEM_WARNING_MESSAGE(check, "spc_pcmNWay_writeDlDataDone: (spk)info.length=%d", info.length);
+ if(!check)
+ goto leavePnwDlDone;
+ SpcIo_GetDataFromAp(curOffSet, gSpc_Pcmnway.spkBufSize, gSpc_Pcmnway_spkBuf, comeFrom);
+
+ }
+ }
+
+leavePnwDlDone:
+ gSpc_Pcmnway.pnwIsSpkBufWaiting = KAL_FALSE;
+}
+
+
+void spc_pcm4way_handler( void )
+{
+ // spc_pcm4wayDl_handler();
+ kal_take_spinlock(pcmEx.PCMEXspinLockID, KAL_INFINITE_WAIT);
+ if(pcmEx.running == 0){
+ kal_give_spinlock(pcmEx.PCMEXspinLockID);
+ return;
+ }
+ if( gSpc_Pcmnway.pnwIsSpkBufWaiting == KAL_TRUE){
+ MD_TRC_SPC_M2A_DROP(SPC_APP_PCMNWAY_USAGE, SPC_APP_PCMNWAY_USAGE, 4);
+ kal_give_spinlock(pcmEx.PCMEXspinLockID);
+ return;
+ }
+
+ // SE buffer
+ if (gSpc_Pcmnway.pnwBufInfo & SPC_PNW_MSG_BUFFER_SE) {
+ gSpc_Pcmnway.seBufSize = ((PCM4WAY_PutToSE((const uint16*)gSpc_Pcmnway_seBuf)) << 1);
+ }
+
+ // Speaker buffer
+ if (gSpc_Pcmnway.pnwBufInfo & SPC_PNW_MSG_BUFFER_SPK) {
+ gSpc_Pcmnway.spkBufSize = ((PCM4WAY_PutToSpk((const uint16*)gSpc_Pcmnway_spkBuf)) << 1);
+ }
+ kal_give_spinlock(pcmEx.PCMEXspinLockID);
+ // Transfer to AUDL
+ // Send notification
+ SpcIO_MsgQueuePut(SPC_ID_AUDIO_STRM_PNW_DL_DATA_REQUEST, 0, 0, SPC_MSG_FROM_AUDHISR);
+ kal_take_spinlock(pcmEx.PCMEXspinLockID, KAL_INFINITE_WAIT);
+ if(pcmEx.running == 0){
+ kal_give_spinlock(pcmEx.PCMEXspinLockID);
+ return;
+ }
+ gSpc_Pcmnway.pnwIsSpkBufWaiting = KAL_TRUE;
+
+ // --------------------------------------------------------------
+ // spc_pcm4wayUl_handler();
+ if( gSpc_Pcmnway.pnwIsMicBufWaiting == KAL_TRUE){
+ MD_TRC_SPC_M2A_DROP(SPC_APP_PCMNWAY_USAGE, SPC_APP_PCMNWAY_USAGE, 3);
+ kal_give_spinlock(pcmEx.PCMEXspinLockID);
+ return;
+ }
+
+
+ // Microphone buffer
+ if (gSpc_Pcmnway.pnwBufInfo & SPC_PNW_MSG_BUFFER_MIC) {
+ gSpc_Pcmnway.micBufSize = ((PCM4WAY_GetFromMic((uint16*)gSpc_Pcmnway_micBuf))<<1);
+ }
+
+ // SD buffer
+ if (gSpc_Pcmnway.pnwBufInfo & SPC_PNW_MSG_BUFFER_SD) {
+ gSpc_Pcmnway.sdBufSize = ((PCM4WAY_GetFromSD((uint16*)gSpc_Pcmnway_sdBuf))<<1);
+ }
+
+ // Transfer to AUDL
+ // Send notification
+ gSpc_Pcmnway.pnwIsMicBufWaiting = KAL_TRUE;
+ kal_give_spinlock(pcmEx.PCMEXspinLockID);
+ SpcIO_MsgQueuePut(SPC_ID_AUDIO_STRM_PNW_UL_DATA_NOTIFY, 0, 0, SPC_MSG_FROM_AUDHISR);
+
+
+}
+
+void spc_pcm2wayUl_handler( void )
+{
+ kal_take_spinlock(pcmEx.PCMEXspinLockID, KAL_INFINITE_WAIT);
+ if(pcmEx.running == 0){
+ kal_give_spinlock(pcmEx.PCMEXspinLockID);
+ return;
+ }
+#if defined(__ENABLE_SPEECH_DVT__)
+ kal_uint16 bufLen;
+#endif // defined(__ENABLE_SPEECH_DVT__)
+
+ if( gSpc_Pcmnway.pnwIsMicBufWaiting == KAL_TRUE){
+ MD_TRC_SPC_M2A_DROP(SPC_APP_PCMNWAY_USAGE, SPC_APP_PCMNWAY_USAGE, 1);
+ kal_give_spinlock(pcmEx.PCMEXspinLockID);
+ return;
+ }
+
+ // Microphone buffer
+ if (gSpc_Pcmnway.pnwBufInfo & SPC_PNW_MSG_BUFFER_MIC) {
+#if 0 //defined(__ENABLE_SPEECH_DVT__)
+/* under construction !*/
+#else // defined(__ENABLE_SPEECH_DVT__)
+ gSpc_Pcmnway.micBufSize = ((PCM2WAY_GetFromMic((uint16*)gSpc_Pcmnway_micBuf))<<1);
+#endif // defined(__ENABLE_SPEECH_DVT__)
+ }
+ gSpc_Pcmnway.pnwIsMicBufWaiting = KAL_TRUE;
+ kal_give_spinlock(pcmEx.PCMEXspinLockID);
+ // Transfer to AUDL
+ // Send notification
+#if 0 // defined(__ENABLE_SPEECH_DVT__)
+/* under construction !*/
+#else // defined(__ENABLE_SPEECH_DVT__)
+ SpcIO_MsgQueuePut(SPC_ID_AUDIO_STRM_PNW_UL_DATA_NOTIFY, 0, 0, SPC_MSG_FROM_AUDHISR);
+#endif // defined(__ENABLE_SPEECH_DVT__)
+
+
+}
+
+void spc_pcm2wayDl_handler( void )
+{
+ kal_take_spinlock(pcmEx.PCMEXspinLockID, KAL_INFINITE_WAIT);
+ if(pcmEx.running == 0){
+ kal_give_spinlock(pcmEx.PCMEXspinLockID);
+ return;
+ }
+#if 0 //defined(__ENABLE_SPEECH_DVT__)
+/* under construction !*/
+#endif // defined(__ENABLE_SPEECH_DVT__)
+
+ if( gSpc_Pcmnway.pnwIsSpkBufWaiting == KAL_TRUE){
+ MD_TRC_SPC_M2A_DROP(SPC_APP_PCMNWAY_USAGE, SPC_APP_PCMNWAY_USAGE, 2);
+ kal_give_spinlock(pcmEx.PCMEXspinLockID);
+ return;
+ }
+
+ // Speaker buffer
+ if (gSpc_Pcmnway.pnwBufInfo & SPC_PNW_MSG_BUFFER_SPK) {
+#if 0 //defined(__ENABLE_SPEECH_DVT__)
+/* under construction !*/
+#else // defined(__ENABLE_SPEECH_DVT__)
+ gSpc_Pcmnway.spkBufSize = ((PCM2WAY_PutToSpk((const uint16*)gSpc_Pcmnway_spkBuf))<<1);
+#endif // defined(__ENABLE_SPEECH_DVT__)
+ }
+ gSpc_Pcmnway.pnwIsSpkBufWaiting = KAL_TRUE;
+ kal_give_spinlock(pcmEx.PCMEXspinLockID);
+ // Transfer to AUDL
+ // Send notification
+#if 0 // defined(__ENABLE_SPEECH_DVT__)
+/* under construction !*/
+#else // defined(__ENABLE_SPEECH_DVT__)
+ SpcIO_MsgQueuePut(SPC_ID_AUDIO_STRM_PNW_DL_DATA_REQUEST, 0, 0, SPC_MSG_FROM_AUDHISR);
+#endif // defined(__ENABLE_SPEECH_DVT__)
+
+
+}
+
+
+void spc_pcm2way_handler( void )
+{
+ spc_pcm2wayDl_handler();
+ spc_pcm2wayUl_handler();
+}
+
+
+/**
+ @param:
+ [0:3] pcmnway buffer infor, please ref SPC_PNW_MSG_BUFFER_x
+ [4]: band information: 0 narrow band, 1 wide band,
+ @format: please reference SPC_PCMNWAY_Format. If its value is 0xFFFF(undefine), we decide it by band information.
+ @appType: application type using in PCMNWAY. If its value is 0xFFFF(undefine), we will choose by ourself
+*/
+void spc_PcmNWayStart(kal_uint32 param, SPC_PCMNWAY_Format format) // , SPC_PCMNWAY_APP_TYPE_T appType)
+{
+ uint32 cfgUL1 , cfgUL2, cfgUL3, cfgUL4, cfgDL;
+
+ if(IS_SPC_APP_USED(SPC_APP_HOLD_USAGE) || IS_SPC_APP_USED(SPC_APP_HOSTED_USAGE)){
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_PCMNWAY_USAGE, SPC_APP_PCMNWAY_USAGE, 3);
+
+ ASSERT(0);
+
+ return;
+ }
+
+
+ gSpc_Pcmnway.pnwBufInfo = (param & 0xf); // i.e. param & (SPC_PNW_MSG_BUFFER_SE|SPC_PNW_MSG_BUFFER_SPK|SPC_PNW_MSG_BUFFER_MIC|SPC_PNW_MSG_BUFFER_SD)
+ gSpc_Pcmnway.pnwBand = ((param >> SPC_PNW_MSG_BIT_BAND) & 0x1);
+
+ ASSERT(gSpc_Pcmnway.pnwBufInfo != 0);
+
+
+ // buffer rest
+ memset( (kal_uint8 *)gSpc_Pcmnway_seBuf, 0, SPC_PCMNWAY_MAX_SIZE_OF_SE_BUF*sizeof(uint16) );
+ memset( (kal_uint8 *)gSpc_Pcmnway_spkBuf, 0, SPC_PCMNWAY_MAX_SIZE_OF_SPK_BUF*sizeof(uint16) );
+ memset( (kal_uint8 *)gSpc_Pcmnway_micBuf, 0, SPC_PCMNWAY_MAX_SIZE_OF_MIC_BUF*sizeof(uint16) );
+ memset( (kal_uint8 *)gSpc_Pcmnway_sdBuf, 0, SPC_PCMNWAY_MAX_SIZE_OF_SD_BUF*sizeof(uint16) );
+ gSpc_Pcmnway.micBufSize = 0;
+ gSpc_Pcmnway.spkBufSize = 0;
+ gSpc_Pcmnway.seBufSize = 0;
+ gSpc_Pcmnway.sdBufSize = 0;
+
+ // reset wating
+ gSpc_Pcmnway.pnwIsMicBufWaiting = KAL_FALSE;
+ gSpc_Pcmnway.pnwIsSpkBufWaiting = KAL_FALSE;
+
+
+ // UL1 path
+ cfgUL1 =DATA_SELECT_AFTER_ENH;
+ if(SPC_PNW_MSG_BUFFER_MIC & gSpc_Pcmnway.pnwBufInfo ) {
+ cfgUL1 |= USE_D2M_PATH;
+ }
+ if(SPC_PNW_MSG_BUFFER_SE & gSpc_Pcmnway.pnwBufInfo ) {
+ cfgUL1 |= USE_M2D_PATH;
+ }
+
+ //UL2 path
+ cfgUL2=DATA_SELECT_AFTER_ENH;
+ //UL3 path
+ cfgUL3=DATA_SELECT_AFTER_ENH;
+ //UL4 path
+ cfgUL4=DATA_SELECT_AFTER_ENH;
+
+ // DL path
+ cfgDL = 0;
+ if(SPC_PNW_MSG_BUFFER_SD & gSpc_Pcmnway.pnwBufInfo ) {
+ cfgDL |= USE_D2M_PATH;
+ }
+ if(SPC_PNW_MSG_BUFFER_SPK & gSpc_Pcmnway.pnwBufInfo ) {
+ cfgDL |= USE_M2D_PATH;
+ }
+
+ if (IS_SPC_APP_USED(SPC_APP_SPEECH_USAGE)) { // in call
+ if( (SPC_PNW_MSG_BUFFER_SPK|SPC_PNW_MSG_BUFFER_MIC) == gSpc_Pcmnway.pnwBufInfo) { // 2way
+ Del_PcmEx_Start(spc_pcm2wayDl_handler, spc_pcm2wayUl_handler,
+ cfgUL1, cfgUL2, cfgUL3, cfgUL4, cfgDL);
+ } else {
+ Del_PcmEx_Start(spc_pcm4way_handler, NULL,
+ cfgUL1, cfgUL2, cfgUL3, cfgUL4, cfgDL);
+ }
+
+
+ } else { // idle
+
+ PCMEX_BAND band = PCMEX_BAND_UNSET;
+ PCMEX_IDLE_ENH_SETTING enhSetting = PCMEX_IDLE_ENH_SETTING_WITH; // default with
+
+ band = ((gSpc_Pcmnway.pnwBufInfo == 0)? PCMEX_BAND_NB : PCMEX_BAND_WB);
+#if 0
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+#endif
+ if( (SPC_PNW_MSG_BUFFER_SPK|SPC_PNW_MSG_BUFFER_MIC) == gSpc_Pcmnway.pnwBufInfo) { // 2way
+ Idle_PcmEx_Start(spc_pcm2wayDl_handler, spc_pcm2wayUl_handler,
+ cfgUL1, cfgUL2, cfgUL3, cfgUL4, cfgDL,
+ band, enhSetting);
+ } else {
+ Idle_PcmEx_Start(spc_pcm4way_handler, NULL,
+ cfgUL1, cfgUL2, cfgUL3, cfgUL4, cfgDL,
+ band, enhSetting);
+ }
+
+ }
+
+
+ // record the spc application usage status
+ SET_SPC_APP_USAGE(SPC_APP_PCMNWAY_USAGE);
+
+}
+
+void spc_PcmNWayStop()
+{
+
+ if(!IS_SPC_APP_USED(SPC_APP_PCMNWAY_USAGE)){
+ // just leave log and return
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_PCMNWAY_USAGE, SPC_APP_PCMNWAY_USAGE, 0);
+ return;
+ }
+
+ PcmEx_Stop();
+
+ // clear buffer
+ gSpc_Pcmnway.pnwBufInfo = 0;
+ gSpc_Pcmnway.pnwBand = 0;
+ gSpc_Pcmnway.micBufSize = 0;
+ gSpc_Pcmnway.spkBufSize = 0;
+ gSpc_Pcmnway.seBufSize = 0;
+ gSpc_Pcmnway.sdBufSize = 0;
+
+ CLR_SPC_APP_USAGE(SPC_APP_PCMNWAY_USAGE);
+
+}
+
+// ----------------------------------------------------------------------------
+// PCMMIXER
+// ----------------------------------------------------------------------------
+typedef struct _SPC_PCMMIXER_T_
+{
+ kal_bool isUlBufWaiting;
+ kal_bool isDlBufWaiting;
+}_SPC_PCMMIXER_T;
+
+static _SPC_PCMMIXER_T gSpc_PCMMixer;
+
+void spc_PCMMixer_UL_handler( void )
+{
+#if 0
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+#endif
+
+ // Send notification
+ SpcIO_MsgQueuePut(SPC_ID_AUDIO_PCMMIXER_UL_DATA_REQUEST, 0, 0, SPC_MSG_FROM_AUDHISR);
+}
+
+void spc_PCMMixer_DL_handler( void )
+{
+ if(gSpc_PCMMixer.isDlBufWaiting){
+ MD_TRC_SPC_M2A_DROP(SPC_APP_MIXER_USAGE, SPC_APP_MIXER_USAGE, 0);
+ return;
+ }
+ gSpc_PCMMixer.isDlBufWaiting = KAL_TRUE;
+ // Send notification
+ SpcIO_MsgQueuePut(SPC_ID_AUDIO_PCMMIXER_DL_DATA_REQUEST, 0, 0, SPC_MSG_FROM_AUDHISR);
+}
+
+
+void spc_PCMMixerConfig(kal_bool isUlMix, kal_bool isDlMix, uint8 ulGainLevel, uint8 dlGainLevel)
+{
+ PcmMixer_ConfigUl(isUlMix, ulGainLevel);
+ PcmMixer_ConfigDl(isDlMix, dlGainLevel);
+}
+
+void spc_PCMMixerStart(kal_bool isUlMix, kal_bool isDlMix, uint8 ulGainLevel, uint8 dlGainLevel)
+{
+ if(IS_SPC_APP_USED(SPC_APP_MIXER_USAGE)){ // application re-entry
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_MIXER_USAGE, SPC_APP_MIXER_USAGE, 5);
+ return;
+ }
+
+ if((!IS_SPC_APP_USED(SPC_APP_SPEECH_USAGE)) && (!IS_SPC_APP_USED(SPC_APP_HOSTED_USAGE)) && (!IS_SPC_APP_USED(SPC_APP_PCMROUTER_USAGE))){ // bg sound on without any speech
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_MIXER_USAGE, SPC_APP_MIXER_USAGE, 3);
+ return;
+ }
+
+ gSpc_PCMMixer.isDlBufWaiting = KAL_FALSE;
+ PcmMixer_ConfigUl(isUlMix, ulGainLevel);
+ PcmMixer_ConfigDl(isDlMix, dlGainLevel);
+
+ PcmMixer_Start(spc_PCMMixer_DL_handler);
+ SET_SPC_APP_USAGE(SPC_APP_MIXER_USAGE);
+}
+
+void spc_PCMMixerStop()
+{
+ if(!IS_SPC_APP_USED(SPC_APP_MIXER_USAGE)){ // application re-entry
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_MIXER_USAGE, SPC_APP_PCMNWAY_USAGE, 0);
+ return;
+ }
+
+ gSpc_PCMMixer.isDlBufWaiting = KAL_TRUE;
+ PcmMixer_Stop();
+
+ CLR_SPC_APP_USAGE(SPC_APP_MIXER_USAGE);
+}
+
+void spc_pcmMixer_requestDlData(void)
+{
+ kal_bool sendResult;
+ if(!IS_SPC_APP_USED(SPC_APP_MIXER_USAGE)){ // prevent data sending after mixer is off
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_MIXER_USAGE, SPC_APP_MIXER_USAGE, 1);
+ return;
+ }
+
+ sendResult = SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_PCMMIXER_DL_DATA_REQUEST, ((PcmMixer_QueryDlBufLen())<<1) , 0);
+ if(KAL_FALSE == sendResult){ //clean waiting flag of speaker to prevent message blocking
+ gSpc_PCMMixer.isDlBufWaiting = KAL_FALSE;
+ MD_TRC_SPC_APP_DATA_SEND_FAIL(SPC_APP_MIXER_USAGE, SPC_APP_MIXER_USAGE, 1);
+ }
+
+}
+
+
+void spc_PCMMixer_writeDlDataDone(kal_uint16 offset, kal_int16 length, SPC_MSG_FROM_T comeFrom)
+{
+ spcBufInfo info;
+ kal_bool check;
+
+ if(!IS_SPC_APP_USED(SPC_APP_MIXER_USAGE)){
+ MD_TRC_SPC_M2A_DROP(SPC_APP_MIXER_USAGE, SPC_APP_MIXER_USAGE, 5);
+ return;
+ }
+
+ ASSERT(length>=sizeof(spcBufInfo));
+
+ SpcIO_GetDataFromAp_inOneTime(offset, length, sizeof(spcBufInfo), &info, emDataBuf, comeFrom);
+
+
+ //header checking
+ check = (info.syncWord == 0xA2A2);
+ MODEM_WARNING_MESSAGE(check, "PcmMixer: unknow syncWord");
+ if(!check)
+ goto leave;
+ check = (info.type == AUD_CCCI_STRMBUF_TYPE_PCM_MIXER_DL);
+ MODEM_WARNING_MESSAGE(check, "PcmMixer: unknow type");
+ if(!check)
+ goto leave;
+ check = (info.length == (length - sizeof(spcBufInfo)));
+ MODEM_WARNING_MESSAGE(check, "PcmMixer: incorrect length");
+ if(!check)
+ goto leave;
+
+ PcmMixer_writeDlBuf((uint16 *)emDataBuf, info.length>>1);
+
+leave:
+ gSpc_PCMMixer.isDlBufWaiting = false;
+}
+
+
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// PCMMIXER3
+// ----------------------------------------------------------------------------
+typedef struct _SPC_PCMMIXER3_T_
+{
+ kal_bool isUlBufWaiting;
+}_SPC_PCMMIXER3_T;
+
+static _SPC_PCMMIXER3_T gSpc_PCMMixer3;
+
+void spc_PCMMixer3_UL_handler( void )
+{
+ if(gSpc_PCMMixer3.isUlBufWaiting){
+ MD_TRC_SPC_M2A_DROP(SPC_APP_MIXER3_USAGE, SPC_APP_MIXER3_USAGE, 0);
+ return;
+ }
+ gSpc_PCMMixer3.isUlBufWaiting = KAL_TRUE;
+ // Send notification
+ SpcIO_MsgQueuePut(SPC_ID_AUDIO_PCMMIXER3_UL_DATA_REQUEST, 0, 0, SPC_MSG_FROM_AUDHISR);
+}
+
+
+void spc_PCMMixer3Config(kal_bool isUlMix, uint8 ulGainLevel)
+{
+ PcmMixer3_ConfigUl(isUlMix, ulGainLevel);
+}
+
+void spc_PCMMixer3Start(kal_bool isUlMix, uint8 ulGainLevel)
+{
+ if(IS_SPC_APP_USED(SPC_APP_MIXER3_USAGE)){ // application re-entry
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_MIXER3_USAGE, SPC_APP_MIXER3_USAGE, 5);
+ return;
+ }
+
+ if((!IS_SPC_APP_USED(SPC_APP_SPEECH_USAGE)) && (!IS_SPC_APP_USED(SPC_APP_HOSTED_USAGE)) && (!IS_SPC_APP_USED(SPC_APP_PCMROUTER_USAGE))){ // bg sound on without any speech
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_MIXER_USAGE, SPC_APP_MIXER_USAGE, 3);
+ return;
+ }
+
+ gSpc_PCMMixer3.isUlBufWaiting = KAL_FALSE;
+ PcmMixer3_ConfigUl(isUlMix, ulGainLevel);
+ //PcmMixer3_ConfigDl(isDlMix, dlGainLevel);
+
+ PcmMixer3_Start(spc_PCMMixer3_UL_handler);
+ SET_SPC_APP_USAGE(SPC_APP_MIXER3_USAGE);
+}
+
+void spc_PCMMixer3Stop()
+{
+ if(!IS_SPC_APP_USED(SPC_APP_MIXER3_USAGE)){ // application re-entry
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_MIXER3_USAGE, SPC_APP_PCMNWAY_USAGE, 0);
+ return;
+ }
+
+ gSpc_PCMMixer3.isUlBufWaiting = KAL_TRUE;
+ PcmMixer3_Stop();
+
+ CLR_SPC_APP_USAGE(SPC_APP_MIXER3_USAGE);
+}
+
+void spc_pcmMixer3_requestUlData(void)
+{
+ kal_bool sendResult;
+ if(!IS_SPC_APP_USED(SPC_APP_MIXER3_USAGE)){ // prevent data sending after mixer is off
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_MIXER3_USAGE, SPC_APP_MIXER3_USAGE, 1);
+ return;
+ }
+
+ sendResult = SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_PCMMIXER3_UL_DATA_REQUEST, ((PcmMixer3_QueryUlBufLen())<<1) , 0);
+ if(KAL_FALSE == sendResult){ //clean waiting flag of speaker to prevent message blocking
+ gSpc_PCMMixer3.isUlBufWaiting = KAL_FALSE;
+ MD_TRC_SPC_APP_DATA_SEND_FAIL(SPC_APP_MIXER3_USAGE, SPC_APP_MIXER3_USAGE, 1);
+ }
+
+}
+
+void spc_PCMMixer3_writeUlDataDone(kal_uint16 offset, kal_int16 length, SPC_MSG_FROM_T comeFrom)
+{
+ spcBufInfo info;
+ kal_bool check;
+
+ if(!IS_SPC_APP_USED(SPC_APP_MIXER3_USAGE)){
+ MD_TRC_SPC_M2A_DROP(SPC_APP_MIXER3_USAGE, SPC_APP_MIXER3_USAGE, 5);
+ return;
+ }
+
+ ASSERT(length>=sizeof(spcBufInfo));
+
+ SpcIO_GetDataFromAp_inOneTime(offset, length, sizeof(spcBufInfo), &info, emDataBuf, comeFrom);
+
+
+ //header checking
+ check = (info.syncWord == 0xA2A2);
+ MODEM_WARNING_MESSAGE(check, "PcmMixer: unknow syncWord");
+ if(!check)
+ goto leave;
+ check = (info.type == AUD_CCCI_STRMBUF_TYPE_TELEPHONYTX_UL);
+ MODEM_WARNING_MESSAGE(check, "PcmMixer: unknow type");
+ if(!check)
+ goto leave;
+ check = (info.length == (length - sizeof(spcBufInfo)));
+ MODEM_WARNING_MESSAGE(check, "PcmMixer: incorrect length");
+ if(!check)
+ goto leave;
+
+ PcmMixer3_writeUlBuf((uint16 *)emDataBuf, info.length>>1);
+
+leave:
+ gSpc_PCMMixer3.isUlBufWaiting = false;
+}
+
+
+
+// ----------------------------------------------------------------------------
+// Background Sound
+// ----------------------------------------------------------------------------
+typedef struct _SPC_BGSND_T_
+{
+ kal_uint8 ulGainLevel;
+ kal_uint8 dlGainLevel;
+
+ kal_bool isDataWaiting;
+ kal_uint32 id;
+}_SPC_BGSND_T;
+
+static _SPC_BGSND_T gSpc_bgSnd;
+
+/**
+ Run under MED/AUDL Thread
+*/
+void spc_bgSnd_writeDataDone(kal_uint16 offset, kal_uint16 length, SPC_MSG_FROM_T comeFrom)
+{
+ spcBufInfo info;
+ kal_bool check;
+
+ if(!IS_SPC_APP_USED(SPC_APP_BGSND_USAGE)){ // prevent data sending after background sound is off
+ MD_TRC_SPC_M2A_DROP(SPC_APP_BGSND_USAGE, SPC_APP_BGSND_USAGE, 1);
+ return;
+ }
+
+ MD_TRC_SPC_BGSND_WRITEDATADONE_ENTER();
+
+ check = (length >= sizeof(spcBufInfo));
+ MODEM_WARNING_MESSAGE(check, "spc_bgSnd_writeDataDone: small data size");
+ if(!check)
+ goto bgsLeave;
+
+ SpcIO_GetDataFromAp_inOneTime(offset, length, sizeof(spcBufInfo), &info, emDataBuf, comeFrom);
+
+ //header check
+ check = (info.syncWord == 0xA2A2);
+ MODEM_WARNING_MESSAGE(check, "spc_bgSnd_writeDataDone: unknow syncWord");
+ if(!check)
+ goto bgsLeave;
+ check = (info.type == AUD_CCCI_STRMBUF_TYPE_BGS_TYPE);
+ MODEM_WARNING_MESSAGE(check, "spc_bgSnd_writeDataDone: unknow type");
+ if(!check)
+ goto bgsLeave;
+ check = (info.length == (length-6));
+ MODEM_WARNING_MESSAGE(check, "spc_bgSnd_writeDataDone: unknow length");
+ if(!check)
+ goto bgsLeave;
+
+ if(info.length>0){
+ EXT_BGSND_WriteSrcBuffer(gSpc_bgSnd.id, emDataBuf, (kal_int32) info.length, BGSND_DL_PROCESS);
+ EXT_BGSND_WriteSrcBuffer(gSpc_bgSnd.id, emDataBuf, (kal_int32) info.length, BGSND_UL_PROCESS);
+ }
+
+bgsLeave:
+ gSpc_bgSnd.isDataWaiting = KAL_FALSE;
+
+ MD_TRC_SPC_BGSND_WRITEDATADONE_LEAVE();
+}
+
+/**
+ Run under MED/AUDL Thread
+*/
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+void spc_bgSnd_requestData(void)
+{
+ int32 bLen;
+ MD_TRC_SPC_BGSND_REQUESTDATA_ENTER();
+ if(!IS_SPC_APP_USED(SPC_APP_BGSND_USAGE)){ // prevent data sending after background sound is off
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_BGSND_USAGE, SPC_APP_BGSND_USAGE, 1);
+ return;
+ }
+
+ if(gSpc_bgSnd.isDataWaiting){
+ MD_TRC_SPC_M2A_DROP(SPC_APP_BGSND_USAGE, SPC_APP_BGSND_USAGE, 0);
+ return;
+ }
+ bLen = MIN( EXT_BGSND_GetFreeSpace(gSpc_bgSnd.id, BGSND_UL_PROCESS), EXT_BGSND_GetFreeSpace(gSpc_bgSnd.id, BGSND_DL_PROCESS));
+ //bLen = BGSND_GetFreeSpace(); //unit is 16bit in BGSND_GetFreeSpace() return
+ // bLen &= ~0x1;
+ MD_TRC_SPC_BGSND_REQUESTDATA_INFO(bLen, BGSND_RB_DEFAULT_THRESHOLD);
+
+ if( bLen >= BGSND_RB_DEFAULT_THRESHOLD ) {
+
+ // send data request to AP
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_BGS_DATA_REQUEST, (bLen<<1) , 0);
+ gSpc_bgSnd.isDataWaiting = KAL_TRUE;
+
+ }
+ MD_TRC_SPC_BGSND_REQUESTDATA_LEAVE();
+
+}
+
+/**
+ Call back handler from HISR
+*/
+void spc_BGSND_DLHdr(void)
+{
+ MD_TRC_SPC_BGSND_DLHDR_ENTER();
+ EXT_BGSND_WriteExtBuffer(gSpc_bgSnd.id, 1, BGSND_DL_PROCESS);
+ EXT_BGSND_WriteExtBuffer(gSpc_bgSnd.id, 1, BGSND_UL_PROCESS);
+
+ if(KAL_FALSE == gSpc_bgSnd.isDataWaiting) {
+ int bLen = MIN( EXT_BGSND_GetFreeSpace(gSpc_bgSnd.id, BGSND_DL_PROCESS), EXT_BGSND_GetFreeSpace(gSpc_bgSnd.id, BGSND_DL_PROCESS));
+ if( (bLen >= BGSND_RB_DEFAULT_THRESHOLD) && (EXT_BGSND_GetStatus(gSpc_bgSnd.id, BGSND_DL_PROCESS) == EXT_SRC_STATE_RUN) ) {
+ SpcIO_MsgQueuePut(SPC_ID_AUDIO_STRM_BGSND_DATA_REQUEST, 0, 0, SPC_MSG_FROM_AUDHISR);
+ }
+ }
+ MD_TRC_SPC_BGSND_DLHDR_LEAVE();
+}
+
+/**
+ Call back handler from AUDIO task when bgSnd is off
+*/
+void spc_bgSnd_closeHandler(void)
+{
+
+ SpcIO_MsgQueuePut(SPC_ID_AUDIO_CONTROL_BGSND_CLOSE, 0, 0, SPC_MSG_FROM_AUDHISR);
+}
+
+void spc_BgSndStart(void)
+{
+#ifdef SPH_CHIP_BACK_PHONECALL_USE
+ return;
+#endif
+
+
+ if(IS_SPC_APP_USED(SPC_APP_BGSND_USAGE)){ // application re-entry
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_BGSND_USAGE, SPC_APP_BGSND_USAGE, 5);
+ return;
+ }
+
+/*
+ if(!IS_SPC_ID_SPEECH_CUSTOM_DATA_REQUEST_DONE){ // prevent background sound on before EM data sending
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_BGSND_USAGE, SPC_APP_BGSND_USAGE, 4);
+ return;
+ }
+*/
+ if((!IS_SPC_APP_USED(SPC_APP_SPEECH_USAGE)) && (!IS_SPC_APP_USED(SPC_APP_HOSTED_USAGE)) && (!IS_SPC_APP_USED(SPC_APP_PCMROUTER_USAGE))){ // bg sound on without any speech
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_BGSND_USAGE, SPC_APP_BGSND_USAGE, 3);
+ return;
+ }
+
+ if(IS_SPC_APP_USED(SPC_APP_HOLD_USAGE)){
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_BGSND_USAGE, SPC_APP_BGSND_USAGE, 2);
+
+ ASSERT(0);
+
+ return;
+ }
+ MD_TRC_SPC_BGSNDSTART_ENTER();
+ gSpc_bgSnd.isDataWaiting = KAL_FALSE;
+ gSpc_bgSnd.id = EXT_BGSND_Start(spc_bgSnd_closeHandler, spc_BGSND_DLHdr, NULL, gSpc_bgSnd.dlGainLevel, gSpc_bgSnd.ulGainLevel);
+ SET_SPC_APP_USAGE(SPC_APP_BGSND_USAGE);
+ MD_TRC_SPC_BGSNDSTART_LEAVE();
+}
+
+void spc_BgSndStop(void)
+{
+
+ if(!IS_SPC_APP_USED(SPC_APP_BGSND_USAGE)){
+ // just leave log and return,
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_BGSND_USAGE, SPC_APP_BGSND_USAGE, 0);
+
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_BGSND_OFF_ACK, 0, 0);
+ return;
+ }
+
+ // to avoid to many data request
+ gSpc_bgSnd.isDataWaiting = KAL_TRUE;
+ MD_TRC_SPC_BGSNDSTOP_ENTER();
+ EXT_BGSND_Flush(gSpc_bgSnd.id);
+ MD_TRC_SPC_BGSNDSTOP_LEAVE();
+}
+
+void spc_BgSndForceClose(void)
+{
+ if(!IS_SPC_APP_USED(SPC_APP_BGSND_USAGE)){ // due to AP close process may interrupt by EPOF command, so the checked is need
+ // just leave log and return,
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_BGSND_USAGE, SPC_APP_BGSND_USAGE, 6);
+
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_BGSND_OFF_ACK, 0, 0);
+ return;
+ }
+
+ EXT_BGSND_Close(gSpc_bgSnd.id);
+ CLR_SPC_APP_USAGE(SPC_APP_BGSND_USAGE);
+}
+
+void spc_BgSndClose(void)
+{
+ spc_BgSndForceClose();
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_BGSND_OFF_ACK, 0, 0);
+}
+
+
+/**
+ @ulGainLevel: 0~7 levels, mapping to 0~32767
+ @dlGainLevel: 0~7 levels, mapping to 0~32767
+*/
+void spc_BgSndConfig(kal_uint8 ulGainLevel, kal_uint8 dlGainLevel)
+{
+ MD_TRC_SPC_BGSNDCONFIG_ENTER();
+ gSpc_bgSnd.ulGainLevel = ulGainLevel;
+ gSpc_bgSnd.dlGainLevel = dlGainLevel;
+
+ // when application is running, update hte gain directly
+ if(IS_SPC_APP_USED(SPC_APP_BGSND_USAGE)){
+ EXT_BGSND_ConfigMixer(gSpc_bgSnd.id, KAL_TRUE, gSpc_bgSnd.dlGainLevel, BGSND_DL_PROCESS);
+ EXT_BGSND_ConfigMixer(gSpc_bgSnd.id, KAL_TRUE, gSpc_bgSnd.ulGainLevel, BGSND_UL_PROCESS);
+ }
+ MD_TRC_SPC_BGSNDCONFIG_LEAVE();
+}
+// ----------------------------------------------------------------------------
+// CTM
+// ----------------------------------------------------------------------------
+
+#ifdef __CTM_SUPPORT__
+
+#if defined(__CCCI_OVER_SDIO_SUPPORT__)
+#define SPC_CTM_DUMP_DEBUG_BUF_SIZE (165 *4 )
+#else
+#define SPC_CTM_DUMP_DEBUG_BUF_SIZE (163 *4 )
+#endif
+
+typedef struct _SPC_CTM_T_
+{
+ kal_bool isDumpDebugFile;
+ kal_bool isDumpDataWaiting;
+ kal_uint16 dumpDebugBuf[SPC_CTM_DUMP_DEBUG_BUF_SIZE];
+ kal_uint16 dumpDebugBufPtr;
+ kal_uint16 mode;
+ kal_bool isPCM;
+}_SPC_CTM_T;
+
+
+#define SPC_CTM_BUFFER_SIZE 44600 // 44596
+__attribute__((aligned (4)))static kal_uint8 gSpc_Ctm_buf[SPC_CTM_BUFFER_SIZE];
+
+static _SPC_CTM_T gSpc_ctm;
+
+
+void spc_ctm_sendDumpDebugData(void)
+{
+ kal_bool sendResult;
+
+ if(!IS_SPC_APP_USED(SPC_APP_CTM_USAGE)){ // prevent data sending after CTM is off
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_CTM_USAGE, SPC_APP_CTM_USAGE, 1);
+ return;
+ }
+
+
+#if defined(__CCCI_OVER_SDIO_SUPPORT__)
+ {
+ uint8 *ptr = (uint8 *)gSpc_ctm.dumpDebugBuf;
+ spcExtendedBufInfo *pinfo;
+ int i, len;
+
+ sendResult=true;
+ for(i=1; i<=4; i++){
+ pinfo = (spcExtendedBufInfo *)ptr;
+ ASSERT(pinfo->syncWord == 0x1234);
+ // ASSERT(pinfo->curIdx == i);
+ // ASSERT(pinfo->totalIdx == 4);
+
+ len = sizeof(spcExtendedBufInfo)+ pinfo->length;
+ sendResult &= SpcIO_WriteDataToAp(NULL, 0, ptr, (len), NULL, 0, SPCIO_MSG_FROM_SPC_CTM_DEBUG_DATA_NOTIFY);
+
+ ptr += len;
+ }
+
+ if(KAL_TRUE != sendResult) {
+ gSpc_ctm.dumpDebugBufPtr = 0;
+ gSpc_ctm.isDumpDataWaiting = KAL_FALSE;
+
+ }
+ }
+#else
+ sendResult = (SpcIO_WriteDataToAp(NULL, 0,
+ gSpc_ctm.dumpDebugBuf, ((gSpc_ctm.dumpDebugBufPtr)<<1), NULL, 0,
+ SPCIO_MSG_FROM_SPC_CTM_DEBUG_DATA_NOTIFY));
+
+ if(KAL_TRUE != sendResult) {
+ //clean up the read waiting flag when send fail to prevent blocking.
+ gSpc_ctm.dumpDebugBufPtr = 0;
+ gSpc_ctm.isDumpDataWaiting = KAL_FALSE;
+
+ }
+#endif
+}
+
+void spc_ctm_sendDumpDebugDataDone(void)
+{
+ if(!IS_SPC_APP_USED(SPC_APP_CTM_USAGE)){
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_CTM_USAGE, SPC_APP_CTM_USAGE, 2);
+ return;
+ }
+ gSpc_ctm.dumpDebugBufPtr = 0;
+ gSpc_ctm.isDumpDataWaiting = false;
+}
+
+static void spc_ctm_handler(L1Ctm_Event event, void *param)
+{
+
+}
+
+/**
+ This function is running under L1audioTask, as a callback function
+ @length: length of buffer unit in 16bit.
+*/
+void spc_Ctm_DebugCallback(uint16 pos, uint16 *buffer, uint16 length, bool isDone)
+{
+
+ if(gSpc_ctm.isDumpDebugFile == false)
+ {
+ return;
+ }
+
+
+ if(true == isDone ){
+
+ if( KAL_TRUE == gSpc_ctm.isDumpDataWaiting){
+ MD_TRC_SPC_M2A_DROP(SPC_APP_CTM_USAGE, SPC_APP_CTM_USAGE, 1);
+ return;
+ }
+
+ // send request to MED
+ SpcIO_MsgQueuePut(SPC_ID_AUDIO_STRM_CTM_DUMP_DATA_NOTIFY, 0, 0, SPC_MSG_FROM_AUDHISR);
+ gSpc_ctm.isDumpDataWaiting = KAL_TRUE;
+
+ } else {
+#if defined(__CCCI_OVER_SDIO_SUPPORT__)
+ spcExtendedBufInfo info;
+#else
+ spcBufInfo info;
+#endif
+ if( KAL_TRUE == gSpc_ctm.isDumpDataWaiting){
+ MD_TRC_SPC_M2A_DROP(SPC_APP_CTM_USAGE, SPC_APP_CTM_USAGE, 0);
+ return;
+ }
+#if defined(__CCCI_OVER_SDIO_SUPPORT__)
+ info.syncWord = 0x1234;
+#else
+ info.syncWord = 0x2A2A;
+#endif
+ info.length = length*sizeof(uint16);
+
+ switch(pos){
+ case UL_IN_WRITE_FILE_REQUEST: // 1
+ info.type = AUD_CCCI_STRMBUF_TYPE_CTM_UL_IN;
+ break;
+ case DL_IN_WRITE_FILE_REQUEST: // 2
+ info.type = AUD_CCCI_STRMBUF_TYPE_CTM_DL_IN;
+ break;
+ case UL_OUT_WRITE_FILE_REQUEST: // 3
+ info.type = AUD_CCCI_STRMBUF_TYPE_CTM_UL_OUT;
+ break;
+ case DL_OUT_WRITE_FILE_REQUEST: // 4
+ info.type = AUD_CCCI_STRMBUF_TYPE_CTM_DL_OUT;
+ break;
+ default:
+ ASSERT(0);
+ }
+
+#if defined(__CCCI_OVER_SDIO_SUPPORT__)
+ info.curIdx = 1;
+ info.totalIdx = 1;
+ memcpy((uint8 *)(&(gSpc_ctm.dumpDebugBuf[gSpc_ctm.dumpDebugBufPtr])), &info, sizeof(spcExtendedBufInfo));
+
+ gSpc_ctm.dumpDebugBufPtr += 5; // header= sizeof(spcBufInfo)
+#else
+ memcpy((uint8 *)(&(gSpc_ctm.dumpDebugBuf[gSpc_ctm.dumpDebugBufPtr])), &info, sizeof(spcBufInfo));
+ gSpc_ctm.dumpDebugBufPtr += 3; // header= sizeof(spcBufInfo)
+#endif
+
+ memcpy((uint8 *)(&(gSpc_ctm.dumpDebugBuf[gSpc_ctm.dumpDebugBufPtr])), buffer, length*sizeof(uint16));
+ gSpc_ctm.dumpDebugBufPtr +=length;
+
+ ASSERT(gSpc_ctm.dumpDebugBufPtr <= SPC_CTM_DUMP_DEBUG_BUF_SIZE); // overflow protection
+ }
+}
+
+/**
+ @mode: 0: DIRECT_MODE, 1: BAUDOT_MODE
+*/
+void spc_NormalCtmStart(kal_uint16 mode){
+ if (L1Ctm_GetMemReq() > SPC_CTM_BUFFER_SIZE)
+ ASSERT(0);
+
+ gSpc_ctm.isDumpDataWaiting = false;
+ memset(gSpc_ctm.dumpDebugBuf, 0, sizeof(uint16)*SPC_CTM_DUMP_DEBUG_BUF_SIZE);
+ gSpc_ctm.dumpDebugBufPtr=0;
+
+ L1Ctm_Open( mode, spc_ctm_handler, gSpc_Ctm_buf, SPC_CTM_BUFFER_SIZE, spc_Ctm_DebugCallback);
+ SET_SPC_APP_USAGE(SPC_APP_CTM_USAGE);
+}
+void spc_C2KCtmStart(kal_uint16 mode){
+ if(FULL_MODE == mode){
+ SAL_C2K_SetTTYStatus(true, true);
+ l1sp_setCtmSpeStatus(1);
+ kal_prompt_trace(MOD_L1SP, "%s() SetSpeechEnhancement = false", __FUNCTION__);
+ SetSpeechEnhancement(false);
+ l1sp_setCtmSpeStatus(0);
+ }
+ else if(VCO_MODE == mode){
+ SAL_C2K_SetTTYStatus(false, true);
+ l1sp_setCtmSpeStatus(1);
+ kal_prompt_trace(MOD_L1SP, "%s() SetSpeechEnhancement = false", __FUNCTION__);
+ SetSPEnhancePath(SpeechEnh_UL);
+ }
+ else if(HCO_MODE == mode){
+ SAL_C2K_SetTTYStatus(true, false);
+ l1sp_setCtmSpeStatus(1);
+ kal_prompt_trace(MOD_L1SP, "%s() SetSpeechEnhancement = false", __FUNCTION__);
+ SetSPEnhancePath(SpeechEnh_DL);
+ }
+ gSpc_ctm.isPCM = false;
+}
+kal_uint16 spc_getCtmMode(){
+ return gSpc_ctm.mode;
+}
+
+kal_bool spc_isPCM(){
+ kal_prompt_trace(MOD_L1SP, "spc_isPCM = %d",gSpc_ctm.isPCM);
+ return gSpc_ctm.isPCM;
+}
+
+void spc_CtmStart(kal_uint16 mode)
+{
+ gSpc_ctm.mode = mode;
+ if(L1SP_STATE_C2K_SPEECH_ON == L1SP_GetState()){
+ spc_C2KCtmStart(mode);
+ }
+ else{
+ spc_NormalCtmStart(mode);
+ gSpc_ctm.isPCM = true;
+ }
+}
+
+void spc_NormalCtmStop(void){
+
+ if(!IS_SPC_APP_USED(SPC_APP_CTM_USAGE)){
+ // just leave log and return
+ MD_TRC_SPC_ILLEGAL_SPC_APP_BEHAVIOR(SPC_APP_CTM_USAGE, SPC_APP_CTM_USAGE, 0);
+ return;
+ }
+
+ L1Ctm_Stop();
+
+ CLR_SPC_APP_USAGE(SPC_APP_CTM_USAGE);
+}
+void spc_CtmStop(void)
+{
+ l1sp_setCtmSpeStatus(1);
+ SetSpeechEnhancement(true);
+ SAL_C2K_SetTTYStatus(false, false);
+
+ if(!gSpc_ctm.isPCM){
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_CTM_OFF_ACK, 0, 0);
+ }
+ else{
+ spc_NormalCtmStop();
+ }
+
+ gSpc_ctm.isPCM = false;
+ gSpc_ctm.mode = 0;
+}
+
+void spc_CtmClose(void)
+{
+ kal_prompt_trace(MOD_L1SP, "[spc_CtmClose] Enter");
+ L1Ctm_Close();
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_CTM_OFF_ACK, 0, 0);
+ kal_prompt_trace(MOD_L1SP, "[spc_CtmClose] Leave");
+}
+
+void spc_RttConfig(uint16 type){
+
+ kal_prompt_trace(MOD_L1SP, "[spc_RttConfig] %d", type);
+ if(type==1)
+ L1Ctm_RTTOpen();
+ else
+ L1Ctm_RTTClose();
+}
+
+
+/*
+[REMIND] This function "L1Ctm_StartNegotiation" is not called from AP side.
+The actual user is L1D in modem. So phase it out.
+
+void spc_CtmNegotiation(void)
+{
+ L1Ctm_StartNegotiation();
+}
+*/
+
+void spc_CtmDebugConfig(kal_bool turnOn)
+{
+ gSpc_ctm.isDumpDebugFile = turnOn;
+}
+
+#endif // __CTM_SUPPORT__
+
+// ----------------------------------------------------------------------------
+// Parameter Setting like EM
+// ----------------------------------------------------------------------------
+
+#if 0
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+#endif
+
+
+void spc_ReceiveViberationSpkParameter(const kal_uint16 offset, const kal_uint16 length, SPC_MSG_FROM_T comeFrom)
+{
+ spcBufInfo info;
+ AUDIO_VIBSPK_PARAMETER_STRUCT *vibSpkParam; //buffer reuse
+
+ vibSpkParam = (AUDIO_VIBSPK_PARAMETER_STRUCT *)(&emDataBuf); //buffer reuse
+
+ //get data
+ SpcIO_GetDataFromAp_inOneTime(offset, length, sizeof(spcBufInfo), &info, vibSpkParam, comeFrom);
+
+ //header checking
+ ASSERT(info.syncWord == 0xA2A2);
+ ASSERT(info.type== AUD_CCCI_STRMBUF_TYPE_VIBSPK_PARAM); //just use the bit[0:3] to inidicate the type.
+ ASSERT(info.length == (length-6));
+
+
+ // copy coefficient
+ spe_setNotchFilterParam(vibSpkParam->notch_filter_para, vibSpkParam->is2In1Spk);
+
+
+}
+
+void spc_ReceiveNxpSmartPaParameter(const kal_uint16 offset, const kal_uint16 length, SPC_MSG_FROM_T comeFrom)
+{
+ spcBufInfo info;
+ AUDIO_NXP_SMARTPA_PARAMETER_STRUCT *nxpPaParam; //buffer reuse
+
+ nxpPaParam = (AUDIO_NXP_SMARTPA_PARAMETER_STRUCT *)(&emDataBuf); //buffer reuse
+
+ //get data
+ SpcIO_GetDataFromAp_inOneTime(offset, length, sizeof(spcBufInfo), &info, nxpPaParam, comeFrom);
+
+ //[REMOVE] header checking
+ // ASSERT(info.syncWord == 0xA2A2);
+ // ASSERT(info.type== AUD_CCCI_STRMBUF_TYPE_NXP_SMARTPA_PARAM); //just use the bit[0:3] to inidicate the type.
+ // ASSERT(info.length == (length-6));
+
+ // SPE_SetEchoRefInfo(nxpPaParam->isNxpFeatureOptOn, nxpPaParam->mic_index, nxpPaParam->chip_delay_with_switch, SPH_MODE_LOUDSPK);
+
+}
+#if defined(_SPE_ENH_MD_PARSE_)
+
+kal_uint16 spc_ReceiveDynamicParameter_viaStructShm(const kal_uint16 offset,const kal_uint16 length,SPC_MSG_FROM_T comeFrom)
+{
+ // spcBufInfo header;
+ // spc_sph_on_info_t info;
+ kal_uint16 totalProcLen = 0;
+ kal_uint16 curOffset = offset;
+#if 0
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+#endif
+
+ while(totalProcLen < length) {
+ kal_uint16 procLen = 0;
+ kal_uint16 newOffset;
+ spc_dynamicParameterParser_dispatcher(curOffset, length, SPC_MSG_FROM_CCCI_STREAM_AND_SHM, &procLen, &newOffset);
+ totalProcLen += procLen;
+ curOffset = newOffset;
+ }
+ return totalProcLen;
+
+}
+#endif
+
+
+
+// ----------------------------------------------------------------------------
+// Volume Setting
+// ----------------------------------------------------------------------------
+/**
+ @digiGain: unit is 0.25 dB
+*/
+void spc_gain_DlDigiGainSet(kal_uint16 digiGain)
+{
+ spGain_SetDigitalGain( (kal_int16)digiGain, false );
+ // l1sp_digiOnly_SetOutputVolume((kal_int16)digiGain);
+}
+
+/**
+ @refDigiGain: unit is 0.25 dB
+*/
+void spc_gain_DlEnhRefDigiGainSet(kal_uint16 refDigiGain)
+{
+ spGain_SetEnhRefDigitalGain((kal_int16)refDigiGain, false);
+ //l1sp_digiOnly_SetEnhRefOutputVolume((kal_int16)refDigiGain);
+}
+
+/**
+ @digiGain: unit is 0.25 dB, but for DSP, only 1 db step range. mean while if you send 1.25 dB and 1.5 dB, they are the same
+*/
+void spc_gain_UlDigiGainSet(kal_uint16 digiGain)
+{
+ spGain_SetMicrophoneVolume((kal_int16)digiGain, false);
+ // l1sp_digiOnly_SetMicrophoneVolume((kal_int16)digiGain);
+}
+
+/**
+ @on: 1 for turn on mute, 0 for turn off mute
+ @byPassCheck: 1 for by pass check, 0 for normal check
+*/
+void spc_gain_UlMuteSet(kal_bool on, kal_bool byPassCheck)
+{
+ if(IS_SPC_APP_USED(SPC_APP_MERGE_SPH_USAGE)
+ || IS_SPC_APP_USED(SPC_APP_SPEECH_USAGE)
+ || IS_SPC_APP_USED(SPC_APP_PCMROUTER_USAGE)
+ || KAL_TRUE == byPassCheck) {
+ gSpc.spcMuteUl = on;
+ SP_MuteUlFromDiffPos(on, SP_MIC_MUTE_POS_FROM_SPC); // L1SP_MuteMicrophone(on);
+ } else {
+ MD_TRC_SPC_SET_DROP_UL_MUTE();
+#if defined(__SMART_PHONE_MODEM__)
+ spc_sendRampDoneAck(SAL_RAMP_UL_POS_EN);
+#endif
+ }
+}
+
+void spc_gain_DlMuteSet(kal_bool on, kal_bool byPassCheck)
+{
+ if(IS_SPC_APP_USED(SPC_APP_MERGE_SPH_USAGE)
+ || IS_SPC_APP_USED(SPC_APP_SPEECH_USAGE)
+ || IS_SPC_APP_USED(SPC_APP_PCMROUTER_USAGE)
+ || KAL_TRUE == byPassCheck){
+ gSpc.spcMuteDl = on;
+ L1SP_MuteSpeaker(on);
+ } else {
+ MD_TRC_SPC_SET_DROP_DL_MUTE();
+#if defined(__SMART_PHONE_MODEM__)
+ spc_sendRampDoneAck(SAL_RAMP_DL_PRE_DACA);
+#endif
+ }
+}
+
+void spc_gain_UlSourceMuteSet(kal_bool on, kal_bool byPassCheck)
+{
+ if(IS_SPC_APP_USED(SPC_APP_MERGE_SPH_USAGE)
+ ||IS_SPC_APP_USED(SPC_APP_SPEECH_USAGE)
+ || IS_SPC_APP_USED(SPC_APP_PCMROUTER_USAGE)
+ || KAL_TRUE == byPassCheck) {
+ gSpc.spcMuteUlSource = on;
+ SP_MuteUlSource(on);
+ } else {
+ MD_TRC_SPC_SET_DROP_UL_SOURCE_MUTE();
+#if defined(__SMART_PHONE_MODEM__)
+ spc_sendRampDoneAck(SAL_RAMP_UL_PRE_EN);
+#endif
+ }
+}
+
+/**
+ run under AUDL/MED, when process message "MSG_ID_AUDIO_M2M_RAMP_DONE"
+*/
+
+void spc_sendRampDoneAck(uint16 ramp_point)
+{
+ MD_TRC_SPC_MUTE_DSP_RAMP_ACK_POINT(gSpc.spcRampAck, ramp_point);
+ if(!IS_SPC_RAMP_WAIT_ACK(ramp_point)) {
+ MD_TRC_SPC_MUTE_DSP_RAMP_NO_ACK();
+ return;
+ }
+ CLR_SPC_RAMP_WAIT_ACK(ramp_point);
+ switch(ramp_point){
+ case SAL_RAMP_UL_POS_EN:
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_MUTE_SPH_UL_ACK, 0, 0);
+ break;
+ case SAL_RAMP_UL_PRE_EN:
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_MUTE_SPH_UL_SOURCE_ACK, 0, 0);
+ break;
+ case SAL_RAMP_DL_PRE_DACA:
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_MUTE_SPH_DL_ACK, 0, 0);
+ break;
+ case SAL_RAMP_DL_PRE_MIXER2:
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_MUTE_SPH_DL_DYNAMIC_ACK, 0, 0);
+ break;
+ default:
+ ASSERT(0);
+ }
+}
+void spc_gain_DlMuteCodecSet(kal_bool on, kal_bool byPassCheck)
+{
+ if(IS_SPC_APP_USED(SPC_APP_MERGE_SPH_USAGE)
+ ||IS_SPC_APP_USED(SPC_APP_SPEECH_USAGE)
+ || IS_SPC_APP_USED(SPC_APP_PCMROUTER_USAGE)
+ || KAL_TRUE == byPassCheck) {
+ L1SP_SetCodecMuteByAp(on);
+ } else {
+ MD_TRC_SPC_SET_DROP_DL_CODEC_MUTE();
+ }
+}
+
+void spc_gain_DlMuteSet_PrePcmMixer(kal_bool on, kal_bool byPassCheck)
+{
+ if(IS_SPC_APP_USED(SPC_APP_MERGE_SPH_USAGE)
+ || IS_SPC_APP_USED(SPC_APP_SPEECH_USAGE)
+ || IS_SPC_APP_USED(SPC_APP_PCMROUTER_USAGE)
+ || KAL_TRUE == byPassCheck) {
+ SP_MuteDl_beforePcmMixer(on);
+ } else {
+ MD_TRC_SPC_SET_DROP_DL_MUTE_WITH_POS();
+#if defined(__SMART_PHONE_MODEM__)
+ spc_sendRampDoneAck(SAL_RAMP_DL_PRE_MIXER2);
+#endif
+ }
+}
+
+
+// ----------------------------------------------------------------------------
+// Device Related Setting
+// ----------------------------------------------------------------------------
+
+void spc_dev_SamplingRateSet(kal_uint16 sampleRate)
+{
+ switch(sampleRate){
+ case 0:
+ AFE_SetVoice8KMode(2); //default 32000, case 0: reset
+ break;
+ case 8000:
+ AFE_SetVoice8KMode(0);
+ break;
+ case 16000:
+ AFE_SetVoice8KMode(1);
+ break;
+ case 32000:
+ AFE_SetVoice8KMode(2);
+ break;
+ case 48000:
+ AFE_SetVoice8KMode(3);
+ break;
+ default:
+ ASSERT(0);
+ }
+}
+
+// ----------------------------------------------------------------------------
+// AUDL running functions Related
+// ----------------------------------------------------------------------------
+
+void spc_A2M_MsgHandler(kal_uint32 ccciMsg, kal_uint32 ccciResv, SPC_MSG_FROM_T comeFrom)
+{
+ kal_uint16 cmd, msgData16;
+ kal_uint16 msgData32;
+ uint16 type16 = 0;
+
+ cmd = SPCIO_CCCI_MSG_CMD(ccciMsg);
+ msgData16 = SPCIO_CCCI_MSG_DATA16(ccciMsg);
+ msgData32 = ccciResv;
+
+ switch(cmd){
+ case MSG_A2M_SPH_DL_DIGIT_VOLUME:
+ spc_gain_DlDigiGainSet(msgData16);
+ break;
+ case MSG_A2M_SPH_UL_DIGIT_VOLUME:
+ spc_gain_UlDigiGainSet(msgData16);
+ break;
+ case MSG_A2M_MUTE_SPH_UL:
+ SET_SPC_RAMP_WAIT_ACK(SAL_RAMP_UL_POS_EN);
+ spc_gain_UlMuteSet( (kal_bool)(msgData16&1), KAL_FALSE);
+ break;
+ case MSG_A2M_MUTE_SPH_DL:
+ SET_SPC_RAMP_WAIT_ACK(SAL_RAMP_DL_PRE_DACA);
+ spc_gain_DlMuteSet( (kal_bool)(msgData16&1), KAL_FALSE);
+ break;
+ // case MSG_A2M_SIDETONE_VOLUME: break;
+ case MSG_A2M_SPH_DL_ENH_REF_DIGIT_VOLUME:
+ spc_gain_DlEnhRefDigiGainSet(msgData16);
+ break;
+ // case MSG_A2M_SIDETONE_CONFIG: break;
+ case MSG_A2M_MUTE_SPH_UL_ENH_RESULT:
+ // spc_gain_UlEnhResultMuteSet((kal_bool)(msgData16&1), KAL_FALSE);
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_MUTE_SPH_UL_ENH_RESULT_ACK, 0, 0);
+ break;
+ case MSG_A2M_MUTE_SPH_UL_SOURCE:
+ SET_SPC_RAMP_WAIT_ACK(SAL_RAMP_UL_PRE_EN);
+ spc_gain_UlSourceMuteSet((kal_bool)(msgData16&1), KAL_FALSE);
+ break;
+ case MSG_A2M_MUTE_SPH_DL_CODEC:
+ spc_gain_DlMuteCodecSet((kal_bool)(msgData16&1), KAL_FALSE);
+ break;
+ case MSG_A2M_MUTE_SPH_DL_DYNAMIC:
+ SET_SPC_RAMP_WAIT_ACK(SAL_RAMP_DL_PRE_MIXER2);
+ spc_gain_DlMuteSet_PrePcmMixer((kal_bool)(msgData16&1), KAL_FALSE);
+ break;
+
+ // --------- [0x10] device related -----------
+ case MSG_A2M_SET_SAMPLE_RATE:
+ spc_dev_SamplingRateSet(msgData16);
+ break;
+ // case MSG_A2M_SET_DUAL_MIC: break;
+ case MSG_A2M_SET_LPBK_POINT_DVT:
+ spc_dev_LoopbackPoint_DVT(msgData16);
+ break;
+
+ // --------- [0x20] speech control -----------
+ case MSG_A2M_SPH_ON:
+ {
+ if(SPC_MSG_FROM_CCCI_STREAM == comeFrom) {
+ type16 = Spc_SpeechOn_withData((kal_uint16)msgData32, msgData16, comeFrom);
+ } else {
+ Spc_SpeechOn((kal_uint8) msgData16);
+ }
+
+#if defined(__ECALL_SUPPORT__)
+ spc_eCall_SDT_Open();
+#endif
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_SPH_ON_ACK, type16, 0);
+ }
+ break;
+ case MSG_A2M_SPH_OFF:
+ {
+#if defined(__ECALL_SUPPORT__)
+ spc_eCall_SDT_Close();
+#endif
+ // Spc_SpeechOff();
+ Spc_SpeechOff_Merge();
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_SPH_OFF_ACK, 0, 0);
+ }
+ break;
+ case MSG_A2M_SET_SPH_MODE:
+ {
+ // Spc_SetSpeechEnhMode_Adaptation( (kal_uint8) msgData16 );
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_SET_SPH_MODE_ACK, msgData16, 0);
+ }
+ break;
+ case MSG_A2M_CTRL_SPH_ENH:
+ {
+ // add condition checking when turn speech enhancment on/off
+ if(IS_SPC_APP_USED(SPC_APP_HOSTED_USAGE)) {
+ MD_TRC_SPC_DROP_SET(ccciMsg, cmd, cmd, msgData16, msgData32);
+ } else {
+ L1SP_EnableSpeechEnhancement((msgData16!=0));
+ }
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_CTRL_SPH_ENH_ACK, msgData16, 0);
+ }
+ break;
+ case MSG_A2M_CONFIG_SPH_ENH:
+ {
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_CONFIG_SPH_ENH_ACK, msgData16, 0);
+ }
+ break;
+ case MSG_A2M_SET_ACOUSTIC_LOOPBACK:
+ {
+#if defined(__ENABLE_SPEECH_DVT__)
+ Spc_PCMNWay_DVT_Test((kal_uint8) msgData16 );
+#else // defined(__ENABLE_SPEECH_DVT__)
+ Spc_AcousticLoopback((msgData16&1), (kal_uint8)(msgData16>>1), (kal_uint8)(msgData32&0xff));
+#endif // defined(__ENABLE_SPEECH_DVT__)
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_SET_ACOUSTIC_LOOPBACK_ACK, msgData16, msgData32);
+ }
+ break;
+ case MSG_A2M_PRINT_SPH_COEFF:
+ {
+ spc_DebugPrint();
+ // ack is: SPCIO_MSG_FROM_SPC_PRINT_SPH_COEFF_ACK --> MSG_M2A_PRINT_SPH_COEFF_ACK
+ }
+ break;
+ case MSG_A2M_SPH_ON_FOR_HOLD_CALL:
+ {
+ // [REMIND] No application can be on under this application
+ spc_SpeechOnForCallHold((msgData16 == 1)); // bit 0, 0 for off, 1 for on
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_SPH_ON_FOR_HOLD_CALL_ACK, 0, 0);
+ }
+ break;
+ case MSG_A2M_SPH_ON_FOR_DACA:
+ {
+ Spc_SpeechOnForDaca((kal_uint8) msgData16, (kal_bool)(msgData16 >> 8));
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_SPH_ON_FOR_DACA_ACK, msgData16, 0);
+ }
+ break;
+
+ case MSG_A2M_SPH_ROUTER_ON:
+ {
+ Spc_SpeechRouterOn((msgData16&1)==1);
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_SPH_ROUTER_ON_ACK, msgData16, 0);
+ }
+ break;
+ case MSG_A2M_SET_VOICE_ENCRYPTION:
+ {
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_SET_VOICE_ENCRYPTION_ACK, msgData16, 0);
+ }
+ break;
+ case MSG_A2M_SPH_DEV_CHANGE:
+ {
+ type16 = Spc_SpeechDeviceChange((kal_uint16)msgData32, msgData16, comeFrom);
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_SPH_DEV_CHANGE_ACK, type16, 0);
+ }
+ break;
+ case MSG_A2M_ENH_CTRL_SUPPORT:
+ {
+ L1SP_EnhancementCtrlSupport(msgData16);
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_ENH_CTRL_SUPPORT_ACK, type16, 0);
+ }
+ break;
+ // --------- [0x30] speech control -----------
+ case MSG_A2M_PNW_ON: // normal use always narrow band/decided by network
+ {
+ spc_PcmNWayStart(msgData16, SPC_PCMNWAY_FORMAT_UNSET) ; // , SPC_PCMNWAY_APP_TYPE_UNSET);
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_PNW_ON_ACK, msgData16, 0);
+ // SPCIO_CCCI_MSG_CONSTRCUT_CMD(MSG_M2A_PNW_ON_ACK, msgData16));
+ }
+ break;
+ case MSG_A2M_PNW_OFF:
+ {
+ spc_PcmNWayStop();
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_PNW_OFF_ACK, msgData16, 0);
+ // SPCIO_CCCI_MSG_CONSTRCUT_CMD(MSG_M2A_PNW_OFF_ACK, msgData16));
+ }
+ break;
+/*
+ case MSG_A2M_RECORD_ON: // spc_RecordStart
+ break;
+ case MSG_A2M_RECORD_OFF: // spc_RecordStop
+ break;
+ case MSG_A2M_DMNR_RECPLAY_ON:
+ break;
+ case MSG_A2M_DMNR_RECPLAY_OFF:
+ break;
+ case MSG_A2M_DMNR_REC_ONLY_ON:
+ break;
+ case MSG_A2M_DMNR_REC_ONLY_OFF:
+ break;
+ case MSG_A2M_PCM_REC_ON: // spc_PcmRecordStart
+ break;
+ case MSG_A2M_PCM_REC_OFF: // spc_PcmRecordStop
+ break;
+*/
+ case MSG_A2M_VM_REC_ON:
+ {
+ spc_VmRecordStart();
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_VM_REC_ON_ACK, msgData16, 0);
+ }
+ break;
+ case MSG_A2M_VM_REC_OFF:
+ {
+ spc_VmRecordStop();
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_VM_REC_OFF_ACK, msgData16, 0);
+ }
+ break;
+ case MSG_A2M_RECORD_RAW_PCM_ON:
+ {
+ // data16 bit[0:3] is position info
+ spc_RawPcmRecordStart((kal_uint8)(msgData16&0xF));
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_RECORD_RAW_PCM_ON_ACK, msgData16, 0);
+ }
+ break;
+ case MSG_A2M_RECORD_RAW_PCM_OFF:
+ {
+ spc_RawPcmRecordStop();
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_RECORD_RAW_PCM_OFF_ACK, msgData16, 0);
+ }
+ break;
+ case MSG_A2M_PCMMIXER_ON:
+ {
+ //bit 0: isDlMix: 0 is replace, 1 is mix
+ //bit 2: isUlMix: 0 is replace, 1 is mix
+ spc_PCMMixerStart((msgData16&4)==4, (msgData16&1)==1, 0, 7);
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_PCMMIXER_ON_ACK, msgData16, 0);
+ }
+ break;
+ case MSG_A2M_PCMMIXER_OFF:
+ {
+ spc_PCMMixerStop();
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_PCMMIXER_OFF_ACK, msgData16, 0);
+ }
+ break;
+ case MSG_A2M_TELEPHONY_TX_ON:
+ {
+ //bit 0: isUlMix: 0 is replace, 1 is mix
+ spc_PCMMixer3Start(msgData16&1, 7);
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_PCMMIXER3_ON_ACK, msgData16, 0);
+ }
+ break;
+ case MSG_A2M_TELEPHONY_TX_OFF:
+ {
+ spc_PCMMixer3Stop();
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_PCMMIXER3_OFF_ACK, msgData16, 0);
+ }
+ break;
+ // --------- [0x40] other control function -----------
+#ifdef __CTM_SUPPORT__
+ case MSG_A2M_CTM_ON:
+ spc_CtmStart(msgData16);
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_CTM_ON_ACK, msgData16, 0);
+ break;
+ case MSG_A2M_CTM_OFF:
+ spc_CtmStop();
+ //SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_CTM_OFF_ACK, msgData16, 0);
+ break;
+ case MSG_A2M_CTM_DUMP_DEBUG_FILE:
+ spc_CtmDebugConfig(msgData16!=0);
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_CTM_DUMP_DEBUG_FILE_ACK, msgData16, 0);
+ break;
+#endif // __CTM_SUPPORT__
+
+ case MSG_A2M_BGSND_ON:
+ spc_BgSndStart();
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_BGSND_ON_ACK, msgData16, 0);
+ break;
+ case MSG_A2M_BGSND_OFF:
+ spc_BgSndStop();
+ // SpcIO_SendMsgToAp( SPCIO_MSG_FROM_SPC_BGSND_OFF_ACK, msgData16, 0);
+ break;
+ case MSG_A2M_BGSND_CONFIG:
+ // msgData16, [15:8] ulGainLevel from 0 ~ 255, [7:0] dlGainLevel from 0 ~ 255
+ // we mapping the value into 0~7 levels. so right shift 5
+ // spc_BgSndConfig((msgData16>>8)>>5, (msgData16&0xff)>>5);
+ spc_BgSndConfig((msgData16>>13), ((msgData16&0xff)>>5));
+ break; // SPCIO_MSG_FROM_SPC_BGSND_CONFIG_ACK-- > MSG_M2A_BGSND_CONFIG_ACK
+ case MSG_A2M_RTT_CONFIG:
+ spc_RttConfig(msgData16);
+ break;
+ case MSG_A2M_PCMMIXER_CONFIG:
+ //bit 0: isDlMix: 0 is replace, 1 is mix
+ //bit 2: isUlMix: 0 is replace, 1 is mix
+ spc_PCMMixerConfig((msgData16&4)==4,(msgData16&1)==1,0,7);
+ break;
+ case MSG_A2M_TELEPHONY_TX_CONFIG:
+ //bit 0: isDlMix: 0 is replace, 1 is mix
+ spc_PCMMixer3Config((msgData16&1)==1,7);
+ break;
+ // --------- [0x50] Recevie DATA notify -----------
+ case MSG_A2M_PNW_DLDATA_NOTIFY:
+ spc_pcmNWay_writeDlDataDone((kal_uint16)msgData32, msgData16, comeFrom);
+ break;
+ case MSG_A2M_BGSND_DATA_NOTIFY:
+ spc_bgSnd_writeDataDone( (kal_uint16)msgData32, msgData16, comeFrom);
+ break;
+ case MSG_A2M_CTM_DATA_NOTIFY: break;
+ case MSG_A2M_DACA_UL_DATA_NOTIFY:
+ spc_daca_writeUlDataDone((kal_uint16)msgData32, msgData16, comeFrom);
+ break;
+ // MSG_A2M_ECALL_MSD,
+ // MSG_A2M_SPC_UL_ENC,
+ // MSG_A2M_SPC_DL_DEC,
+ case MSG_A2M_PCMMIXER_DLDATA_NOTIFY:
+ spc_PCMMixer_writeDlDataDone((kal_uint16)msgData32, msgData16, comeFrom);
+ break;
+ case MSG_A2M_PCMMIXER_ULDATA_NOTIFY:
+ break;
+ case MSG_A2M_TELEPHONY_TX_ULDATA_NOTIFY:
+ spc_PCMMixer3_writeUlDataDone((kal_uint16)msgData32, msgData16, comeFrom);
+ break;
+ // --------- [0x60] Send DATA Ack ---------------
+ case MSG_A2M_PNW_ULDATA_READ_ACK:
+ spc_pcmNWay_sendUlDataDone();
+ break;
+ case MSG_A2M_REC_DATA_READ_ACK: // removed from 93md
+ // spc_record_sendMicDataDone();
+ break;
+#ifdef __CTM_SUPPORT__
+ case MSG_A2M_CTM_DEBUG_DATA_READ_ACK:
+ spc_ctm_sendDumpDebugDataDone();
+ break;
+#endif
+ case MSG_A2M_PCM_REC_DATA_READ_ACK: // removed from 93md
+ // spc_pcmRec_sendMicDataDone();
+ break;
+ case MSG_A2M_VM_REC_DATA_READ_ACK:
+ spc_vmRec_sendMicDataDone();
+ break;
+ case MSG_A2M_DACA_DL_DATA_READ_ACK:
+ spc_daca_sendDlDataDone();
+ break;
+ case MSG_A2M_RAW_PCM_REC_DATA_READ_ACK:
+ spc_RawPcmRec_sendDataDone();
+ break;
+
+ // --------- [0x70] EM related --------------------
+ // case MSG_A2M_EM_INCALL: break;
+ // case MSG_A2M_EM_DMNR: break;
+ // case MSG_A2M_EM_WB: break;
+ // case MSG_A2M_EM_MAGICON: break;
+ case MSG_A2M_NETWORK_STATUS_ACK:
+ break;
+/*
+ case MSG_A2M_QUERY_RF_INFO:
+ // spc_notify_rf_info();
+ break;
+ case MSG_A2M_EM_HAC:
+ break;
+*/
+ case MSG_A2M_DYNAMIC_PAR:
+
+#if defined(_SPE_ENH_MD_PARSE_)
+ type16 = spc_ReceiveDynamicParameter((kal_uint16)msgData32, msgData16, comeFrom);
+#endif
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_DYNAMIC_PAR_ACK, type16, 0 );
+ break;
+ case MSG_A2M_SPH_ENH_CORE:
+ // use for OPEN DSP??
+ break;
+ case MSG_A2M_DYNAMIC_PAR_IN_STRUCT_SHM:
+
+#if defined(_SPE_ENH_MD_PARSE_)
+ type16 = spc_ReceiveDynamicParameter_viaStructShm((kal_uint16)msgData32, msgData16, comeFrom);
+#else // for 95,97
+ spc_ReceiveEMIParInfo(msgData32, msgData16, comeFrom);
+#endif
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_DYNAMIC_PAR_IN_STRUCT_SHM_ACK, type16, 0 );
+ break;
+
+
+ // --------- [0x80] New feature data related --------------------
+ case MSG_A2M_VIBSPK_PARAMETER:
+ spc_ReceiveViberationSpkParameter((kal_uint16)msgData32, msgData16, comeFrom);
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_VIBSPK_PARAMETER_ACK, 0, 0 );
+ break;
+
+ case MSG_A2M_NXP_SMARTPA_PARAMETER:
+ spc_ReceiveNxpSmartPaParameter((kal_uint16)msgData32, msgData16, comeFrom);
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_NXP_SMARTPA_PARAMETER_ACK, 0, 0 );
+ break;
+
+ // --------- [0x90] New feature data related --------------------
+ case MSG_A2M_NW_CODEC_INFO_READ_ACK:
+ spc_ReceiveNwCodecInfoReadDone();
+ break;
+
+ // --------- [0xA0] Alive related --------------------
+ case MSG_A2M_AUD_ALIVE_READ_ACK:
+ break;
+
+
+ // --------- [0xB0] Telematics feature --------------------
+ case MSG_A2M_IVS_SWITCH:
+#if defined(__ECALL_SUPPORT__)
+ if(msgData16 == 1)
+ {
+ spc_eCall_IVS_Open();
+ }
+ else if(msgData16 == 0)
+ {
+ spc_eCall_IVS_Close();
+ }
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_IVS_SWITCH_ACK, 0, 0);
+#endif
+ break;
+ case MSG_A2M_PSAP_SWITCH:
+#if defined(__ECALL_SUPPORT__)
+ if(msgData16 == 1)
+ {
+ spc_eCall_PSAP_Open();
+ }
+ else if(msgData16 == 0)
+ {
+ spc_eCall_PSAP_Close();
+ }
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_PSAP_SWITCH_ACK, 0, 0);
+#endif
+ break;
+ case MSG_A2M_IVS_SEND:
+#if defined(__ECALL_SUPPORT__)
+ eCall_IVS_SendStart();
+#endif
+ break;
+ case MSG_A2M_PSAP_SEND:
+#if defined(__ECALL_SUPPORT__)
+ eCall_PSAP_SendStart();
+#endif
+ break;
+ case MSG_A2M_ECALL_CTL_SEQ_SWITCH:
+#if defined(__ECALL_SUPPORT__)
+ Set_eCall_Par_Crtl_Switch((kal_uint8)msgData16);
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_ECALL_CTL_SEQ_SWITCH_ACK, 0, 0);
+#endif
+ break;
+
+#if defined(__ECALL_SUPPORT__)
+ case MSG_A2M_ECALL_MSD:
+ spc_eCall_Msd_Data((kal_uint16)msgData32, msgData16,comeFrom);
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_MSD_DATA_ACK, 0, 0);
+ break;
+#endif
+ case MSG_A2M_ECALL_TX_CTRL_PAR:
+#if defined(__ECALL_SUPPORT__)
+ spc_eCall_TX_CTRL_Data((kal_uint16)msgData32, msgData16,comeFrom);
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_ECALL_TX_CTRL_PAR_ACK, 0, 0);
+#endif
+ break;
+ case MSG_A2M_ECALL_RX_CTRL_PAR:
+#if defined(__ECALL_SUPPORT__)
+#endif
+ break;
+
+ default:
+ if(SPC_MSG_FROM_CCCI == comeFrom)
+ SpcIO_unknownMsgAckToAp(cmd, 0, 0);
+ MD_TRC_SPCIO_INVALID_MSG(SPC_ID_AUDIO_A2M_CCCI, ccciMsg, ccciResv);
+
+ }
+}
+
+
+// ----------------------------------------------------------------------------
+// Init Related
+// ----------------------------------------------------------------------------
+
+#ifndef TK6291_FAKE_COMPILE
+extern unsigned short L1D_Audio_ChkDspInitDone();
+#endif //#ifndef TK6291_FAKE_COMPILE
+/**
+ Function owner is EL1.
+ @return: true all rat init done, else is false
+*/
+/*
+#ifndef TK6291_FAKE_COMPILE
+extern kal_bool MML1_RF_CHECK_RF_INIT_STATUS(void);
+#endif //#ifndef TK6291_FAKE_COMPILE
+*/
+
+void Spc_Init_B4_Scheduling(void)
+{
+ // all data inside gSpc are 0 when boot up
+ gSpc.spcGetEpofTimes = 0;
+
+ // ====== Initial needed by other application =======
+ //background sound
+ gSpc_bgSnd.ulGainLevel = 5;
+ gSpc_bgSnd.dlGainLevel = 5;
+}
+
+void Spc_Init(void) {
+
+ /*
+ // for MT6752 MD1, due to RF K needs 1.5 second, please wait for it.
+#if (defined(MT6752) && defined (__MD1__)) || defined(MT6595) || defined(MT6735)
+ #ifndef TK6291_FAKE_COMPILE
+ while( false == MML1_RF_CHECK_RF_INIT_STATUS()) {
+ MD_TRC_SPC_AUDIOTASK_WAIT_EL1_RF_INIT(tick);
+ kal_sleep_task( AUD_1TICK(1) );
+ tick++;
+ }
+ #endif //#ifndef TK6291_FAKE_COMPILE
+#endif
+ */
+ gSpc_acLoopback.isLoopback = 0; // set loopback state = 0
+ // ----------------------
+#if SPC_CUST_ENH
+ // add IDs for DV process
+ DV_dl_audioid = L1Audio_GetAudioID();
+ L1Audio_SetEventHandler(DV_dl_audioid, (L1Audio_EventHandler)DV_DL_process);
+ DV_ul_audioid = L1Audio_GetAudioID();
+ L1Audio_SetEventHandler(DV_ul_audioid, (L1Audio_EventHandler)DV_UL_process);
+#endif
+ #if defined(__ECALL_SUPPORT__)
+ gSpc.eCall_Ctrl_Seq_Switch = 0;
+ spc_Set_Ecall_Lib_Status(SPC_ECALL_DISABLE);
+ memset(eCall_Msd, 0, 140*sizeof(kal_uint8));
+ #endif
+}
+
+
+kal_bool spc_endApp(void)
+{
+ kal_bool isAppOn=false;
+
+ if(IS_SPC_APP_USED(SPC_APP_PCMNWAY_USAGE)) {
+ spc_PcmNWayStop();
+ isAppOn=true;
+ }
+
+#if 0
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+#endif
+
+ if(IS_SPC_APP_USED(SPC_APP_BGSND_USAGE)) {
+ if(EXT_SRC_STATE_RUN == EXT_BGSND_GetStatus(gSpc_bgSnd.id, BGSND_DL_PROCESS) ){
+ // force close without ack
+ spc_BgSndForceClose();
+
+ } else if (EXT_SRC_STATE_FLUSHING == EXT_BGSND_GetStatus(gSpc_bgSnd.id, BGSND_DL_PROCESS)
+ || EXT_SRC_STATE_FLUSHING_OVER == EXT_BGSND_GetStatus(gSpc_bgSnd.id, BGSND_DL_PROCESS)) {
+ // AP has send close request, as the result we need to send ack to AP
+ spc_BgSndClose();
+ } // else is idle
+ isAppOn=true;
+ }
+
+
+ if(IS_SPC_APP_USED(SPC_APP_CTM_USAGE)) {
+#ifdef __CTM_SUPPORT__
+ spc_CtmStop();
+#endif
+ isAppOn=true;
+ }
+
+#if 0
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+#endif
+
+ if(IS_SPC_APP_USED(SPC_APP_VM_REC_USAGE)) {
+ spc_VmRecordStop();
+ isAppOn=true;
+ }
+
+ if(IS_SPC_APP_USED(SPC_APP_RAW_PCM_REC_USAGE)) {
+ spc_RawPcmRecordStop();
+ isAppOn=true;
+ }
+
+ return isAppOn;
+}
+void Spc_ForceEndAllApp(void) // AP send ETOF to MD L4C. L4C will send ILM to MED and invoke this function
+{
+ kal_bool is_factory_mode = SpcIO_isFactoryBoot();
+ gSpc.spcGetEpofTimes |= ENUM_EPOF_DO_FORCEENDALLAPP;
+
+ MD_TRC_SPC_EPOF_NOTIFY(gSpc.spcAppUsage);
+
+ SP_DSPTone_ForceEnd();
+
+ spc_endApp();
+
+ // main app
+ if(IS_SPC_APP_USED(SPC_APP_SPEECH_USAGE)) {
+ // Spc_SpeechOff();
+ Spc_SpeechOff_Merge();
+ }
+
+ if(IS_SPC_APP_USED(SPC_APP_PCMROUTER_USAGE)) {
+ Spc_SpeechRouterOn(false);
+ }
+#if defined( __SMART_PHONE_MODEM__ )
+ if(is_factory_mode != true)
+ {
+ SpcIO_SendMsgToAp(SPCIO_MSG_FROM_SPC_EPOF_NOTIFY, (kal_uint16)0, 0);
+ MD_TRC_SPC_EPOF_SPC_FORCEENDALLAPP_NOTIFY_AP();
+ }
+#endif //#if defined( __SMART_PHONE_MODEM__ )
+ if(is_factory_mode == true)
+ {
+ //Notify L4C: speech driver enter EPOF done
+ msg_send6(MOD_MED, MOD_L4C, AUDIO_SAP, MSG_ID_AUDIO_L4C_EPOF_ACK, (local_para_struct *)NULL, NULL);
+ kal_prompt_trace(MOD_L1SP, "[EPOF]Spc_ForceEndAllApp notify L4C done at factory mode");
+ }
+
+}
+
+#if defined(_SPE_ENH_MD_PARSE_)
+
+spcDynParNBData NBParData;
+spcDynParNBData_V10 NBParData_v10; //need remove later
+spcDynParWBData WBParData;
+spcDynParSWBData SWBParData;
+spcDynParNBIIRData NBIIRParData;
+spcDynParWBIIRData WBIIRParData;
+spcDynParSWBIIRData SWBIIRParData;
+
+kal_uint16 spc_dynamicParameterParser_volInUnit(AUD_SPC_DYNAMIC_PARAM_MAGICNUM_T unit,
+ const kal_uint16 offset, const kal_uint16 length, SPC_MSG_FROM_T comeFrom,
+ kal_uint16 *procLen)
+{
+ kal_uint16 curOffset;
+ kal_uint16 Data_Header;
+
+ kal_uint16 tempProclen = 0;
+
+ MD_TRC_SPC_SPE_RECEIVEDYNAMICPARAMETER(unit, length, comeFrom);
+
+ kal_prompt_trace(MOD_L1SP, "where am I? %x", offset);
+ curOffset = SpcIo_GetDataFromAp(offset, sizeof(Data_Header), &Data_Header, comeFrom);
+ tempProclen += sizeof(Data_Header);
+
+ kal_prompt_trace(MOD_L1SP, "where am I?? %x", curOffset);
+
+ if((Data_Header&0x0F) == 0xF)
+ {
+ switch(unit) {
+ case Vol_in_general_unit:
+ {
+ spcCommonData *CommonParData;
+ uint16 *m_para; // debug print
+
+ CommonParData = (spcCommonData *)emDataBuf;
+ // reuse the emDataBuf to get data
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(spcCommonData), CommonParData, comeFrom);
+ tempProclen += sizeof(spcCommonData);
+
+ L1SP_LoadCommonSpeechPara(CommonParData->Common_Para);
+
+ // debug Print
+ m_para = CommonParData->Common_Para; // size NUM_COMMON_PARAS
+ MD_TRC_L1SP_COMMON_PARAM_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11]);
+
+ L1Audio_SetDebugInfo(CommonParData->Debug_info_para);
+ VMREC_ConfigEpl();
+ spc_dev_LoopbackPoint_DVT(CommonParData->Debug_info_para[15]);
+
+ // debug Print
+ m_para = CommonParData->Debug_info_para;
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+
+ SET_SPC_EM_INIT(SPC_EM_INIT_COMMON);
+ }
+ break;
+ case Vol_in_MagiClarity:
+ {
+ spcMagiClarityData *MagiClarityData;
+ MagiClarityData = (spcMagiClarityData *)emDataBuf;
+
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(spcMagiClarityData), MagiClarityData, comeFrom);
+ tempProclen += sizeof(spcMagiClarityData);
+
+ // L1SP_MagiClarityData(MagiClarityData->MagiClarity_Para);
+
+ }
+ break;
+ case Vol_in_echoRefforUsbAudio:
+ {
+ spcDynParEchoRefForUsbAudio_T *usbAudioParam;
+ usbAudioParam = (spcDynParEchoRefForUsbAudio_T *)(&emDataBuf); //buffer reuse
+
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(spcDynParEchoRefForUsbAudio_T), usbAudioParam, comeFrom);
+ tempProclen += sizeof(spcDynParEchoRefForUsbAudio_T);
+
+ // [remove]
+ // SPE_SetEchoRefInfo(usbAudioParam->isEchoRefForUsbAudioOn, usbAudioParam->mic_index, usbAudioParam->chip_delay_with_switch, SPH_MODE_USB);
+ }
+ break;
+ default:
+ break;
+ }
+
+
+ }
+ else
+ {
+ MD_TRC_SPC_SPE_ASSERT_CHECK(Data_Header,unit,0);
+ ASSERT(0); // Not support the Header
+ }
+
+ *procLen = tempProclen;
+ return curOffset;
+
+}
+
+kal_uint16 spc_dynamicParameterParser_dmnrUnit(spcDynParHeader *Header,
+ const kal_uint16 offset, const kal_uint16 length, SPC_MSG_FROM_T comeFrom,
+ kal_uint16 *procLen)
+{
+ kal_uint16 DynamicParCount;
+ kal_uint16 i;
+ kal_uint16 Data_Header;
+ kal_uint16 curOffset = offset;
+ kal_uint16 tempProclen = 0;
+
+ int16 *m_para; // debug print
+
+ // kal_trace( TRACE_FUNC,SPC_SPE_RECEIVEDYNAMICPARAMETER4);
+ MD_TRC_SPC_SPE_RECEIVEDYNAMICPARAMETER(Vol_in_DMNR, length, comeFrom);
+ DynamicParCount = (((Header->NumEachLayer)&0xF0)>>4) * ((Header->NumEachLayer)&0x0F);
+
+
+ for(i=0;i<DynamicParCount;i++)
+ {
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(Data_Header), &Data_Header, comeFrom);
+ tempProclen += sizeof(Data_Header);
+ MD_TRC_SPC_SPE_DMNR_HEADER(Data_Header);
+ if(Data_Header==Header_DMNR_NB_REC)
+ {
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(DMNR_NB_REC), &DMNR_NB_REC, comeFrom);
+ tempProclen += sizeof(DMNR_NB_REC);
+ L1SP_SetDMNRPara(DMNR_NB_REC);
+ SET_SPC_EM_INIT(SPC_EM_INIT_DMNR);
+
+ m_para = DMNR_NB_REC;
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_NB_REC[16]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_NB_REC[32]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], 0,0,0,0);
+
+ }
+ else if(Data_Header == Header_DMNR_WB_REC)
+ {
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(DMNR_WB_REC), &DMNR_WB_REC, comeFrom);
+ tempProclen += sizeof(DMNR_WB_REC);
+ L1SP_SetWbDMNRPara(DMNR_WB_REC);
+ SET_SPC_EM_INIT(SPC_EM_INIT_DMNR);
+
+ m_para = DMNR_WB_REC;
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_WB_REC[16]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_WB_REC[32]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_WB_REC[48]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_WB_REC[64]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], 0,0,0,0);
+ }
+ else if(Data_Header == Header_DMNR_NB_LSP)
+ {
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(DMNR_NB_LoudSpk), &DMNR_NB_LoudSpk, comeFrom);
+ tempProclen += sizeof(DMNR_NB_LoudSpk);
+ L1SP_SetLSpkDMNRPara(DMNR_NB_LoudSpk);
+ SET_SPC_EM_INIT(SPC_EM_INIT_LSPK_DMNR);
+
+ m_para = DMNR_NB_LoudSpk;
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_NB_LoudSpk[16]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_NB_LoudSpk[32]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], 0,0,0,0);
+
+ }
+
+ else if(Data_Header == Header_DMNR_WB_LSP)
+ {
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(DMNR_WB_LoudSpk), &DMNR_WB_LoudSpk, comeFrom);
+ tempProclen += sizeof(DMNR_WB_LoudSpk);
+ L1SP_SetLSpkWbDMNRPara(DMNR_WB_LoudSpk);
+ SET_SPC_EM_INIT(SPC_EM_INIT_LSPK_DMNR);
+
+ m_para = DMNR_WB_LoudSpk;
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_WB_LoudSpk[16]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_WB_LoudSpk[32]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_WB_LoudSpk[48]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_WB_LoudSpk[64]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], 0,0,0,0);
+ }
+ else if((Data_Header == Header_DMNR_SWB_REC) )
+ {
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(DMNR_SWB_REC), &DMNR_SWB_REC, comeFrom);
+ tempProclen += sizeof(DMNR_SWB_REC);
+ L1SP_SetSWbDMNRPara(DMNR_SWB_REC);
+ SET_SPC_EM_INIT(SPC_EM_INIT_DMNR);
+ m_para = DMNR_SWB_REC;
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_SWB_REC[16]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_SWB_REC[32]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_SWB_REC[48]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_SWB_REC[64]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_SWB_REC[80]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_SWB_REC[96]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_SWB_REC[112]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], 0, 0,0,0, 0, 0, 0);
+ }
+ else if((Data_Header == Header_DMNR_SWB_LSP) )
+ {
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(DMNR_SWB_LoudSpk), &DMNR_SWB_LoudSpk, comeFrom);
+ tempProclen += sizeof(DMNR_SWB_LoudSpk);
+ L1SP_SetLSpkSWbDMNRPara(DMNR_SWB_LoudSpk);
+ SET_SPC_EM_INIT(SPC_EM_INIT_LSPK_DMNR);
+ m_para = DMNR_SWB_LoudSpk;
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_SWB_LoudSpk[16]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_SWB_LoudSpk[32]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_SWB_LoudSpk[48]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_SWB_LoudSpk[64]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_SWB_LoudSpk[80]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_SWB_LoudSpk[96]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], m_para[9], m_para[10], m_para[11], m_para[12], m_para[13], m_para[14], m_para[15]);
+ m_para = &(DMNR_SWB_LoudSpk[112]);
+ MD_TRC_L1SP_MODE_VALUE(m_para[0], m_para[1], m_para[2], m_para[3], m_para[4], m_para[5], m_para[6], m_para[7], m_para[8], 0, 0,0,0, 0, 0, 0);
+ }
+ else
+ {
+ MD_TRC_SPC_SPE_ASSERT_CHECK(Data_Header,Vol_in_DMNR,0);
+ ASSERT(0);//not support the dataheader
+ }
+ // SetSpeechEnhancement(false);
+ // SetSpeechEnhancement(true);
+ }
+
+
+ *procLen = tempProclen;
+ return curOffset;
+}
+
+
+kal_uint16 spc_dynamicParameterParser_volDeUnit_ver10(kal_uint16 DynamicParCount,
+ const kal_uint16 offset, const kal_uint16 length, SPC_MSG_FROM_T comeFrom,
+ kal_uint16 *procLen)
+{
+ kal_uint16 Data_Header;
+ kal_uint16 tempProclen = 0;
+ kal_uint16 curOffset = offset;
+
+ kal_uint16 i,Network,k;
+
+ for(i = 0 ; i < DynamicParCount ; i ++)
+ {
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(Data_Header), &Data_Header, comeFrom);
+ tempProclen += sizeof(Data_Header);
+
+ if(((Data_Header&0xF000)>>8)==NB_Par)
+ {
+
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(spcDynParNBData_V10), &NBParData_v10, comeFrom);
+ tempProclen += sizeof(spcDynParNBData_V10);
+
+ Network = (Data_Header&0x0FFF); // [bit0~bit11] bit0:GSM bit1:WCDMA bit2:CDMA bit3:VOLTE bit4:C2K
+ MD_TRC_SPC_SPE_CHECK_SPEECH_PAR_HEADER_FORMAT(Data_Header,Network);
+ if((Network>>12)==DONT_CARE_NETWORK)
+ {
+ for(k = 0; k < TOTAL_NETWORK_NUMBER; k++)
+ {
+ memcpy(Temp_speech_NB_Mode_para[k], NBParData_v10.speech_Mode_para, NUM_MODE_PARAS*sizeof(uint16)) ;
+ memcpy(Temp_speech_NB_FIR_IN_para[k], NBParData_v10.speech_NB_FIR_IN_para, 45*sizeof(uint16)) ;
+ memcpy(Temp_speech_NB_FIR_OUT_para[k], NBParData_v10.speech_NB_FIR_OUT_para, 45*sizeof(uint16)) ;
+ }
+ }
+ else
+ {
+ for(k = 0; k < TOTAL_NETWORK_NUMBER; k++)
+ {
+ if(((Network>>k)&0x1))
+ {
+ memcpy(Temp_speech_NB_Mode_para[k], NBParData_v10.speech_Mode_para, NUM_MODE_PARAS*sizeof(uint16)) ;
+ memcpy(Temp_speech_NB_FIR_IN_para[k], NBParData_v10.speech_NB_FIR_IN_para, 45*sizeof(uint16)) ;
+ memcpy(Temp_speech_NB_FIR_OUT_para[k], NBParData_v10.speech_NB_FIR_OUT_para, 45*sizeof(uint16)) ;
+ }
+ }
+ }
+
+ SET_SPC_EM_INIT(SPC_EM_INIT_NB);
+ }
+ else if((((Data_Header&0xF000)>>8)==WB_Par))
+ {
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(spcDynParWBData), &WBParData, comeFrom);
+ tempProclen += sizeof(spcDynParWBData);
+
+ Network = (Data_Header&0x0FFF); // [bit0~bit11] bit0:GSM bit1:WCDMA bit2:CDMA bit3:VOLTE bit4:C2K
+ MD_TRC_SPC_SPE_CHECK_SPEECH_PAR_HEADER_FORMAT(Data_Header,Network);
+ if((Network>>12)==DONT_CARE_NETWORK)
+ {
+ for(k = 0; k < TOTAL_NETWORK_NUMBER; k++)
+ {
+ memcpy(Temp_speech_WB_Mode_para[k], WBParData.speech_Mode_para, NUM_MODE_PARAS*sizeof(uint16)) ;
+ memcpy(Temp_speech_WB_FIR_IN_para[k], WBParData.speech_WB_FIR_IN_para, NUM_WB_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_WB_FIR_OUT_para[k], WBParData.speech_WB_FIR_OUT_para, NUM_WB_FIR_COEFFS*sizeof(uint16)) ;
+ }
+ }
+ else
+ {
+ for(k = 0; k < TOTAL_NETWORK_NUMBER; k++)
+ {
+ if(((Network>>k)&0x1))
+ {
+ memcpy(Temp_speech_WB_Mode_para[k], WBParData.speech_Mode_para, NUM_MODE_PARAS*sizeof(uint16)) ;
+ memcpy(Temp_speech_WB_FIR_IN_para[k], WBParData.speech_WB_FIR_IN_para, NUM_WB_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_WB_FIR_OUT_para[k], WBParData.speech_WB_FIR_OUT_para, NUM_WB_FIR_COEFFS*sizeof(uint16)) ;
+ }
+ }
+ }
+ SET_SPC_EM_INIT(SPC_EM_INIT_WB);
+ }
+ else if((((Data_Header&0xF000)>>8)==SWB_Par))
+ {
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(spcDynParSWBData), &SWBParData, comeFrom);
+ tempProclen += sizeof(spcDynParSWBData);
+
+ Network = (Data_Header&0x0FFF); // [bit0~bit11] bit0:GSM bit1:WCDMA bit2:CDMA bit3:VOLTE bit4:C2K
+ MD_TRC_SPC_SPE_CHECK_SPEECH_PAR_HEADER_FORMAT(Data_Header,Network);
+ if((Network>>12)==DONT_CARE_NETWORK)
+ {
+ for(k = 0; k < TOTAL_NETWORK_NUMBER; k++)
+ {
+ memcpy(Temp_speech_SWB_Mode_para[k], SWBParData.speech_Mode_para, NUM_MODE_PARAS*sizeof(uint16)) ;
+ memcpy(Temp_speech_SWB_FIR_IN_para[k], SWBParData.speech_SWB_FIR_IN_para, NUM_SWB_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_SWB_FIR_OUT_para[k], SWBParData.speech_SWB_FIR_OUT_para, NUM_SWB_FIR_COEFFS*sizeof(uint16)) ;
+ }
+ }
+ else
+ {
+ for(k = 0; k < TOTAL_NETWORK_NUMBER; k++)
+ {
+ if(((Network>>k)&0x1))
+ {
+ memcpy(Temp_speech_SWB_Mode_para[k], SWBParData.speech_Mode_para, NUM_MODE_PARAS*sizeof(uint16)) ;
+ memcpy(Temp_speech_SWB_FIR_IN_para[k], SWBParData.speech_SWB_FIR_IN_para, NUM_SWB_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_SWB_FIR_OUT_para[k], SWBParData.speech_SWB_FIR_OUT_para, NUM_SWB_FIR_COEFFS*sizeof(uint16)) ;
+ }
+ }
+ }
+ SET_SPC_EM_INIT(SPC_EM_INIT_SWB);
+ }
+ else
+ {
+ //Not suppot bandover
+ MD_TRC_SPC_SPE_ASSERT_CHECK(Data_Header,0,0);
+ ASSERT(0);
+ }
+ }
+
+ *procLen = tempProclen;
+ return curOffset;
+}
+
+kal_uint16 spc_dynamicParameterParser_volDeUnit_ver20(kal_uint16 DynamicParCount,
+ const kal_uint16 offset, const kal_uint16 length, SPC_MSG_FROM_T comeFrom,
+ kal_uint16 *procLen)
+{
+ kal_uint16 Data_Header;
+ kal_uint16 tempProclen = 0;
+ kal_uint16 curOffset = offset;
+
+ kal_uint16 i,Network,k;
+
+ for(i = 0 ; i < DynamicParCount ; i ++)
+ {
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(Data_Header), &Data_Header, comeFrom);
+ tempProclen += sizeof(Data_Header);
+
+ if(((Data_Header&0xF000)>>8)==NB_Par)
+ {
+
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(spcDynParNBData), &NBParData, comeFrom);
+ tempProclen += sizeof(spcDynParNBData);
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(spcDynParNBIIRData), &NBIIRParData, comeFrom);
+ tempProclen += sizeof(spcDynParNBIIRData);
+
+ Network = (Data_Header&0x0FFF); // [bit0~bit11] bit0:GSM bit1:WCDMA bit2:CDMA bit3:VOLTE bit4:C2K
+ MD_TRC_SPC_SPE_CHECK_SPEECH_PAR_HEADER_FORMAT(Data_Header,Network);
+ if(Network==0x0FFF) // all network use same par.
+ {
+ for(k = 0; k < TOTAL_NETWORK_NUMBER; k++)
+ {
+ memcpy(Temp_speech_NB_Mode_para[k], NBParData.speech_Mode_para, NUM_MODE_PARAS*sizeof(uint16)) ;
+ memcpy(Temp_speech_NB_FIR_IN_para[k], NBParData.speech_NB_FIR_IN_para, NUM_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_NB_FIR_OUT_para[k], NBParData.speech_NB_FIR_OUT_para, NUM_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_NB_IIR_IN_para[k], NBIIRParData.speech_NB_IIR_IN_para, NUM_IIR_COEFFS*sizeof(uint16));
+ memcpy(Temp_speech_NB_IIR_OUT_para[k], NBIIRParData.speech_NB_IIR_OUT_para, NUM_IIR_COEFFS*sizeof(uint16));
+ memcpy(Temp_speech_NB_MIC1_IIR_para[k], NBIIRParData.speech_NB_MIC1_IIR_para, NUM_MIC1_IIR_COEFFS*sizeof(uint16));
+ memcpy(Temp_speech_NB_MIC2_IIR_para[k], NBIIRParData.speech_NB_MIC2_IIR_para, NUM_MIC2_IIR_COEFFS*sizeof(uint16));
+ }
+ }
+ else
+ {
+ for(k = 0; k < TOTAL_NETWORK_NUMBER; k++)
+ {
+ if(((Network>>k)&0x1))
+ {
+ memcpy(Temp_speech_NB_Mode_para[k], NBParData.speech_Mode_para, NUM_MODE_PARAS*sizeof(uint16)) ;
+ memcpy(Temp_speech_NB_FIR_IN_para[k], NBParData.speech_NB_FIR_IN_para, NUM_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_NB_FIR_OUT_para[k], NBParData.speech_NB_FIR_OUT_para, NUM_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_NB_IIR_IN_para[k], NBIIRParData.speech_NB_IIR_IN_para, NUM_IIR_COEFFS*sizeof(uint16));
+ memcpy(Temp_speech_NB_IIR_OUT_para[k], NBIIRParData.speech_NB_IIR_OUT_para, NUM_IIR_COEFFS*sizeof(uint16));
+ memcpy(Temp_speech_NB_MIC1_IIR_para[k], NBIIRParData.speech_NB_MIC1_IIR_para, NUM_MIC1_IIR_COEFFS*sizeof(uint16));
+ memcpy(Temp_speech_NB_MIC2_IIR_para[k], NBIIRParData.speech_NB_MIC2_IIR_para, NUM_MIC2_IIR_COEFFS*sizeof(uint16));
+ }
+ }
+ }
+
+ SET_SPC_EM_INIT(SPC_EM_INIT_NB);
+ }
+ else if((((Data_Header&0xF000)>>8)==WB_Par))
+ {
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(spcDynParWBData), &WBParData, comeFrom);
+ tempProclen += sizeof(spcDynParWBData);
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(spcDynParWBIIRData), &WBIIRParData, comeFrom);
+ tempProclen += sizeof(spcDynParWBIIRData);
+
+ Network = (Data_Header&0x0FFF); // [bit0~bit11] bit0:GSM bit1:WCDMA bit2:CDMA bit3:VOLTE bit4:C2K
+ MD_TRC_SPC_SPE_CHECK_SPEECH_PAR_HEADER_FORMAT(Data_Header,Network);
+ if(Network==0x0FFF) // all network use same par.
+ {
+ for(k = 0; k < TOTAL_NETWORK_NUMBER; k++)
+ {
+ memcpy(Temp_speech_WB_Mode_para[k], WBParData.speech_Mode_para, NUM_MODE_PARAS*sizeof(uint16)) ;
+ memcpy(Temp_speech_WB_FIR_IN_para[k], WBParData.speech_WB_FIR_IN_para, NUM_WB_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_WB_FIR_OUT_para[k], WBParData.speech_WB_FIR_OUT_para, NUM_WB_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_WB_IIR_IN_para[k], WBIIRParData.speech_WB_IIR_IN_para, NUM_IIR_COEFFS*sizeof(uint16));
+ memcpy(Temp_speech_WB_IIR_OUT_para[k], WBIIRParData.speech_WB_IIR_OUT_para, NUM_IIR_COEFFS*sizeof(uint16));
+ memcpy(Temp_speech_WB_MIC1_IIR_para[k], WBIIRParData.speech_WB_MIC1_IIR_para, NUM_MIC1_IIR_COEFFS*sizeof(uint16));
+ memcpy(Temp_speech_WB_MIC2_IIR_para[k], WBIIRParData.speech_WB_MIC2_IIR_para, NUM_MIC2_IIR_COEFFS*sizeof(uint16));
+ }
+ }
+ else
+ {
+ for(k = 0; k < TOTAL_NETWORK_NUMBER; k++)
+ {
+ if(((Network>>k)&0x1))
+ {
+ memcpy(Temp_speech_WB_Mode_para[k], WBParData.speech_Mode_para, NUM_MODE_PARAS*sizeof(uint16)) ;
+ memcpy(Temp_speech_WB_FIR_IN_para[k], WBParData.speech_WB_FIR_IN_para, NUM_WB_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_WB_FIR_OUT_para[k], WBParData.speech_WB_FIR_OUT_para, NUM_WB_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_WB_IIR_IN_para[k], WBIIRParData.speech_WB_IIR_IN_para, NUM_IIR_COEFFS*sizeof(uint16));
+ memcpy(Temp_speech_WB_IIR_OUT_para[k], WBIIRParData.speech_WB_IIR_OUT_para, NUM_IIR_COEFFS*sizeof(uint16));
+ memcpy(Temp_speech_WB_MIC1_IIR_para[k], WBIIRParData.speech_WB_MIC1_IIR_para, NUM_MIC1_IIR_COEFFS*sizeof(uint16));
+ memcpy(Temp_speech_WB_MIC2_IIR_para[k], WBIIRParData.speech_WB_MIC2_IIR_para, NUM_MIC2_IIR_COEFFS*sizeof(uint16));
+ }
+ }
+ }
+ SET_SPC_EM_INIT(SPC_EM_INIT_WB);
+ }
+ else if((((Data_Header&0xF000)>>8)==SWB_Par))
+ {
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(spcDynParSWBData), &SWBParData, comeFrom);
+ tempProclen += sizeof(spcDynParSWBData);
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(spcDynParSWBIIRData), &SWBIIRParData, comeFrom);
+ tempProclen += sizeof(spcDynParSWBIIRData);
+
+ Network = (Data_Header&0x0FFF); // [bit0~bit11] bit0:GSM bit1:WCDMA bit2:CDMA bit3:VOLTE bit4:C2K
+ MD_TRC_SPC_SPE_CHECK_SPEECH_PAR_HEADER_FORMAT(Data_Header,Network);
+ if(Network==0x0FFF) // all network use same par.
+ {
+ for(k = 0; k < TOTAL_NETWORK_NUMBER; k++)
+ {
+ memcpy(Temp_speech_SWB_Mode_para[k], SWBParData.speech_Mode_para, NUM_MODE_PARAS*sizeof(uint16)) ;
+ memcpy(Temp_speech_SWB_FIR_IN_para[k], SWBParData.speech_SWB_FIR_IN_para, NUM_SWB_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_SWB_FIR_OUT_para[k], SWBParData.speech_SWB_FIR_OUT_para, NUM_SWB_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_SWB_IIR_IN_para[k], SWBIIRParData.speech_SWB_IIR_IN_para, NUM_IIR_COEFFS*sizeof(uint16));
+ memcpy(Temp_speech_SWB_IIR_OUT_para[k], SWBIIRParData.speech_SWB_IIR_OUT_para, NUM_IIR_COEFFS*sizeof(uint16));
+ memcpy(Temp_speech_SWB_MIC1_IIR_para[k], SWBIIRParData.speech_SWB_MIC1_IIR_para, NUM_MIC1_IIR_COEFFS*sizeof(uint16));
+ memcpy(Temp_speech_SWB_MIC2_IIR_para[k], SWBIIRParData.speech_SWB_MIC2_IIR_para, NUM_MIC2_IIR_COEFFS*sizeof(uint16));
+ }
+ }
+ else
+ {
+ for(k = 0; k < TOTAL_NETWORK_NUMBER; k++)
+ {
+ if(((Network>>k)&0x1))
+ {
+ memcpy(Temp_speech_SWB_Mode_para[k], SWBParData.speech_Mode_para, NUM_MODE_PARAS*sizeof(uint16)) ;
+ memcpy(Temp_speech_SWB_FIR_IN_para[k], SWBParData.speech_SWB_FIR_IN_para, NUM_SWB_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_SWB_FIR_OUT_para[k], SWBParData.speech_SWB_FIR_OUT_para, NUM_SWB_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_SWB_IIR_IN_para[k], SWBIIRParData.speech_SWB_IIR_IN_para, NUM_IIR_COEFFS*sizeof(uint16));
+ memcpy(Temp_speech_SWB_IIR_OUT_para[k], SWBIIRParData.speech_SWB_IIR_OUT_para, NUM_IIR_COEFFS*sizeof(uint16));
+ memcpy(Temp_speech_SWB_MIC1_IIR_para[k], SWBIIRParData.speech_SWB_MIC1_IIR_para, NUM_MIC1_IIR_COEFFS*sizeof(uint16));
+ memcpy(Temp_speech_SWB_MIC2_IIR_para[k], SWBIIRParData.speech_SWB_MIC2_IIR_para, NUM_MIC2_IIR_COEFFS*sizeof(uint16));
+ }
+ }
+ }
+ SET_SPC_EM_INIT(SPC_EM_INIT_SWB);
+ }
+ else
+ {
+ //Not suppot bandover
+ MD_TRC_SPC_SPE_ASSERT_CHECK(Data_Header,0,0);
+ ASSERT(0);
+ }
+ }
+ SET_SPC_EM_INIT(SPC_EM_INIT_IIR);
+ *procLen = tempProclen;
+ return curOffset;
+}
+
+kal_uint16 spc_dynamicParameterParser_volDeUnit_ver00(kal_uint16 DynamicParCount,
+ const kal_uint16 offset, const kal_uint16 length, SPC_MSG_FROM_T comeFrom,
+ kal_uint16 *procLen)
+{
+ kal_uint16 Data_Header;
+ kal_uint16 tempProclen = 0;
+ kal_uint16 curOffset = offset;
+
+ kal_uint16 i,Network,k;
+
+ for(i = 0 ; i < DynamicParCount ; i ++)
+ {
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(Data_Header), &Data_Header, comeFrom);
+ tempProclen = tempProclen + sizeof(Data_Header);
+
+ if(((Data_Header&0xF0)==NB_Par))
+ {
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(spcDynParNBData), &NBParData, comeFrom);
+ tempProclen = tempProclen + sizeof(spcDynParNBData);
+
+ Network = (Data_Header&0x0F);
+ if(Network == GSM_NETWORK||Network == WCDMA_NETWORK||Network == CDMA_NETWORK||Network == VOLTE_NETWORK||Network == C2K_NETWORK)
+ {
+ memcpy(Temp_speech_NB_Mode_para[Network-1], NBParData.speech_Mode_para, NUM_MODE_PARAS*sizeof(uint16)) ;
+ memcpy(Temp_speech_NB_FIR_IN_para[Network-1], NBParData.speech_NB_FIR_IN_para, NUM_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_NB_FIR_OUT_para[Network-1], NBParData.speech_NB_FIR_OUT_para, NUM_FIR_COEFFS*sizeof(uint16)) ;
+ }
+ else if(Network==DONT_CARE_NETWORK)
+ {
+ for(k = 0; k < TOTAL_NETWORK_NUMBER; k++)
+ {
+ memcpy(Temp_speech_NB_Mode_para[k], NBParData.speech_Mode_para, NUM_MODE_PARAS*sizeof(uint16)) ;
+ memcpy(Temp_speech_NB_FIR_IN_para[k], NBParData.speech_NB_FIR_IN_para, NUM_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_NB_FIR_OUT_para[k], NBParData.speech_NB_FIR_OUT_para, NUM_FIR_COEFFS*sizeof(uint16)) ;
+ }
+ }
+ else
+ {
+ // not support the network info
+ MD_TRC_SPC_SPE_ASSERT_CHECK(Network,0,0);
+ ASSERT(0);
+
+ }
+ SET_SPC_EM_INIT(SPC_EM_INIT_NB);
+ }
+ else if(((Data_Header&0xF0)==WB_Par))
+ {
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(spcDynParWBData), &WBParData, comeFrom);
+ tempProclen = tempProclen + sizeof(spcDynParWBData);
+
+ Network = (Data_Header&0x0F);
+ if(Network == GSM_NETWORK||Network == WCDMA_NETWORK||Network == CDMA_NETWORK||Network == VOLTE_NETWORK||Network == C2K_NETWORK)
+ {
+ memcpy(Temp_speech_WB_Mode_para[Network-1], WBParData.speech_Mode_para, NUM_MODE_PARAS*sizeof(uint16)) ;
+ memcpy(Temp_speech_WB_FIR_IN_para[Network-1], WBParData.speech_WB_FIR_IN_para, NUM_WB_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_WB_FIR_OUT_para[Network-1], WBParData.speech_WB_FIR_OUT_para, NUM_WB_FIR_COEFFS*sizeof(uint16)) ;
+ }
+ else if(Network==DONT_CARE_NETWORK)
+ {
+ for(k = 0; k < TOTAL_NETWORK_NUMBER; k++)
+ {
+ memcpy(Temp_speech_WB_Mode_para[k], WBParData.speech_Mode_para, NUM_MODE_PARAS*sizeof(uint16)) ;
+ memcpy(Temp_speech_WB_FIR_IN_para[k], WBParData.speech_WB_FIR_IN_para, NUM_WB_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_WB_FIR_OUT_para[k], WBParData.speech_WB_FIR_OUT_para, NUM_WB_FIR_COEFFS*sizeof(uint16)) ;
+ }
+ }
+ else
+ {
+ // not support the network info
+ MD_TRC_SPC_SPE_ASSERT_CHECK(Network,0,0);
+ ASSERT(0);
+ }
+ SET_SPC_EM_INIT(SPC_EM_INIT_WB);
+ }
+ else if(((Data_Header&0xF0)==SWB_Par))
+ {
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(spcDynParSWBData), &SWBParData, comeFrom);
+ tempProclen = tempProclen + sizeof(spcDynParSWBData);
+
+ Network = (Data_Header&0x0F);
+ if(Network == GSM_NETWORK||Network == WCDMA_NETWORK||Network == CDMA_NETWORK||Network == VOLTE_NETWORK||Network == C2K_NETWORK)
+ {
+ memcpy(Temp_speech_SWB_Mode_para[Network-1], SWBParData.speech_Mode_para, NUM_MODE_PARAS*sizeof(uint16)) ;
+ memcpy(Temp_speech_SWB_FIR_IN_para[Network-1], SWBParData.speech_SWB_FIR_IN_para, NUM_SWB_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_SWB_FIR_OUT_para[Network-1], SWBParData.speech_SWB_FIR_OUT_para, NUM_SWB_FIR_COEFFS*sizeof(uint16)) ;
+ }
+ else if(Network==DONT_CARE_NETWORK)
+ {
+ for(k = 0; k < TOTAL_NETWORK_NUMBER; k++)
+ {
+ memcpy(Temp_speech_SWB_Mode_para[k], SWBParData.speech_Mode_para, NUM_MODE_PARAS*sizeof(uint16)) ;
+ memcpy(Temp_speech_SWB_FIR_IN_para[k], SWBParData.speech_SWB_FIR_IN_para, NUM_SWB_FIR_COEFFS*sizeof(uint16)) ;
+ memcpy(Temp_speech_SWB_FIR_OUT_para[k], SWBParData.speech_SWB_FIR_OUT_para, NUM_SWB_FIR_COEFFS*sizeof(uint16)) ;
+ }
+ }
+ else
+ {
+ // not support the network info
+ MD_TRC_SPC_SPE_ASSERT_CHECK(Network,0,0);
+ ASSERT(0);
+ }
+ SET_SPC_EM_INIT(SPC_EM_INIT_SWB);
+ }
+ else
+ {
+ //Not suppot bandover
+ MD_TRC_SPC_SPE_ASSERT_CHECK(Data_Header,0,0);
+ ASSERT(0);
+ }
+ }
+
+ *procLen = tempProclen;
+ return curOffset;
+}
+
+
+
+/**
+ @return: magic
+ @procLen: [OUTPUT] process length
+*/
+
+uint16 spc_dynamicParameterParser_dispatcher(const kal_uint16 offset, const kal_uint16 length, SPC_MSG_FROM_T comeFrom,
+ kal_uint16 *procLen, kal_uint16 *newOffset)
+{
+ spcDynParHeader Header;
+ kal_uint16 curOffset;
+ uint16 unProcLen = length;
+
+ memset(&Header, 0, sizeof(spcDynParHeader));
+ curOffset = SpcIo_GetDataFromAp(offset, sizeof(spcDynParHeader), &Header, comeFrom);
+ unProcLen = unProcLen - sizeof(spcDynParHeader);
+
+ kal_prompt_trace(MOD_L1SP, "where am I dispatcher: %x, %x, %x, %d", offset, curOffset, length, comeFrom);
+
+
+ switch(Header.SphUnitMagiNum){
+ case 0:
+ {
+ // when curOffset == offset, it also means cannot get data from AP param_shm
+ // cannot get data from AP
+ unProcLen = 0;
+
+ }
+ break;
+ case Vol_de_speech_unit:
+ {
+ kal_uint16 DynamicParCount = 0; //initialize
+ kal_uint16 SpeechIndex; // bit1: Volume index, bit0: Mode
+ // kal_uint16 Data_Header;
+ kal_uint16 Mode;
+ kal_uint16 count;
+
+ //Param_Header_Layer1; Network
+ //Param_Header_Layer2; VoiceBand
+ // kal_trace( TRACE_FUNC,SPC_SPE_RECEIVEDYNAMICPARAMETER1);
+ MD_TRC_SPC_SPE_RECEIVEDYNAMICPARAMETER(Vol_de_speech_unit, length, comeFrom);
+ if(Header.NumLayer == 0x2)
+ {
+ DynamicParCount = (((Header.NumEachLayer)&0x00F0)>>4) * ((Header.NumEachLayer)&0x000F);
+ }
+ else if(Header.NumLayer == 0x1)
+ {
+ DynamicParCount = ((Header.NumEachLayer)&0x000F);
+ }
+ else
+ {
+ //Not suppot over 2 Layer
+ MD_TRC_SPC_SPE_ASSERT_CHECK(Header.NumLayer,0,0);
+ ASSERT(0);
+ }
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(SpeechIndex), &SpeechIndex, comeFrom);
+ unProcLen = unProcLen - sizeof(SpeechIndex);
+
+ Mode = (SpeechIndex&0x0F);
+ SpeechIndex = (((SpeechIndex)&0xF0)>>4);
+ MD_TRC_SPC_SPE_RECEIVEDYNAMICPARAMETER2(Mode,SpeechIndex,Header.Param_Header_Layer3);
+
+ if(Header.Param_Header_Layer3== 0x10) // Version 1.0.
+ {
+ kal_uint16 procLen=0;
+ curOffset = spc_dynamicParameterParser_volDeUnit_ver10(DynamicParCount, curOffset, unProcLen, comeFrom, &procLen);
+ unProcLen = unProcLen - procLen;
+ }
+ else if(Header.Param_Header_Layer3== 0x20) // Version 2.0.
+ {
+ kal_uint16 procLen=0;
+ curOffset = spc_dynamicParameterParser_volDeUnit_ver20(DynamicParCount, curOffset, unProcLen, comeFrom, &procLen);
+ unProcLen = unProcLen - procLen;
+
+ }
+ else //Version 0.0
+ {
+ kal_uint16 procLen=0;
+ curOffset = spc_dynamicParameterParser_volDeUnit_ver00(DynamicParCount, curOffset, unProcLen, comeFrom, &procLen);
+ unProcLen = unProcLen - procLen;
+ }
+ l1sp_setAllSpeechModePara((kal_uint16 *) Temp_speech_NB_Mode_para, TOTAL_NETWORK_NUMBER * NUM_MODE_PARAS);
+ l1sp_setAllSpeechFirCoeff_InputOnly((kal_int16 *)Temp_speech_NB_FIR_IN_para, TOTAL_NETWORK_NUMBER * NUM_FIR_COEFFS);
+ l1sp_setAllSpeechFirCoeff_OutputOnly((kal_int16 *)Temp_speech_NB_FIR_OUT_para, TOTAL_NETWORK_NUMBER * NUM_FIR_COEFFS);
+ l1sp_setAllWbSpeechModePara((kal_uint16 *)Temp_speech_WB_Mode_para, TOTAL_NETWORK_NUMBER * NUM_MODE_PARAS);
+ l1sp_setAllWbSpeechFirCoeff_InputOnly((kal_int16 *)Temp_speech_WB_FIR_IN_para, TOTAL_NETWORK_NUMBER * NUM_WB_FIR_COEFFS);
+ l1sp_setAllWbSpeechFirCoeff_OutputOnly((kal_int16 *)Temp_speech_WB_FIR_OUT_para, TOTAL_NETWORK_NUMBER * NUM_WB_FIR_COEFFS);
+ l1sp_setAllSWbSpeechModePara((kal_uint16 *)Temp_speech_SWB_Mode_para, TOTAL_NETWORK_NUMBER * NUM_MODE_PARAS);
+ l1sp_setAllSWbSpeechFirCoeff_InputOnly((kal_int16 *)Temp_speech_SWB_FIR_IN_para, TOTAL_NETWORK_NUMBER * NUM_SWB_FIR_COEFFS);
+ l1sp_setAllSWbSpeechFirCoeff_OutputOnly((kal_int16 *)Temp_speech_SWB_FIR_OUT_para, TOTAL_NETWORK_NUMBER * NUM_SWB_FIR_COEFFS);
+
+ for(count=0;count<TOTAL_NETWORK_NUMBER;count++)
+ {
+ MD_TRC_SPC_SPE_CHECK_NB_MODE_PAR(count,Temp_speech_NB_Mode_para[count][0],Temp_speech_NB_Mode_para[count][1],Temp_speech_NB_Mode_para[count][2],Temp_speech_NB_Mode_para[count][3],Temp_speech_NB_Mode_para[count][4]);
+ MD_TRC_SPC_SPE_CHECK_NB_FIR_IN_PAR(count,Temp_speech_NB_FIR_IN_para[count][0],Temp_speech_NB_FIR_IN_para[count][1],Temp_speech_NB_FIR_IN_para[count][2],Temp_speech_NB_FIR_IN_para[count][3],Temp_speech_NB_FIR_IN_para[count][4]);
+ MD_TRC_SPC_SPE_CHECK_NB_FIR_OUT_PAR(count,Temp_speech_NB_FIR_OUT_para[count][0],Temp_speech_NB_FIR_OUT_para[count][1],Temp_speech_NB_FIR_OUT_para[count][2],Temp_speech_NB_FIR_OUT_para[count][3],Temp_speech_NB_FIR_OUT_para[count][4]);
+ MD_TRC_SPC_SPE_CHECK_WB_MODE_PAR(count,Temp_speech_WB_Mode_para[count][0],Temp_speech_WB_Mode_para[count][1],Temp_speech_WB_Mode_para[count][2],Temp_speech_WB_Mode_para[count][3],Temp_speech_WB_Mode_para[count][4]);
+ MD_TRC_SPC_SPE_CHECK_WB_FIR_IN_PAR(count,Temp_speech_WB_FIR_IN_para[count][0],Temp_speech_WB_FIR_IN_para[count][1],Temp_speech_WB_FIR_IN_para[count][2],Temp_speech_WB_FIR_IN_para[count][3],Temp_speech_WB_FIR_IN_para[count][4]);
+ MD_TRC_SPC_SPE_CHECK_WB_FIR_OUT_PAR(count,Temp_speech_WB_FIR_OUT_para[count][0],Temp_speech_WB_FIR_OUT_para[count][1],Temp_speech_WB_FIR_OUT_para[count][2],Temp_speech_WB_FIR_OUT_para[count][3],Temp_speech_WB_FIR_OUT_para[count][4]);
+ MD_TRC_SPC_SPE_CHECK_SWB_MODE_PAR(count,Temp_speech_SWB_Mode_para[count][0],Temp_speech_SWB_Mode_para[count][1],Temp_speech_SWB_Mode_para[count][2],Temp_speech_SWB_Mode_para[count][3],Temp_speech_SWB_Mode_para[count][4]);
+ MD_TRC_SPC_SPE_CHECK_SWB_FIR_IN_PAR(count,Temp_speech_SWB_FIR_IN_para[count][0],Temp_speech_SWB_FIR_IN_para[count][1],Temp_speech_SWB_FIR_IN_para[count][2],Temp_speech_SWB_FIR_IN_para[count][3],Temp_speech_SWB_FIR_IN_para[count][4]);
+ MD_TRC_SPC_SPE_CHECK_SWB_FIR_OUT_PAR(count,Temp_speech_SWB_FIR_OUT_para[count][0],Temp_speech_SWB_FIR_OUT_para[count][1],Temp_speech_SWB_FIR_OUT_para[count][2],Temp_speech_SWB_FIR_OUT_para[count][3],Temp_speech_SWB_FIR_OUT_para[count][4]);
+ }
+
+ if(Header.Param_Header_Layer3== 0x20) // Version 2.0.
+ {
+ l1sp_setAllSpeechIirCoeff_InputOnly((kal_int16 *)Temp_speech_NB_IIR_IN_para, TOTAL_NETWORK_NUMBER * NUM_IIR_COEFFS);
+ l1sp_setAllSpeechIirCoeff_OutputOnly((kal_int16 *)Temp_speech_NB_IIR_OUT_para, TOTAL_NETWORK_NUMBER * NUM_IIR_COEFFS);
+ l1sp_setAllSpeechMic1IirCoeff((kal_int16 *)Temp_speech_NB_MIC1_IIR_para, TOTAL_NETWORK_NUMBER * NUM_MIC1_IIR_COEFFS);
+ l1sp_setAllSpeechMic2IirCoeff((kal_int16 *)Temp_speech_NB_MIC2_IIR_para, TOTAL_NETWORK_NUMBER * NUM_MIC2_IIR_COEFFS);
+ l1sp_setAllWBSpeechIirCoeff_InputOnly((kal_int16 *)Temp_speech_WB_IIR_IN_para, TOTAL_NETWORK_NUMBER * NUM_IIR_COEFFS);
+ l1sp_setAllWBSpeechIirCoeff_OutputOnly((kal_int16 *)Temp_speech_WB_IIR_OUT_para, TOTAL_NETWORK_NUMBER * NUM_IIR_COEFFS);
+ l1sp_setAllWBSpeechMic1IirCoeff((kal_int16 *)Temp_speech_WB_MIC1_IIR_para, TOTAL_NETWORK_NUMBER * NUM_MIC1_IIR_COEFFS);
+ l1sp_setAllWBSpeechMic2IirCoeff((kal_int16 *)Temp_speech_WB_MIC2_IIR_para, TOTAL_NETWORK_NUMBER * NUM_MIC2_IIR_COEFFS);
+ l1sp_setAllSWBSpeechIirCoeff_InputOnly((kal_int16 *)Temp_speech_SWB_IIR_IN_para, TOTAL_NETWORK_NUMBER * NUM_IIR_COEFFS);
+ l1sp_setAllSWBSpeechIirCoeff_OutputOnly((kal_int16 *)Temp_speech_SWB_IIR_OUT_para, TOTAL_NETWORK_NUMBER * NUM_IIR_COEFFS);
+ l1sp_setAllSWBSpeechMic1IirCoeff((kal_int16 *)Temp_speech_SWB_MIC1_IIR_para, TOTAL_NETWORK_NUMBER * NUM_MIC1_IIR_COEFFS);
+ l1sp_setAllSWBSpeechMic2IirCoeff((kal_int16 *)Temp_speech_SWB_MIC2_IIR_para, TOTAL_NETWORK_NUMBER * NUM_MIC2_IIR_COEFFS);
+ // l1sp_set par
+ for(count=0;count<TOTAL_NETWORK_NUMBER;count++)
+ {
+ MD_TRC_SPC_SPE_CHECK_NB_IIR_IN_PAR(count,Temp_speech_NB_IIR_IN_para[count][0],Temp_speech_NB_IIR_IN_para[count][1],Temp_speech_NB_IIR_IN_para[count][2],Temp_speech_NB_IIR_IN_para[count][3],Temp_speech_NB_IIR_IN_para[count][4]);
+ MD_TRC_SPC_SPE_CHECK_NB_IIR_OUT_PAR(count,Temp_speech_NB_IIR_OUT_para[count][0],Temp_speech_NB_IIR_OUT_para[count][1],Temp_speech_NB_IIR_OUT_para[count][2],Temp_speech_NB_IIR_OUT_para[count][3],Temp_speech_NB_IIR_OUT_para[count][4]);
+ MD_TRC_SPC_SPE_CHECK_NB_MIC1_IIR_PAR(count,Temp_speech_NB_MIC1_IIR_para[count][0],Temp_speech_NB_MIC1_IIR_para[count][1],Temp_speech_NB_MIC1_IIR_para[count][2],Temp_speech_NB_MIC1_IIR_para[count][3],Temp_speech_NB_MIC1_IIR_para[count][4]);
+ MD_TRC_SPC_SPE_CHECK_NB_MIC2_IIR_PAR(count,Temp_speech_NB_MIC2_IIR_para[count][0],Temp_speech_NB_MIC2_IIR_para[count][1],Temp_speech_NB_MIC2_IIR_para[count][2],Temp_speech_NB_MIC2_IIR_para[count][3],Temp_speech_NB_MIC2_IIR_para[count][4]);
+ MD_TRC_SPC_SPE_CHECK_WB_IIR_IN_PAR(count,Temp_speech_WB_IIR_IN_para[count][0],Temp_speech_WB_IIR_IN_para[count][1],Temp_speech_WB_IIR_IN_para[count][2],Temp_speech_WB_IIR_IN_para[count][3],Temp_speech_WB_IIR_IN_para[count][4]);
+ MD_TRC_SPC_SPE_CHECK_WB_IIR_OUT_PAR(count,Temp_speech_WB_IIR_OUT_para[count][0],Temp_speech_WB_IIR_OUT_para[count][1],Temp_speech_WB_IIR_OUT_para[count][2],Temp_speech_WB_IIR_OUT_para[count][3],Temp_speech_WB_IIR_OUT_para[count][4]);
+ MD_TRC_SPC_SPE_CHECK_WB_MIC1_IIR_PAR(count,Temp_speech_WB_MIC1_IIR_para[count][0],Temp_speech_WB_MIC1_IIR_para[count][1],Temp_speech_WB_MIC1_IIR_para[count][2],Temp_speech_WB_MIC1_IIR_para[count][3],Temp_speech_WB_MIC1_IIR_para[count][4]);
+ MD_TRC_SPC_SPE_CHECK_WB_MIC2_IIR_PAR(count,Temp_speech_WB_MIC2_IIR_para[count][0],Temp_speech_WB_MIC2_IIR_para[count][1],Temp_speech_WB_MIC2_IIR_para[count][2],Temp_speech_WB_MIC2_IIR_para[count][3],Temp_speech_WB_MIC2_IIR_para[count][4]);
+ MD_TRC_SPC_SPE_CHECK_SWB_IIR_IN_PAR(count,Temp_speech_SWB_IIR_IN_para[count][0],Temp_speech_SWB_IIR_IN_para[count][1],Temp_speech_SWB_IIR_IN_para[count][2],Temp_speech_SWB_IIR_IN_para[count][3],Temp_speech_SWB_IIR_IN_para[count][4]);
+ MD_TRC_SPC_SPE_CHECK_SWB_IIR_OUT_PAR(count,Temp_speech_SWB_IIR_OUT_para[count][0],Temp_speech_SWB_IIR_OUT_para[count][1],Temp_speech_SWB_IIR_OUT_para[count][2],Temp_speech_SWB_IIR_OUT_para[count][3],Temp_speech_SWB_IIR_OUT_para[count][4]);
+ MD_TRC_SPC_SPE_CHECK_SWB_MIC1_IIR_PAR(count,Temp_speech_SWB_MIC1_IIR_para[count][0],Temp_speech_SWB_MIC1_IIR_para[count][1],Temp_speech_SWB_MIC1_IIR_para[count][2],Temp_speech_SWB_MIC1_IIR_para[count][3],Temp_speech_SWB_MIC1_IIR_para[count][4]);
+ MD_TRC_SPC_SPE_CHECK_SWB_MIC2_IIR_PAR(count,Temp_speech_SWB_MIC2_IIR_para[count][0],Temp_speech_SWB_MIC2_IIR_para[count][1],Temp_speech_SWB_MIC2_IIR_para[count][2],Temp_speech_SWB_MIC2_IIR_para[count][3],Temp_speech_SWB_MIC2_IIR_para[count][4]);
+
+ }
+
+ }
+
+#if defined(__SPEECH_WW_OPERATOR_SCORE_ENHANCE__)
+ spe_setMagiCon();
+ if(Mode!=0xF)
+ {
+ if(Mode == SPH_MODE_HAC)
+ {
+ spe_setHacModeNeeded(true);
+ }
+ else if(Mode == SPH_MODE_AUX1) //Magi con
+ {
+ Mode = SPH_MODE_LOUDSPK;
+ }
+ // Spc_SetSpeechEnhMode_Adaptation( (kal_uint8) Mode );
+ L1SP_SetSpeechEnhanceAndFir(Mode, SPH_ENH_AND_FIR_UPDATE_TYPE_ALL);
+ }
+ else
+ {
+
+ SetSpeechEnhancement(true);
+
+ }
+
+#else
+ spe_DisableMagiCon();
+ if(Mode!=0xF)
+ {
+
+ if(Mode == SPH_MODE_HAC)
+ {
+ spe_setHacModeNeeded(true);
+ }
+ else if(Mode == SPH_MODE_EARPHONE)
+ {
+ spe_setMagiCon();
+ }
+ else if(Mode == SPH_MODE_AUX1) //Magi con
+ {
+ Mode = SPH_MODE_LOUDSPK;
+ spe_setMagiCon();
+
+ }
+ // Spc_SetSpeechEnhMode_Adaptation( (kal_uint8) Mode );
+ L1SP_SetSpeechEnhanceAndFir(Mode, SPH_ENH_AND_FIR_UPDATE_TYPE_ALL);
+ }
+ else
+ {
+
+ SetSpeechEnhancement(true);
+
+ }
+#endif
+ }
+
+ break;
+
+ case Vol_in_general_unit:
+ {
+ kal_uint16 procLen=0;
+ curOffset = spc_dynamicParameterParser_volInUnit(Vol_in_general_unit, curOffset, unProcLen, comeFrom, &procLen);
+ unProcLen = unProcLen - procLen;
+ SetSpeechEnhancement(false);
+ SetSpeechEnhancement(true);
+ }
+ break;
+
+ case Vol_in_DMNR:
+ {
+ kal_uint16 procLen=0;
+ curOffset = spc_dynamicParameterParser_dmnrUnit(&Header, curOffset, unProcLen, comeFrom, &procLen);
+ unProcLen = unProcLen - procLen;
+
+ SetSpeechEnhancement(false);
+ SetSpeechEnhancement(true);
+ }
+ break;
+ case Vol_in_MagiClarity:
+ {
+ kal_uint16 procLen=0;
+ curOffset = spc_dynamicParameterParser_volInUnit(Vol_in_MagiClarity, curOffset, unProcLen, comeFrom, &procLen);
+ unProcLen = unProcLen - procLen;
+ }
+ break;
+ case Vol_in_echoRefforUsbAudio:
+ {
+ kal_uint16 procLen=0;
+ curOffset = spc_dynamicParameterParser_volInUnit(Vol_in_echoRefforUsbAudio, curOffset, unProcLen, comeFrom, &procLen);
+ unProcLen = unProcLen - procLen;
+ }
+ break;
+ default:
+
+ MD_TRC_SPC_SPE_ASSERT_CHECK(Header.SphUnitMagiNum,0,0);
+ ASSERT(0); //NOT SUPPORT THE MAGIC NUM
+ break;
+ }
+
+ kal_prompt_trace(MOD_L1SP, "unProclen=%d with SphUnitMagiNum=%x", unProcLen, Header.SphUnitMagiNum);
+
+ if(NULL!=newOffset) {
+ *newOffset = curOffset;
+ }
+ if(NULL!=procLen) {
+ *procLen = (length - unProcLen);
+ }
+ return Header.SphUnitMagiNum;
+
+}
+
+uint16 spc_ReceiveDynamicParameter(const kal_uint16 offset, const kal_uint16 length, SPC_MSG_FROM_T comeFrom)
+{
+ kal_uint16 curOffset;
+
+
+ // Header Check
+ spcBufInfo info;
+ curOffset = SpcIo_GetDataFromAp(offset, sizeof(spcBufInfo), &info, comeFrom);
+
+
+ ASSERT(info.syncWord == 0xA2A2);
+ ASSERT((info.type) == AUD_CCCI_STRMBUF_TYPE_DYNAMCI_PAR_TYPE); //just use the bit[0:3] to inidicate the type.
+ ASSERT(info.length == (length-6));
+
+ return spc_dynamicParameterParser_dispatcher(curOffset, length-sizeof(spcBufInfo), comeFrom, NULL, NULL);
+}
+#endif
+
+
+kal_uint16 get_spcGetEpofTimes(enum_EPOF_event EPOF_event)
+{
+ return( (gSpc.spcGetEpofTimes) & EPOF_event );
+}
+
+void set_spcGetEpofTimes(enum_EPOF_event EPOF_event, int on)
+{
+ if(on)
+ gSpc.spcGetEpofTimes |= EPOF_event;
+ else
+ gSpc.spcGetEpofTimes &= (~EPOF_event);
+}
+
+
+// ============================================================================
+#define ILM_SPC_CUST_DUMP_BUF_LEN 2560
+typedef struct{
+ LOCAL_PARA_HDR
+ //raw information from eMAC
+ uint16 dumpLen;
+ uint16 dumpBuf[ILM_SPC_CUST_DUMP_BUF_LEN];
+}ilm_spc_cust_dump_t;
+
+void spc_customDump(uint16 bufLen, uint16 *dumpBuf)
+{
+
+ ilm_spc_cust_dump_t *ilm;
+ uint16 len = bufLen;
+ uint16 idx = 0;
+
+ // static int32 i=0;
+
+ if ( 0 == bufLen)
+ return;
+
+ while(len > ILM_SPC_CUST_DUMP_BUF_LEN) {
+ ilm = (ilm_spc_cust_dump_t *)construct_local_para( sizeof(ilm_spc_cust_dump_t), TD_CTRL);
+ ilm->dumpLen = ILM_SPC_CUST_DUMP_BUF_LEN;
+ memcpy((ilm->dumpBuf), &(dumpBuf[idx]), sizeof(uint16)*ILM_SPC_CUST_DUMP_BUF_LEN);
+ msg_send6(MOD_L1SP, MOD_MED, AUDIO_SAP, MSG_ID_AUDIO_CUST_DUMP_REQ, (local_para_struct *)ilm, NULL);
+
+ idx = idx + ILM_SPC_CUST_DUMP_BUF_LEN;
+ len = len - ILM_SPC_CUST_DUMP_BUF_LEN;
+
+ // i++;
+ }
+
+
+ ilm = (ilm_spc_cust_dump_t *)construct_local_para( sizeof(ilm_spc_cust_dump_t), TD_CTRL);
+ ilm->dumpLen = len;
+ memcpy((ilm->dumpBuf), &(dumpBuf[idx]), sizeof(uint16)*len);
+ msg_send6(MOD_L1SP, MOD_MED, AUDIO_SAP, MSG_ID_AUDIO_CUST_DUMP_REQ, (local_para_struct *)ilm, NULL);
+
+ // i++;
+
+ // kal_prompt_trace(MOD_L1SP, "spc_customDump' i=%d", i);
+}
+
+void spc_sendCustomDump(void *ilm)
+{
+ uint16 bufLen;
+ uint16 *dumpBuf;
+ uint16 lenInByte;
+ spcBufInfo info;
+ bool sendResult = true;
+
+ // static int32 j=0;
+
+ bufLen = ((ilm_spc_cust_dump_t *)(ilm))->dumpLen;
+ dumpBuf = ((ilm_spc_cust_dump_t *)(ilm))->dumpBuf;
+
+ if(NULL == dumpBuf || 0 == bufLen)
+ return;
+
+ lenInByte = (bufLen <<1);
+
+#if 0
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+#endif
+
+
+ info.syncWord = 0x2A2A;
+ info.type = AUD_CCCI_STRMBUF_TYPE_CUST_DUMP;
+ info.length = lenInByte;
+
+ sendResult = SpcIO_WriteDataToAp(&info, sizeof(spcBufInfo),
+ (void *)(dumpBuf), lenInByte, NULL, 0,
+ SPCIO_MSG_FROM_SPC_CUST_DUMP_NOTIFY);
+
+ if(false == sendResult) {
+ // leave log here
+ MD_TRC_SPC_CUST_DUMP_DROP();
+ }
+
+}
+
+// Remind: DebugInfo[15] also control this. loopback point
+void spc_dev_LoopbackPoint_DVT(kal_uint16 point){
+ switch(point){
+
+ case 0:
+ AFE_SetConn0(0x54321076); //default value, case 0 : reset
+ break;
+ case 1:
+ AFE_SetConn0(0x54321010); // O17, O18
+ break;
+ case 2:
+ AFE_SetConn0(0x54321032); // O23, O24
+ break;
+ case 3:
+ AFE_SetConn0(0x54321054); // O25
+ break;
+ case 4:
+ AFE_SetConn0(0x54321045); // O25_swap
+ break;
+ case 5:
+ AFE_SetConn0(0x54327676); // DL -> UL
+ break;
+ default:
+ kal_prompt_trace(MOD_L1SP, "[LPBK_DVT] invalid value, set 0x54321076");
+ AFE_SetConn0(0x54321076);
+ }
+}
+
+#if defined(__ECALL_SUPPORT__)
+void spc_eCall_SDT_Open(void)
+{
+ spc_Set_Ecall_Lib_Status(SPC_ECALL_SDT_ONLY);
+ eCall_IVS_Open(aud_ecall_event_callback);
+ eCall_IVS_PutMSD(eCall_Msd,140,0); // DEFAULT PAR
+}
+
+void spc_eCall_SDT_Close(void)
+{
+ eCall_IVS_Close();
+ spc_Set_Ecall_Lib_Status(SPC_ECALL_DISABLE);
+}
+
+void spc_eCall_IVS_Open(void)
+{
+ eCall_IVS_Close();
+ spc_Set_Ecall_Lib_Status(SPC_ECALL_ENABLE);
+ eCall_IVS_Open(aud_ecall_event_callback);
+ eCall_IVS_PutMSD(eCall_Msd,140,0);
+}
+
+void spc_eCall_IVS_Close(void)
+{
+ eCall_IVS_Close();
+ spc_Set_Ecall_Lib_Status(SPC_ECALL_SDT_ONLY);
+ eCall_IVS_Open(aud_ecall_event_callback);
+}
+
+void spc_eCall_PSAP_Open(void)
+{
+ eCall_IVS_Close();
+ spc_Set_Ecall_Lib_Status(SPC_ECALL_DISABLE); // Set ivs ststus=disable
+ eCall_PSAP_Open(aud_ecall_event_callback);
+}
+
+void spc_eCall_PSAP_Close(void)
+{
+ eCall_PSAP_Close();
+ spc_Set_Ecall_Lib_Status(SPC_ECALL_SDT_ONLY);// Set ivs ststus=SDT detect
+ eCall_IVS_Open(aud_ecall_event_callback);
+}
+
+void spc_eCall_Msd_Data(kal_uint16 offset, kal_int16 length,SPC_MSG_FROM_T comeFrom)
+{
+ spcBufInfo info;
+ kal_uint16 curOffSet;
+
+ curOffSet = SpcIo_GetDataFromAp(offset, sizeof(spcBufInfo), &info,comeFrom);
+
+ ASSERT(info.syncWord == 0xA2A2);
+ ASSERT(info.type == AUD_CCCI_ECALL_MSD_TYPE);
+
+ //ASSERT(info.length == (length - sizeof(spcBufInfo)));
+ SpcIo_GetDataFromAp(curOffSet, 140, eCall_Msd,comeFrom);
+ eCall_IVS_PutMSD(eCall_Msd,140,1);
+
+
+}
+
+void spc_eCall_TX_CTRL_Data(kal_uint16 offset, kal_int16 length,SPC_MSG_FROM_T comeFrom)
+{
+ spcBufInfo info;
+ kal_uint16 curOffSet;
+ uint32 i;
+ Int16 eCall_TX_Temp[800];
+
+
+ if(gSpc.eCall_Ctrl_Seq_Switch == 0)
+ {
+ return;
+ }
+
+
+ curOffSet = SpcIo_GetDataFromAp(offset, sizeof(spcBufInfo), &info, comeFrom);
+ ASSERT(info.syncWord == 0xA2A2);
+ ASSERT(info.type == AUD_CCCI_ECALL_MSD_TYPE);
+ //ASSERT(info.length == (length - sizeof(spcBufInfo)));
+ memset(eCall_TX_Temp, 0, 800*sizeof(short));
+ curOffSet = SpcIo_GetDataFromAp(curOffSet, 1600, &eCall_TX_Temp, comeFrom);
+
+ MD_TRC_SPC_ECALL_CHECK_TX_CTRL_HEADER(eCall_TX_Temp[0]);
+ if(eCall_TX_Temp[0] == 0xAA)
+ {
+ memset(eCall_TX_CTRL_SEQ_State, 0, 800*sizeof(int16));
+ memcpy(eCall_TX_CTRL_SEQ_State, eCall_TX_Temp, 800*sizeof(int16));
+
+ for(i=0;i<30;i++)
+ {
+ MD_TRC_ECALL_TX_CTRL_STATE(i*5,eCall_TX_CTRL_SEQ_State[i*5],i*5+1,eCall_TX_CTRL_SEQ_State[i*5+1],i*5+2,eCall_TX_CTRL_SEQ_State[i*5+2],i*5+3,eCall_TX_CTRL_SEQ_State[i*5+3],i*5+4,eCall_TX_CTRL_SEQ_State[i*5+4]);
+ }
+ }
+ else if(eCall_TX_Temp[0] == 0xBB)
+ {
+ memset(eCall_TX_CTRL_SEQ_dlData, 0, 800*sizeof(int16));
+ memcpy(eCall_TX_CTRL_SEQ_dlData, eCall_TX_Temp, 800*sizeof(int16));
+ for(i=0;i<30;i++)
+ {
+ MD_TRC_ECALL_TX_CTRL_DATA(i*5,eCall_TX_CTRL_SEQ_dlData[i*5],i*5+1,eCall_TX_CTRL_SEQ_dlData[i*5+1],i*5+2,eCall_TX_CTRL_SEQ_dlData[i*5+2],i*5+3,eCall_TX_CTRL_SEQ_dlData[i*5+3],i*5+4,eCall_TX_CTRL_SEQ_dlData[i*5+4]);
+ }
+ }
+ else if(eCall_TX_Temp[0] == 0xCC)
+ {
+ memset(eCall_TX_CTRL_SEQ_dlMetric, 0, 800*sizeof(short));
+ memcpy(eCall_TX_CTRL_SEQ_dlMetric, eCall_TX_Temp, 800*sizeof(int16));
+ for(i=0;i<30;i++)
+ {
+ MD_TRC_ECALL_TX_CTRL_METRIC(i*5,eCall_TX_CTRL_SEQ_dlMetric[i*5],i*5+1,eCall_TX_CTRL_SEQ_dlMetric[i*5+1],i*5+2,eCall_TX_CTRL_SEQ_dlMetric[i*5+2],i*5+3,eCall_TX_CTRL_SEQ_dlMetric[i*5+3],i*5+4,eCall_TX_CTRL_SEQ_dlMetric[i*5+4]);
+ }
+ }
+
+
+}
+
+void Set_eCall_Par_Crtl_Switch(kal_uint8 Switch)
+{
+
+ gSpc.eCall_Ctrl_Seq_Switch = Switch;
+ MD_TRC_ECALL_IVS_SEND_PAR_CTRL_SWITCH(gSpc.eCall_Ctrl_Seq_Switch);
+}
+
+void spc_eCall_RX_CTRL_Data(uint16 header)
+{
+
+ spcBufInfo info;
+ bool sendResult = true;
+ info.syncWord = 0x2A2A;
+ info.type = AUD_CCCI_ECALL_MSD_TYPE;
+ info.length = 1600;
+ uint32 i;
+
+ if(gSpc.eCall_Ctrl_Seq_Switch == 0)
+ {
+ return;
+ }
+
+ if(header == 0xDD )
+ {
+ sendResult = SpcIO_WriteDataToAp(&info, sizeof(spcBufInfo), eCall_RX_CTRL_SEQ_State, info.length, NULL, 0,SPCIO_MSG_FROM_SPC_ECALL_RX_CTRL_PAR_NOTIFY);
+ for(i=0;i<30;i++)
+ {
+ MD_TRC_ECALL_RX_CTRL_STATE(i*5,eCall_RX_CTRL_SEQ_State[i*5],i*5+1,eCall_RX_CTRL_SEQ_State[i*5+1],i*5+2,eCall_RX_CTRL_SEQ_State[i*5+2],i*5+3,eCall_RX_CTRL_SEQ_State[i*5+3],i*5+4,eCall_RX_CTRL_SEQ_State[i*5+4]);
+ }
+ }
+ else if(header == 0xEE)
+ {
+ sendResult = SpcIO_WriteDataToAp(&info, sizeof(spcBufInfo), eCall_RX_CTRL_SEQ_dlData, info.length, NULL, 0,SPCIO_MSG_FROM_SPC_ECALL_RX_CTRL_PAR_NOTIFY);
+ for(i=0;i<30;i++)
+ {
+ MD_TRC_ECALL_RX_CTRL_DATA(i*5,eCall_RX_CTRL_SEQ_dlData[i*5],i*5+1,eCall_RX_CTRL_SEQ_dlData[i*5+1],i*5+2,eCall_RX_CTRL_SEQ_dlData[i*5+2],i*5+3,eCall_RX_CTRL_SEQ_dlData[i*5+3],i*5+4,eCall_RX_CTRL_SEQ_dlData[i*5+4]);
+ }
+ }
+ else if (header == 0xFF)
+ {
+ sendResult = SpcIO_WriteDataToAp(&info, sizeof(spcBufInfo), eCall_RX_CTRL_SEQ_dlMetric, info.length, NULL, 0,SPCIO_MSG_FROM_SPC_ECALL_RX_CTRL_PAR_NOTIFY);
+ for(i=0;i<30;i++)
+ {
+ MD_TRC_ECALL_RX_CTRL_METRIC(i*5,eCall_RX_CTRL_SEQ_dlMetric[i*5],i*5+1,eCall_RX_CTRL_SEQ_dlMetric[i*5+1],i*5+2,eCall_RX_CTRL_SEQ_dlMetric[i*5+2],i*5+3,eCall_RX_CTRL_SEQ_dlMetric[i*5+3],i*5+4,eCall_RX_CTRL_SEQ_dlMetric[i*5+4]);
+ }
+ }
+
+ if(sendResult == false) {
+ MD_TRC_SPC_SEND_DATA_TO_AP_FAIL();
+ }
+}
+
+void spc_eCall_Handshake_Info_Notify (uint16 header,uint32 data)
+{
+ MD_TRC_ECALL_IVS_ECALL_HANDSHAKE_INFO_NOTIFY(header,data);
+ SpcIO_SendMsgToAp( SPCIO_MSG_FROM_ECALL_HANDSHAKE_INFO_ACK, header, data);
+}
+
+void spc_Set_Ecall_Lib_Status(uint8 status)
+{
+ gSpc.eCall_LIB_Status = status;
+}
+
+uint8 spc_Get_Ecall_Lib_Status(void)
+{
+ return gSpc.eCall_LIB_Status;
+}
+
+#if defined(__L5_SUPPORT__)
+void spc_L5ECALL_Status_Info_Callback(kal_uint16 status, kal_uint32 data){
+ ilm_SP_L5ECALL_Status_INFO_t *local_para;
+ local_para = (ilm_SP_L5ECALL_Status_INFO_t *) construct_local_para( sizeof(ilm_SP_L5ECALL_Status_INFO_t), TD_CTRL );
+ local_para->Status = status;
+ local_para->Data = data;
+ msg_send6(MOD_L1SP, MOD_L5UECALL, L1SP_L5UECALL_SAP, MSG_ID_L5UECALL_L1SP_ECALL_STATUS_IND, (local_para_struct *)local_para, NULL);
+}
+#endif
+#endif
+
+#if defined(_SPE_ENH_DSP_PARSE_)
+
+void spc_ReceiveEMIParInfo(const kal_uint32 offset, const kal_uint16 length, SPC_MSG_FROM_T comeFrom)
+{
+
+ //kal_int16 procLen;
+ kal_uint16 curOffset;
+ spcBufInfo header;
+ spc_sph_on_info_t info;
+ kal_uint32 EMI_Offset;
+
+
+ //unsigned short Common_Para[NUM_COMMON_PARAS];
+ //unsigned short Dbg_Para[16];
+
+ #if defined(SPH_CHIP_BACK_PHONECALL_USE)
+ return;
+ #endif // SPH_CHIP_BACK_PHONECALL_USE
+
+ //header
+ curOffset = SpcIo_GetDataFromAp(offset, sizeof(spcBufInfo), &header, comeFrom);
+ //header checking
+
+ ASSERT(header.syncWord == 0xA2A2);
+ ASSERT( (header.type == AUD_CCCI_STRMBUF_TYPE_SPH_INFO) );
+ ASSERT(header.length == (length - sizeof(spcBufInfo)));
+
+ curOffset = SpcIo_GetDataFromAp(curOffset, sizeof(spc_sph_on_info_t), &info, comeFrom);
+ MD_TRC_SPC_SPE_CHECK_EMI_COMMON_PAR(info.common_param[0], info.common_param[1], info.common_param[2], info.common_param[3], info.common_param[4], info.common_param[5], info.common_param[6], info.common_param[7], info.common_param[8], info.common_param[9], info.common_param[10], info.common_param[11]);
+ MD_TRC_SPC_SPE_CHECK_EMI_DBG_PAR(info.debug_info[0], info.debug_info[1], info.debug_info[2], info.debug_info[3], info.debug_info[4], info.debug_info[5], info.debug_info[6], info.debug_info[7], info.debug_info[8], info.debug_info[9], info.debug_info[10], info.debug_info[11]);
+ L1SP_LoadCommonSpeechPara((uint16 *) info.common_param);
+ L1Audio_SetDebugInfo((uint16 *) info.debug_info);
+ VMREC_ConfigEpl();
+ spc_dev_LoopbackPoint_DVT(info.debug_info[15]);
+ MD_TRC_SPC_SPE_CHECK_EMI_SPEECH_INFO(2,info.param_usip_index,info.param_usip_len,info.param_shm_valid, info.param_path);
+ EMI_Offset =0;
+ if(info.param_path == 2 && info.param_shm_valid ==1 )
+ {
+ EMI_Offset =( info.param_usip_index + EMI_SPE_PAR_OFFSET)/2 ;
+ //memcpy(Common_Para, (((unsigned short *)(SP_GetSphParamBufAddr())) +EMI_Offset+EMI_NEED_3K_0+ EMI_MD_COMMON_PAR_OFFSET), sizeof(unsigned short) * NUM_COMMON_PARAS);
+ // memcpy(Dbg_Para, (((unsigned short *)(SP_GetSphParamBufAddr())) + EMI_Offset +EMI_NEED_3K_0+EMI_MD_DBG_PAR_OFFSET), sizeof(unsigned short) * 16);
+ //kal_trace( TRACE_FUNC,SPC_SPE_CHECK_EMI_COMMON_PAR,Common_Para[0],Common_Para[1],Common_Para[2],Common_Para[3],Common_Para[4],Common_Para[5],Common_Para[6],Common_Para[7],Common_Para[8],Common_Para[9],Common_Para[10],Common_Para[11]);
+ //kal_trace( TRACE_FUNC,SPC_SPE_CHECK_EMI_DBG_PAR,Dbg_Para[0],Dbg_Para[1],Dbg_Para[2],Dbg_Para[3],Dbg_Para[4],Dbg_Para[5],Dbg_Para[6],Dbg_Para[7],Dbg_Para[8],Dbg_Para[9],Dbg_Para[10],Dbg_Para[11]);
+ // L1SP_LoadCommonSpeechPara((uint16 *)Common_Para);
+ //L1Audio_SetDebugInfo((uint16 *)Dbg_Para);
+ l1sp_SetParEMIInfo(EMI_Offset,info.param_usip_len);
+ SetSpeechEnhancement(true);
+ }else if (info.param_path == 2 && info.param_shm_valid ==2 ) //use previous par.
+ {
+ SetSpeechEnhancement(true);
+ }
+ else
+ {
+ // need use MD default par
+ l1sp_SetParEMIInfo(EMI_MD_DEFAULT_OFFSET,EMI_MD_DEFAULT_LEN);
+ //L1SP_LoadCommonSpeechPara((uint16 *)Speech_Common_Para);
+ // L1Audio_SetDebugInfo((uint16 *)Debug_Info_Para);
+ SetSpeechEnhancement(true);
+
+ }
+
+}
+
+#endif
+
+void spc_setLoopback_dl_ul(kal_bool enable){
+ kal_prompt_trace(MOD_L1SP, "[set_spcLoopback_dl_ul] %d", enable);
+
+ ilm_SPC_SETLOOPBACK_DL_UL_t *local_para;
+
+ local_para = (ilm_SPC_SETLOOPBACK_DL_UL_t *) construct_local_para( sizeof(ilm_SPC_SETLOOPBACK_DL_UL_t), TD_CTRL );
+ local_para -> enable = enable;
+
+ msg_send6(MOD_L1SP, MOD_MED, AUDIO_SAP, MSG_ID_AUDIO_M2M_SPC_SETLOOPBACK_DL_UL, (local_para_struct *)local_para, NULL);
+
+}