/*****************************************************************************
* FUNCTION
* aud_stretch_check_file_format_req_hdlr
* DESCRIPTION
* This function is to check format for audio file
* PARAMETERS
* ilm_ptr [?]
* RETURNS
* void
*****************************************************************************/
void aud_stretch_check_file_format_req_hdlr(ilm_struct *ilm_ptr)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_int16 format;
kal_bool is_support;
STFSAL ext_file;
FSAL_Status fsal_ret;
media_stretch_check_file_format_req_struct *msg_p;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
msg_p = (media_stretch_check_file_format_req_struct*) ilm_ptr->local_para_ptr;
/* Get file audio type from extension */
format = med_get_media_type(msg_p->file_path);
if(format == MED_TYPE_MP4 || format == MED_TYPE_3GP)
{
kal_uint8 result;
/* Get video's audio type */
result = aud_stretch_is_aduio_in_video_PP_support(msg_p->file_path, NULL, 0, 0);
aud_app_set_result(result);
}
else
{
/* get file handle */
fsal_ret = FSAL_Open(&ext_file, (void*)msg_p->file_path, FSAL_READ);
if (fsal_ret == FSAL_OK)
{
/* Check if the file can play with time stretch on */
is_support = AudioPP_TS_IsSupport((Media_Format) format, &ext_file);
FSAL_Close(&ext_file);
if (is_support)
{
aud_app_set_result(MED_RES_OK);
}
else
{
aud_app_set_result(MED_RES_UNSUPPORTED_SPEED);
}
}
else if (fsal_ret == FSAL_OPEN_ERROR)
{
aud_app_set_result(MED_RES_OPEN_FILE_FAIL);
}
else
{
aud_app_set_result(MED_RES_FAIL);
}
}
EFFECT_SET_EVENT(TS_EVT_CHECK);
}
void FdSaveLog(kal_uint16 filecount)
{
#ifdef FD_LOG_DEBUG_INFO
STFSAL rRecordFile;
gFdLogFilename[14] = (filecount%10)+'0';
gFdLogFilename[13] = ((filecount/10)%10)+'0';
gFdLogFilename[12] = ((filecount/10/10)%10)+'0';
FSAL_Open(&rRecordFile, gFdLogFilename, FSAL_WRITE);
kal_mem_cpy((void*)(gFdPrzBuff), (void*)(gFdSetMemInfo.PpSrcBufAddr), FD_IMAGE_XS*FD_IMAGE_YS*CAMERA_FD_IMAGE_BYTES);
FSAL_Write(&rRecordFile, (kal_uint8*)(gFdLogBuff), gFdLogSize);
FSAL_Close(&rRecordFile);
#endif
}
/*****************************************************************************
* FUNCTION
* aud_stretch_check_stream_format_req_hdlr
* DESCRIPTION
* This function is to check format for audio data stream
* PARAMETERS
* ilm_ptr [?]
* RETURNS
* void
*****************************************************************************/
void aud_stretch_check_stream_format_req_hdlr(ilm_struct *ilm_ptr)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_bool is_support;
STFSAL ext_file;
FSAL_Status fsal_ret;
media_stretch_check_stream_format_req_struct *msg_p;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
msg_p = (media_stretch_check_stream_format_req_struct*) ilm_ptr->local_para_ptr;
FSAL_Direct_SetRamFileSize(&ext_file, msg_p->size);
fsal_ret = FSAL_Open(&ext_file, (void*)msg_p->data_p, FSAL_ROMFILE);
if (fsal_ret == FSAL_OK)
{
/* Check if the file can play with time stretch on */
is_support = AudioPP_TS_IsSupport((Media_Format) msg_p->format, &ext_file);
FSAL_Close(&ext_file);
if (is_support)
{
aud_app_set_result(MED_RES_OK);
EFFECT_SET_EVENT(TS_EVT_CHECK);
return;
}
}
aud_app_set_result(MED_RES_FAIL);
EFFECT_SET_EVENT(TS_EVT_CHECK);
}
/*****************************************************************************
* FUNCTION
* aud_media_get_audio_format_in_video
* DESCRIPTION
* This function is to get the audio format in video
* PARAMETERS
*
* RETURNS
* kal_uint8 result
*****************************************************************************/
kal_uint8 aud_stretch_is_aduio_in_video_PP_support(kal_wchar *file_name, kal_uint8 *data, kal_uint32 data_len, kal_int16 data_format)
{
#if defined(MED_PURE_AUDIO)
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
MP4_Parser_Status eMp4ParserRet;
FSAL_Status eFSALRet;
kal_uint8 result;
kal_bool is_file_opened = KAL_FALSE;
kal_bool has_aud_track;
kal_bool is_PP_support = KAL_FALSE;
Media_Format audio_format;
kal_uint32 filesize;
kal_uint32 index;
kal_uint64 temp;
STFSAL stFSAL_ROM;
kal_uint8 *fsal_rom_buf;
STMp4Parser *stMp4Parser_aud;
STFSAL *stFSAL_aud;
STFSAL *stFSAL_aud_stsz;
STFSAL *stFSAL_aud_stco;
STFSAL *stFSAL_aud_aud_data;
kal_uint32 *mp4_aud_buf;
kal_uint32 *mp4_aud_data_buf;
kal_uint32 *mp4_aud_stco_buf;
kal_uint32 *mp4_aud_stsz_buf;
kal_uint32 *mp4_aud_stbl_buf;
FS_FileLocationHint *aud_seek_hint;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
/* Open file for playing */
stFSAL_aud = (STFSAL*)get_ctrl_buffer(sizeof(STFSAL));
eFSALRet = FSAL_Open(stFSAL_aud, (void*)file_name, FSAL_READ);
if (eFSALRet != FSAL_OK)
{
result = MED_RES_OPEN_FILE_FAIL;
goto pure_audio_error_out;
}
is_file_opened = KAL_TRUE;
/* Allocate working buffer for operation */
stMp4Parser_aud = (STMp4Parser*)get_ctrl_buffer(sizeof(STMp4Parser));
stFSAL_aud_stsz = (STFSAL*)get_ctrl_buffer(sizeof(STFSAL));
stFSAL_aud_stco = (STFSAL*)get_ctrl_buffer(sizeof(STFSAL));
stFSAL_aud_aud_data = (STFSAL*)get_ctrl_buffer(sizeof(STFSAL));
mp4_aud_buf = (kal_uint32*)med_alloc_ext_mem( AUD_MP4_FSAL_BUF_SIZE*sizeof(kal_uint32) );
mp4_aud_data_buf = (kal_uint32*)med_alloc_ext_mem( AUD_MP4_FSAL_BUF_SIZE*sizeof(kal_uint32) );
mp4_aud_stco_buf = (kal_uint32*)med_alloc_ext_mem( AUD_MP4_STCO_BUF_SIZE*sizeof(kal_uint32) );
mp4_aud_stsz_buf = (kal_uint32*)med_alloc_ext_mem( AUD_MP4_STSZ_BUF_SIZE*sizeof(kal_uint32) );
mp4_aud_stbl_buf = (kal_uint32*)med_alloc_ext_mem( AUD_MP4_STBL_BUF_SIZE*sizeof(kal_uint32) );
aud_seek_hint = (FS_FileLocationHint*)med_alloc_ext_mem( AUD_DEC_SEEK_HINT_SIZE*sizeof(FS_FileLocationHint) );
/* Set buffer for FSAL */
FSAL_SetBuffer(stFSAL_aud, AUD_MP4_FSAL_BUF_SIZE, (kal_uint8*)mp4_aud_buf);
/* Set seek hint */
eFSALRet = FSAL_GetFileSize(stFSAL_aud, &filesize);
if (eFSALRet != FSAL_OK)
{
result = MED_RES_OPEN_FILE_FAIL;
goto pure_audio_error_out;
}
for (index = 0; index < AUD_DEC_SEEK_HINT_SIZE; index++)
{
temp = ((kal_uint64) filesize * (kal_uint64) (index + 1)) / (kal_uint64) (AUD_DEC_SEEK_HINT_SIZE + 1);
aud_seek_hint[index].Index = (kal_uint32) temp;
}
DRM_set_seek_hint(stFSAL_aud->hFile, AUD_DEC_SEEK_HINT_SIZE, aud_seek_hint);
/* Creat MP4 parser */
eMp4ParserRet = MP4_Parse(stMp4Parser_aud, stFSAL_aud);
if (eMp4ParserRet != MP4_PARSER_OK && eMp4ParserRet != MP4_PARSER_WARNING_TRAILING_GARBAGE)
{
result = MED_RES_BAD_FORMAT;
goto pure_audio_error_out;
}
/* Check if there's audio track */
MP4_MetaHasAudioTrack(stMp4Parser_aud, &has_aud_track);
if (!has_aud_track)
{
result = MED_RES_MP4_NO_AUDIO_TRACK;
goto pure_audio_error_out;
}
/* Prepare cache table */
eMp4ParserRet = MP4_STBL_CacheTablePreprocess(
stMp4Parser_aud,
mp4_aud_stbl_buf,
AUD_MP4_STBL_BUF_SIZE);
if (eMp4ParserRet != MP4_PARSER_OK)
{
result = MED_RES_BAD_FORMAT;
goto pure_audio_error_out;
}
/* FSAL aud data */
eFSALRet = FSAL_Open_Attach(stFSAL_aud_aud_data, stFSAL_aud);
if (eFSALRet != FSAL_OK)
{
result = MED_RES_OPEN_FILE_FAIL;
goto pure_audio_error_out;
}
FSAL_SetBuffer(stFSAL_aud_aud_data, AUD_MP4_FSAL_BUF_SIZE, (kal_uint8*)mp4_aud_data_buf);
/* FASL stco */
eFSALRet = FSAL_Open_Attach(stFSAL_aud_stco, stFSAL_aud);
if (eFSALRet != FSAL_OK)
{
result = MED_RES_OPEN_FILE_FAIL;
goto pure_audio_error_out;
}
FSAL_SetBuffer(stFSAL_aud_stco, AUD_MP4_STCO_BUF_SIZE, (kal_uint8*)mp4_aud_stco_buf);
/* FSAL stsz */
eFSALRet = FSAL_Open_Attach(stFSAL_aud_stsz, stFSAL_aud);
if (eFSALRet != FSAL_OK)
{
result = MED_RES_OPEN_FILE_FAIL;
goto pure_audio_error_out;
}
FSAL_SetBuffer(stFSAL_aud_stsz, AUD_MP4_STSZ_BUF_SIZE, (kal_uint8*)mp4_aud_stsz_buf);
/* Set FSAL to MP4 Parser */
MP4_Audio_SetFSAL(stMp4Parser_aud, stFSAL_aud_aud_data);
MP4_SetFSAL_STCO(stMp4Parser_aud, MP4_TRACK_AUDIO, stFSAL_aud_stco);
MP4_SetFSAL_STSZ(stMp4Parser_aud, MP4_TRACK_AUDIO, stFSAL_aud_stsz);
MP4_UpdateSampleCount(stMp4Parser_aud, MP4_TRACK_AUDIO);
/* Get Audio Type */
audio_format = MP4_Audio_Type_To_Media_Format(MP4_GetAudioType(stMp4Parser_aud));
AUD_VALUE_TRACE(audio_format, -1, __LINE__);
/* The audio format in 3GP/MP4 file */
switch (audio_format)
{
/* Check AMR / AMR-WB by format enum directly */
#ifdef AMR_DECODE
case MEDIA_FORMAT_AMR:
#ifdef AMRWB_DECODE
case MEDIA_FORMAT_AMR_WB:
#endif
is_PP_support = AudioPP_TS_IsSupport((Media_Format) audio_format, NULL);
break;
#endif /*AMR_DECODE*/
/* Need to wrap audio data in FSAL ROM file for check function */
#if defined(AAC_DECODE)
case MEDIA_FORMAT_AAC:
{
kal_uint32 uSampleNo;
kal_uint32 num_bytes;
/* Seek to front and read a small range of data */
eMp4ParserRet = MP4_Audio_TimeToSampleNo(stMp4Parser_aud, 0, &uSampleNo );
if(eMp4ParserRet != MP4_PARSER_OK)
{
result = MED_RES_FAIL;
goto pure_audio_error_out;
}
eMp4ParserRet = MP4_Audio_Seek(stMp4Parser_aud, uSampleNo);
if(eMp4ParserRet != MP4_PARSER_OK)
{
result = MED_RES_FAIL;
goto pure_audio_error_out;
}
/* Read audio data into buffer and set it to FSAL ROM file */
fsal_rom_buf = (kal_uint8*)med_alloc_ext_mem( AUD_STRETCH_FSAL_ROM_SIZE*sizeof(kal_uint8) );
eMp4ParserRet = MP4_Audio_Read(stMp4Parser_aud, fsal_rom_buf, AUD_STRETCH_FSAL_ROM_SIZE, &num_bytes);
if((eMp4ParserRet != MP4_PARSER_OK) && (eMp4ParserRet != MP4_PARSER_READ_EOF))
{
med_free_ext_mem((void**)&fsal_rom_buf);
result = MED_RES_FAIL;
goto pure_audio_error_out;
}
FSAL_Direct_SetRamFileSize(&stFSAL_ROM, num_bytes);
eFSALRet = FSAL_Open(&stFSAL_ROM, (void*)fsal_rom_buf, FSAL_ROMFILE);
if (eFSALRet != FSAL_OK)
{
med_free_ext_mem((void**)&fsal_rom_buf);
result = MED_RES_OPEN_FILE_FAIL;
goto pure_audio_error_out;
}
/* check time stretch support by using extract audio data in FSAL ROM file */
is_PP_support = AudioPP_TS_IsSupport((Media_Format) audio_format, &stFSAL_ROM);
med_free_ext_mem((void**)&fsal_rom_buf);
break;
}
#endif /*AAC_DECODE*/
default:
result = MED_RES_INVALID_FORMAT;
goto pure_audio_error_out;
break;
}
if (is_PP_support)
{
result = MED_RES_OK;
}
else
{
result = MED_RES_UNSUPPORTED_SPEED;
}
pure_audio_error_out:
if (is_file_opened)
{
FSAL_Close(stFSAL_aud);
free_ctrl_buffer(stMp4Parser_aud);
free_ctrl_buffer(stFSAL_aud_stsz);
free_ctrl_buffer(stFSAL_aud_stco);
free_ctrl_buffer(stFSAL_aud_aud_data);
med_free_ext_mem((void**)&mp4_aud_buf);
med_free_ext_mem((void**)&mp4_aud_data_buf);
med_free_ext_mem((void**)&mp4_aud_stco_buf);
med_free_ext_mem((void**)&mp4_aud_stsz_buf);
med_free_ext_mem((void**)&mp4_aud_stbl_buf);
med_free_ext_mem((void**)&aud_seek_hint);
}
free_ctrl_buffer(stFSAL_aud);
return result;
#else
return MED_RES_INVALID_FORMAT;
#endif /* #if defined(MED_PURE_AUDIO) */
}
/*****************************************************************************
* FUNCTION
* get_aud_info
* DESCRIPTION
*
* PARAMETERS
* filename [?]
* aud_info_p [?]
* RETURNS
* kal_bool
*****************************************************************************/
kal_bool get_aud_info(kal_wchar *filename, aud_info_struct *aud_info_p)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_int16 format;
kal_uint32 size;
FS_HANDLE file;
STFSAL fsal_handle;
audInfoStruct *aud_info;
kal_uint32 channel_num;
audio_input_stream_struct *input_stream;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
Media_Status(*get_aud_info_func) (STFSAL * pstFSAL, audInfoStruct * contentInfo, void *param) = NULL;
if ((file = DRM_open_file(filename, FS_READ_ONLY | FS_OPEN_NO_DIR, DRM_PERMISSION_PLAY)) < 0)
{
return KAL_FALSE;
}
format = med_get_media_type(filename);
input_stream = audio_file_input_stream_alloc(file);
size = audio_input_stream_get_data_size(input_stream);
/* get id3 tags info */
memset(aud_info_p, 0, sizeof(aud_info_struct));
daf_set_data_info(aud_info_p, 0, 0, size, 0, 0);
if (id3_tag_parse(input_stream, &id3_tag))
{
/* copy title to info_p */
if (id3_tag.frames[ID3_FRAME_TITLE].text != NULL)
{
kal_wstrncpy(
(kal_wchar*) aud_info_p->title,
(const kal_wchar*)id3_tag.frames[ID3_FRAME_TITLE].text,
MAX_ID3_TITLE_LEN);
}
/* copy artist to info_p */
if (id3_tag.frames[ID3_FRAME_ARTIST].text != NULL)
{
kal_wstrncpy(
(kal_wchar*) aud_info_p->artist,
(const kal_wchar*)id3_tag.frames[ID3_FRAME_ARTIST].text,
MAX_ID3_ARTIST_LEN);
}
/* copy album to info_p */
if (id3_tag.frames[ID3_FRAME_ALBUM].text != NULL)
{
kal_wstrncpy(
(kal_wchar*) aud_info_p->album,
(const kal_wchar*)id3_tag.frames[ID3_FRAME_ALBUM].text,
MAX_ID3_ALBUM_LEN);
}
/* copy genre to info_p */
if (id3_tag.frames[ID3_FRAME_GENRE].text != NULL)
{
kal_wstrncpy(
(kal_wchar*) aud_info_p->genre,
(const kal_wchar*)id3_tag.frames[ID3_FRAME_GENRE].text,
MAX_ID3_GENRE_LEN);
}
/* copy year to info_p */
if (id3_tag.frames[ID3_FRAME_YEAR].text != NULL)
{
kal_wstrncpy(
(kal_wchar*) aud_info_p->year,
(const kal_wchar*)id3_tag.frames[ID3_FRAME_YEAR].text,
MAX_ID3_YEAR_LEN);
}
}
DRM_close_file(file);
switch (format)
{
#ifdef AU_DECODE
case MED_TYPE_AU:
get_aud_info_func = AU_GetContentDescInfo;
break;
#endif /* AU_DECODE */
#ifdef AIFF_DECODE
case MED_TYPE_AIFF:
get_aud_info_func = AIFF_GetContentDescInfo;
break;
#endif /* AIFF_DECODE */
case MED_TYPE_WAV:
get_aud_info_func = WAV_GetContentDescInfo;
break;
#ifdef AMR_DECODE
case MED_TYPE_AMR:
case MED_TYPE_AMR_WB:
get_aud_info_func = AMR_GetContentDescInfo;
break;
#endif /* AMR_DECODE */
#ifdef AAC_DECODE
case MED_TYPE_AAC:
get_aud_info_func = AAC_GetContentDescInfo;
break;
case MED_TYPE_M4A:
get_aud_info_func = M4A_GetContentDescInfo;
break;
#endif /* AAC_DECODE */
#ifdef WMA_DECODE
case MED_TYPE_WMA:
get_aud_info_func = WMA_GetContentDescInfo;
break;
#endif /* WMA_DECODE */
#if defined(MED_PURE_AUDIO)
case MED_TYPE_MP4:
case MED_TYPE_3GP:
get_aud_info_func = M4A_GetContentDescInfo;
break;
#endif /* defined(MED_PURE_AUDIO) */
#ifdef DAF_DECODE
case MED_TYPE_DAF:
#ifdef MUSICAM_DECODE
case MED_TYPE_MUSICAM:
#endif
get_aud_info_func = DAF_GetContentDescInfo;
break;
#endif /* DAF_DECODE */
case MED_TYPE_PCM_8K:
case MED_TYPE_PCM_16K:
get_aud_info_func = PCM_GetContentDescInfo;
break;
case MED_TYPE_GSM_EFR:
get_aud_info_func = VM_GetContentDescInfo;
break;
}
if (get_aud_info_func != NULL)
{
aud_info = (audInfoStruct*) & id3_tag; /* reuse id3_tag memory for aud_info */
if (FSAL_Open(&fsal_handle, filename, FSAL_READ) == FSAL_OK)
{
if (get_aud_info_func(&fsal_handle, aud_info, (void*)format) == MEDIA_SUCCESS)
{
#ifdef WMA_DECODE
if (format == MED_TYPE_WMA)
{
kal_wstrncpy(
(kal_wchar*) aud_info_p->title,
(const kal_wchar*)aud_info->title,
MAX_ID3_TITLE_LEN);
kal_wstrncpy(
(kal_wchar*) aud_info_p->artist,
(const kal_wchar*)aud_info->artist,
MAX_ID3_ARTIST_LEN);
kal_wstrncpy(
(kal_wchar*) aud_info_p->album,
(const kal_wchar*)aud_info->album,
MAX_ID3_ALBUM_LEN);
}
#endif /* WMA_DECODE */
channel_num = (aud_info->stereo ? 2 : 1);
daf_set_data_info(
aud_info_p,
channel_num,
aud_info->time,
size,
aud_info->bitRate,
aud_info->sampleRate);
}
FSAL_Close(&fsal_handle);
}
}
audio_input_stream_free(input_stream);
return KAL_TRUE;
}
/*****************************************************************************
* FUNCTION
* aud_trim_open_req_hdlr
* DESCRIPTION
* This function is used to open a trimming handler.
* PARAMETERS
*
* RETURNS
* void
*****************************************************************************/
void aud_trim_open_req_hdlr(ilm_struct *ilm_ptr)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_uint32 file_len = 0;
FSAL_Status fsal_result;
kal_uint8* fsal_buf_p = NULL;
media_open_func_ptr open_fct = NULL;
kal_int32 result = MED_RES_FAIL;
l4aud_trim_open_req_struct* msg_p = (l4aud_trim_open_req_struct*) ilm_ptr->local_para_ptr;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
ASSERT(msg_p->file_name_in && msg_p->file_name_out && msg_p->handle_p);
/* Check if trimming handler is already opened. Currently, we only support one instance. */
if (g_is_trim_opened)
{
result = MED_RES_BUSY;
goto aud_trim_open_failed;
}
/* Initialize context */
g_is_trim_opened = KAL_TRUE;
memset(&g_trim_ctx, 0, sizeof(aud_trim_context_t));
g_trim_ctx.file_output = -1;
g_trim_ctx.src_mod_id = ilm_ptr->src_mod_id;
/* Select a MHdl open function per media format */
g_trim_ctx.format = med_get_media_type(msg_p->file_name_in);
switch (g_trim_ctx.format)
{
#ifdef DAF_DECODE
case MED_TYPE_DAF:
#endif /* DAF_DECODE */
open_fct = DAF_Open;
break;
default:
/* Unsupport format */
ASSERT(0);
}
if (open_fct)
{
/* Create a FSAL handler */
if ((fsal_result = FSAL_Open(&g_trim_ctx.fsal_handle, msg_p->file_name_in, FSAL_READ_SHARED)) != FSAL_OK)
{
result = MED_RES_OPEN_FILE_FAIL;
goto aud_trim_open_failed;
}
g_trim_ctx.is_fsal_opened = KAL_TRUE;
fsal_buf_p = (kal_uint8*) get_ctrl_buffer(sizeof(kal_uint8) * AUD_PROC_BUF_SIZE);
FSAL_SetBuffer(&g_trim_ctx.fsal_handle, AUD_PROC_BUF_SIZE, fsal_buf_p);
/* Open a MHdl handler */
g_trim_ctx.mhdl_handle_p = open_fct(_aud_trim_event_callback_fct, &g_trim_ctx.fsal_handle, NULL);
_AUD_TRIM_TRACE(g_trim_ctx.mhdl_handle_p, g_trim_ctx.format, fsal_buf_p);
if (g_trim_ctx.mhdl_handle_p == NULL)
{
result = MED_RES_BAD_FORMAT;
goto aud_trim_open_failed;
}
/* Create output file handle */
g_trim_ctx.file_output = FS_Open(msg_p->file_name_out, FS_READ_WRITE | FS_OPEN_SHARED | FS_NOBUSY_CHECK_MODE);
if (g_trim_ctx.file_output >= 0) /* File already exists */
{
/* Check if the size of file is 0 because MMI may create the file to be trimmed to in advance */
FS_GetFileSize(g_trim_ctx.file_output, &file_len);
if (file_len != 0)
{
/* Seek to the beginning of the file to overwrite all the data */
FS_Seek(g_trim_ctx.file_output, 0, FS_FILE_BEGIN);
}
}
else /* File does not exist */
{
/* Create a new file */
g_trim_ctx.file_output = FS_Open(msg_p->file_name_out, FS_CREATE | FS_READ_WRITE | FS_OPEN_SHARED | FS_NOBUSY_CHECK_MODE);
}
_AUD_TRIM_TRACE(g_trim_ctx.file_output, file_len, -1);
if (g_trim_ctx.file_output < 0)
{
result = MED_RES_OPEN_FILE_FAIL;
goto aud_trim_open_failed;
}
}
/* Open successful */
*msg_p->handle_p = (kal_uint32)g_trim_ctx.mhdl_handle_p;
AUD_TRIM_RETURN(MED_RES_OK);
return;
aud_trim_open_failed:
/* Open failed */
_aud_trim_close();
*msg_p->handle_p = (kal_uint32)0;
AUD_TRIM_RETURN(result);
}
/*****************************************************************************
* FUNCTION
* get_aud_info
* DESCRIPTION
*
* IMPACT
*
* PARAMETERS
* kal_wchar* filename
* aud_info_struct* aud_info_p
* RETURNS
* kal_bool
* GLOBALS AFFECTED
*
*****************************************************************************/
kal_bool get_aud_info( kal_wchar* filename, aud_info_struct* aud_info_p )
{
kal_int16 format;
kal_uint32 size;
FS_HANDLE file;
#ifdef __AUD_NEW_INTERFACE__
STFSAL fsal_handle;
audInfoStruct* aud_info;
#endif // __AUD_NEW_INTERFACE__
audio_input_stream_struct* input_stream;
mmi_trace(1,"chenhe,get_aud_info");
if( (file = DRM_open_file( (const UINT8 *)filename, FS_READ_ONLY|FS_OPEN_NO_DIR, 0 )) < 0 )
return KAL_FALSE;
format = med_get_media_type( filename );
input_stream = audio_file_input_stream_alloc( file );
size = audio_input_stream_get_data_size( input_stream );
memset(aud_info_p, 0, sizeof(aud_info_struct) );
daf_set_data_info( aud_info_p, 0, 0, size, 0, 0 );
mmi_trace(1,"chenhe,get_aud_info,format is %d,size is %p",format,size);
if( format == MED_TYPE_DAF )
daf_parse_data_info( aud_info_p, input_stream, &id3_tag );
else
{
#ifdef AAC_DECODE
if( format == MED_TYPE_AAC )
{
if( id3_tag_parse( input_stream, &id3_tag ) )
{
// copy title to info_p
if( id3_tag.frames[ID3_FRAME_TITLE].text != NULL )
kal_wstrncpy( (kal_wchar*)aud_info_p->title, (const kal_wchar*)id3_tag.frames[ID3_FRAME_TITLE].text, MAX_ID3_TITLE_LEN );
// copy artist to info_p
if( id3_tag.frames[ID3_FRAME_ARTIST].text != NULL )
kal_wstrncpy( (kal_wchar*)aud_info_p->artist, (const kal_wchar*)id3_tag.frames[ID3_FRAME_ARTIST].text, MAX_ID3_ARTIST_LEN );
// copy album to info_p
if( id3_tag.frames[ID3_FRAME_ALBUM].text != NULL )
kal_wstrncpy( (kal_wchar*)aud_info_p->album, (const kal_wchar*)id3_tag.frames[ID3_FRAME_ALBUM].text, MAX_ID3_ALBUM_LEN );
// copy genre to info_p
if( id3_tag.frames[ID3_FRAME_GENRE].text != NULL )
kal_wstrncpy( (kal_wchar*)aud_info_p->genre, (const kal_wchar*)id3_tag.frames[ID3_FRAME_GENRE].text, MAX_ID3_GENRE_LEN );
// copy year to info_p
if( id3_tag.frames[ID3_FRAME_YEAR].text != NULL )
kal_wstrncpy( (kal_wchar*)aud_info_p->year, (const kal_wchar*)id3_tag.frames[ID3_FRAME_YEAR].text, MAX_ID3_YEAR_LEN );
}
}
#endif // AAC_DECODE
}
DRM_close_file( file );
#ifdef __AUD_NEW_INTERFACE__
if( format == MED_TYPE_AAC || format == MED_TYPE_WMA )
{
aud_info = (audInfoStruct*) &id3_tag; // reuse id3_tag memory for aud_info
if( FSAL_Open( &fsal_handle, filename, FSAL_READ ) == FSAL_OK )
{
media_get_info_func_ptr getInfoFunc;
switch( format )
{
#ifdef AAC_DECODE
case MED_TYPE_AAC:
getInfoFunc = AAC_GetContentDescInfo;
break;
#endif // AAC_DECODE
#ifdef WMA_DECODE
case MED_TYPE_WMA:
getInfoFunc = WMA_GetContentDescInfo;
break;
#endif // WMA_DECODE
default:
ASSERT(0);
break;
}
if( getInfoFunc( &fsal_handle, aud_info ) == MEDIA_SUCCESS )
{
#ifdef WMA_DECODE
if( format == MED_TYPE_WMA )
{
kal_wstrncpy( (kal_wchar*)aud_info_p->title, (const kal_wchar*)aud_info->title, MAX_ID3_TITLE_LEN );
kal_wstrncpy( (kal_wchar*)aud_info_p->artist, (const kal_wchar*)aud_info->artist, MAX_ID3_ARTIST_LEN );
kal_wstrncpy( (kal_wchar*)aud_info_p->album, (const kal_wchar*)aud_info->album, MAX_ID3_ALBUM_LEN );
}
#endif // WMA_DECODE
channel_num = (aud_info->stereo ? 2: 1);
daf_set_data_info( aud_info_p, channel_num, aud_info->time, size, aud_info->bitRate, aud_info->sampleRate );
}
FSAL_Close( &fsal_handle );
}
}
#endif // __AUD_NEW_INTERFACE__
audio_input_stream_free( input_stream );
return KAL_TRUE;
}
