/***************************************************************************** * Copyright (C) 2018 SP Technology * AISTB2 HAL implementation. * SP Technology All Rights Reserved. * * Author: SP Technology * Date: 2019.01.14 * Description: * Note: *****************************************************************************/ /* * Comment out if you want to remove log. */ #define LOG_TAG "HAL_mic" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if defined(_INTEK_PORTING_) #include #endif #include "utils.h" #include "EchoEffect.h" #include "HAL_mic.h" #ifdef __cplusplus extern "C" { #endif #if defined(_INTEK_PORTING_) #define HAL_MIC_DIRECT_STOP_START #define HAL_MIC_ECHO_PROCESS_WO_RBUF #endif #define SYNA_ALSA_PARAM_PERIOD 256 #define SYNA_ALSA_PARAM_N 8 #define SYNA_ALSA_PARAM_RATE 48000 #define INPUT_BUF_LENGHT 2000 #define RAW_BUF_CNT 4 #define AEC_BUF_CNT_GOOGLE 24 #define AEC_BUF_CNT_CAF 4 #define DUMP_THREAD_MSG_Q_SIZE 16 #define SYNA_AEC_REF_ALSA_CARD 0 #define SYNA_AEC_REF_ALSA_DEV 0 #define SYNA_BUILT_IN_MIC_CARD 0 #define SYNA_BUILT_IN_MIC_DEV 1 #define FRAME_SIZE_32BIT 8 #define SAMPLES_PER_FRAME 0x1000 #if 0 //defined(_INTEK_PORTING_) #define MAX_MIC_VOLUME_TABLE 33 #define DEFAULT_MIC_VOLUME_LEVEL 24 #endif typedef enum{ stream_raw = 0, stream_max } stream_index; typedef struct{ uint32_t sample_rate; audio_channel_mask_t channel_mask; audio_format_t format; } effect_audio_config; int effect_init(); void effect_deinit(); int stream_read(stream_index stream, unsigned char *buf, size_t bytes); typedef enum { dump_index_ref, dump_index_effect } dump_index_type; typedef struct{ dump_index_type index; int size; void* buf; } dump_msg_type; typedef struct { unsigned char *buf; int size; int rd; int wd; int fullness; pthread_mutex_t lock; } ringbuf_type; //static MIC_STATE mic_state = MIC_ON; static int dump_effect_enable = 0; static int dump_ref_enable = 0; static struct pcm *ref_pcm = NULL; static unsigned int pcm_buf_size = 0; //dump files static FILE* dump_effect_fp = NULL; static FILE* dump_ref_fp = NULL; static unsigned int dump_total = 0; static pthread_t tid_dump; static sync_queue* msgq_dump = NULL; static pthread_attr_t attr; // effect workder static pthread_t tid_effect_worker; static ringbuf_type ringbuf_raw; static int effect_worker_exit = 0; //static pthread_mutex_t effectlock; static pthread_t tid_input_reader_ref; static ringbuf_type ringbuf_ref; //static effect_audio_config streamConfigs[stream_max] = { // {48000, AUDIO_CHANNEL_IN_MONO, AUDIO_FORMAT_PCM_16_BIT}, //}; #if defined(_INTEK_PORTING_) #define PROPERTY_IS_MIC_OWNER "vendor.audio.skb.d0_owner_is" #define PROPERTY_SET_MIC_OWNER "vendor.audio.skb.d0_owner_to_be" #define OWNER_NUGU "nugu" #define OWNER_KARAOKE "karaoke" #define HAL_MIC_WORKER_STAE_IDLE 0 #define HAL_MIC_WORKER_STAE_RUN 1 #define HAL_MIC_SLEEP_TIME_MSEC 250 /* 250ms */ #define HAL_MIC_WAIT_TIME_SEC 2 /* sec */ #define HAL_MIC_WAIT_COUNT (HAL_MIC_WAIT_TIME_SEC*1000/HAL_MIC_SLEEP_TIME_MSEC) #if 0 static float micVolume[MAX_MIC_VOLUME_TABLE] = { -103.0, -36.0, -35.0, -34.0, -33.0, -32.0, -31.0, -30.0, -29.0, -28.0, -27.0, -26.0, -25.0, -24.0, -23.0, -22.0, -21.0, -20.0, -19.0, -18.0, -17.0, -16.0, -15.0, -14.0, -13.0, -12.0, -11.0, -10.0, -8.0, -6.0, -4.0, -2.0, 0.0, }; static int micVolumeLv = DEFAULT_MIC_VOLUME_LEVEL; #else static int micVolumeLv = 100; #endif static int mic_act = 0; static int mic_worker_state = HAL_MIC_WORKER_STAE_IDLE; #if !defined(HAL_MIC_DIRECT_STOP_START) static int mic_worker_exit = 0; static pthread_t tid_mic_worker; #endif static int mic_switch_worker_exit = 0; static pthread_t tid_mic_switch_worker; #endif static HANDLE hStream = NULL; #if defined(_INTEK_PORTING_) static int gMicSwitchStatus = 0; static int readMicState(void) { int fd; char status[64]; int retval = 0; if ((fd = open("/sys/class/switch/mic/state", O_RDONLY)) < 0) { return false; } if (read(fd, status, 64) < 0) { close(fd); return 0; } if (!strncmp(status, "1", 1)) retval = 1; else retval = 0; close(fd); //L_DEBUG("readMicState retval=%d", retval); return retval; } #endif static void dump_data(dump_index_type index, void*buf, int size) { char* path; FILE* fp; switch(index) { case dump_index_ref: path = (char*)"/data/vendor/ref.dat"; fp = dump_ref_fp; break; case dump_index_effect: path = (char*)"/data/vendor/effect.dat"; fp = dump_effect_fp; break; default: return; } if (fp == NULL) { fp = fopen(path, "w"); if (fp == NULL) { return; } L_DEBUG("open dump file %p\n", fp); if (index == dump_index_ref) { dump_ref_fp = fp; }else if (index == dump_index_effect) { dump_effect_fp = fp; } dump_total = 0; } if (fp) { if (dump_total < 400*1024*1024) { fwrite(buf, size, 1, fp); dump_total += size; } } } static void dump_data_wrap(dump_index_type index, void* buf, int size) { dump_msg_type msg; msg.index = index; msg.size = size; msg.buf = malloc(size); memcpy(msg.buf, buf, size); sync_queue_push(msgq_dump, &msg); } static void* dump_thread(void * args __unused){ //int r; dump_msg_type msg; L_DEBUG("dump thread is running.\n"); while (!effect_worker_exit) { sync_queue_pop(msgq_dump, &msg); if (msg.index == -1) { break; } dump_data(msg.index, msg.buf, msg.size); free(msg.buf); } L_DEBUG("dump_thread exit\n"); return 0; } static void ringbuf_write(ringbuf_type* ringbuf, unsigned char *buf, int size) { pthread_mutex_lock(&ringbuf->lock); unsigned char* pw = ringbuf->buf + ringbuf->wd; //L_DEBUG("ringbuf_write ringbuf->wd=0x%08x size=%d\n", ringbuf->wd, size); if (ringbuf->wd + size > ringbuf->size) { int len1 = ringbuf->size - ringbuf->wd; int len2 = size - len1; //L_DEBUG("\t ringbuf_write split size=%d len1=%d,len2=%d\n", size, len1, len2); memcpy((void*)pw, buf, len1); memcpy(ringbuf->buf, (void*)((unsigned char*)buf + len1), len2); ringbuf->wd = len2; } else { //L_DEBUG("\t ringbuf_write one size=%d\n", size); memcpy((void*)pw, buf, size); ringbuf->wd += size; if (ringbuf->wd == ringbuf->size) { ringbuf->wd = 0; } } if (ringbuf->fullness + size <= ringbuf->size) { ringbuf->fullness += size; } else { ringbuf->fullness = ringbuf->size; ringbuf->rd = ringbuf->wd; if (ringbuf == &ringbuf_ref) { L_DEBUG("[%p]overflow %d", ringbuf, ringbuf->fullness + size - ringbuf->size); } } pthread_mutex_unlock(&ringbuf->lock); } static int ringbuf_read(ringbuf_type* ringbuf, unsigned char* buf, int size) { while(1) { if (ringbuf->fullness < size) { usleep(10000); return -1; } else { break; } } //L_DEBUG("ringbuf_read ringbuf->rd=0x%08x size=%d\n", ringbuf->rd, size); pthread_mutex_lock(&ringbuf->lock); if (ringbuf->rd + size <= ringbuf->size) { unsigned char* pr = (unsigned char*)ringbuf->buf + ringbuf->rd; //L_DEBUG("\t ringbuf_read one size=%d\n", size); memcpy(buf, (void*)(pr), size); ringbuf->rd += size; if (ringbuf->rd == ringbuf->size) { ringbuf->rd = 0; } } else { int len1 = ringbuf->size - ringbuf->rd; int len2 = size - len1; //L_DEBUG("\t ringbuf_read split size=%d len1=%d,len2=%d\n", size, len1, len2); memcpy(buf, (void*)((unsigned char*)ringbuf->buf + ringbuf->rd), len1); memcpy((void*)((unsigned char*)buf + len1), ringbuf->buf, len2); ringbuf->rd = len2; } ringbuf->fullness -= size; pthread_mutex_unlock(&ringbuf->lock); return 0; } #if defined(HAL_MIC_ECHO_PROCESS_WO_RBUF) static void process_effect(unsigned char *sound_data, int sample_cnt) { HRESULT rc = SUCCESS; //L_DEBUG("process_effect sample_cnt %d", sample_cnt); echo_process_pcm(sound_data, sound_data, sample_cnt * 2); if (dump_effect_enable) dump_data_wrap(dump_index_effect, sound_data, sample_cnt * 2); rc = AMP_SND_PushPCM_NonBlock(hStream, sound_data, sample_cnt * 2); if (rc != S_OK) { L_DEBUG("AMP_SND_PushPCM fail:%x\n", rc); } } #else static void process_effect(int sample_cnt) { int ret = 0; //unsigned char sound_data[SAMPLES_PER_FRAME * 2]; unsigned char *sound_data = NULL; sound_data = (unsigned char *)malloc(sample_cnt * 2); if (sound_data) { ret = stream_read(stream_raw, sound_data, sample_cnt * 2); if (ret == 0) { echo_process_pcm(sound_data, sound_data, sample_cnt * 2); if (dump_effect_enable) dump_data_wrap(dump_index_effect, sound_data, sample_cnt * 2); HRESULT rc = SUCCESS; rc = AMP_SND_PushPCM(hStream, sound_data, sample_cnt * 2); if (rc != S_OK) { L_DEBUG("AMP_SND_PushPCM fail:%x\n", rc); } } free(sound_data); } } #endif static int open_ref_input(){ int count = 10; struct pcm_config alsa_config; alsa_config.channels = 2; alsa_config.rate = SYNA_ALSA_PARAM_RATE; alsa_config.format = PCM_FORMAT_S32_LE; alsa_config.period_size = SYNA_ALSA_PARAM_PERIOD; alsa_config.period_count = SYNA_ALSA_PARAM_N; alsa_config.start_threshold = 0; alsa_config.stop_threshold = 0; alsa_config.silence_threshold = 0; ref_pcm = pcm_open(SYNA_AEC_REF_ALSA_CARD, SYNA_AEC_REF_ALSA_DEV, PCM_IN|PCM_MONOTONIC, &alsa_config); if (ref_pcm == NULL) { return -1; } while (count--) { if (!pcm_is_ready(ref_pcm)) { L_DEBUG("can't open ref i2s alsa input!"); usleep(100); } else { break; } } L_DEBUG("pcm_open ... count = %d", count); if (count <= 0) { pcm_close(ref_pcm); ref_pcm = NULL; return -1; } pcm_buf_size = pcm_frames_to_bytes(ref_pcm,pcm_get_buffer_size(ref_pcm)); L_DEBUG("pcm buffer size %d\n", pcm_buf_size); return 0; } #if !defined(_INTEK_PORTING_) static void copy_to_raw(void* buf, int size) { int i; int sample_cnt = size/FRAME_SIZE_32BIT; short tmp[16384]; int* p = (int*)buf; for(i=0; i < sample_cnt; i++){ tmp[i] = p[2*i]>>16; } ringbuf_write(&ringbuf_raw, (unsigned char*)tmp, 2*sample_cnt); } #endif #if !defined(HAL_MIC_ECHO_PROCESS_WO_RBUF) static void copy_to_mono(void* buf, int size) { int i; int sample_cnt = size/FRAME_SIZE_32BIT; //short tmp[SAMPLES_PER_FRAME * FRAME_SIZE_32BIT]; short *tmp; short* p = (short*)buf; tmp = (short*)malloc(sizeof(short)*sample_cnt); if (tmp) { //L_DEBUG("copy_to_mono: %d\n", size); for(i = 0; i < sample_cnt; i++){ tmp[i] = p[4*i]; } ringbuf_write(&ringbuf_raw, (unsigned char*)tmp, 2*sample_cnt); free(tmp); } } #endif static void* effect_worker(void * args __unused){ int ret = 0; //static unsigned int print_cnt = 0; //unsigned char mic_buf[pcm_buf_size]; //unsigned char ref_buf[pcm_buf_size]; unsigned char *ref_buf = NULL; #if defined(HAL_MIC_ECHO_PROCESS_WO_RBUF) int i; int sample_cnt = pcm_buf_size/FRAME_SIZE_32BIT; short *tmp = NULL; short* p = NULL; short multiple = 1; tmp = (short*)malloc(sizeof(short)*sample_cnt); if (!tmp) { return 0; } #endif ref_buf = (unsigned char*)malloc(pcm_buf_size); if (ref_buf) { while (!effect_worker_exit){ ret = ringbuf_read(&ringbuf_ref, ref_buf, pcm_buf_size); if (ret == 0) { if (dump_ref_enable) { dump_data_wrap(dump_index_ref, ref_buf, pcm_buf_size); } #if defined(HAL_MIC_ECHO_PROCESS_WO_RBUF) p = (short*)ref_buf; if (gMicSwitchStatus) { for(i = 0; i < sample_cnt; i++) { tmp[i] = p[4*i + 1] * multiple; } process_effect((unsigned char*)tmp, pcm_buf_size/FRAME_SIZE_32BIT); } #else copy_to_mono(ref_buf, pcm_buf_size); process_effect(pcm_buf_size/FRAME_SIZE_32BIT); #endif } } free(ref_buf); } #if defined(HAL_MIC_ECHO_PROCESS_WO_RBUF) if (tmp) free(tmp); #endif L_DEBUG("effect_worker exit"); return 0; } static void* input_reader(void * args){ int ret; //unsigned char buf[pcm_buf_size]; unsigned char *buf = NULL; //int pcm_dev_no = (int)args; struct pcm* pcm_dev; ringbuf_type* ringbuf; (void)args; prctl(PR_SET_NAME, "reader_ref", 0, 0, 0); pcm_dev = ref_pcm; ringbuf = &ringbuf_ref; buf = (unsigned char *)malloc(pcm_buf_size); if (buf) { while (!effect_worker_exit) { ret = pcm_read(pcm_dev, buf, pcm_buf_size); if (ret == 0) ringbuf_write(ringbuf, buf, pcm_buf_size); else { L_DEBUG("input_reader pcm read error"); usleep(10000); } } free(buf); } return 0; } #if !defined(_INTEK_PORTING_) static void cp_16_32(void* buf16, void* buf32, int size) { int sample_cnt = size/2; int i; int* p32 = (int*)buf32; short* p16 = (short*)buf16; for(i=0; i < sample_cnt; i++) { p32[i] = ((int)p16[i]) << 16; } } #endif int effect_init() { int r = open_ref_input(); if (r != 0){ L_DEBUG("effect_init: failed!"); return -1; } pthread_attr_init(&attr); if(pthread_attr_setschedpolicy(&attr, SCHED_RR) !=0 ) { L_DEBUG("Unable to set policy.\n"); } struct sched_param schedparam; pthread_attr_getschedparam(&attr, &schedparam); schedparam.sched_priority = 98; int res = pthread_attr_setschedparam(&attr, &schedparam); if (res != 0) { L_DEBUG( "unable set priority!"); } memset((void*)&ringbuf_raw, 0 ,sizeof(ringbuf_type)); ringbuf_raw.size = RAW_BUF_CNT*pcm_buf_size; ringbuf_raw.buf = (unsigned char*)malloc(ringbuf_raw.size); pthread_mutex_init(&(ringbuf_raw.lock), NULL); if (dump_effect_enable || dump_effect_enable) msgq_dump = sync_queue_create(DUMP_THREAD_MSG_Q_SIZE, sizeof(dump_msg_type)); int input_buf_cnt = (INPUT_BUF_LENGHT*SYNA_ALSA_PARAM_RATE)/((pcm_buf_size/FRAME_SIZE_32BIT)*1000); L_DEBUG("input buf cnt %d\n", input_buf_cnt); memset((void*)&ringbuf_ref, 0 ,sizeof(ringbuf_type)); ringbuf_ref.size = input_buf_cnt*pcm_buf_size; ringbuf_ref.buf = (unsigned char*)malloc(ringbuf_ref.size); pthread_mutex_init(&(ringbuf_ref.lock), NULL); return 0; } void effect_deinit() { if (ref_pcm) { pcm_close(ref_pcm); ref_pcm = NULL; L_DEBUG("pcm_close... \n"); } if (ringbuf_raw.buf) { free(ringbuf_raw.buf); ringbuf_raw.buf = NULL; } pthread_mutex_destroy(&(ringbuf_raw.lock)); if (ringbuf_ref.buf) { free(ringbuf_ref.buf); ringbuf_ref.buf = NULL; } pthread_mutex_destroy(&(ringbuf_ref.lock)); if (msgq_dump) { sync_queue_delete(msgq_dump); msgq_dump = NULL; } if (dump_ref_fp) fclose(dump_ref_fp); if (dump_effect_fp) fclose(dump_effect_fp); pthread_attr_destroy(&attr); } int stream_read(stream_index stream, unsigned char *buf, size_t bytes) { int ret = 0; //static long long int cnt_gg=0, cnt_caf=0, cnt_raw = 0; //static int print_int = 100; if (stream == stream_raw) { #if 0 if ((cnt_raw++%print_int)==0) { L_DEBUG("raw read %lld", cnt_raw); } #endif ret = ringbuf_read(&ringbuf_raw, buf, bytes); } else { pcm_read(ref_pcm, buf, bytes); } return ret; } int sound_init() { //AMP_STATE state; HRESULT rc; AMP_SND_STRM_ATTR stStrmAttr; int i; UINT32 aChMask[] = { AMP_AUDIO_CHMASK_LEFT, AMP_AUDIO_CHMASK_RGHT, AMP_AUDIO_CHMASK_CNTR, AMP_AUDIO_CHMASK_LFE, AMP_AUDIO_CHMASK_SRRD_LEFT, AMP_AUDIO_CHMASK_SRRD_RGHT }; static UINT32 m_pcm_bit_depth = 16; static UINT32 m_chnr = 1; static UINT32 m_fs = 48000; static INT32 m_spk_mode = AMP_AUDIO_CHMAP_3_2_0; static INT32 m_lfe_mode = AMP_AUDIO_LFE_ON; AMP_APP_PARASPKMODE stSpkMode; rc = AMP_SND_Init(); if (rc != SUCCESS) { L_DEBUG("AMP_SND_Init fail:%x!\n", rc); return -1; } AmpMemClear(&stSpkMode, sizeof(AMP_APP_PARASPKMODE)); stSpkMode.eSpkMode = m_spk_mode; stSpkMode.eLfeMode = m_lfe_mode; AMP_SND_SetSpkMode(&stSpkMode); AmpMemClear(&stStrmAttr, sizeof(AMP_SND_STRM_ATTR)); stStrmAttr.uiBlkNum = 16; stStrmAttr.uiBlkLen = 1024 * (m_pcm_bit_depth >> 3) * m_chnr; stStrmAttr.uiChannels = m_chnr; stStrmAttr.uiBitDepth = m_pcm_bit_depth; stStrmAttr.uiSampleRate = m_fs; stStrmAttr.uiBufNr = 1; for (i = 0; i < (int)stStrmAttr.uiChannels; i++) { stStrmAttr.uiChanMask[i] = aChMask[i]; } rc = AMP_SND_CreateStream(&stStrmAttr, &hStream); if (rc != SUCCESS) { L_DEBUG("AMP_SND_CreateStream fail:%x.\n", rc); return -1; } AMP_SND_SetBitDepth(hStream, m_pcm_bit_depth); AMP_SND_SetSampleRate(hStream, m_fs); return 0; } int amp_init() { #if !defined(_INTEK_PORTING_) char const *client_argv[] = { "client", "iiop:1.0//127.0.0.1:999/AMP::FACTORY/factory" }; HRESULT result = 0xFFFFFFFF; AMP_FACTORY hFactory; //UINT32 test_case = 0; MV_OSAL_Init(); /* Get factory */ result = AMP_Initialize(2, (char**)client_argv, &hFactory); assert(result == SUCCESS); result = AMP_GetFactory(&hFactory); assert(result == SUCCESS); int ret = sound_init(); assert(ret != 0); (void)ret; #endif return 0; } int amp_deinit() { #if !defined(_INTEK_PORTING_) // sound_Deinit AMP_SND_DestroyStream(hStream); hStream = NULL; AMP_SND_Deinit(); AMP_Deinitialize(); #endif return 0; } #if defined(_INTEK_PORTING_) static void* mic_worker(void * args __unused) { HAL_Error ret; int wait_count; char property[PROPERTY_VALUE_MAX]; memset(property, 0, PROPERTY_VALUE_MAX); property_set(PROPERTY_SET_MIC_OWNER, OWNER_KARAOKE); wait_count = 0; #if defined(HAL_MIC_DIRECT_STOP_START) while (wait_count < HAL_MIC_WAIT_COUNT) #else while ((!mic_worker_exit) && (wait_count < HAL_MIC_WAIT_COUNT)) #endif { if (mic_worker_state == HAL_MIC_WORKER_STAE_IDLE) { property_get(PROPERTY_IS_MIC_OWNER, property, ""); if ((!strcmp(property, OWNER_KARAOKE))) { ret = HAL_MicInit(); L_DEBUG("mic_worker 1 ret =%d", ret); if (ret == HAL_OK) { HAL_MicSetOnOff(MIC_ON); mic_worker_state = HAL_MIC_WORKER_STAE_RUN; #if !defined(HAL_MIC_DIRECT_STOP_START) mic_worker_exit = 1; #endif break; } } } usleep(HAL_MIC_SLEEP_TIME_MSEC*1000); wait_count++; L_DEBUG("mic_worker wait_count=%d", wait_count); } if ((wait_count == HAL_MIC_WAIT_COUNT) && (mic_worker_state != HAL_MIC_WORKER_STAE_RUN)) { ret = HAL_MicInit(); L_DEBUG("mic_worker 2 ret =%d", ret); if (ret == HAL_OK) { HAL_MicSetOnOff(MIC_ON); mic_worker_state = HAL_MIC_WORKER_STAE_RUN; } } L_DEBUG("mic_worker exit"); return 0; } static void* mic_switch_worker(void * args __unused) { int micStatus = 0, micInCnt = 0; gMicSwitchStatus = readMicState(); while (!mic_switch_worker_exit) { if (gMicSwitchStatus) { gMicSwitchStatus = readMicState(); } else { micStatus = readMicState(); if (micStatus) { micInCnt++; if (micInCnt >= (4 + 2) /* 250ms*(4 + 2) = 1.5 sec */) { gMicSwitchStatus = 1; } } else micInCnt = 0; } usleep(HAL_MIC_SLEEP_TIME_MSEC*1000); } L_DEBUG("mic_switch_worker exit"); return 0; } int HAL_MicActivate(void) { L_DEBUG("HAL_MicActivate Enter"); if (mic_act) return 0; mic_worker_state = HAL_MIC_WORKER_STAE_IDLE; #if defined(HAL_MIC_DIRECT_STOP_START) mic_worker(NULL); #else mic_worker_exit = 0; pthread_create(&tid_mic_worker, NULL, mic_worker, NULL); #endif mic_switch_worker_exit = 0; pthread_create(&tid_mic_switch_worker, NULL, mic_switch_worker, NULL); mic_act = 1; L_DEBUG("HAL_MicActivate Leave"); return 0; } int HAL_MicDeactivate(void) { void* retval; L_DEBUG("HAL_MicDeactivate Enter"); if (!mic_act) return 0; mic_switch_worker_exit = 1; pthread_join(tid_mic_switch_worker, &retval); #if !defined(HAL_MIC_DIRECT_STOP_START) mic_worker_exit = 1; pthread_join(tid_mic_worker, &retval); #endif if (mic_worker_state == HAL_MIC_WORKER_STAE_RUN) { HAL_MicSetOnOff(MIC_OFF); HAL_MicDeinit(); } property_set(PROPERTY_SET_MIC_OWNER, OWNER_NUGU); mic_act = 0; L_DEBUG("HAL_MicDeactivate Leave"); return 0; } #endif /** * @return HAL interface version */ int HAL_MicGetVersion() { L_DEBUG("%s()", __FUNCTION__); return 0; } HAL_Error HAL_MicInit() { HAL_Error ret = HAL_OK; L_DEBUG("%s()", __FUNCTION__); if (amp_init() < 0) { ret = HAL_ERROR; goto amp_init_failed; } if (effect_init() < 0) { ret = HAL_ERROR; goto effect_init_failed; } return ret; effect_init_failed: amp_deinit(); amp_init_failed: return ret; } HAL_Error HAL_MicDeinit() { L_DEBUG("%s()", __FUNCTION__); effect_deinit(); amp_deinit(); return HAL_OK; } HAL_Error HAL_MicSetOnOff(MIC_STATE status) { HAL_Error ret = HAL_OK; void* retval; L_DEBUG("%s(%d)", __FUNCTION__, status); switch (status) { case MIC_MAX: HAL_MicSetEchoLevel(HAL_MicGetEchoMaxLevel()); case MIC_ON: #if defined(_INTEK_PORTING_) HAL_MicSetVolume(micVolumeLv); #endif echo_state_set(true); effect_worker_exit = 0; pthread_create(&tid_effect_worker, NULL, effect_worker, NULL); if (dump_effect_enable || dump_effect_enable) pthread_create(&tid_dump, NULL, dump_thread, NULL); pthread_create(&tid_input_reader_ref, NULL, input_reader, (void*)1); break; case MIC_OFF: echo_state_set(false); effect_worker_exit = 1; pthread_join(tid_input_reader_ref, &retval); if (dump_effect_enable || dump_effect_enable) pthread_join(tid_dump, &retval); pthread_join(tid_effect_worker, &retval); break; default: ret = HAL_ERROR; break; } return ret; } MIC_STATE HAL_MicGetOnOff() { L_DEBUG("%s", __FUNCTION__); bool state = echo_state_get(); return state ? MIC_ON : MIC_OFF; } HAL_Error HAL_MicSetEchoLevel(int lv) { L_DEBUG("%s(%d)", __FUNCTION__, lv); echo_params param; echo_params_get(¶m); #if defined(_INTEK_PORTING_) if (lv > HAL_MicGetEchoMaxLevel()) lv = HAL_MicGetEchoMaxLevel(); #endif param.delay = lv; echo_params_set(¶m); return HAL_OK; } int HAL_MicGetEchoLevel() { L_DEBUG("%s", __FUNCTION__); echo_params param; echo_params_get(¶m); return param.delay; } int HAL_MicGetEchoMaxLevel() { L_DEBUG("%s", __FUNCTION__); echo_params param; echo_params_max_get(¶m); return param.delay; } HAL_Error HAL_MicSetVolume(unsigned int volume) { L_DEBUG("%s()", __FUNCTION__); #if defined(_INTEK_PORTING_) #if 0 if (!((0 <= volume) && (volume < MAX_MIC_VOLUME_TABLE))) return HAL_ERROR; #else if (!((0 <= volume) && (volume <= 100))) return HAL_ERROR; #endif #endif if (hStream) { #if 0 //defined(_INTEK_PORTING_) L_DEBUG("%s() volume=%d -> %f", __FUNCTION__, volume, micVolume[volume]); AMP_SND_SetStreamVolumeIndB(hStream, micVolume[volume]); #else #if defined(_INTEK_PORTING_) float fVolume = 12.0 - (100.0 - (float)volume)/2.0; AMP_SND_SetStreamVolumeIndB(hStream, fVolume); L_DEBUG("volume: %f\n", fVolume); #else AMP_SND_SetStreamVolume(hStream, volume); AMP_SND_GetStreamVolume(hStream, &volume); L_DEBUG("volume: %d\n", volume); #endif //set volume in db, please refer to //AMP_SND_SetStreamVolumeIndB(hStream, volume); #endif } micVolumeLv = volume; return HAL_OK; } #if defined(_INTEK_PORTING_) HAL_Error HAL_MicGetVolume(int *volume) { L_DEBUG("%s()", __FUNCTION__); if (volume) *volume = micVolumeLv; L_DEBUG("%s() micVolumeLv=%d", __FUNCTION__, micVolumeLv); return HAL_OK; } #endif HAL_Error HAL_MicPause() { L_DEBUG("%s", __FUNCTION__); return HAL_OK; } HAL_Error HAL_MicResume() { L_DEBUG("%s", __FUNCTION__); return HAL_OK; } #ifdef __cplusplus } #endif