/****************************************************************************
* audio_pcm_capture/pcm_capture_main.cxx
*
* Copyright 2019 Sony Semiconductor Solutions Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name of Sony Semiconductor Solutions Corporation nor
* the names of its contributors may be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdio.h>
#include <strings.h>
#include <asmp/mpshm.h>
#include "memutils/simple_fifo/CMN_SimpleFifo.h"
#include "memutils/memory_manager/MemHandle.h"
#include "memutils/message/Message.h"
#include "audio/audio_high_level_api.h"
#include "audio/utilities/frame_samples.h"
#include "include/msgq_id.h"
#include "include/mem_layout.h"
#include "include/memory_layout.h"
#include "include/msgq_pool.h"
#include "include/pool_layout.h"
#include "include/fixed_fence.h"
#include "stdlib.h"
#include "api.h"
#include "baby_cry_model.h"
#include "baby_cry_keyword.h"
baby_cry_Struct *st;
baby_cry_ApiResult result;
/****************************************************************************
* Codec parameters
****************************************************************************/
/* Recording default time(sec). */
#define PCM_CAPTURE_TIME (10)
/* Sampling rate
* 16kHz : AS_SAMPLINGRATE_16000
* 44.1kHz : AS_SAMPLINGRATE_44100
* 48kHz : AS_SAMPLINGRATE_48000
* 192kHz : AS_SAMPLINGRATE_192000
*/
#define SAMPLINGRATE AS_SAMPLINGRATE_16000
#define CHANNEL_NUMBER AS_CHANNEL_MONO
/* Bit length
* 16bit : AS_BITLENGTH_16
* 24bit : AS_BITLENGTH_24
*/
#define BIT_LENGTH AS_BITLENGTH_16
/* Use microphone channel number.
* [Analog microphone]
* Maximum number: 4
* The channel number is 1/2/4
* [Digital microphone]
* Maximum number: 8
* The channel number is 1/2/4/6/8
*/
#define USE_MIC_CHANNEL_NUM (1)
/* Set the PCM buffer size. */
#define READ_SIMPLE_FIFO_SIZE (160 * USE_MIC_CHANNEL_NUM * 2) /* 160 sample, 4ch, 16bit */
#define SIMPLE_FIFO_FRAME_NUM (60)
/****************************************************************************
* PCM capture function
****************************************************************************/
/*
* Audio signal process (Modify for your application)
*
* [in] buf capture data
* [in] size capture size
*
*/
static void app_pcm_output(uint8_t *buf, uint32_t size)
{
int status = 0;
/* Sample code.
* Please modify according to the application.
* For example, output capture data.
*/
/* printf("Size %d [%02x %02x %02x %02x %02x %02x %02x %02x...]\n",
size,
buf[0],
buf[1],
buf[2],
buf[3],
buf[4],
buf[5],
buf[6],
buf[7]); */
status = api_process(st, (int16_t*)buf, &result);
switch (status)
{
case BABY_CRY_API_VAD_DONE:
if (result.activity_index == VAD_VOICE_ACTIVITY_IDX)
{
}
break;
case BABY_CRY_API_KEYWORD_DONE:
printf("{\"Keyword\":\"%s\", \"confidence_score\":%.2f}\r\n", output_class[result.activity_index], result.confidence_score);
#ifdef DO_CYCLE_COUNT
printf("Cycle count = %d \r\n", SysCntVal);
#endif
break;
case BABY_CRY_API_WAKEWD_DONE:
//printf("{\"Wakeword\":\"%s\", \"confidence_score\":%.2f}\r\n", waked_output_class[result.activity_index], result.confidence_score);
break;
}
}
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
using namespace MemMgrLite;
/* PCM codec search path. */
#define DSPBIN_PATH "/mnt/sd0/BIN"
/* Section number of memory layout to use */
#define AUDIO_SECTION SECTION_NO0
/* PCM FIFO buffer size */
#define SIMPLE_FIFO_BUF_SIZE (READ_SIMPLE_FIFO_SIZE * SIMPLE_FIFO_FRAME_NUM)
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/****************************************************************************
* Private Type Declarations
****************************************************************************/
/* For FIFO. */
struct fifo_info_s
{
CMN_SimpleFifoHandle handle;
AsRecorderOutputDeviceHdlr output_device;
uint32_t fifo_area[SIMPLE_FIFO_BUF_SIZE / sizeof(uint32_t)];
uint8_t write_buf[READ_SIMPLE_FIFO_SIZE];
};
/****************************************************************************
* Private Data
****************************************************************************/
/* For FIFO. */
static fifo_info_s s_fifo;
/* For share memory. */
static mpshm_t s_shm;
/* For target codec parameters. */
static uint32_t target_samplingrate = SAMPLINGRATE;
static uint32_t target_channel_number = CHANNEL_NUMBER;
static uint32_t target_bit_lengt = BIT_LENGTH;
static uint32_t target_recording_time = PCM_CAPTURE_TIME;
/****************************************************************************
* Private Functions
****************************************************************************/
static void outputDeviceCallback(uint32_t size)
{
/* do nothing */
}
static bool app_init_simple_fifo(void)
{
if (CMN_SimpleFifoInitialize(&s_fifo.handle,
s_fifo.fifo_area,
SIMPLE_FIFO_BUF_SIZE, NULL) != 0)
{
printf("Error: Fail to initialize simple FIFO.");
return false;
}
CMN_SimpleFifoClear(&s_fifo.handle);
s_fifo.output_device.simple_fifo_handler =
(void *)(&s_fifo.handle);
s_fifo.output_device.callback_function = outputDeviceCallback;
return true;
}
static void app_pop_simple_fifo(bool is_end_process = false)
{
size_t occupied_simple_fifo_size =
CMN_SimpleFifoGetOccupiedSize(&s_fifo.handle);
uint32_t output_size = 0;
while (occupied_simple_fifo_size > 0)
{
output_size = (occupied_simple_fifo_size > READ_SIMPLE_FIFO_SIZE) ? READ_SIMPLE_FIFO_SIZE : occupied_simple_fifo_size;
if (CMN_SimpleFifoPoll(&s_fifo.handle,
(void *)s_fifo.write_buf,
output_size) == 0)
{
printf("ERROR: Fail to get data from simple FIFO.\n");
break;
}
/* Data output */
app_pcm_output((uint8_t *)s_fifo.write_buf, output_size);
if (is_end_process)
{
/* At end processing, all remaining data is spit */
occupied_simple_fifo_size = CMN_SimpleFifoGetOccupiedSize(&s_fifo.handle);
}
else
{
occupied_simple_fifo_size -= output_size;
}
}
}
static bool printAudCmdResult(uint8_t command_code, AudioResult &result)
{
if (AUDRLT_ERRORRESPONSE == result.header.result_code)
{
printf("Command code(0x%x): AUDRLT_ERRORRESPONSE:"
"Module id(0x%x): Error code(0x%x)\n",
command_code,
result.error_response_param.module_id,
result.error_response_param.error_code);
return false;
}
else if (AUDRLT_ERRORATTENTION == result.header.result_code)
{
printf("Command code(0x%x): AUDRLT_ERRORATTENTION\n", command_code);
return false;
}
return true;
}
static void app_attention_callback(const ErrorAttentionParam *attparam)
{
printf("Attention!! %s L%d ecode %d subcode %d\n",
attparam->error_filename,
attparam->line_number,
attparam->error_code,
attparam->error_att_sub_code);
}
static bool app_create_audio_sub_system(void)
{
bool result = false;
/* Create manager of AudioSubSystem. */
AudioSubSystemIDs ids;
ids.app = MSGQ_AUD_APP;
ids.mng = MSGQ_AUD_MGR;
ids.player_main = 0xFF;
ids.player_sub = 0xFF;
ids.micfrontend = MSGQ_AUD_FRONTEND;
ids.mixer = 0xFF;
ids.recorder = MSGQ_AUD_RECORDER;
ids.effector = 0xFF;
ids.recognizer = 0xFF;
AS_CreateAudioManager(ids, app_attention_callback);
/* Create Frontend. */
AsCreateMicFrontendParams_t frontend_create_param;
frontend_create_param.msgq_id.micfrontend = MSGQ_AUD_FRONTEND;
frontend_create_param.msgq_id.mng = MSGQ_AUD_MGR;
frontend_create_param.msgq_id.dsp = MSGQ_AUD_PREDSP;
frontend_create_param.pool_id.input = S0_INPUT_BUF_POOL;
frontend_create_param.pool_id.output = S0_NULL_POOL;
frontend_create_param.pool_id.dsp = S0_PRE_APU_CMD_POOL;
AS_CreateMicFrontend(&frontend_create_param, NULL);
/* Create Recorder. */
AsCreateRecorderParams_t recorder_create_param;
recorder_create_param.msgq_id.recorder = MSGQ_AUD_RECORDER;
recorder_create_param.msgq_id.mng = MSGQ_AUD_MGR;
recorder_create_param.msgq_id.dsp = MSGQ_AUD_DSP;
recorder_create_param.pool_id.input = S0_INPUT_BUF_POOL;
recorder_create_param.pool_id.output = S0_ES_BUF_POOL;
recorder_create_param.pool_id.dsp = S0_ENC_APU_CMD_POOL;
result = AS_CreateMediaRecorder(&recorder_create_param, NULL);
if (!result)
{
printf("Error: AS_CreateMediaRecorder() failure. system memory insufficient!\n");
return false;
}
/* Create Capture feature. */
AsCreateCaptureParam_t capture_create_param;
capture_create_param.msgq_id.dev0_req = MSGQ_AUD_CAP;
capture_create_param.msgq_id.dev0_sync = MSGQ_AUD_CAP_SYNC;
capture_create_param.msgq_id.dev1_req = 0xFF;
capture_create_param.msgq_id.dev1_sync = 0xFF;
result = AS_CreateCapture(&capture_create_param);
if (!result)
{
printf("Error: As_CreateCapture() failure. system memory insufficient!\n");
return false;
}
return true;
}
static void app_deact_audio_sub_system(void)
{
AS_DeleteAudioManager();
AS_DeleteMediaRecorder();
AS_DeleteMicFrontend();
AS_DeleteCapture();
}
static bool app_power_on(void)
{
AudioCommand command;
command.header.packet_length = LENGTH_POWERON;
command.header.command_code = AUDCMD_POWERON;
command.header.sub_code = 0x00;
command.power_on_param.enable_sound_effect = AS_DISABLE_SOUNDEFFECT;
AS_SendAudioCommand(&command);
AudioResult result;
AS_ReceiveAudioResult(&result);
return printAudCmdResult(command.header.command_code, result);
}
static bool app_power_off(void)
{
AudioCommand command;
command.header.packet_length = LENGTH_SET_POWEROFF_STATUS;
command.header.command_code = AUDCMD_SETPOWEROFFSTATUS;
command.header.sub_code = 0x00;
AS_SendAudioCommand(&command);
AudioResult result;
AS_ReceiveAudioResult(&result);
return printAudCmdResult(command.header.command_code, result);
}
static bool app_set_ready(void)
{
AudioCommand command;
command.header.packet_length = LENGTH_SET_READY_STATUS;
command.header.command_code = AUDCMD_SETREADYSTATUS;
command.header.sub_code = 0x00;
AS_SendAudioCommand(&command);
AudioResult result;
AS_ReceiveAudioResult(&result);
return printAudCmdResult(command.header.command_code, result);
}
static bool app_init_mic_gain(void)
{
AudioCommand command;
command.header.packet_length = LENGTH_INITMICGAIN;
command.header.command_code = AUDCMD_INITMICGAIN;
command.header.sub_code = 0;
command.init_mic_gain_param.mic_gain[0] = 0;
command.init_mic_gain_param.mic_gain[1] = 0;
command.init_mic_gain_param.mic_gain[2] = 0;
command.init_mic_gain_param.mic_gain[3] = 0;
command.init_mic_gain_param.mic_gain[4] = 0;
command.init_mic_gain_param.mic_gain[5] = 0;
command.init_mic_gain_param.mic_gain[6] = 0;
command.init_mic_gain_param.mic_gain[7] = 0;
AS_SendAudioCommand(&command);
AudioResult result;
AS_ReceiveAudioResult(&result);
return printAudCmdResult(command.header.command_code, result);
}
static bool app_set_recorder_status(void)
{
AudioCommand command;
command.header.packet_length = LENGTH_SET_RECORDER_STATUS;
command.header.command_code = AUDCMD_SETRECORDERSTATUS;
command.header.sub_code = 0x00;
command.set_recorder_status_param.input_device = AS_SETRECDR_STS_INPUTDEVICE_MIC;
command.set_recorder_status_param.input_device_handler = 0x00;
command.set_recorder_status_param.output_device = AS_SETRECDR_STS_OUTPUTDEVICE_RAM;
command.set_recorder_status_param.output_device_handler = &s_fifo.output_device;
AS_SendAudioCommand(&command);
AudioResult result;
AS_ReceiveAudioResult(&result);
return printAudCmdResult(command.header.command_code, result);
}
static bool app_init_micfrontend(void)
{
AudioCommand command;
command.header.packet_length = LENGTH_INIT_MICFRONTEND;
command.header.command_code = AUDCMD_INIT_MICFRONTEND;
command.header.sub_code = 0x00;
command.init_micfrontend_param.ch_num = target_channel_number;
command.init_micfrontend_param.bit_length = target_bit_lengt;
command.init_micfrontend_param.samples = getCapSampleNumPerFrame(AS_CODECTYPE_LPCM,
target_samplingrate);
command.init_micfrontend_param.preproc_type = AsMicFrontendPreProcThrough;
snprintf(command.init_micfrontend_param.preprocess_dsp_path,
AS_PREPROCESS_FILE_PATH_LEN,
"%s", "/mnt/sd0/BIN/PREPROC");
command.init_micfrontend_param.data_dest = AsMicFrontendDataToRecorder;
AS_SendAudioCommand(&command);
AudioResult result;
AS_ReceiveAudioResult(&result);
return printAudCmdResult(command.header.command_code, result);
}
static bool app_init_recorder(void)
{
AudioCommand command;
command.header.packet_length = LENGTH_INIT_RECORDER;
command.header.command_code = AUDCMD_INITREC;
command.header.sub_code = 0x00;
command.recorder.init_param.sampling_rate = target_samplingrate;
command.recorder.init_param.channel_number = target_channel_number;
command.recorder.init_param.bit_length = target_bit_lengt;
command.recorder.init_param.codec_type = AS_CODECTYPE_LPCM;
snprintf(command.recorder.init_param.dsp_path, AS_AUDIO_DSP_PATH_LEN, "%s", DSPBIN_PATH);
AS_SendAudioCommand(&command);
AudioResult result;
AS_ReceiveAudioResult(&result);
return printAudCmdResult(command.header.command_code, result);
}
static bool app_start_recorder(void)
{
CMN_SimpleFifoClear(&s_fifo.handle);
AudioCommand command;
command.header.packet_length = LENGTH_START_RECORDER;
command.header.command_code = AUDCMD_STARTREC;
command.header.sub_code = 0x00;
AS_SendAudioCommand(&command);
AudioResult result;
AS_ReceiveAudioResult(&result);
return printAudCmdResult(command.header.command_code, result);
}
static bool app_stop_recorder(void)
{
AudioCommand command;
command.header.packet_length = LENGTH_STOP_RECORDER;
command.header.command_code = AUDCMD_STOPREC;
command.header.sub_code = 0x00;
AS_SendAudioCommand(&command);
AudioResult result;
AS_ReceiveAudioResult(&result);
if (!printAudCmdResult(command.header.command_code, result))
{
return false;
}
/* Spout processing of remaining data. */
app_pop_simple_fifo(true);
return true;
}
static bool app_set_clkmode(void)
{
cxd56_audio_clkmode_t clk_mode;
if (target_samplingrate == AS_SAMPLINGRATE_192000)
{
clk_mode = CXD56_AUDIO_CLKMODE_HIRES;
}
else
{
clk_mode = CXD56_AUDIO_CLKMODE_NORMAL;
}
AudioCommand command;
command.header.packet_length = LENGTH_SETRENDERINGCLK;
command.header.command_code = AUDCMD_SETRENDERINGCLK;
command.header.sub_code = 0x00;
command.set_renderingclk_param.clk_mode = clk_mode;
AS_SendAudioCommand(&command);
AudioResult result;
AS_ReceiveAudioResult(&result);
return printAudCmdResult(command.header.command_code, result);
}
static bool app_init_libraries(void)
{
int ret;
uint32_t addr = AUD_SRAM_ADDR;
/* Initialize shared memory.*/
ret = mpshm_init(&s_shm, 1, 1024 * 128 * 2);
if (ret < 0)
{
printf("Error: mpshm_init() failure. %d\n", ret);
return false;
}
ret = mpshm_remap(&s_shm, (void *)addr);
if (ret < 0)
{
printf("Error: mpshm_remap() failure. %d\n", ret);
return false;
}
/* Initalize MessageLib. */
err_t err = MsgLib::initFirst(NUM_MSGQ_POOLS, MSGQ_TOP_DRM);
if (err != ERR_OK)
{
printf("Error: MsgLib::initFirst() failure. 0x%x\n", err);
return false;
}
err = MsgLib::initPerCpu();
if (err != ERR_OK)
{
printf("Error: MsgLib::initPerCpu() failure. 0x%x\n", err);
return false;
}
void *mml_data_area = translatePoolAddrToVa(MEMMGR_DATA_AREA_ADDR);
err = Manager::initFirst(mml_data_area, MEMMGR_DATA_AREA_SIZE);
if (err != ERR_OK)
{
printf("Error: Manager::initFirst() failure. 0x%x\n", err);
return false;
}
err = Manager::initPerCpu(mml_data_area, static_pools, pool_num, layout_no);
if (err != ERR_OK)
{
printf("Error: Manager::initPerCpu() failure. 0x%x\n", err);
return false;
}
/* Create static memory pool of VoiceCall. */
const uint8_t sec_no = AUDIO_SECTION;
const NumLayout layout_no = MEM_LAYOUT_PCM_CAPTURE;
void *work_va = translatePoolAddrToVa(S0_MEMMGR_WORK_AREA_ADDR);
const PoolSectionAttr *ptr = &MemoryPoolLayouts[AUDIO_SECTION][layout_no][0];
err = Manager::createStaticPools(sec_no,
layout_no,
work_va,
S0_MEMMGR_WORK_AREA_SIZE,
ptr);
if (err != ERR_OK)
{
printf("Error: Manager::createStaticPools() failure. %d\n", err);
return false;
}
return true;
}
static bool app_finalize_libraries(void)
{
/* Finalize MessageLib. */
MsgLib::finalize();
/* Destroy static pools. */
MemMgrLite::Manager::destroyStaticPools(AUDIO_SECTION);
/* Finalize memory manager. */
MemMgrLite::Manager::finalize();
/* Destroy shared memory. */
int ret;
ret = mpshm_detach(&s_shm);
if (ret < 0)
{
printf("Error: mpshm_detach() failure. %d\n", ret);
return false;
}
ret = mpshm_destroy(&s_shm);
if (ret < 0)
{
printf("Error: mpshm_destroy() failure. %d\n", ret);
return false;
}
return true;
}
void app_recorde_process(uint32_t rec_time)
{
/* Timer Start */
/* time_t start_time;
time_t cur_time;
time(&start_time);
do
{
app_pop_simple_fifo();
} while ((time(&cur_time) - start_time) < rec_time); */
while(1)
{
app_pop_simple_fifo();
}
}
static bool app_argparse(int argc, char *argv[])
{
struct
{
const char *target;
uint32_t *param;
uint32_t target_param;
const char *help;
} nodes[] = {
{"16k", &target_samplingrate, AS_SAMPLINGRATE_16000, "Sampling rate 16kHz"},
{"48k", &target_samplingrate, AS_SAMPLINGRATE_48000, "Sampling rate 48kHz"},
{"192k", &target_samplingrate, AS_SAMPLINGRATE_192000, "Sampling rate 192kHz"},
{"1ch", &target_channel_number, AS_CHANNEL_MONO, "Channel number 1ch(MONO)"},
{"2ch", &target_channel_number, AS_CHANNEL_STEREO, "Channel number 2ch(STEREO)"},
{"4ch", &target_channel_number, AS_CHANNEL_4CH, "Channel number 4ch"},
{"16b", &target_bit_lengt, AS_BITLENGTH_16, "Bit length 16bit"},
{"24b", &target_bit_lengt, AS_BITLENGTH_24, "Bit length 24bit"},
{NULL, NULL, 0, NULL},
},
*p_node;
/* Set default parameter. */
target_samplingrate = SAMPLINGRATE;
target_channel_number = CHANNEL_NUMBER;
target_bit_lengt = BIT_LENGTH;
target_recording_time = PCM_CAPTURE_TIME;
if (argc < 2)
{
/* Default configuration */
return true;
}
/* Help! Display Description */
if (strcmp(argv[1], "help") == 0)
{
printf("\n");
for (p_node = nodes; p_node->target; p_node++)
{
printf("%-4s - %s\n", p_node->target, p_node->help);
}
printf("1... - recording time (sec)\n\n");
return false;
}
/* Option determination */
else
{
for (int i = 1; i < argc; i++)
{
for (p_node = nodes; p_node->target; p_node++)
{
if (strncasecmp(p_node->target, argv[i], strlen(p_node->target)) == 0)
{
if (p_node->param)
{
*p_node->param = p_node->target_param;
}
break;
}
}
/* When there is no option entered. */
if (p_node->target == NULL)
{
/* Numerical judgment */
int time = atoi(argv[i]);
if (time > 0)
{
target_recording_time = time;
}
else
{
printf("\nInvalid option '%s'\n", argv[i]);
printf("Try '%s help' for more information.\n\n", argv[0]);
}
}
}
}
return true;
}
static const char *app_param_to_str(int id, uint32_t param)
{
struct
{
int id;
uint32_t param;
const char *title;
} nodes[] = {
{-1, AS_SAMPLINGRATE_16000, "16kHz"},
{-1, AS_SAMPLINGRATE_48000, "48kHz"},
{-1, AS_SAMPLINGRATE_192000, "192kHz"},
{-2, AS_CHANNEL_MONO, "1ch(MONO)"},
{-2, AS_CHANNEL_STEREO, "2ch(STEREO)"},
{-2, AS_CHANNEL_4CH, "4ch"},
{-3, AS_BITLENGTH_16, "16bit"},
{-3, AS_BITLENGTH_24, "24bit"},
{0, 0, "!!! Undefined value !!!"},
},
*p_node;
for (p_node = nodes; p_node->id; p_node++)
{
if (p_node->id == id && p_node->param == param)
{
break;
}
}
return p_node->title;
}
static void app_disp_codec_params(void)
{
printf("\n");
printf("Sampling rate %s\n", app_param_to_str(-1, target_samplingrate));
printf("Channel number %s\n", app_param_to_str(-2, target_channel_number));
printf("Bit length %s\n", app_param_to_str(-3, target_bit_lengt));
printf("\n");
}
void init_baby_cry_VCE(void)
{
/*Initialize the baby cry VCE model*/
#ifdef WAKEWORD_SUPPORT
int32_t size = api_getsizeof((baby_cry_VCEModel *)&baby_cry_model[0], (baby_cry_VCEModel *)&wakewd_model[0]);
#else
int32_t size = api_getsizeof((baby_cry_VCEModel *)&baby_cry_model[0], NULL);
#endif
printf("Total memory required : %d bytes\n", size);
char *pBuf = (char *)malloc(size);
if (!pBuf)
{
printf("baby Cry API instance creation failed\n");
return;
}
#ifdef WAKEWORD_SUPPORT
st = api_create(pBuf, (baby_cry_VCEModel *)&baby_cry_model[0], (baby_cry_VCEModel *)&wakewd_model[0]);
#else
st = api_create(pBuf, (baby_cry_VCEModel *)&baby_cry_model[0], NULL);
#endif
api_set_confidence_level(st, 0.1);
api_enable_vad_process(st, 1);
}
/****************************************************************************
* Public function
****************************************************************************/
extern "C" int myApps_main(int argc, FAR char *argv[])
{
/* Command line argument analysis */
if (!app_argparse(argc, argv))
{
goto errout;
}
printf("Baby cry Project Demo !!\n");
/* Initialize baby cry VCE parameters */
init_baby_cry_VCE();
/* Show codec parameters */
app_disp_codec_params();
z
/* First, initialize the shared memory and memory utility used by AudioSubSystem. */
if (!app_init_libraries())
{
printf("Error: init_libraries() failure.\n");
goto errout;
}
/* Next, Create the features used by AudioSubSystem. */
if (!app_create_audio_sub_system())
{
printf("Error: act_audiosubsystem() failure.\n");
goto errout_create_audio_sub_system;
}
/* On and after this point, AudioSubSystem must be active.
* Register the callback function to be notified when a problem occurs.
*/
/* Change AudioSubsystem to Ready state so that I/O parameters can be changed. */
if (!app_power_on())
{
printf("Error: app_power_on() failure.\n");
goto errout_power_on;
}
/* Initialize simple fifo. */
if (!app_init_simple_fifo())
{
printf("Error: app_init_simple_fifo() failure.\n");
goto errout_init_simple_fifo;
}
/* Set the initial gain of the microphone to be used. */
if (!app_init_mic_gain())
{
printf("Error: app_init_mic_gain() failure.\n");
goto errout_init_simple_fifo;
}
/* Set audio clock mode. */
if (!app_set_clkmode())
{
printf("Error: app_set_clkmode() failure.\n");
goto errout_init_simple_fifo;
}
/* Set recorder operation mode. */
if (!app_set_recorder_status())
{
printf("Error: app_set_recorder_status() failure.\n");
goto errout_init_simple_fifo;
}
/* Initialize recorder. */
if (!app_init_recorder())
{
printf("Error: app_init_recorder() failure.\n");
goto errout_init_recorder;
}
/* Initialize MicFrontend. */
if (!app_init_micfrontend())
{
printf("Error: app_init_micfrontend() failure.\n");
goto errout_init_recorder;
}
/* Start recorder operation. */
if (!app_start_recorder())
{
printf("Error: app_start_recorder() failure.\n");
}
else
{
/* Running... */
//printf("Running time is %d sec\n", target_recording_time);
app_recorde_process(target_recording_time);
/* Stop recorder operation. */
if (!app_stop_recorder())
{
printf("Error: app_stop_recorder() failure.\n");
/* To end processing */
}
}
errout_init_recorder:
/* Return the state of AudioSubSystem before voice_call operation. */
if (!app_set_ready())
{
printf("Error: app_set_ready() failure.\n");
/* To end processing */
}
errout_init_simple_fifo:
/* Change AudioSubsystem to PowerOff state. */
if (!app_power_off())
{
printf("Error: app_power_off() failure.\n");
/* To end processing */
}
errout_power_on:
/* Deactivate the features used by AudioSubSystem. */
app_deact_audio_sub_system();
errout_create_audio_sub_system:
/* finalize the shared memory and memory utility used by AudioSubSystem. */
if (!app_finalize_libraries())
{
printf("Error: finalize_libraries() failure.\n");
}
errout:
printf("Exit PCM capture example\n");
return 0;
}
Comments