/*****************************************************************************
* FUNCTION
* gdi_image_decoder_stop_all
* DESCRIPTION
*
* PARAMETERS
* void
* RETURNS
*
*****************************************************************************/
GDI_RESULT gdi_image_decoder_stop_all(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
GDI_ENTER_CRITICAL_SECTION(gdi_image_decoder_stop_all)
S16 next_idx;
/* check if anything in decoder */
if (gdi_image_decoder_item_first_idx == -1)
{
GDI_RETURN(GDI_SUCCEED);
}
/* stop current running decoder */
switch (gdi_image_decoder_item_list[gdi_image_decoder_item_first_idx].img_type)
{
case GDI_IMAGE_TYPE_JPG_FILE:
media_img_stop(MOD_MMI);
break;
default:
GDI_ASSERT(0);
}
/* close file */
/* DRM_REPLACE */
/* FS_Close(gdi_image_decoder_item_list[gdi_image_decoder_item_first_idx].file_handle); */
DRM_close_file(gdi_image_decoder_item_list[gdi_image_decoder_item_first_idx].file_handle);
next_idx = gdi_image_decoder_item_first_idx;
while (next_idx != -1)
{
/* close all opened file */
if (gdi_image_decoder_item_list[next_idx].file_handle >= 0)
{
/* DRM_REPLACE */
/* FS_Close(gdi_image_decoder_item_list[next_idx].file_handle); */
DRM_close_file(gdi_image_decoder_item_list[next_idx].file_handle);
gdi_image_decoder_item_list[next_idx].file_handle = -1;
/* gdi_image_decoder_item_list[next_idx].file_size = 0; */
}
gdi_image_decoder_item_list[next_idx].is_used = FALSE;
next_idx = gdi_image_decoder_item_list[next_idx].next_idx;
}
gdi_image_decoder_item_first_idx = -1;
gdi_image_decoder_item_last_idx = -1;
GDI_RETURN(GDI_SUCCEED);
GDI_EXIT_CRITICAL_SECTION(gdi_image_decoder_stop_all)
}
/*****************************************************************************
* FUNCTION
* mmi_fmsr_start_record
* DESCRIPTION
* Start to record FM radio
* PARAMETERS
* filename [IN] The record file name
* format [IN] The record file format
* quality [IN] The record file quality
* RETURNS
* void
*****************************************************************************/
BOOL mmi_fmsr_start_record(UI_string_type filename, U8 format, U8 quality)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
U8 file_format;
mdi_result result;
#ifdef __DRM_SUPPORT__
{
FS_HANDLE handle;
BOOL is_permitted = FALSE;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if ((handle = DRM_open_file((PU16) filename, FS_READ_ONLY, DRM_PERMISSION_NONE)) >= FS_NO_ERROR)
{
if (DRM_get_object_method(handle, NULL) == DRM_METHOD_NONE)
{
is_permitted = TRUE;
}
DRM_close_file(handle);
}
else if (handle < -1) /* file open error. but not DRM related problem */
{
is_permitted = TRUE;
}
if (!is_permitted)
{
mmi_fmsr_record_error_hdlr(DRM_NOT_PERMIT_TO_APPEND);
return FALSE;
}
}
#endif /* __DRM_SUPPORT__ */
#ifdef __MMI_BACKGROUND_CALL__
if (srv_ucm_is_background_call())
{
return FALSE;
}
#endif /* __MMI_BACKGROUND_CALL__ */
switch (format)
{
#if !defined(__FMRADIO_I2S_SUPPORT__) || defined(__I2S_AMR_RECORD__)
case FMSR_FORMAT_AMR:
file_format = MEDIA_AMR;
break;
#endif
#if !defined(__FMRADIO_I2S_SUPPORT__) || defined(__I2S_WAV_RECORD__)
case FMSR_FORMAT_WAV:
file_format = MEDIA_WAV_DVI_ADPCM;
break;
#endif
#if !defined(__FMRADIO_I2S_SUPPORT__) || defined(__I2S_AWB_RECORD__)
#if defined(AMRWB_ENCODE) && defined(AMRWB_DECODE)
case FMSR_FORMAT_AWB:
file_format = MEDIA_AMR_WB;
break;
#endif
#endif /* defined(AMRWB_ENCODE) && defined(AMRWB_DECODE) */
#if defined(__I2S_DAF_RECORD__)
case FMSR_FORMAT_DAF:
file_format = MDI_FORMAT_DAF;
break;
#endif
default:
file_format = MEDIA_AMR;
break;
}
result = mdi_fmr_start_record(filename, file_format, quality);
if (result == MDI_AUDIO_SUCCESS)
{
g_fmsr_cntx.rec.is_start_duration = TRUE;
g_fmsr_cntx.rec.state = FMSR_STATE_RECORD;
return TRUE;
}
/* Record request fail, need to stop FM radio playing */
else if (g_fmsr_cntx.rec.state == FMSR_STATE_READY)
{
/* Do not show message in the FM radio stop callback. */
g_fmsr_cntx.rec.is_show_msg = FALSE;
mmi_fmsr_power_off();
}
/* Show error message for the error cause */
g_fmsr_cntx.rec.is_show_msg = TRUE;
mmi_fmsr_record_error_hdlr(result);
return FALSE;
}
/*****************************************************************************
* FUNCTION
* gdi_image_decoder_decode_finish_hdlr
* DESCRIPTION
*
* PARAMETERS
* msgPtr [?]
* RETURNS
* void
*****************************************************************************/
void gdi_image_decoder_decode_finish_hdlr(void *msgPtr)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
U8 *dest_buf_ptr;
U8 *src_buf_ptr;
S32 index;
S32 dest_width;
S32 dest_height;
S32 dest_offset_x;
S32 dest_offset_y;
S32 dest_pitch;
S32 src_pitch;
S32 layer_offset_x, layer_offset_y;
BOOL is_blt;
gdi_rect_struct dest_clip;
gdi_handle handle;
S32 fs_ret;
gdi_handle old_layer_handle;
gdi_handle old_lcd_handle;
U8 src_cf;
media_img_decode_finish_ind_struct *para_ptr = (media_img_decode_finish_ind_struct*) msgPtr;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
/* no item. this will occure if driver already send out message to GDI, meanwhile user call
decoder_stop to remove this decoder item. so this index will be -1 */
if (gdi_image_decoder_item_first_idx == -1)
{
return;
}
/* jpeg_local_para_struct *para_ptr = (jpeg_local_para_struct*)msgPtr; */
/* ignore this message if it is not in the list */
if (para_ptr->seq_num != gdi_image_decoder_item_list[gdi_image_decoder_item_first_idx].seq_num)
{
return;
}
/* check if hw is powered on */
/* ASSERT(gdi_image_jpeg_is_hw_init == TRUE); */
/* close file handle */
/* DRM_REPLACE */
/* fs_ret = FS_Close(gdi_image_decoder_item_list[gdi_image_decoder_item_first_idx].file_handle); */
fs_ret = DRM_close_file(gdi_image_decoder_item_list[gdi_image_decoder_item_first_idx].file_handle);
ASSERT(fs_ret >= 0);
handle = gdi_image_decoder_item_list[gdi_image_decoder_item_first_idx].seq_num;
/* if decode succeed */
if (para_ptr->result == MED_RES_OK)
{
/* set variables */
index = gdi_image_decoder_item_first_idx;
dest_width = gdi_image_decoder_item_list[index].dest_width;
dest_height = gdi_image_decoder_item_list[index].dest_height;
dest_offset_x = gdi_image_decoder_item_list[index].dest_offset_x;
dest_offset_y = gdi_image_decoder_item_list[index].dest_offset_y;
dest_clip.x1 = gdi_image_decoder_item_list[index].clipx1;
dest_clip.y1 = gdi_image_decoder_item_list[index].clipy1;
dest_clip.x2 = gdi_image_decoder_item_list[index].clipx2;
dest_clip.y2 = gdi_image_decoder_item_list[index].clipy2;
dest_pitch = gdi_act_layer->width;
is_blt = gdi_image_decoder_item_list[index].is_blt;
/* get actual resized image, with stuffing pixels */
src_pitch = para_ptr->image_width;
/* if not totally out of clip region */
if (!((dest_offset_x > dest_clip.x2) ||
(dest_offset_y > dest_clip.y2) ||
(dest_offset_x + dest_width < dest_clip.x1) || (dest_offset_y + dest_height < dest_clip.y1)))
{
gdi_lcd_get_active(&old_lcd_handle);
gdi_lcd_set_active(gdi_image_decoder_item_list[index].lcd_handle);
gdi_layer_get_active(&old_layer_handle);
gdi_layer_set_active(gdi_image_decoder_item_list[index].layer_handle);
gdi_layer_get_buffer_ptr(&dest_buf_ptr);
src_buf_ptr = (U8*) gdi_work_buffer;
#ifdef GDI_USING_2D_ENGINE_V2
if (gdi_act_layer->vcf == GDI_COLOR_FORMAT_32)
{
src_cf = GDI_COLOR_FORMAT_24;
}
else
{
src_cf = gdi_act_layer->vcf;
}
gdi_bitblt_internal((U8*)gdi_work_buffer, dest_width,
0, 0,
dest_width, dest_height,
src_cf,
gdi_act_layer->buf_ptr, gdi_act_layer->width,
dest_offset_x, dest_offset_y,
dest_clip.x1, dest_clip.y1, dest_clip.x2, dest_clip.y2,
gdi_act_layer->vcf, gdi_act_layer->layer_size,
FALSE,
FALSE, 0,
FALSE, 0,
FALSE, 0,
GDI_TRANSFORM_NONE,
GDI_TRANSFORM_DIRECTION_LT);
if (gdi_act_layer_info->source_key_enable)
{
gdi_act_replace_src_key(
gdi_act_layer->buf_ptr,
gdi_act_layer->width,
dest_offset_x,
dest_offset_y,
dest_clip.x1,
dest_clip.y1,
dest_clip.x2,
dest_clip.y2,
gdi_act_layer_info->source_key,
dest_width,
dest_height);
}
#else
gdi_2d_memory_blt(
src_buf_ptr, /* src_ptr */
src_pitch, /* src_pitch */
0, /* src_offset_x */
0, /* src_offset_y */
dest_width, /* src_width */
dest_height, /* src_height */
dest_buf_ptr, /* dest_ptr */
dest_pitch, /* dest_pitch */
dest_offset_x, /* dest_offset_x */
dest_offset_y, /* dest_offset_y */
dest_clip); /* dest_clip */
#endif
gdi_layer_get_position(&layer_offset_x, &layer_offset_y);
layer_offset_x += dest_offset_x;
layer_offset_y += dest_offset_y;
if (is_blt)
{
gdi_layer_blt_previous(
layer_offset_x,
layer_offset_y,
layer_offset_x + dest_width,
layer_offset_y + dest_height);
}
gdi_layer_set_active(old_layer_handle);
gdi_lcd_set_active(old_lcd_handle);
}
if (gdi_image_decoder_result_callback != NULL)
{
gdi_image_decoder_result_callback(GDI_SUCCEED, handle);
}
}
else
{
if (gdi_image_decoder_result_callback != NULL)
{
gdi_image_decoder_result_callback(GDI_FAILED, handle);
}
}
gdi_image_decoder_item_list[gdi_image_decoder_item_first_idx].is_used = FALSE;
gdi_image_decoder_item_first_idx = gdi_image_decoder_item_list[gdi_image_decoder_item_first_idx].next_idx;
if (gdi_image_decoder_item_first_idx != -1)
{
gdi_image_decoder_decode_from_list();
}
}
/*****************************************************************************
* FUNCTION
* gdi_image_decoder_stop
* DESCRIPTION
*
* PARAMETERS
* handle [IN]
* RETURNS
*
*****************************************************************************/
GDI_RESULT gdi_image_decoder_stop(gdi_handle handle)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
GDI_ENTER_CRITICAL_SECTION(gdi_image_decoder_stop)
S16 this_idx;
S16 prev_idx = -1;
this_idx = gdi_image_decoder_item_first_idx;
while (this_idx != -1)
{
if (handle == gdi_image_decoder_item_list[this_idx].seq_num)
{
/* stop jpeg decoderr driver */
if (this_idx == gdi_image_decoder_item_first_idx)
{
/* is the one that currently decoding - stop it */
/* handle each decoder's stop function */
switch (gdi_image_decoder_item_list[this_idx].img_type)
{
case GDI_IMAGE_TYPE_JPG_FILE:
media_img_stop(MOD_MMI);
break;
default:
GDI_ASSERT(0);
}
/* close file */
/* DRM_REPLACE */
/* FS_Close(gdi_image_decoder_item_list[this_idx].file_handle); */
DRM_close_file(gdi_image_decoder_item_list[this_idx].file_handle);
gdi_image_decoder_item_list[this_idx].is_used = FALSE;
gdi_image_decoder_item_first_idx = gdi_image_decoder_item_list[this_idx].next_idx;
if (gdi_image_decoder_item_first_idx != -1)
{
gdi_image_decoder_decode_from_list();
}
}
else
{
/* not first one */
/* DRM_REPLACE */
/* FS_Close(gdi_image_decoder_item_list[this_idx].file_handle); */
DRM_close_file(gdi_image_decoder_item_list[this_idx].file_handle);
/* file is successfully read into buffer, clear file handle */
gdi_image_decoder_item_list[this_idx].file_handle = -1;
/* gdi_image_decoder_item_list[this_idx].file_size = 0; */
gdi_image_decoder_item_list[this_idx].is_used = FALSE;
gdi_image_decoder_item_list[prev_idx].next_idx = gdi_image_decoder_item_list[this_idx].next_idx;
}
GDI_RETURN(GDI_SUCCEED);
}
prev_idx = this_idx;
this_idx = gdi_image_decoder_item_list[this_idx].next_idx;
}
GDI_RETURN(GDI_IMAGE_DECODER_ERR_WRONG_HANDLE);
GDI_EXIT_CRITICAL_SECTION(gdi_image_decoder_stop)
}
/*****************************************************************************
* FUNCTION
* gdi_image_decoder_decode_file_with_output_clipping
* DESCRIPTION
*
* PARAMETERS
* offset_x [IN]
* offset_y [IN]
* width [IN]
* height [IN]
* output_clipx1 [IN]
* output_clipy1 [IN]
* output_clipx2 [IN]
* output_clipy2 [IN]
* is_blt [IN]
* image_name [?]
* handle_ptr [?]
* RETURNS
*
*****************************************************************************/
GDI_RESULT gdi_image_decoder_decode_file_with_output_clipping(
S32 offset_x,
S32 offset_y,
S32 width,
S32 height,
S32 output_clipx1,
S32 output_clipy1,
S32 output_clipx2,
S32 output_clipy2,
BOOL is_blt,
S8 *image_name,
gdi_handle *handle_ptr)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
GDI_ENTER_CRITICAL_SECTION(gdi_image_decoder_decode_file)
S16 valid_idx;
S16 this_idx;
U32 file_size;
BOOL has_entry = FALSE;
FS_HANDLE file_handle;
U16 image_type;
if (handle_ptr != NULL)
{
*handle_ptr = GDI_ERROR_HANDLE;
}
if (width == 0 || height == 0)
{
GDI_RETURN(GDI_SUCCEED);
}
/* check if it is a decodable file format */
image_type = gdi_image_get_type_from_file(image_name);
if (image_type != GDI_IMAGE_TYPE_JPG_FILE) /* currently, we only support jpeg file */
{
GDI_RETURN(GDI_IMAGE_DECODER_ERR_INVALID_IMG_TYPE);
}
/* find a valid entry to record this jpeg decoder */
for (valid_idx = 0; valid_idx < GDI_IMAGE_DECODER_ITEM_COUNT; valid_idx++)
{
if (gdi_image_decoder_item_list[valid_idx].is_used == FALSE)
{
has_entry = TRUE;
break;
}
}
if (has_entry == FALSE)
{
/* cant find entry to save jpeg decoder data */
GDI_RETURN(GDI_IMAGE_DECODER_ERR_NO_ITEM_ENTRY);
}
/* open file */
file_handle = DRM_open_file((U16*) image_name, FS_READ_ONLY, 0);
if (file_handle >= 0)
{
/* check if size can fit into file buffer */
/* DRM_REPLACE */
/* FS_GetFileSize(file_handle, (kal_uint32*)&file_size); */
DRM_file_size(file_handle, (kal_uint32*) & file_size);
/* check if dest size larger than intermediate frame buffer */
if (gdi_image_decoder_frame_buf_size < (U32) ((width + 16) * (height + 16))) /* +16 for jpeg's stuffing */
{
/* DRM_REPLACE */
/* FS_Close(file_handle); */
DRM_close_file(file_handle);
GDI_RETURN(GDI_IMAGE_DECODER_ERR_FRAME_BUF_NOT_ENOUGH);
}
if (gdi_image_decoder_item_first_idx == -1)
{
/* first in the list, re-assign first index */
gdi_image_decoder_item_first_idx = valid_idx;
}
else
{
this_idx = gdi_image_decoder_item_first_idx;
/* loop to find next */
while (this_idx != -1)
{
if (gdi_image_decoder_item_list[this_idx].next_idx == -1)
{
gdi_image_decoder_item_list[this_idx].next_idx = valid_idx;
break;
}
this_idx = gdi_image_decoder_item_list[this_idx].next_idx;
}
}
/* find a valid seq number */
if (gdi_image_decoder_item_seq_num_idx < GDI_IMAGE_DECODER_ITEM_SEQ_NUM_LIMIT - 1)
{
gdi_image_decoder_item_seq_num_idx++;
}
else
{
gdi_image_decoder_item_seq_num_idx = 1;
}
gdi_image_decoder_item_list[valid_idx].is_used = TRUE;
gdi_image_decoder_item_list[valid_idx].file_handle = file_handle;
gdi_image_decoder_item_list[valid_idx].is_blt = is_blt;
gdi_image_decoder_item_list[valid_idx].img_type = image_type;
gdi_image_decoder_item_list[valid_idx].dest_offset_x = offset_x;
gdi_image_decoder_item_list[valid_idx].dest_offset_y = offset_y;
gdi_image_decoder_item_list[valid_idx].dest_width = (U16) width;
gdi_image_decoder_item_list[valid_idx].dest_height = (U16) height;
gdi_image_decoder_item_list[valid_idx].next_idx = -1;
gdi_image_decoder_item_list[valid_idx].seq_num = gdi_image_decoder_item_seq_num_idx;
gdi_image_decoder_item_list[valid_idx].layer_handle = (gdi_handle) gdi_act_layer;
gdi_image_decoder_item_list[valid_idx].lcd_handle = GDI_LCD->act_handle;
gdi_image_decoder_item_list[valid_idx].clipx1 = gdi_act_layer->clipx1;
gdi_image_decoder_item_list[valid_idx].clipy1 = gdi_act_layer->clipy1;
gdi_image_decoder_item_list[valid_idx].clipx2 = gdi_act_layer->clipx2;
gdi_image_decoder_item_list[valid_idx].clipy2 = gdi_act_layer->clipy2;
gdi_image_decoder_item_list[valid_idx].output_clipx1 = output_clipx1;
gdi_image_decoder_item_list[valid_idx].output_clipy1 = output_clipy1;
gdi_image_decoder_item_list[valid_idx].output_clipx2 = output_clipx2;
gdi_image_decoder_item_list[valid_idx].output_clipy2 = output_clipy2;
if (gdi_image_decoder_item_list[gdi_image_decoder_item_first_idx].next_idx == -1)
{
/* only one jpeg wait to decoder, call this function, if already has another jpeg is decoding,
the following function will be called when the previous jpeg is decoderd */
gdi_image_decoder_decode_from_list();
}
/* succeed create a jpeg decoder entry , return it's sequential no as handle */
if (handle_ptr != NULL)
{
*handle_ptr = gdi_image_decoder_item_seq_num_idx;
}
GDI_RETURN(GDI_SUCCEED);
}
else
{
/* open File error */
GDI_RETURN(GDI_IMAGE_DECODER_ERR_OPEN_FILE_FAILED);
}
GDI_EXIT_CRITICAL_SECTION(gdi_image_decoder_decode_file)
}
kal_bool get_aud_meta_data_file(kal_wchar *filename, aud_info_struct *aud_info_p)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_uint32 size;
FS_HANDLE file;
audio_input_stream_struct *input_stream;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if ((file = DRM_open_file(filename, FS_READ_ONLY | FS_OPEN_NO_DIR, DRM_PERMISSION_PLAY)) < 0)
{
return KAL_FALSE;
}
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);
}
if (id3_tag.frames[ID3_FRAME_COPYRIGHT].text != NULL)
{
kal_wstrncpy(
(kal_wchar*) aud_info_p->copyright,
(const kal_wchar*)id3_tag.frames[ID3_FRAME_COPYRIGHT].text,
MAX_ID3_COPYRIGHT_LEN);
}
}
DRM_close_file(file);
audio_input_stream_free(input_stream);
return KAL_TRUE;
}
/*****************************************************************************
* 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
* 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;
}
/*****************************************************************************
* FUNCTION
* mmi_rmgr_populate_drm_info_aux
* DESCRIPTION
*
* PARAMETERS
* rights [?]
* permission [IN]
* data [?]
* RETURNS
*
*****************************************************************************/
kal_bool mmi_rmgr_populate_drm_info_aux(kal_wchar *path, kal_uint8 app_perm, kal_uint8 *data, kal_int32 ref)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
FS_HANDLE input = FS_ERROR_RESERVED;
kal_int32 start = 0, end = 0, cons_ret = DRM_RESULT_NON_DRM;
kal_bool ret = KAL_FALSE, flag = KAL_TRUE;
kal_uint8 permission;
drm_method_enum method;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
/* permission's incorrect, but ok here*/
if (app_perm == DRM_PERMISSION_ALL)
permission = DRM_PERMISSION_PLAY;
else
permission = app_perm;
if(ref < 0)
{
input = DRM_open_file(path, FS_READ_ONLY, permission);
if (input < FS_NO_ERROR)
return ret;
method = DRM_get_object_method(input, NULL);
}
else
{
method = DRM_get_object_method_by_ref(ref);
}
if (method != DRM_METHOD_NONE)
{
if (ref < 0)
{
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_RMGR_DETAIL_RIGHT));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_RMGR_DETAIL_PROTECTED));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
}
}
else
{
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_RMGR_DETAIL_RIGHT));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_RMGR_DETAIL_UNPROTECTED));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
if (ref < 0)
{
DRM_close_file(input);
}
else
{
DRM_free_ro_detail();
}
return ret;
}
#ifdef __DRM_V02__
if (ref < 0)
{
kal_wchar *sepa = kal_wstrrchr(path, (kal_int32) '\\');
if (DRM_is_archive(input, NULL) && sepa && kal_wstrncmp(sepa - 4, L".odf\\", 5) != 0)
{
/* Multi Part ODF */
mmi_ucs2cat((PS8) data, (PS8) L" ");
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_RMGR_MULTI_PART));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
return ret;
}
}
#endif
if (method == DRM_METHOD_FORWARD_LOCK)
{
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_RMGR_SUMMARY));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_RMGR_DETAIL_UNLIMITED));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
if (ref < 0)
{
DRM_close_file(input);
}
else
{
DRM_free_ro_detail();
}
return ret;
}
do
{
if (permission & (DRM_PERMISSION_PLAY | DRM_PERMISSION_DISPLAY | DRM_PERMISSION_EXECUTE | DRM_PERMISSION_PRINT | DRM_PERMISSION_EXPORT))
{
drm_constraint_struct cons;
if (ref < 0)
{
if (app_perm == DRM_PERMISSION_ALL && permission != DRM_PERMISSION_PLAY)
{
input = DRM_open_file(path, FS_READ_ONLY, permission);
if (input < FS_NO_ERROR)
return KAL_FALSE;
}
cons_ret = DRM_get_constraint(input, NULL, permission, &cons);
}
else
{
cons_ret = DRM_get_constraint_by_ref(ref, permission, &cons);
}
if (cons_ret >= DRM_RESULT_OK && cons.status == DRM_STATUS_RIGHTS_PRESENT)
{
if (flag)
{
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_RMGR_SUMMARY));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
flag = KAL_FALSE;
}
switch(permission)
{
case DRM_PERMISSION_PLAY:
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_DRM_PLAY));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
break;
case DRM_PERMISSION_DISPLAY:
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_DRM_DISPLAY));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
break;
case DRM_PERMISSION_EXECUTE:
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_DRM_EXECUTE));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
break;
case DRM_PERMISSION_PRINT:
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_DRM_PRINT));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
break;
case DRM_PERMISSION_EXPORT:
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_DRM_EXPORT));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
break;
default:
break;
}
if (((method & DRM_METHOD_COMBINED_DELIVERY) ||
(method & DRM_METHOD_SEPARATE_DELIVERY) ||
(method & DRM_METHOD_V2)) &&
(cons.status != DRM_STATUS_NO_RIGHTS))
{
MYTIME t;
S8 buffer[20];
drm_constraint_struct *constraint;
constraint = &cons;
if (constraint->type != DRM_CONSTRAINT_NONE)
{
if (constraint->type & DRM_CONSTRAINT_COUNT)
{
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_RMGR_DETAIL_COUNT));
sprintf((char*)buffer, "\n%d/%d", constraint->used_count, constraint->total_count);
mmi_asc_to_ucs2((PS8) & data[mmi_ucs2strlen((PS8) data) << 1], (PS8) buffer);
mmi_ucs2cat((PS8) data, (PS8) L"\n");
}
#ifdef __DRM_V02__
if (constraint->type & DRM_CONSTRAINT_ACCUMULATED)
{
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_RMGR_DETAIL_ACCUMULATED));
sprintf((char*)buffer, "\n%d ", constraint->accum_dur);
mmi_asc_to_ucs2((PS8) & data[mmi_ucs2strlen((PS8) data) << 1], (PS8) buffer);
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_RMGR_DETAIL_SEC));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
}
if (constraint->type & DRM_CONSTRAINT_TIMEDCOUNT)
{
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_RMGR_DETAIL_TIMEDCOUNT));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
sprintf((char*)buffer, "%d ", constraint->timed_count);
mmi_asc_to_ucs2((PS8) & data[mmi_ucs2strlen((PS8) data) << 1], (PS8) buffer);
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_RMGR_DETAIL_TIMEDCOUNT_TIME));
sprintf((char*)buffer, "%d ", constraint->period);
mmi_asc_to_ucs2((PS8) & data[mmi_ucs2strlen((PS8) data) << 1], (PS8) buffer);
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_RMGR_DETAIL_SEC));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
}
#endif /* __DRM_V02__ */
if (constraint->type & DRM_CONSTRAINT_DATETIME)
{
if ((constraint->type & DRM_CONSTRAINT_INTERVAL) && constraint->start_intv != 0)
{
/* date time contains interval -> show interval*/
if (constraint->start_time <= constraint->start_intv &&
constraint->end_time >= constraint->end_intv)
{
start = constraint->start_intv;
end = constraint->end_intv;
}
/* interval contains date time -> show date time*/
else if (constraint->start_intv <= constraint->start_time &&
constraint->end_intv >= constraint->end_time)
{
start = constraint->start_time;
end = constraint->end_time;
}
/* date time overlaps interval -> show overlap*/
else if (constraint->start_intv <= constraint->start_time &&
constraint->end_intv <= constraint->end_time &&
constraint->start_time <= constraint->end_intv)
{
start = constraint->start_time;
end = constraint->end_intv;
}
/* interval overlaps date time -> show overlap*/
else if (constraint->start_time <= constraint->start_intv &&
constraint->end_time <= constraint->end_intv &&
constraint->start_intv <= constraint->end_time)
{
start = constraint->start_intv;
end = constraint->end_time;
}
else
{
start = constraint->start_intv;
end = constraint->end_intv;
}
}
else
{
start = constraint->start_time;
end = constraint->end_time;
}
}
else if (constraint->type & DRM_CONSTRAINT_INTERVAL)
{
if (constraint->interval <= 0)
{
start = -1;
end = -1;
}
else
{
start = constraint->start_intv;
end = constraint->end_intv;
}
}
if (start > 0)
{
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_RMGR_DETAIL_START));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
mmi_dt_utc_sec_2_mytime(start, &t, FALSE);
date_string(&t, (PU16) & data[mmi_ucs2strlen((PS8) data) << 1], DT_IDLE_SCREEN);
mmi_ucs2cat((PS8) data, (PS8) L" ");
time_string(&t, (PU16) & data[mmi_ucs2strlen((PS8) data) << 1], DT_IDLE_SCREEN);
mmi_ucs2cat((PS8) data, (PS8) L"\n");
}
if (end > 0)
{
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_RMGR_DETAIL_END));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
mmi_dt_utc_sec_2_mytime(end, &t, FALSE);
date_string(&t, (PU16) & data[mmi_ucs2strlen((PS8) data) << 1], DT_IDLE_SCREEN);
mmi_ucs2cat((PS8) data, (PS8) L" ");
time_string(&t, (PU16) & data[mmi_ucs2strlen((PS8) data) << 1], DT_IDLE_SCREEN);
mmi_ucs2cat((PS8) data, (PS8) L"\n");
}
}
else
{
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_RMGR_DETAIL_UNLIMITED));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
}
}
}
if (ref < 0)
{
DRM_close_file(input);
}
}
permission = permission<<1;
}
while(permission < DRM_PERMISSION_ALL && app_perm == DRM_PERMISSION_ALL);
if (flag)
{
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_ID_RMGR_SUMMARY));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
mmi_ucs2cat((PS8) data, (PS8) GetString(STR_GLOBAL_INVALID));
mmi_ucs2cat((PS8) data, (PS8) L"\n");
}
return ret;
}
