static int audio_command(struct audio_client *ac, uint32_t cmd) { struct adsp_command_hdr rpc; memset(&rpc, 0, sizeof(rpc)); rpc.opcode = cmd; return audio_ioctl(ac, &rpc, sizeof(rpc)); }
static int audio_in_open(struct audio_client *ac, uint32_t bufsz, #ifdef CONFIG_MSM_QDSP6_CALLREC uint32_t flags, #endif uint32_t rate, uint32_t channels) { struct adsp_open_command rpc; memset(&rpc, 0, sizeof(rpc)); rpc.format.standard.format = ADSP_AUDIO_FORMAT_PCM; rpc.format.standard.channels = channels; rpc.format.standard.bits_per_sample = 16; rpc.format.standard.sampling_rate = rate; rpc.format.standard.is_signed = 1; rpc.format.standard.is_interleaved = 1; rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_OPEN_READ; rpc.device = ADSP_AUDIO_DEVICE_ID_DEFAULT; #ifdef CONFIG_MSM_QDSP6_CALLREC if (flags == AUDIO_FLAG_READ) rpc.stream_context = ADSP_AUDIO_DEVICE_CONTEXT_RECORD; else rpc.stream_context = ADSP_AUDIO_DEVICE_CONTEXT_MIXED_RECORD; #else rpc.stream_context = ADSP_AUDIO_DEVICE_CONTEXT_RECORD; #endif rpc.buf_max_size = bufsz; TRACE("%p: open in\n", ac); return audio_ioctl(ac, &rpc, sizeof(rpc)); }
static int audio_open_control(struct audio_client *ac) { struct adsp_open_command rpc; memset(&rpc, 0, sizeof(rpc)); rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_OPEN_DEVICE; return audio_ioctl(ac, &rpc, sizeof(rpc)); }
int q6audio_async(struct audio_client *ac) { struct adsp_command_hdr rpc; memset(&rpc, 0, sizeof(rpc)); rpc.opcode = ADSP_AUDIO_IOCTL_CMD_STREAM_EOS; rpc.response_type = ADSP_AUDIO_RESPONSE_ASYNC; return audio_ioctl(ac, &rpc, sizeof(rpc)); }
static int audio_stream_mute(struct audio_client *ac, int mute) { struct adsp_set_mute_command rpc; int rc; memset(&rpc, 0, sizeof(rpc)); rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_SET_STREAM_MUTE; rpc.mute = mute; rc = audio_ioctl(ac, &rpc, sizeof(rpc)); return rc; }
static int audio_stream_volume(struct audio_client *ac, int volume) { struct adsp_set_volume_command rpc; int rc; memset(&rpc, 0, sizeof(rpc)); rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_SET_STREAM_VOL; rpc.volume = volume; rc = audio_ioctl(ac, &rpc, sizeof(rpc)); return rc; }
static int audio_tx_mute(struct audio_client *ac, uint32_t dev_id, int mute) { struct adsp_set_dev_mute_command rpc; memset(&rpc, 0, sizeof(rpc)); rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_SET_DEVICE_MUTE; rpc.device_id = dev_id; rpc.path = ADSP_PATH_TX; rpc.mute = !!mute; return audio_ioctl(ac, &rpc, sizeof(rpc)); }
static int audio_rx_volume(struct audio_client *ac, uint32_t dev_id, int32_t volume) { struct adsp_set_dev_volume_command rpc; memset(&rpc, 0, sizeof(rpc)); rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_SET_DEVICE_VOL; rpc.device_id = dev_id; rpc.path = ADSP_PATH_RX; rpc.volume = volume; return audio_ioctl(ac, &rpc, sizeof(rpc)); }
int _oss_ioctl(int fd, unsigned long com, ...) { va_list ap; void *argp; va_start(ap, com); argp = va_arg(ap, void *); va_end(ap); if (IOCGROUP(com) == 'P') return audio_ioctl(fd, com, argp); else if (IOCGROUP(com) == 'M') return mixer_ioctl(fd, com, argp); else return ioctl(fd, com, argp); }
static int audio_set_table(struct audio_client *ac, uint32_t device_id, int size) { struct adsp_set_dev_cfg_table_command rpc; memset(&rpc, 0, sizeof(rpc)); rpc.hdr.opcode = ADSP_AUDIO_IOCTL_SET_DEVICE_CONFIG_TABLE; if (q6_device_to_dir(device_id) == Q6_TX) rpc.hdr.data = tx_clk_freq; rpc.device_id = device_id; rpc.phys_addr = audio_phys; rpc.phys_size = size; rpc.phys_used = size; TRACE("control: set table %x\n", device_id); return audio_ioctl(ac, &rpc, sizeof(rpc)); }
static int audio_mp3_open(struct audio_client *ac, uint32_t bufsz, uint32_t rate, uint32_t channels) { struct adsp_open_command rpc; memset(&rpc, 0, sizeof(rpc)); rpc.format.standard.format = ADSP_AUDIO_FORMAT_MP3; rpc.format.standard.channels = channels; rpc.format.standard.bits_per_sample = 16; rpc.format.standard.sampling_rate = rate; rpc.format.standard.is_signed = 1; rpc.format.standard.is_interleaved = 0; rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_OPEN_WRITE; rpc.device = ADSP_AUDIO_DEVICE_ID_DEFAULT; rpc.stream_context = ADSP_AUDIO_DEVICE_CONTEXT_PLAYBACK; rpc.buf_max_size = bufsz; return audio_ioctl(ac, &rpc, sizeof(rpc)); }
static int qdsp6_devchg_notify(struct audio_client *ac, uint32_t dev_type, uint32_t dev_id) { struct adsp_device_switch_command rpc; if (dev_type != ADSP_AUDIO_RX_DEVICE && dev_type != ADSP_AUDIO_TX_DEVICE) return -EINVAL; memset(&rpc, 0, sizeof(rpc)); rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_DEVICE_SWITCH_PREPARE; if (dev_type == ADSP_AUDIO_RX_DEVICE) { rpc.old_device = audio_rx_device_id; rpc.new_device = dev_id; } else { rpc.old_device = audio_tx_device_id; rpc.new_device = dev_id; } rpc.device_class = 0; rpc.device_type = dev_type; return audio_ioctl(ac, &rpc, sizeof(rpc)); }
static int dvbdev_ioctl(struct dvb_device *dvbdev, int num, struct file *file, unsigned int cmd, unsigned long arg) { struct dvb_struct *dvb=(struct dvb_struct *) dvbdev->priv; //void *parg=(void *)arg; int type=num2type(dvb, num); switch (type) { case DVB_DEVICE_VIDEO_0: return video_ioctl(dvbdev, file, cmd, arg); case DVB_DEVICE_AUDIO_0: return audio_ioctl(dvbdev, file, cmd, arg); case DVB_DEVICE_FRONTEND_0: return frontend_ioctl(dvbdev, file, cmd, arg); case DVB_DEVICE_SEC_0: return sec_ioctl(dvbdev, file, cmd, arg); case DVB_DEVICE_DEMUX_0: return demux_ioctl(dvbdev, file, cmd, arg); case DVB_DEVICE_DVR_0: return DmxDevDVRIoctl(&dvb->dmxdev, file, cmd, arg); case DVB_DEVICE_CA_0: return ca_ioctl(dvbdev, file, cmd, arg); case DVB_DEVICE_NET_0: return net_ioctl(dvbdev, file, cmd, arg); default: return -EOPNOTSUPP; } return 0; }
void local_player_task(uint_32 para) { _mqx_int return_code, res; my_audio_format_t format; FILE_PTR stream_ptr = NULL, stream_ptr1 = NULL; //device_ptr = NULL, uint_32 mclk_freq, fs_freq, bit_width = 0; I2S_STATISTICS_STRUCT stats; int32_t numberOfSamples =0, sampleProduced, bufOut; file_meta_data_t * metadata = NULL; audio_stream_type_t stream_type; char_ptr mem_ptr = NULL; boolean shell_cmd = FALSE; CCI_Ctx ctx; int32_t strLen, i; uint32_t file_extension=0; _task_id pcm_flush_id = MQX_NULL_TASK_ID; uint_32 cnt = 0; int32_t max_audio_buf_size = 0; lp_param_t * lpp_param = (lp_param_t *)para; TASK_TEMPLATE_STRUCT task_template; printf("local_player_task.. Enter 1\n"); if (msi_snd_init_with_periodbuffer(1024, 18) != 0) /* for SPI sd card play FLAC, 18K buffer is at least! */ { LOCALPLAY_LOG(" Error: Unable to open the device \"%s\".\n", AUDIO_DIVECE_NAME_STR); return; } /* create semaphore must before pcm_flush_task */ if(MQX_OK != _lwsem_create(&pcm_decoded_sem, 0)) { LOCALPLAY_LOG("\n Error - Unable to creat lwsem: pcm_decoded_sem\n"); } LOCALPLAY_LOG("Creating pcm flush task.........\n"); task_template.TASK_TEMPLATE_INDEX = 0; task_template.TASK_ADDRESS = pcm_flush_task; task_template.TASK_STACKSIZE = 2000; task_template.TASK_PRIORITY = 12; task_template.TASK_NAME = "pcm_flush"; task_template.TASK_ATTRIBUTES = 0; task_template.CREATION_PARAMETER = 0; task_template.DEFAULT_TIME_SLICE = 0; pcm_flush_id = _task_create_blocked(0, 0, (uint_32)&task_template); if (pcm_flush_id == MQX_NULL_TASK_ID) { printf("local_player_task create pcm_flush_task failed \n"); goto clean_up; } else{ gPcmFlushTaskFinish = 0; _task_ready(_task_get_td(pcm_flush_id)); _lwevent_set(&player_event, PLAYER_EVENT_MSK_SONG_RESUME); } metadata = (file_meta_data_t *) _mem_alloc_system_zero(sizeof(file_meta_data_t)); if (NULL == metadata) { LOCALPLAY_LOG("\n Failed to allocate memory for metadata.\n"); return; } decoding = TRUE; while (1) { #ifndef USB_ACCESSORY_PLAY _lwevent_wait_ticks( &player_event, PLAYER_EVENT_MSK_SONG_READY | PLAYER_EVENT_MSK_SD_FS_UNMOUNTED | PLAYER_EVENT_MSK_SHELL_COMMAND, FALSE, 0); #else _lwevent_wait_ticks( &player_event, PLAYER_EVENT_MSK_SONG_READY | PLAYER_EVENT_MSK_SD_FS_UNMOUNTED | PLAYER_EVENT_MSK_SHELL_COMMAND | PLAYER_EVENT_MSK_USB_ATTACHED, FALSE, 0); #endif shell_cmd = FALSE; #ifdef USB_ACCESSORY_PLAY if (player_event.VALUE & PLAYER_EVENT_MSK_USB_ATTACHED) { _lwevent_clear(&player_event, PLAYER_EVENT_MSK_USB_ATTACHED); //LOCALPLAY_LOG("__guoyifang__: sd_player_task PLAYER_EVENT_MSK_USB_ACC_ATTACHED \n"); break; } #endif if (player_event.VALUE & PLAYER_EVENT_MSK_SD_FS_UNMOUNTED) { _lwevent_clear(&player_event, PLAYER_EVENT_MSK_SD_FS_UNMOUNTED); //LOCALPLAY_LOG("__guoyifang__: sd_player_task PLAYER_EVENT_MSK_SD_FS_UNMOUNTED \n"); break; } if (player_event.VALUE & PLAYER_EVENT_MSK_SONG_READY) { _lwevent_clear(&player_event, PLAYER_EVENT_MSK_SONG_READY); } if (player_event.VALUE & PLAYER_EVENT_MSK_SHELL_COMMAND) { _lwevent_clear(&player_event, PLAYER_EVENT_MSK_SHELL_COMMAND); shell_cmd = TRUE; } LOCALPLAY_LOG(" --------------------------------------------------------------\n"); printf("play lock umount at %d\n",lpp_param->lp_type); _lwsem_wait(lpp_param->mfs_io_sem); /******************decoding is a critical value, assume decoding is TRUE every time.*******************/ printf("SET decoding.\n"); decoding = TRUE; // next/prev btn ISR may clear decoding to 0 /*******************************************/ /*config the audio subsystem according metadata*/ printf( " Open stream file %s\n", full_path); stream_ptr = fopen(full_path, "r"); if (stream_ptr == NULL) { printf(" Unable to open the file: %s\n", full_path); goto clean_up; } stream_ptr1 = fopen(full_path, "r"); if (stream_ptr1 == NULL) { printf(" Unable to open the file: %s\n", full_path); goto clean_up; } /* Determine the extension of the file */ i=0; strLen= strlen((const char *)full_path); if(strLen > 4){ /* find the '.' */ while(strLen--){ if(full_path[i]=='.') break; i++; } if(strLen){ char *p; /* Copy out the extension : 8.3 filename */ memcpy(&file_extension, full_path+i+1, 3); p = (char *) (&file_extension); for(i = 0; i < 4; i++, p++){ if((*p >= 'a') && (*p <= 'z')){ *p -= ('a' - 'A'); } } } ctx.user_data = (void*) stream_ptr; ctx.cci_dec_read = get_file_data;; ctx.cci_dec_seek = seek_file_data; ctx.cci_dec_tell = get_file_position; /* Check if metadata was found. */ return_code = cci_extract_meta_data(file_extension, metadata, &ctx); if (return_code != 0) { printf("\n Metadata not found\n"); goto clean_up; } print_metadata(metadata); //todo } else { printf("\n Metadata not found\n"); goto clean_up; } if ( metadata->stream_type == STREAM_TYPE_MP3 ) { /* Seek from the beginning of the file */ seek_file_data(0, metadata->start_pos, 0, stream_ptr); } else { /* Seek from the beginning of the file */ seek_file_data(0, 0, 0, stream_ptr); } stream_type = metadata->stream_type; #if 0 format.audio_format.ENDIAN = AUDIO_LITTLE_ENDIAN; format.audio_format.ALIGNMENT = AUDIO_ALIGNMENT_LEFT; if((streamType == kCodecStreamTypePcm) || // bitsPerSample Value is 8/16/24 /* * The demo not support kCodecStreamTypeImaAdpcm/kCodecStreamTypeMsAdpcm currently. */ (streamType == kCodecStreamTypeImaAdpcm) || // bitsPerSample Value is 4 (streamType == kCodecStreamTypeMsAdpcm)) // bitsPerSample Value is 4 { format.audio_format.BITS = metadata->i32BitsPerSample; }else{ format.audio_format.BITS = 16; } // Currently, the wave decoder output 16bits only for kCodecStreamTypePcm. format.audio_format.BITS = 16; format.audio_format.SIZE = (format.audio_format.BITS + 7)/8; format.audio_format.CHANNELS = metadata->i32NumChannels; format.fs_freq = metadata->u32SampleRate; fs_freq = format.fs_freq; mclk_freq = fs_freq * CLK_MULT; // Setup audio data format in device if (ioctl(device_ptr, IO_IOCTL_AUDIO_SET_IO_DATA_FORMAT, &format.audio_format) != I2S_OK) { LOCALPLAY_LOG(" Error: Input data format not supported.\n"); goto clean_up; } // Setup rest of parameters - master clock, valid data bits and sampling frequency if ((ioctl(device_ptr, IO_IOCTL_I2S_SET_MCLK_FREQ, &mclk_freq) != I2S_OK) || (ioctl(device_ptr, IO_IOCTL_I2S_SET_DATA_BITS, &format.audio_format.BITS) != I2S_OK) || (ioctl(device_ptr, IO_IOCTL_I2S_SET_FS_FREQ, &fs_freq) != I2S_OK)) { LOCALPLAY_LOG(" Error: Unable to setup \"%s\" device driver.\n", AUDIO_DIVECE_NAME_STR); goto clean_up; } // Setup audio codec return_code = SetupCodec(device_ptr); if (return_code != 0) { LOCALPLAY_LOG(" Audio codec configuration failed. Error 0x%X.\n", return_code); goto clean_up; } ioctl(device_ptr, IO_IOCTL_I2S_GET_FS_FREQ, &fs_freq); ioctl(device_ptr, IO_IOCTL_I2S_GET_DATA_BITS, &bit_width); LOCALPLAY_LOG(" Playback information\n"); LOCALPLAY_LOG(" Sampling frequency: %d Hz\n", fs_freq); LOCALPLAY_LOG(" Bit depth: %d bits\n", (uint_8)bit_width); LOCALPLAY_LOG(" Channels: "); if (format.audio_format.CHANNELS == 1) { LOCALPLAY_LOG("mono\n"); } else { LOCALPLAY_LOG("stereo\n"); } #else if((stream_type == STREAM_TYPE_PCM) || // bitsPerSample Value is 8/16/24 /* * The demo not support kCodecStreamTypeImaAdpcm/kCodecStreamTypeMsAdpcm currently. */ (stream_type == STREAM_TYPE_IMAADPCM) || // bitsPerSample Value is 4 (stream_type == STREAM_TYPE_MSADPCM)) // bitsPerSample Value is 4 { format.audio_format.BITS = metadata->bits_per_sample; }else{ format.audio_format.BITS = 16; } format.audio_format.CHANNELS = metadata->num_channels; // Currently, the wave decoder output 16bits only for kCodecStreamTypePcm. format.audio_format.BITS = 16; #if 0 if(audio_ioctl(setChNum, format.audio_format.CHANNELS)!= I2S_OK) { LOCALPLAY_LOG(" Error: audio_ioctl setChNum failed.\n"); goto clean_up; } if(audio_ioctl(setBitWidth, format.audio_format.BITS)!= I2S_OK) { LOCALPLAY_LOG(" Error: audio_ioctl setBitWidth failed.\n"); goto clean_up; } #endif format.fs_freq = metadata->sample_rate; #if 0 if(audio_ioctl(setSamplerate, format.fs_freq)!= I2S_OK) { LOCALPLAY_LOG(" Error: audio_ioctl setSamplerate failed.\n"); goto clean_up; } #endif msi_snd_set_format(format.fs_freq, format.audio_format.BITS, format.audio_format.CHANNELS); #endif mem_ptr = (char_ptr) _mem_alloc_system_zero(codec_get_mem_info(stream_type)); if (NULL == mem_ptr) { LOCALPLAY_LOG("Failed to allocate memory for the decoder.\n"); goto clean_up; } // MP4 decoder need two fd g_userData[0] = (int) stream_ptr; g_userData[1] = (int) stream_ptr1; if (metadata->audio_sub_type == MEDIA_SUBTYPE_ADTS) g_userData[2] = 1; else if (metadata->audio_sub_type == MEDIA_SUBTYPE_M4A) g_userData[2] = 2; else if ( metadata->stream_type == STREAM_TYPE_OPUS ) { g_userData[2] = metadata->sample_rate; g_userData[3] = metadata->num_channels; } else g_userData[2] = 0; g_callbackFunctionArray[0] = (int32_t *) &get_file_data; g_callbackFunctionArray[1] = (int32_t *) &seek_file_data; g_callbackFunctionArray[2] = (int32_t *) &get_file_position; while (1) { res = codec_init(stream_type, (long **)&mem_ptr,g_callbackFunctionArray, &g_userData[0]); if (res == CODEC_INIT_ERROR) { LOCALPLAY_LOG("\n Codec Init Failed with error code %d\n", res); decoding = FALSE; goto clean_up; } if (res == CODEC_MORE_DATA_REQUIRED) { LOCALPLAY_LOG("\n More Data Processing Required for Init \n"); } if (res == CODEC_SUCCESS) { LOCALPLAY_LOG("\n Codec Init Done Successfully \n\n"); break; } else { printf("codec init other err\n"); decoding = FALSE; goto clean_up; } } if (res == CODEC_SUCCESS) { LOCALPLAY_LOG(" Playing %s...\n\n", full_path); // ioctl(device_ptr, IO_IOCTL_I2S_CLEAR_STATISTICS, NULL); /* Reset variables before every song's playbacking */ //printf("SET decoding.\n"); //decoding = TRUE; // next/prev btn ISR may clear decoding to 0 cnt = 0; max_audio_buf_size = 0; g_audio_buf_ptr = NULL; //_lwevent_clear(&player_event, PLAYER_EVENT_MSK_AUDIO_BUF_FILLED); /* Clear pcm_decoded_sem for play next song */ _lwsem_poll(&pcm_decoded_sem); _lwsem_poll(&pcm_decoded_sem); if(MQX_OK != _lwsem_create(&pcm_flush_sem, AUDIO_BUF_CNT)) { LOCALPLAY_LOG("\n Error - Unable to create lwsem: pcm_flush_sem\n"); } /* * umute */ msi_snd_umute(); //sai_dma_output_init(); while (decoding) { /* * For FLAC decoder, it produced more than 18K bytes per frame, and takes about 30ms. * While take 44.1K/16bit/2ch/4Kbytes DMA buffer as example, the margin time is 4K/4/2/44100~=10ms. * We need bigger DMA buffer, or decode in a ping-pong way. */ res = codec_decode(stream_type, (long **)&mem_ptr, &sampleProduced, &bufOut); if (res == CODEC_END_OF_DECODE) { printf("\n End of Decode \n"); break; } else if (res == CODEC_DECODE_ERROR) { printf("\n Codec Decode Failed \n"); break; } else if(res != CODEC_SUCCESS){ printf("codec_decode else err %d\n",res); break; } cnt += sampleProduced; while (decoding) { numberOfSamples = codec_get_pcm_samples(stream_type, (long **)&mem_ptr, &sampleProduced, &bufOut); if (numberOfSamples == 0) break; #if 1 if (max_audio_buf_size < sampleProduced) { //More bigger buffer needed max_audio_buf_size = sampleProduced; if (NULL != g_audio_buf_ptr) { LOCALPLAY_LOG(" Bigger buffer needed.\n"); _mem_free(g_audio_buf_ptr); } g_audio_buf_ptr = (uchar_ptr) _mem_alloc_system_zero(max_audio_buf_size); if (NULL == g_audio_buf_ptr) { LOCALPLAY_LOG(" Failed to allocate g_audio_buf_ptr. max_audio_buf_size %d \n", max_audio_buf_size); decoding = 0; break; } #if 1 //sai_dma_buffer_adjust(sampleProduced); #endif } #endif if (MQX_OK != _lwsem_wait(&pcm_flush_sem)) { LOCALPLAY_LOG("\n Error: Wait for pcm_flush_sem failed.\n"); // _task_set_error(res); } _mem_copy((void *)bufOut, g_audio_buf_ptr, sampleProduced); //g_audio_buf_ptr = bufOut; g_buf_bytes_to_flush = sampleProduced; if (_lwsem_post(&pcm_decoded_sem) != MQX_OK) { LOCALPLAY_LOG("\n pcm_flush : Error - Unable to set pcm_decoded_sem."); } if (numberOfSamples == sampleProduced) sampleProduced = 0; }//end while decoding }//end while decoding }//end if res==kCodeSuccess #if 0 fflush(device_ptr); #else msi_snd_mute(); if (MQX_OK != _lwsem_wait(&pcm_flush_sem)) LOCALPLAY_LOG("\n Error: Wait for latest pcm_flush_sem failed.\n"); msi_snd_flush(); #endif #if 1 //sai_dma_output_stop(); #endif #if 0 /* Print transfer statistics */ if (ioctl(device_ptr, IO_IOCTL_I2S_GET_STATISTICS, &stats) != I2S_OK) { LOCALPLAY_LOG(" Error: Cannot read I2S statistics.\n"); } else { LOCALPLAY_LOG("\n Playback stats\n"); LOCALPLAY_LOG(" Total interrupts: %d\n", stats.INTERRUPTS); LOCALPLAY_LOG(" Bytes requested for transmit: %d\n", stats.PACKETS_REQUESTED * format.audio_format.SIZE); LOCALPLAY_LOG(" Bytes transmitted: %d\n", stats.TX_PACKETS * format.audio_format.SIZE); LOCALPLAY_LOG(" Underruns of hardware FIFO: %d\n", stats.FIFO_ERROR); LOCALPLAY_LOG(" Software buffer empty: %d\n", stats.BUFFER_ERROR); } #endif LOCALPLAY_LOG("\n DONE\n"); clean_up: printf("done to clean up,decoding %d \n",decoding); /* Clean up for next song */ if (NULL != mem_ptr) { _mem_free(mem_ptr); mem_ptr = NULL; } if (NULL != g_audio_buf_ptr) { _mem_free(g_audio_buf_ptr); g_audio_buf_ptr = NULL; } if (NULL != stream_ptr) { res = fclose(stream_ptr); if ((res != MQX_OK)&&(res != MFS_DISK_IS_WRITE_PROTECTED)) { /*LOCALPLAY_LOG*/printf(" Error: Unable to close file 0x%x.\n", res); } stream_ptr = NULL; } if (NULL != stream_ptr1) { res = fclose(stream_ptr1); if ((res != MQX_OK)&&(res != MFS_DISK_IS_WRITE_PROTECTED)) { /*LOCALPLAY_LOG*/printf(" Error: Unable to close file 0x%x.\n", res); } stream_ptr1 = NULL; } if(MQX_OK != _lwsem_destroy(&pcm_flush_sem)) { LOCALPLAY_LOG("\n Error - Unable to destroy lwsem: pcm_flush_sem\n"); } if (decoding == TRUE) { // playback finished in normal way, ie, next/prev not pressed if (!shell_cmd) { // and was not triggered by Shell // just like next btn being pressed _lwevent_set(&player_event, PLAYER_EVENT_MSK_NEXT_BTN_PRESSED); } } /* if exit this task ,must route this point ! */ printf("play unlock umount at %d\n",lpp_param->lp_type); _lwsem_post(lpp_param->mfs_io_sem); }//end while(1) #if 0 // clean up further if (NULL != device_ptr) { if (fclose(device_ptr) != MQX_OK) { LOCALPLAY_LOG(" Error: Unable to close \"%s\" device driver.\n", full_path); } } #else msi_snd_deinit(); #endif if (NULL != metadata) _mem_free(metadata); if (MQX_NULL_TASK_ID != pcm_flush_id) { gPcmFlushTaskFinish = 1; _lwsem_post(&pcm_decoded_sem); while(gPcmFlushTaskFinish == 1){ _sched_yield(); } //_task_destroy(pcm_flush_id); pcm_flush_id = MQX_NULL_TASK_ID; ///*LOCALPLAY_LOG*/printf(" pcm flush task destoryed \n"); } if(MQX_OK != _lwsem_destroy(&pcm_decoded_sem)) { LOCALPLAY_LOG("\n Error - Unable to destroy lwsem: pcm_decoded_sem\n"); } //printf("__guoyifang__: sd_player_task %d set PLAYER_TASK_KILLED.\n",lpp_param->lp_type); _lwevent_set(&player_event, PLAYER_EVENT_MSK_PLAYER_TASK_KILLED); printf("sd_player_task exit.\n"); //_task_block(); //wait for being destroyed }