FreeCalypso > hg > fc-magnetite
view src/cs/services/etm/etm_audio.c @ 30:4993332e514b
atp.lib done
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Thu, 29 Sep 2016 15:29:16 +0000 |
parents | 945cf7f506b2 |
children | 9394305d4ff5 |
line wrap: on
line source
/******************************************************************************** * Enhanced TestMode (ETM) * @file etm_audio.c (Support for AUDIO commands) * * @author Kim T. Peteren (ktp@ti.com) * @version 0.8 * * * History: * * Date Modification * ------------------------------------ * 16/06/2003 Creation * 30/06/2003 Small cleanup in func. etm_audio_write, etm_audio_saveload and * etm_aud_wait_for_aud_event is updated and renamed * 12/08/2003 The func. etm_audio_write has been updated regarding the AEC struct. * 14/08/2003 The func. etm_audio_read has been updated regarding the AEC struct. * 17/03/2004 Modified the event handling, events revceived from the Audio SWE. * Integrated event callback function, etm_audio_callback(). * * (C) Copyright 2003 by Texas Instruments Incorporated, All Rights Reserved *********************************************************************************/ #include "etm/etm.h" #include "etm/etm_api.h" #include "etm/etm_trace.h" #include "etm/etm_env.h" // Need because use of T_ETM_ENV_CTRL_BLK #include "etm/etm_audio_err.h" // Privat Audio error codes for PC and Target #include "etm/etm_trace.h" #include "audio/audio_api.h" #include "rv/rv_general.h" #include "spi/spi_drv.h" // used for codec read/write #include "memif/mem.h" #include <string.h> /****************************************************************************** * Globals *****************************************************************************/ // Version of the ETM AUDIO module //const uint16 etm_audio_revision = (1<<12) | (0x1); extern T_ETM_ENV_CTRL_BLK *etm_env_ctrl_blk; static int etm_audio_event_status = 0; /****************************************************************************** * Internal prototypes *****************************************************************************/ int etm_audio(uint8 *indata, int insize); T_RV_HDR *etm_audio_wait_for_event(UINT16 msg_id_expected); T_ETM_PKT *etm_audio_setup(uint8 fid, uint8 cfg_data); void etm_audio_callback(void *event_from_audio); /****************************************************************************** * Register the Audio Module to the ETM database *****************************************************************************/ int etm_audio_init(void) { int result; result = etm_register("AUDIO", ETM_AUDIO, 0, 0, etm_audio); return result; } /****************************************************************************** * Audio Full Access Read Function *****************************************************************************/ int etm_audio_read(T_ETM_PKT *pkt, uint8 *buf) { int result, size = 0, size_tmp, i; uint8 param; T_AUDIO_FULL_ACCESS_READ audio; T_AUDIO_AEC_CFG *aec_parameter = NULL; void *parameter = NULL; param = *buf; if ((result = etm_pkt_put8(pkt, param)) < 0) return result; tr_etm(TgTrAudio, "ETM AUDIO: _audio_read: param(%d)", param); audio.variable_indentifier = param; audio.data = (T_AUDIO_FULL_ACCESS_READ *) &pkt->data[2]; //data[0] = fid //data[1] = parameter/identifier if ((result = audio_full_access_read(&audio)) != AUDIO_OK){ tr_etm(TgTrAudio, "ETM AUDIO: _audio_read: ERROR(%d)", result); if (result == AUDIO_ERROR) return ETM_INVAL; // Invalid audio parameter else return ETM_AUDIO_FATAL; } switch (param) { case AUDIO_PATH_USED: size = sizeof(T_AUDIO_VOICE_PATH_SETTING); break; case AUDIO_MICROPHONE_MODE: case AUDIO_MICROPHONE_GAIN: case AUDIO_MICROPHONE_EXTRA_GAIN: case AUDIO_MICROPHONE_OUTPUT_BIAS: case AUDIO_MICROPHONE_SPEAKER_LOOP_SIDETONE: size = sizeof(INT8); break; case AUDIO_MICROPHONE_SPEAKER_LOOP_AEC: size = sizeof(T_AUDIO_AEC_CFG); aec_parameter = (T_AUDIO_AEC_CFG *) &pkt->data[2]; etm_pkt_put16(pkt, aec_parameter->aec_enable); // 1 #if (L1_NEW_AEC) etm_pkt_put16(pkt, aec_parameter->continuous_filtering); // 2 etm_pkt_put16(pkt, aec_parameter->granularity_attenuation); // 3 etm_pkt_put16(pkt, aec_parameter->smoothing_coefficient); // 4 etm_pkt_put16(pkt, aec_parameter->max_echo_suppression_level); // 5 etm_pkt_put16(pkt, aec_parameter->vad_factor); // 6 etm_pkt_put16(pkt, aec_parameter->absolute_threshold); // 7 etm_pkt_put16(pkt, aec_parameter->factor_asd_filtering); // 8 etm_pkt_put16(pkt, aec_parameter->factor_asd_muting); // 9 etm_pkt_put16(pkt, aec_parameter->aec_visibility); //10 #else etm_pkt_put16(pkt, aec_parameter->aec_mode); // 2 etm_pkt_put16(pkt, aec_parameter->echo_suppression_level); // 3 #endif // end of (L1_NEW_AEC) etm_pkt_put16(pkt, aec_parameter->noise_suppression_enable); // 4 or 11 etm_pkt_put16(pkt, aec_parameter->noise_suppression_level); // 5 or 12 break; case AUDIO_MICROPHONE_FIR: case AUDIO_SPEAKER_FIR: size = sizeof(T_AUDIO_FIR_COEF); break; case AUDIO_SPEAKER_MODE: case AUDIO_SPEAKER_GAIN: case AUDIO_SPEAKER_FILTER: case AUDIO_SPEAKER_BUZZER_STATE: size = sizeof(INT8); break; case AUDIO_SPEAKER_VOLUME_LEVEL: size = sizeof(T_AUDIO_SPEAKER_LEVEL); break; default: size = ETM_INVAL; } pkt->size += size; return ETM_OK; } /****************************************************************************** * Audio Full Access Write Function *****************************************************************************/ int etm_audio_write(T_ETM_PKT *pkt, uint8 *buf) { T_RV_HDR *msg = NULL; T_RV_RETURN return_path; T_AUDIO_FULL_ACCESS_WRITE audio; T_AUDIO_AEC_CFG *aec_parameter = NULL; void *parameter = NULL; int result = ETM_OK, i; uint8 param; param = *buf++; if ((result = etm_pkt_put8(pkt, param)) < ETM_OK) { return result; } tr_etm(TgTrAudio, "ETM AUDIO: _audio_write: param(%d)", param); return_path.addr_id = NULL; //etm_env_ctrl_blk->addr_id; return_path.callback_func = etm_audio_callback; audio.variable_indentifier = param; audio.data = buf; switch (param) { case AUDIO_MICROPHONE_SPEAKER_LOOP_AEC: tr_etm(TgTrAudio, "ETM AUDIO: _audio_write: AUDIO_MICROPHONE_SPEAKER_LOOP_AEC"); // RemoveMe aec_parameter = etm_malloc (sizeof(T_AUDIO_AEC_CFG)); aec_parameter->aec_enable = etm_get16(buf); buf += 2;// 1 #if (L1_NEW_AEC) if (etm_get16(buf)) // 2 aec_parameter->continuous_filtering = TRUE; else aec_parameter->continuous_filtering = FALSE; buf += 2; aec_parameter->granularity_attenuation = etm_get16(buf); buf += 2;// 3 aec_parameter->smoothing_coefficient = etm_get16(buf); buf += 2;// 4 aec_parameter->max_echo_suppression_level = etm_get16(buf); buf += 2;// 5 aec_parameter->vad_factor = etm_get16(buf); buf += 2;// 6 aec_parameter->absolute_threshold = etm_get16(buf); buf += 2;// 7 aec_parameter->factor_asd_filtering = etm_get16(buf); buf += 2;// 8 aec_parameter->factor_asd_muting = etm_get16(buf); buf += 2;// 9 aec_parameter->aec_visibility = etm_get16(buf); buf += 2;// 10 #else aec_parameter->aec_mode = etm_get16(buf); buf += 2;// 2 aec_parameter->echo_suppression_level = etm_get16(buf); buf += 2;// 3 #endif // end of (L1_NEW_AEC) #if (L1_ANR == 0) aec_parameter->noise_suppression_enable = etm_get16(buf); buf += 2;// 4 or 11 aec_parameter->noise_suppression_level = etm_get16(buf); // 5 or 12 #endif // end of (L1_ANR) audio.data = aec_parameter; break; case AUDIO_MICROPHONE_FIR: case AUDIO_SPEAKER_FIR: tr_etm(TgTrAudio, "ETM AUDIO: _audio_write: AUDIO_MICROPHONE/SPEAKER_FIR [%d]", sizeof(T_AUDIO_FIR_COEF)/2); // RemoveMe parameter = etm_malloc (sizeof(T_AUDIO_FIR_COEF)); // Write coeffient values for (i=0; i <= (sizeof(T_AUDIO_FIR_COEF)/2); i++) { ((T_AUDIO_FIR_COEF *) parameter)->coefficient[i] = etm_get16(buf); buf += 2; } audio.data = parameter; break; } if ((result = audio_full_access_write(&audio, return_path)) != AUDIO_OK) { tr_etm(TgTrAudio, "ETM AUDIO: _audio_write: ERROR(%d)", result); if (result == AUDIO_ERROR) result = ETM_INVAL; // Invalid audio parameter else result = ETM_AUDIO_FATAL; } // Wait for recv. of event: AUDIO_FULL_ACCESS_WRITE_DONE rvf_wait(0xffff, 100); // Timeout 100 ticks tr_etm(TgTrAudio, "ETM AUDIO: _audio_write: STATUS(%d)", etm_audio_event_status); if (parameter != NULL) { etm_free(parameter); parameter = NULL; } if (aec_parameter != NULL) { etm_free(aec_parameter); aec_parameter = NULL; } if (etm_audio_event_status != 0) { etm_audio_event_status = 0; result = ETM_AUDIO_FATAL; } return result; } /****************************************************************************** * Audio Save and Load cfg file Function *****************************************************************************/ int etm_audio_saveload(T_ETM_PKT *pkt, uint8 saveload, void *buf, int size) { T_RV_HDR *msg; T_AUDIO_MODE_SAVE audio_s; T_AUDIO_MODE_LOAD audio_l; T_RV_RETURN return_path; int result = ETM_OK; int error, event; return_path.addr_id = etm_env_ctrl_blk->addr_id; return_path.callback_func = NULL; switch(saveload) { case 'S': memcpy(audio_s.audio_mode_filename, buf, size); result = audio_mode_save(&audio_s, return_path); break; case 'L': memcpy(audio_l.audio_mode_filename, buf, size); result = audio_mode_load(&audio_l, return_path); break; default: tr_etm(TgTrAudio, "ETM AUDIO: _audio_saveload: FAILED"); break; } rvf_wait(0xffff, 100); // Timeout 100 ticks tr_etm(TgTrAudio, "ETM AUDIO: _audio_saveload: STATUS(%d)", etm_audio_event_status); if (etm_audio_event_status != 0) { etm_audio_event_status = 0; return ETM_AUDIO_FATAL; } if (result != AUDIO_OK) return ETM_AUDIO_FATAL; return result; } /****************************************************************************** * ETM AUDIO callback functio *****************************************************************************/ void etm_audio_callback(void *event_from_audio) { tr_etm(TgTrEtmLow,"ETM: AUDIO: _audio_callback: recv. event (0x%x)", ((T_RV_HDR *) event_from_audio)->msg_id); switch (((T_RV_HDR *) event_from_audio)->msg_id) { case AUDIO_FULL_ACCESS_WRITE_DONE: tr_etm(TgTrAudio, "ETM AUDIO: _audio_callback: recv. event AUDIO_FULL_ACCESS_WRITE_DONE"); etm_audio_event_status = ((T_AUDIO_FULL_ACCESS_WRITE_DONE *) event_from_audio)->status; break; case AUDIO_MODE_SAVE_DONE: tr_etm(TgTrAudio, "ETM AUDIO: _audio_callback: recv. event AUDIO_MODE_SAVE_DONE"); etm_audio_event_status = ((T_AUDIO_SAVE_DONE *) event_from_audio)->status; break; case AUDIO_MODE_LOAD_DONE: tr_etm(TgTrAudio, "ETM AUDIO: _audio_callback: recv. event AUDIO_MODE_LOAD_DONE"); etm_audio_event_status = ((T_AUDIO_LOAD_DONE *) event_from_audio)->status; break; } if (event_from_audio != NULL) { // etm_free(event_from_audio); event_from_audio = NULL; } } /****************************************************************************** * ETM AUDIO Moudle - Main Task *****************************************************************************/ // AUDIO packet structure for audio read/write and codec read/write: // |fid(8)|param(8)|--data(W)--| and for audio save/load |fid|--data(W)--| int etm_audio(uint8 *indata, int insize) { int error = ETM_OK; uint8 fid; T_ETM_PKT *pkt = NULL; fid = *indata++; tr_etm(TgTrAudio, "ETM AUDIO: _audio: fid(%c) param(%d) recv. size(%d)", fid, *indata, insize); /* Create TestMode return Packet */ if ((pkt = (T_ETM_PKT *) etm_malloc(sizeof(T_ETM_PKT))) == NULL) { return ETM_NOMEM; } // Init. of return packet pkt->mid = ETM_AUDIO; pkt->status = ETM_OK; pkt->size = 0; pkt->index = 0; etm_pkt_put8(pkt, fid); if (error == ETM_OK) { switch (fid) { case 'R': error = etm_audio_read(pkt, indata); break; case 'W': error = etm_audio_write(pkt, indata); break; case 'S': case 'L': error = etm_audio_saveload(pkt, fid, indata, insize); break; default: tr_etm(TgTrAudio, "ETM AUDIO: _audio: fid(%c) - ERROR ", fid); error = ETM_NOSYS; break; } } if (error < 0) { tr_etm(TgTrAudio,"ETM AUDIO: _audio: ERROR(%d)", error); pkt->status = -error; } etm_pkt_send(pkt); etm_free(pkt); return ETM_OK; }