| /******************************************************************************* |
| * Copyright (C) 2018 Cadence Design Systems, Inc. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining |
| * a copy of this software and associated documentation files (the |
| * "Software"), to use this Software with Cadence processor cores only and |
| * not with any other processors and platforms, subject to |
| * the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included |
| * in all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
| * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
| * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| |
| ******************************************************************************/ |
| |
| #define MODULE_TAG UTEST |
| |
| #include "xaf-utils-test.h" |
| |
| #include "audio/xa_vorbis_dec_api.h" |
| #include "audio/xa-mixer-api.h" |
| #include "audio/xa-audio-decoder-api.h" |
| |
| #include "xa_playback.h" |
| |
| #define PRINT_USAGE do { fprintf(stderr, "\nUsage: %s <input-file1> <input-file2>\n", argv[0]); \ |
| fprintf(stderr, " Only .ogg and .pcm files are supported. \n"); \ |
| fprintf(stderr, " Playback is configured @ 48kHz, 2 ch, 16 bits pcm. \n"); \ |
| fprintf(stderr, " <input-file2> is optional. \n"); \ |
| fprintf(stderr, " pcm output is written to dec-mix-out.pcm, by default. \n\n"); \ |
| } while(0) |
| |
| #define MAX_INP_STRMS 2 |
| #define NUM_COMP_IN_GRAPH 3 |
| |
| /* ...global variables */ |
| int g_pthread_exit_code=0x12345678; |
| |
| /* ...playback format */ |
| xaf_format_t pb_format; |
| |
| /* ...playback device parameters */ |
| void *pb_handle = NULL; |
| |
| void thread_exit_handler(int sig) |
| { |
| /* ...unused arg */ |
| (void) sig; |
| |
| pthread_exit(0); |
| } |
| |
| static int vorbis_setup(void *p_decoder) |
| { |
| int param[2]; |
| |
| /* 1: Raw decode, 0: Ogg decode */ |
| param[0] = XA_VORBISDEC_CONFIG_PARAM_RAW_VORBIS_FILE_MODE; |
| param[1] = 0; |
| |
| XF_CHK_API(xaf_comp_set_config(p_decoder, 1, ¶m[0])); |
| |
| return 0; |
| } |
| |
| static int pcm_setup(void *p_pcm) |
| { |
| int param[6]; |
| |
| param[0] = XA_CODEC_CONFIG_PARAM_SAMPLE_RATE; |
| param[1] = pb_format.sample_rate; |
| param[2] = XA_CODEC_CONFIG_PARAM_CHANNELS; |
| param[3] = pb_format.channels; |
| param[4] = XA_CODEC_CONFIG_PARAM_PCM_WIDTH; |
| param[5] = pb_format.pcm_width; |
| |
| XF_CHK_API(xaf_comp_set_config(p_pcm, 3, ¶m[0])); |
| |
| return 0; |
| } |
| |
| static int mixer_setup(void *p_decoder, xaf_format_t *p_format) |
| { |
| int param[6]; |
| |
| param[0] = XA_MIXER_CONFIG_PARAM_SAMPLE_RATE; |
| param[1] = p_format->sample_rate; |
| param[2] = XA_MIXER_CONFIG_PARAM_CHANNELS; |
| param[3] = p_format->channels; |
| param[4] = XA_MIXER_CONFIG_PARAM_PCM_WIDTH; |
| param[5] = p_format->pcm_width; |
| |
| XF_CHK_API(xaf_comp_set_config(p_decoder, 3, ¶m[0])); |
| |
| return 0; |
| } |
| |
| static int consume_output(void *p_buf, int buf_length, void *p_output) |
| { |
| XAF_CHK_PTR(p_buf); |
| XAF_CHK_PTR(p_output); |
| |
| #if !defined BOARD |
| FILE *fp = p_output; |
| fwrite(p_buf, 1, buf_length, fp); |
| |
| if (xa_playback_buf(pb_handle, p_buf, buf_length)) { |
| TRACE(ERROR, _b("Playback Failed \n")); |
| return -1; |
| } |
| #else |
| #endif |
| return 0; |
| } |
| |
| static int read_input(void *p_buf, int buf_length, int *read_length, void *p_input) |
| { |
| XAF_CHK_PTR(p_buf); |
| XAF_CHK_PTR(read_length); |
| XAF_CHK_PTR(p_input); |
| |
| #if !defined BOARD |
| FILE *fp = p_input; |
| *read_length = fread(p_buf, 1, buf_length, fp); |
| #else |
| #endif |
| return 0; |
| } |
| |
| static int comp_process_entry(void *arg) |
| { |
| void *p_comp; |
| void *p_input, *p_output; |
| xaf_comp_status comp_status; |
| xaf_info_t comp_info; |
| int input_over, read_length; |
| void * (*arg_arr)[3]; |
| void *pg_pthread_exit_code = (void*)&g_pthread_exit_code; |
| |
| XAF_CHK_PTR(arg); |
| |
| arg_arr = arg; |
| p_comp = (*arg_arr)[0]; |
| p_input = (*arg_arr)[1]; |
| p_output = (*arg_arr)[2]; |
| input_over = 0; |
| |
| XF_CHK_API(xaf_comp_process(NULL, p_comp, NULL, 0, XAF_EXEC_FLAG)); |
| |
| while (1) |
| { |
| XF_CHK_API(xaf_comp_get_status(NULL, p_comp, &comp_status, &comp_info)); |
| |
| if (comp_status == XAF_EXEC_DONE) break; |
| |
| if (comp_status == XAF_NEED_INPUT && !input_over) |
| { |
| void *p_buf = (void *) comp_info.buf; |
| int size = comp_info.length; |
| |
| XF_CHK_API(read_input(p_buf, size, &read_length, p_input)); |
| |
| if (read_length) |
| XF_CHK_API(xaf_comp_process(NULL, p_comp, (void *)comp_info.buf, read_length, XAF_INPUT_READY_FLAG)); |
| else |
| { |
| XF_CHK_API(xaf_comp_process(NULL, p_comp, NULL, 0, XAF_INPUT_OVER_FLAG)); |
| input_over = 1; |
| } |
| } |
| |
| if (comp_status == XAF_OUTPUT_READY) |
| { |
| void *p_buf = (void *) comp_info.buf; |
| int size = comp_info.length; |
| |
| XF_CHK_API(consume_output(p_buf, size, p_output)); |
| XF_CHK_API(xaf_comp_process(NULL, p_comp, (void *)comp_info.buf, comp_info.length, XAF_NEED_OUTPUT_FLAG)); |
| } |
| } |
| pthread_exit(pg_pthread_exit_code); |
| |
| return 0; |
| } |
| |
| int main(int argc, const char **argv) |
| { |
| void *p_adev = NULL; |
| void *p_decoder[MAX_INP_STRMS]; |
| void *p_mixer; |
| mem_obj_t* mem_handle; |
| int num_comp = NUM_COMP_IN_GRAPH; |
| |
| xaf_comp_status dec_status; |
| xaf_info_t comp_info; |
| |
| void *p_input[MAX_INP_STRMS], *p_output; |
| |
| xf_id_t dec_id[MAX_INP_STRMS]; |
| int (*dec_setup[MAX_INP_STRMS])(void *p_comp); |
| |
| pthread_t dec_thread[MAX_INP_STRMS]; |
| pthread_t mixer_thread; |
| void *dec_thread_args[MAX_INP_STRMS][3]; |
| void *mixer_thread_args[3]; |
| |
| const char *ext; |
| FILE *fp, *ofp; |
| void *dec_inbuf[MAX_INP_STRMS][2]; |
| int buf_length = XAF_INBUF_SIZE; |
| int read_length; |
| int input_over = 0; |
| int i, j; |
| int num_strms; |
| |
| unsigned int card = 0; |
| unsigned int device = 0; |
| unsigned int period_size = 1024; |
| unsigned int period_count = 4; |
| |
| int pthread_error; |
| void *pthread_exit_code[3]; |
| |
| struct sigaction actions; |
| memset(&actions, 0, sizeof(actions)); |
| sigemptyset(&actions.sa_mask); |
| actions.sa_flags = 0; |
| actions.sa_handler = thread_exit_handler; |
| sigaction(SIGUSR1,&actions,NULL); |
| |
| /* ...initialize playback format */ |
| pb_format.sample_rate = 48000; |
| pb_format.channels = 2; |
| pb_format.pcm_width = 16; |
| |
| audio_frmwk_buf_size = 0; //unused |
| audio_comp_buf_size = 0; //unused |
| |
| print_banner("\'Audio decoder(PCM/Ogg-Vorbis) + Mixer\'"); |
| |
| /* ...initialize tracing facility */ |
| TRACE_INIT("Xtensa Audio Framework - Sample Application"); |
| |
| #if !defined BOARD |
| /* ...check input arguments */ |
| if (argc < 2 || argc > (MAX_INP_STRMS+1)) |
| { |
| TRACE(ERROR, _b("Usage: ./xaf-test <infile1> <infile2>\n")); |
| PRINT_USAGE; |
| return 0; |
| } |
| |
| argc--; |
| for (i=0; i<argc; i++) |
| { |
| ext = strrchr(argv[i+1], '.'); |
| if (!ext) |
| { |
| PRINT_USAGE; |
| return 0; |
| } |
| ext++; |
| if (!strcmp(ext, "pcm")) { |
| dec_id[i] = "audio-decoder/pcm"; |
| dec_setup[i] = pcm_setup; |
| } |
| else if (!strcmp(ext, "ogg")) { |
| dec_id[i] = "audio-decoder/vorbis"; |
| dec_setup[i] = vorbis_setup; |
| } |
| else { |
| TRACE(ERROR, _x("Unknown Decoder Extension '%s'"), ext); |
| PRINT_USAGE; |
| exit(-1); |
| } |
| /* ...open file */ |
| if ((fp = fopen(argv[i+1], "rb")) == NULL) |
| { |
| TRACE(ERROR, _x("Failed to open '%s': %d"), argv[i+1], errno); |
| exit(-1); |
| } |
| p_input[i] = fp; |
| } |
| num_strms = i; |
| |
| if ((ofp = fopen("dec-mix-out.pcm", "wb")) == NULL) |
| { |
| TRACE(ERROR, _x("Failed to open '%s': %d"), "dec-mix-out.pcm", errno); |
| exit(-1); |
| } |
| p_output = ofp; |
| #endif |
| |
| mem_handle = mem_init(); //initialize memory handler |
| |
| XF_CHK_API(xaf_adev_open(&p_adev, audio_frmwk_buf_size, audio_comp_buf_size, mem_malloc, mem_free)); |
| |
| /* ...create mixer component */ |
| XF_CHK_API(xaf_comp_create(p_adev, &p_mixer, "mixer", 0, 1, NULL, XAF_MIXER)); |
| XF_CHK_API(mixer_setup(p_mixer, &pb_format)); |
| |
| for (i=0; i<num_strms; i++) |
| { |
| /* ...create decoder component */ |
| XF_CHK_API(xaf_comp_create(p_adev, &p_decoder[i], dec_id[i], 2, 0, &dec_inbuf[i][0], XAF_DECODER)); |
| XF_CHK_API((dec_setup[i])(p_decoder[i])); |
| |
| /* ...start decoder component */ |
| XF_CHK_API(xaf_comp_process(p_adev, p_decoder[i], NULL, 0, XAF_START_FLAG)); |
| |
| /* ...feed input to decoder component */ |
| for (j=0; j<2; j++) |
| { |
| XF_CHK_API(read_input(dec_inbuf[i][j], buf_length, &read_length, p_input[i])); |
| |
| if (read_length) |
| XF_CHK_API(xaf_comp_process(p_adev, p_decoder[i], dec_inbuf[i][j], read_length, XAF_INPUT_READY_FLAG)); |
| else |
| break; |
| } |
| |
| /* ...initialization loop */ |
| while (1) |
| { |
| XF_CHK_API(xaf_comp_get_status(p_adev, p_decoder[i], &dec_status, &comp_info)); |
| |
| if (dec_status == XAF_INIT_DONE || dec_status == XAF_EXEC_DONE) break; |
| |
| if (dec_status == XAF_NEED_INPUT && !input_over) |
| { |
| void *p_buf = (void *) comp_info.buf; |
| int size = comp_info.length; |
| |
| XF_CHK_API(read_input(p_buf, size, &read_length, p_input[i])); |
| |
| if (read_length) |
| XF_CHK_API(xaf_comp_process(p_adev, p_decoder[i], p_buf, read_length, XAF_INPUT_READY_FLAG)); |
| else |
| break; |
| } |
| } |
| |
| if (dec_status != XAF_INIT_DONE) |
| { |
| TRACE(ERROR, _x("Failed to init")); |
| exit(-1); |
| } |
| |
| XF_CHK_API(xaf_connect(p_decoder[i], p_mixer, 4)); |
| } |
| |
| XF_CHK_API(xaf_comp_process(p_adev, p_mixer, NULL, 0, XAF_START_FLAG)); |
| XF_CHK_API(xaf_comp_get_status(p_adev, p_mixer, &dec_status, &comp_info)); |
| |
| if (dec_status != XAF_INIT_DONE) |
| { |
| TRACE(ERROR, _x("Failed to init")); |
| exit(-1); |
| } |
| |
| /* ...open playback device */ |
| pb_handle = xa_playback_open(card, device, pb_format.channels, pb_format.sample_rate, |
| pb_format.pcm_width, period_size, period_count); |
| if (!pb_handle) { |
| TRACE(ERROR, _x("Playback open error\n")); |
| return -1; |
| } |
| |
| for (i=0; i<num_strms; i++) |
| { |
| dec_thread_args[i][0] = p_decoder[i]; |
| dec_thread_args[i][1] = p_input[i]; |
| dec_thread_args[i][2] = p_output; |
| pthread_create(&dec_thread[i], 0, (void *(*)(void*))&comp_process_entry, dec_thread_args[i]); |
| } |
| |
| mixer_thread_args[0] = p_mixer; |
| mixer_thread_args[1] = NULL; |
| mixer_thread_args[2] = p_output; |
| pthread_create(&mixer_thread, 0, (void *(*)(void*))comp_process_entry, &mixer_thread_args[0]); |
| |
| for (i=0; i<num_strms; i++) |
| { |
| pthread_error = pthread_join(dec_thread[i], (void **) &pthread_exit_code[i]); |
| if(pthread_error) |
| { |
| TRACE(ERROR, _b("decode thread %d join error:%x\n"), i, pthread_error); |
| } |
| } |
| pthread_error = pthread_join(mixer_thread, (void **) &pthread_exit_code[i]); |
| if(pthread_error) |
| { |
| TRACE(ERROR, _b("mixer thread join error:%x\n"), pthread_error); |
| } |
| |
| for (i=0; i<num_strms; i++) |
| { |
| XF_CHK_API(xaf_comp_delete(p_decoder[i])); |
| if (p_input[i]) fclose(p_input[i]); |
| } |
| XF_CHK_API(xaf_comp_delete(p_mixer)); |
| |
| /* ...exec done, clean-up */ |
| xa_playback_close(pb_handle); |
| |
| XF_CHK_API(xaf_adev_close(p_adev, 0 /*unused*/)); |
| if (p_output) fclose(p_output); |
| |
| mem_exit(); |
| XF_CHK_API(print_mem_mcps_info(mem_handle, num_comp)); |
| |
| return 0; |
| } |
| |