FreeCalypso > hg > fc-magnetite
view src/g23m-aci/aci/ati_audio.c @ 597:f18b29e27be5
First attempt at MCSI voice path automatic switching
The function is implemented at the ACI level in both aci2 and aci3,
successfully avoids triggering the DSP bug on the first call,
but the shutdown of MCSI upon call completion is not working properly yet
in either version.
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Wed, 27 Mar 2019 22:18:35 +0000 |
parents | ade27cd84b97 |
children | 8f50b202e81f |
line wrap: on
line source
/* * This ATI module and the AT commands implemented therein are a FreeCalypso * addition. The purpose of these AT commands is to exercise the audio * capabilities of the firmware - by using these commands, you should be * able to emit sounds from the speaker or record voice from the microphone * without needing to be in a call, and without bringing up GSM at all. * * Our corrected implementation of the AT@AUL command (originally added * by Openmoko) has been moved into this module as well. */ #ifndef ATI_AUDIO_C #define ATI_AUDIO_C #include "aci_all.h" #include <ctype.h> #include <string.h> #include "aci_cmh.h" #include "ati_cmd.h" #include "aci_cmd.h" #include "aci_io.h" #include "aci_cmd.h" #include "l4_tim.h" #include "line_edit.h" #include "aci_lst.h" #include "pcm.h" #include "audio.h" #include "aci.h" #include "rx.h" #include "pwr.h" #include "l4_tim.h" #ifdef GPRS #ifdef DTI #include "dti.h" #include "dti_conn_mng.h" #include "dti_cntrl_mng.h" #endif /* DTI */ #include "gaci.h" #include "gaci_cmh.h" #include "gaci_cmd.h" #endif /* GPRS */ #include "aci_mem.h" #include "aci_prs.h" #include "ati_int.h" #ifndef _SIMULATION_ #include "ffs/ffs.h" #endif #ifdef FF_ATI_BAT #include "typedefs.h" #include "gdd.h" #include "bat.h" #include "ati_bat.h" #endif /*FF_ATI_BAT*/ #include "audio/audio_api.h" #include "audio.h" /* Condat */ #include "fc-target.cfg" #include "armio.h" #if defined(CONFIG_TARGET_DSAMPLE) || defined(CONFIG_TARGET_FCDEV3B) /* AT@SPKR - turn loudspeaker amplifier on or off */ GLOBAL T_ATI_RSLT atAtSPKR ( char *cl, UBYTE srcId ) { int state; TRACE_FUNCTION("atAtSPKR()"); cl = parse(cl, "D", &state); if (!cl) return (ATI_FAIL); if (state) AI_SetBit(1); else AI_ResetBit(1); return (ATI_CMPL); } GLOBAL T_ATI_RSLT queatAtSPKR (char *cl, UBYTE srcId) { char *me="@SPKR: "; int state; TRACE_FUNCTION("queatAtSPKR()"); state = AI_ReadBit(1); sprintf(g_sa, "%s%d", me, state); io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); return (ATI_CMPL); } #endif /* AT@SND - emit sound through Condat API */ GLOBAL T_ATI_RSLT atAtSND ( char *cl, UBYTE srcId ) { UBYTE sound_id = TONES_KEYBEEP; cl = parse(cl, "x", &sound_id); audio_PlaySoundID(AUDIO_SPEAKER, sound_id, 0, AUDIO_PLAY_ONCE); return (ATI_CMPL); } static void audio_callback(void *event_from_audio) { /* do nothing at this time */ } /* * PURPOSE : @AUL command (Audio table load) */ static char aul_name[AUDIO_MODE_FILENAME_MAX_SIZE]; GLOBAL T_ATI_RSLT atAtAUL (char *cl, UBYTE srcId) { T_AUDIO_MODE_LOAD aul_param; T_RV_RETURN return_path; TRACE_FUNCTION("atAtAUL()"); cl = parse(cl, "S", (LONG)(sizeof(aul_param.audio_mode_filename)), aul_param.audio_mode_filename); if (!cl || !aul_param.audio_mode_filename[0]) return (ATI_FAIL); /* Openmoko backward compatibility */ if (isdigit(aul_param.audio_mode_filename[0]) && !aul_param.audio_mode_filename[1]) sprintf(aul_param.audio_mode_filename, "para%c", aul_param.audio_mode_filename[0]); return_path.addr_id = NULL; return_path.callback_func = audio_callback; if (audio_mode_load(&aul_param, return_path) == AUDIO_OK) { strcpy(aul_name, aul_param.audio_mode_filename); return (ATI_CMPL); } else return (ATI_FAIL); } GLOBAL T_ATI_RSLT queatAtAUL (char *cl, UBYTE srcId) { char *me="@AUL: "; TRACE_FUNCTION("queatAtAUL()"); if (aul_name[0]) sprintf(g_sa, "%s/aud/%s.cfg", me, aul_name); else sprintf(g_sa, "%s", me); io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); return (ATI_CMPL); } #ifdef CONFIG_TARGET_FCDEV3B extern UBYTE aci_digital_voice_autoswitch; /* AT@VPATH - configure digital voice path */ GLOBAL T_ATI_RSLT atAtVPATH ( char *cl, UBYTE srcId ) { int vpath_int; T_AUDIO_VOICE_PATH_SETTING vpath; T_AUDIO_FULL_ACCESS_WRITE audio_param; T_RV_RETURN return_path; TRACE_FUNCTION("atAtVPATH()"); cl = parse(cl, "D", &vpath_int); if (!cl) return (ATI_FAIL); vpath = vpath_int; audio_param.variable_indentifier = AUDIO_PATH_USED; audio_param.data = &vpath; return_path.addr_id = NULL; return_path.callback_func = audio_callback; if (audio_full_access_write(&audio_param, return_path) == AUDIO_OK) return (ATI_CMPL); else return (ATI_FAIL); } GLOBAL T_ATI_RSLT queatAtVPATH (char *cl, UBYTE srcId) { char *me="@VPATH: "; T_AUDIO_VOICE_PATH_SETTING vpath; T_AUDIO_FULL_ACCESS_READ audio_param; TRACE_FUNCTION("queatAtVPATH()"); audio_param.variable_indentifier = AUDIO_PATH_USED; audio_param.data = &vpath; if (audio_full_access_read(&audio_param) != AUDIO_OK) return (ATI_FAIL); sprintf(g_sa, "%s%d", me, vpath); io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); return (ATI_CMPL); } /* AT@VSEL - configure digital voice path automatic operation */ GLOBAL T_ATI_RSLT atAtVSEL ( char *cl, UBYTE srcId ) { int vsel_int; TRACE_FUNCTION("atAtVSEL()"); cl = parse(cl, "D", &vsel_int); if (!cl) return (ATI_FAIL); if (vsel_int != 0 && vsel_int != 1) return (ATI_FAIL); aci_digital_voice_autoswitch = vsel_int; return (ATI_CMPL); } GLOBAL T_ATI_RSLT queatAtVSEL (char *cl, UBYTE srcId) { char *me="@VSEL: "; TRACE_FUNCTION("queatAtVSEL()"); sprintf(g_sa, "%s%u", me, aci_digital_voice_autoswitch); io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); return (ATI_CMPL); } #endif static char melody_E1_name[AUDIO_PATH_NAME_MAX_SIZE]; /* AT@E1 - play an E1 format melody */ GLOBAL T_ATI_RSLT atAtE1 ( char *cl, UBYTE srcId ) { T_AUDIO_MELODY_E1_PARAMETER e1_param; int loopback = 0; T_RV_RETURN return_path; cl = parse(cl, "Sd", (LONG)(sizeof(e1_param.melody_name)), e1_param.melody_name, &loopback); if (!cl || !e1_param.melody_name[0]) return (ATI_FAIL); e1_param.loopback = loopback; e1_param.melody_mode = AUDIO_MELODY_NORMAL_MODE; return_path.addr_id = NULL; return_path.callback_func = audio_callback; if (audio_melody_E1_start(&e1_param, return_path) == AUDIO_OK) { strcpy(melody_E1_name, e1_param.melody_name); return (ATI_CMPL); } else return (ATI_FAIL); } /* AT@E1STOP - stop melody started with AT@E1 */ GLOBAL T_ATI_RSLT atAtE1STOP ( char *cl, UBYTE srcId ) { T_AUDIO_MELODY_E1_STOP_PARAMETER e1stop_param; T_RV_RETURN return_path; if (!melody_E1_name[0]) return (ATI_FAIL); strcpy(e1stop_param.melody_name, melody_E1_name); return_path.addr_id = NULL; return_path.callback_func = audio_callback; if (audio_melody_E1_stop(&e1stop_param, return_path) == AUDIO_OK) return (ATI_CMPL); else return (ATI_FAIL); } static char melody_E2_name[AUDIO_PATH_NAME_MAX_SIZE]; /* AT@E2 - play an E2 format melody */ GLOBAL T_ATI_RSLT atAtE2 ( char *cl, UBYTE srcId ) { T_AUDIO_MELODY_E2_PARAMETER e2_param; int loopback = 0; T_RV_RETURN return_path; cl = parse(cl, "Sd", (LONG)(sizeof(e2_param.melody_E2_name)), e2_param.melody_E2_name, &loopback); if (!cl || !e2_param.melody_E2_name[0]) return (ATI_FAIL); e2_param.E2_loopback = loopback; e2_param.melody_E2_mode = AUDIO_MELODY_NORMAL_MODE; return_path.addr_id = NULL; return_path.callback_func = audio_callback; if (audio_melody_E2_start(&e2_param, return_path) == AUDIO_OK) { strcpy(melody_E2_name, e2_param.melody_E2_name); return (ATI_CMPL); } else return (ATI_FAIL); } /* AT@E2LSI - load melody E2 instrument list file */ GLOBAL T_ATI_RSLT atAtE2LSI ( char *cl, UBYTE srcId ) { T_AUDIO_MELODY_E2_LOAD_FILE_INSTR_PARAMETER e2_lsi_param; cl = parse(cl, "S", (LONG)(sizeof(e2_lsi_param.melody_E2_file_name)), e2_lsi_param.melody_E2_file_name); if (!cl || !e2_lsi_param.melody_E2_file_name[0]) return (ATI_FAIL); if (audio_melody_E2_load_file_instruments(&e2_lsi_param) == AUDIO_OK) return (ATI_CMPL); else return (ATI_FAIL); } /* AT@E2STOP - stop melody started with AT@E2 */ GLOBAL T_ATI_RSLT atAtE2STOP ( char *cl, UBYTE srcId ) { T_AUDIO_MELODY_E2_STOP_PARAMETER e2stop_param; T_RV_RETURN return_path; if (!melody_E2_name[0]) return (ATI_FAIL); strcpy(e2stop_param.melody_E2_name, melody_E2_name); return_path.addr_id = NULL; return_path.callback_func = audio_callback; if (audio_melody_E2_stop(&e2stop_param, return_path) == AUDIO_OK) return (ATI_CMPL); else return (ATI_FAIL); } /* AT@TONE - exercise TONES through RiViera Audio Service API */ GLOBAL T_ATI_RSLT atAtTONE ( char *cl, UBYTE srcId ) { int tone_start[3], tone_stop[3], tone_freq[3], tone_ampl[3]; int frame_dur, sequence_dur, period_dur, repetition; int i; T_AUDIO_TONES_PARAMETER t; T_RV_RETURN return_path; cl = parse(cl, "DDDDDDDDDDDDDDDD", &tone_start[0], &tone_stop[0], &tone_freq[0], &tone_ampl[0], &tone_start[1], &tone_stop[1], &tone_freq[1], &tone_ampl[1], &tone_start[2], &tone_stop[2], &tone_freq[2], &tone_ampl[2], &frame_dur, &sequence_dur, &period_dur, &repetition); if (!cl) return (ATI_FAIL); for (i = 0; i < 3; i++) { t.tones[i].start_tone = tone_start[i]; t.tones[i].stop_tone = tone_stop[i]; t.tones[i].frequency_tone = tone_freq[i]; t.tones[i].amplitude_tone = -tone_ampl[i]; } t.frame_duration = frame_dur; t.sequence_duration = sequence_dur; t.period_duration = period_dur; t.repetition = repetition; return_path.addr_id = NULL; return_path.callback_func = audio_callback; if (audio_tones_start(&t, return_path) == AUDIO_OK) return (ATI_CMPL); else return (ATI_FAIL); } /* AT@TSTOP - stop tones started with AT@TONE */ GLOBAL T_ATI_RSLT atAtTSTOP ( char *cl, UBYTE srcId ) { T_RV_RETURN return_path; return_path.addr_id = NULL; return_path.callback_func = audio_callback; if (audio_tones_stop(return_path) == AUDIO_OK) return (ATI_CMPL); else return (ATI_FAIL); } /* AT@VMP - play back a voice memo recording */ GLOBAL T_ATI_RSLT atAtVMP ( char *cl, UBYTE srcId ) { T_AUDIO_VM_PLAY_PARAMETER play_param; T_RV_RETURN return_path; cl = parse(cl, "S", (LONG)(sizeof(play_param.memo_name)), play_param.memo_name); if (!cl || !play_param.memo_name[0]) return (ATI_FAIL); return_path.addr_id = NULL; return_path.callback_func = audio_callback; if (audio_vm_play_start(&play_param, return_path) == AUDIO_OK) return (ATI_CMPL); else return (ATI_FAIL); } /* AT@VMPS - stop VM play started with AT@VMP */ GLOBAL T_ATI_RSLT atAtVMPS ( char *cl, UBYTE srcId ) { T_RV_RETURN return_path; return_path.addr_id = NULL; return_path.callback_func = audio_callback; if (audio_vm_play_stop(return_path) == AUDIO_OK) return (ATI_CMPL); else return (ATI_FAIL); } static const T_AUDIO_TONES_PARAMETER recorder_warning_tone = { 0, 500, 1400, -5, 0, 500, 0, 0, 0, 500, 0, 0, 500, 500, 15000, TONE_INFINITE }; /* AT@VMR - record a voice memo */ GLOBAL T_ATI_RSLT atAtVMR ( char *cl, UBYTE srcId ) { T_AUDIO_VM_RECORD_PARAMETER record_param; int duration = 0, compression = 0; LONG mic_gain = 0x100, network_gain = 0x100; T_RV_RETURN return_path; cl = parse(cl, "Sddyy", (LONG)(sizeof(record_param.memo_name)), record_param.memo_name, &duration, &compression, &mic_gain, &network_gain); if (!cl || !record_param.memo_name[0] || !duration) return (ATI_FAIL); record_param.memo_duration = duration; record_param.compression_mode = compression; record_param.microphone_gain = mic_gain; record_param.network_gain = network_gain; return_path.addr_id = NULL; return_path.callback_func = audio_callback; if (audio_vm_record_start(&record_param, (T_AUDIO_TONES_PARAMETER *) &recorder_warning_tone, return_path) == AUDIO_OK) return (ATI_CMPL); else return (ATI_FAIL); } /* AT@VMRS - stop VM recording started with AT@VMR */ GLOBAL T_ATI_RSLT atAtVMRS ( char *cl, UBYTE srcId ) { T_RV_RETURN return_path; return_path.addr_id = NULL; return_path.callback_func = audio_callback; if (audio_vm_record_stop(return_path) == AUDIO_OK) return (ATI_CMPL); else return (ATI_FAIL); } #endif /* ATI_AUDIO_C */