sfapi.c

snowfish mtk的开发平台软件补充

#define		KEY_PUB_8				0xfffe//KP_MID_KEY
#define		KEY_PUB_STAR			0xffbf //KP_MID_KEY
#define		KEY_PUB_9				0xfffd//KP_MID_KEY
#define		KEY_PUB_2				0xfffb//KP_LOW_KEY
#define		KEY_PUB_3				0xfff7//KP_LOW_KEY
#define		KEY_PUB_ESC				0xffbf //KP_LOW_KEY
#define		KEY_PUB_VOLUP				0xf7ff//KP_LOW_KEY
#define		KEY_PUB_VOLDOWN			0xffef //KP_LOW_KEY

#define		REGISTER_PUB_LSK		KEY_REGISTER_MID
#define		REGISTER_PUB_RSK		KEY_REGISTER_MID
#define		REGISTER_PUB_LEFT		KEY_REGISTER_LOW
#define		REGISTER_PUB_RIGHT		KEY_REGISTER_MID
#define		REGISTER_PUB_UP			KEY_REGISTER_LOW
#define		REGISTER_PUB_DOWN		KEY_REGISTER_LOW
#define		REGISTER_PUB_OK			KEY_REGISTER_MID
#define		REGISTER_PUB_CALL		KEY_REGISTER_MID
#define		REGISTER_PUB_POUND		KEY_REGISTER_MID
#define		REGISTER_PUB_0			KEY_REGISTER_MID
#define		REGISTER_PUB_1			KEY_REGISTER_LOW
#define		REGISTER_PUB_4			KEY_REGISTER_LOW
#define		REGISTER_PUB_5			KEY_REGISTER_LOW
#define		REGISTER_PUB_6			KEY_REGISTER_LOW
#define		REGISTER_PUB_7			KEY_REGISTER_LOW
#define		REGISTER_PUB_8			KEY_REGISTER_MID
#define		REGISTER_PUB_STAR		KEY_REGISTER_MID
#define		REGISTER_PUB_9			KEY_REGISTER_MID
#define		REGISTER_PUB_2			KEY_REGISTER_LOW
#define		REGISTER_PUB_3			KEY_REGISTER_LOW
#define		REGISTER_PUB_ESC		KEY_REGISTER_LOW
#define		REGISTER_PUB_VOLUP		KEY_REGISTER_LOW
#define		REGISTER_PUB_VOLDOWN		KEY_REGISTER_LOW


SFUint32 SFSystem_GetKeyState(void)
{
	SFUint32 keyValue = 0;
			
	if(g_bRotate90
	    #if defined(__IMT_LCD_ROTATE_MMI__)
	    && !gMMILcdRotateState
	    #endif
	    )
	{
		if(!(DRV_Reg32(REGISTER_PUB_1)&(~KEY_PUB_1)))
		{
			keyValue |= SFKS_UP;
			keyValue |= SFKS_RIGHT;
		}
		if(!(DRV_Reg32(REGISTER_PUB_2)&(~KEY_PUB_2)))
		{
			keyValue |= SFKS_RIGHT;
		}
		if(!(DRV_Reg32(REGISTER_PUB_3)&(~KEY_PUB_3)))
		{
			keyValue |= SFKS_DOWN;
			keyValue |= SFKS_RIGHT;
		}
		if(!(DRV_Reg32(REGISTER_PUB_4)&(~KEY_PUB_4)))
		{
			keyValue |= SFKS_UP;
		}
		if(!(DRV_Reg32(REGISTER_PUB_6)&(~KEY_PUB_6)))
		{
			keyValue |= SFKS_DOWN;
		}
		if(!(DRV_Reg32(REGISTER_PUB_7)&(~KEY_PUB_7)))
		{
			keyValue |= SFKS_UP;
			keyValue |= SFKS_LEFT;
		}
		if(!(DRV_Reg32(REGISTER_PUB_8)&(~KEY_PUB_8)))
		{
			keyValue |= SFKS_LEFT;
		}
		if(!(DRV_Reg32(REGISTER_PUB_9)&(~KEY_PUB_9)))
		{
			keyValue |= SFKS_DOWN;
			keyValue |= SFKS_LEFT;
		}	
	}
	else
	{
		if(!(DRV_Reg32(REGISTER_PUB_1)&(~KEY_PUB_1)))
		{
			keyValue |= SFKS_UP;
			keyValue |= SFKS_LEFT;
		}
		if(!(DRV_Reg32(REGISTER_PUB_2)&(~KEY_PUB_2)))
		{
			keyValue |= SFKS_UP;
		}
		if(!(DRV_Reg32(REGISTER_PUB_3)&(~KEY_PUB_3)))
		{
			keyValue |= SFKS_UP;
			keyValue |= SFKS_RIGHT;
		}
		if(!(DRV_Reg32(REGISTER_PUB_4)&(~KEY_PUB_4)))
		{
			keyValue |= SFKS_LEFT;
		}
		if(!(DRV_Reg32(REGISTER_PUB_6)&(~KEY_PUB_6)))
		{
			keyValue |= SFKS_RIGHT;
		}
		if(!(DRV_Reg32(REGISTER_PUB_7)&(~KEY_PUB_7)))
		{
			keyValue |= SFKS_DOWN;
			keyValue |= SFKS_LEFT;
		}
		if(!(DRV_Reg32(REGISTER_PUB_8)&(~KEY_PUB_8)))
		{
			keyValue |= SFKS_DOWN;
		}
		if(!(DRV_Reg32(REGISTER_PUB_9)&(~KEY_PUB_9)))
		{
			keyValue |= SFKS_DOWN;
			keyValue |= SFKS_RIGHT;
		}
		
		if(!(DRV_Reg32(REGISTER_PUB_5)&(~KEY_PUB_5)))
		{
			keyValue |= SFKS_NUM7;
		}
		if(!(DRV_Reg32(REGISTER_PUB_POUND)&(~KEY_PUB_POUND)))
		{
			keyValue |= SFKS_NUM8;
		}		
	}

	if(!(DRV_Reg32(REGISTER_PUB_5)&(~KEY_PUB_5)))
	keyValue |= SFKS_NUM7;
	if(!(DRV_Reg32(REGISTER_PUB_POUND)&(~KEY_PUB_POUND)))
	keyValue |= SFKS_NUM8;
	if(!(DRV_Reg32(REGISTER_PUB_0)&(~KEY_PUB_0)))
	keyValue |= SFKS_NUM1;	
	if(!(DRV_Reg32(REGISTER_PUB_STAR)&(~KEY_PUB_STAR)))
	keyValue |= SFKS_NUM2;			
	if(!(DRV_Reg32(REGISTER_PUB_VOLDOWN)&(~KEY_PUB_VOLDOWN)))
	keyValue |= SFKS_NUM1;	
	if(!(DRV_Reg32(REGISTER_PUB_VOLUP)&(~KEY_PUB_VOLUP)))
	keyValue |= SFKS_NUM2;	
		
	if(!(DRV_Reg32(REGISTER_PUB_LEFT)&(~KEY_PUB_LEFT)))
	keyValue |= SFKS_NUM0;
	if(!(DRV_Reg32(REGISTER_PUB_RIGHT)&(~KEY_PUB_RIGHT)))
	keyValue |= SFKS_NUM9;		

	return keyValue;
	
}

void SFPCMDevice_GetCurrentPosition(SFPCMDevice* self,SFUint32*pPlayCursor,SFUint32* pWriteCursor)
{
	PARAM_UNUSED(self);
	if(pPlayCursor)
	{
		*pPlayCursor=(uint32)(pu8_g_sound_out_ptr-pu8_g_sound_bufstart);
	}
	
	if(pWriteCursor)
	{
		*pWriteCursor=(uint32)(pu8_g_sound_in_ptr-pu8_g_sound_bufstart);
	}	
}

void SFPCMDevice_LockBuffer(SFPCMDevice* self,SFUint32 offset,SFUint32 size,SFAny** pBuf0,SFUint32* pBufSize0,SFAny** pBuf1,SFUint32* pBufSize1)
{
	if(offset==0xFFFFFFFF)
	{
		SFPCMDevice_GetCurrentPosition(self,SFNull,&offset);
	}
	
	if(offset+size>SF_SOUND_BUFFER_SIZE)
	{
		*pBuf0=pu8_g_sound_bufstart+offset;
		*pBufSize0=SF_SOUND_BUFFER_SIZE-offset;

		*pBuf1=pu8_g_sound_bufstart;
		*pBufSize1=offset+size-SF_SOUND_BUFFER_SIZE;
	}
	else
	{
		*pBuf0=pu8_g_sound_bufstart+offset;
		*pBufSize0=size;

		*pBuf1=SFNull;
		*pBufSize1=0;
	}
}

void SFPCMDevice_UnlockBuffer(SFPCMDevice* self,SFAny* aBuf0,SFUint32
aBufSize0,SFAny* aBuf1,SFUint32 aBufSize1)
{
	//提交音频数据
	if(aBuf1 && aBufSize1)
	{
		pu8_g_sound_in_ptr=(SFUint8*)aBuf1+aBufSize1;
	}
	else
	{
		pu8_g_sound_in_ptr=(SFUint8*)aBuf0+aBufSize0;
	}

//提交_pSndCommitBegin到_pSndCommitEnd的数据，提交完毕让_pSndCommitBegin＝ _pSndCommitEnd

}
//
//const U8	*u8_g_game_dir=(U8 *)L"D:\\game\\";
//
//S32 mmi_gamesimu_create_file_dir(S8 *filepath)
//{
//    
//    S8 buf_createpath[128];
//    S8 buf_filepath[FMGR_PATH_BUFFER_SIZE];
//    S32 fs_ret;
//    S32 str_len;
//    S32 cmp_ret;
//    S32 i;
//    FS_HANDLE file_handle;
//
//   
//    fs_ret = 0;
//
//    file_handle = FS_Open((kal_uint16*) filepath, FS_OPEN_DIR | FS_READ_ONLY);
//
//    /* path already exist */
//    if (file_handle >= 0)
//    {
//        FS_Close(file_handle);
//        return 0;   /* already exist, 0 means successful in file system */
//    }
//
//    /* create directory if it is not there */
//    pfnUnicodeStrcpy((PS8) buf_filepath, (PS8) filepath);
//
//    str_len = pfnUnicodeStrlen((PS8) buf_filepath);
//    str_len *= ENCODING_LENGTH;
//
//    /* skip drive. "C:\" */
//    for (i = 3 * ENCODING_LENGTH; i < str_len; i += 2)
//    {
//        cmp_ret = pfnUnicodeStrncmp((PS8) & buf_filepath[i], (PS8) L"\\", 1);
//        if (cmp_ret == 0)
//        {
//            /* create dir */
//
//            pfnUnicodeStrncpy((PS8) buf_createpath, (PS8) buf_filepath, i / ENCODING_LENGTH);
//            buf_createpath[i] = '\0';
//            buf_createpath[i + 1] = '\0';
//
//            fs_ret = FS_CreateDir((PU16) buf_createpath);
//
//            if (fs_ret < 0)
//            {
//                return fs_ret;
//            }
//        }
//    }
//
//    return fs_ret;
//}
/*
void mmi_gamesimu_exit_from_fmgr(void *filename, int is_short)
{
    
    //DeleteUptoScrID(SCREENID_GAMESIMU_LIST);
    DeleteNHistory(1);
    GoBackHistory();
}
*/
void EntryRomList(void)
{
#if 0
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    S8 buf_filepath[FMGR_PATH_BUFFER_SIZE];
    FS_HANDLE file_handle;
    FMGR_FILTER filter;
    S32 create_result;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
   memset(buf_filepath,0x00,FMGR_PATH_BUFFER_SIZE);
   pfnUnicodeStrcpy((S8 *)buf_filepath,(const S8 *)u8_g_game_dir);

    #ifndef NAND_SUPPORT
    if(fmgr_is_msdc_present() == FALSE)
    {
          DisplayPopup((PU8)GetString(STR_GLOBAL_NOTIFY_NO_MEMORY_CARD), IMG_GLOBAL_EMPTY,0, 1000, EMPTY_LIST_TONE);
          return;
    }
    #endif

    EntryNewScreen(SCREENID_GAMESIMU_LIST, NULL, EntryRomList, NULL);

    create_result = mmi_gamesimu_create_file_dir(buf_filepath);

    /* check if it is valid path */
    file_handle = FS_Open((PU16) buf_filepath, FS_OPEN_DIR | FS_READ_ONLY);

    if (file_handle >= 0)
    {
        FS_Close(file_handle);

        FMGR_FILTER_INIT(&filter);
	
	FMGR_FILTER_SET(&filter,FMGR_TYPE_NES);

        mmi_fmgr_select_path_and_enter(
            APP_GAME_SIMU,
            FMGR_SELECT_BROWSE,
            filter,
            buf_filepath,
            (PsExtFuncPtr) mmi_gamesimu_exit_from_fmgr);

        /* check if device is busy or not */
        if (FS_GetDevStatus(buf_filepath[0], FS_FEATURE_STATE_ENUM) == FS_DEVICE_BUSY)
        {
            /*  mmi_fmgr_select_path_and_enter will also add screen to histry */
            DeleteUptoScrID(SCREENID_GAMESIMU_LIST);

            /* Delete up to previous screen */
            DeleteNHistory(1);
        }
    }
    else
    {
        {
            /* storage is card */

            /* photo's path is not exist, and card is write protected, cant create photo folder */
            if (create_result == FS_WRITE_PROTECTION)
            {
                DisplayPopup(
                    (PU8) GetString(FMGR_FS_WRITE_PROTECTION_TEXT),
                    IMG_GLOBAL_WARNING,
                    1,
                    ST_NOTIFYDURATION,
                    WARNING_TONE);
            }
            else if (create_result == FS_DISK_FULL)
            {
                DisplayPopup(
                    (PU8) GetString(FMGR_FS_DISK_FULL_TEXT),
                    IMG_GLOBAL_WARNING,
                    1,
                    ST_NOTIFYDURATION,
                    WARNING_TONE);
            }
            else if (create_result == FS_ROOT_DIR_FULL)
            {
                DisplayPopup(
                    (PU8) GetString(FMGR_FS_ROOT_DIR_FULL_TEXT),
                    IMG_GLOBAL_WARNING,
                    1,
                    ST_NOTIFYDURATION,
                    WARNING_TONE);
            }
            else
            {
                DisplayPopup(
                    (PU8) GetString(STR_GLOBAL_NOTIFY_NO_MEMORY_CARD),
                    IMG_GLOBAL_WARNING,
                    1,
                    ST_NOTIFYDURATION,
                    WARNING_TONE);
            }

            DeleteUptoScrID(SCREENID_GAMESIMU);
            return;

        }
    }
#endif
}

/*Added by bob, to dynamic get memory for MP4, @20070720, begin*/
void* sf_system_malloc(unsigned int size)
{
	//return SnowFishMemPool;//med_alloc_ext_mem(size);
	return med_alloc_ext_mem(size);
}

void* sf_system_malloc_fast(unsigned int size)
{
	void* ptr;

	ptr = med_alloc_int_mem(size);
	return ptr;
}

void sf_system_free(void*ptr)
{
	med_free_ext_mem(&ptr);
}

void sf_system_free_fast(void* ptr)
{
	//todo
	med_free_int_mem(&ptr);
}



#if defined(__SF_MP4_SUPPORT__)

#include "med_global.h" 
#include "med_utility.h" 
#include "mdi_video.h" 

static void LCDDisplay_adrs (const lcd_frame_update_struct *lcd_param, void* adrs, U8 layer)
{
	kal_uint16 w, h;
	lcd_frame_update_struct lcd_data = {0};

	lcd_power_up();

	w = lcd_param->lcm_end_x - lcd_param->lcm_start_x + 1;
	h = lcd_param->lcm_end_y - lcd_param->lcm_start_y + 1;

	if (layer == 0)
	{
		SET_LCD_LAYER0_WINDOW_SIZE(w,h);
		SET_LCD_LAYER0_WINDOW_OFFSET(0,0);
		SET_LCD_LAYER0_ROTATE(lcd_param->rotate_value);
		lcd_data.update_layer=LCD_LAYER0_ENABLE;

		REG_LCD_LAYER0_BUFF_ADDR = (kal_uint32) adrs;
	}
	else if (layer == 1)
	{
		SET_LCD_LAYER1_WINDOW_SIZE(w,h);
		SET_LCD_LAYER1_WINDOW_OFFSET(0,0);
		SET_LCD_LAYER1_ROTATE(lcd_param->rotate_value);
		lcd_data.update_layer=LCD_LAYER1_ENABLE;

		REG_LCD_LAYER1_BUFF_ADDR = (kal_uint32) adrs;
	}
	else if (layer == 2)
	{
		SET_LCD_LAYER2_WINDOW_SIZE(w,h);
		SET_LCD_LAYER2_WINDOW_OFFSET(0,0);
		SET_LCD_LAYER2_ROTATE(lcd_param->rotate_value);
		lcd_data.update_layer=LCD_LAYER2_ENABLE;

		REG_LCD_LAYER2_BUFF_ADDR = (kal_uint32) adrs;
	}
	else if (layer == 3)
	{
		SET_LCD_LAYER3_WINDOW_SIZE(w,h);
		SET_LCD_LAYER3_WINDOW_OFFSET(0,0);
		SET_LCD_LAYER3_ROTATE(lcd_param->rotate_value);
		lcd_data.update_layer=LCD_LAYER3_ENABLE;

		REG_LCD_LAYER3_BUFF_ADDR = (kal_uint32) adrs;
	}
	else
	{
		MMI_ASSERT(0);
	}


	if (lcd_param->rotate_value == MDI_VIDEO_LCD_ROTATE_0)
	{
		lcd_data.roi_offset_x = 0;
		lcd_data.roi_offset_y = 0;
	}
	else
	{
		lcd_data.roi_offset_x = lcd_param->roi_offset_x;
		lcd_data.roi_offset_y = lcd_param->roi_offset_y;
	}

	lcd_data.lcm_start_x = lcd_param->lcm_start_x;
	lcd_data.lcm_start_y = lcd_param->lcm_start_y;
	lcd_data.lcm_end_x = lcd_param->lcm_end_x;
	lcd_data.lcm_end_y = lcd_param->lcm_end_y;
	lcd_data.rotate_value = lcd_param->rotate_value;
	lcd_data.update_layer = lcd_param->update_layer;
	lcd_data.hw_update_layer = lcd_param->hw_update_layer;

	lcd_data.module_id = LCD_UPDATE_MODULE_JPEG_VIDEO;
	lcd_data.lcd_id = MAIN_LCD;
	lcd_data.fb_update_mode = LCD_SW_TRIGGER_MODE;
	lcd_data.memory_output  = KAL_FALSE;
	lcd_data.block_mode_flag = KAL_TRUE;
	lcd_data.lcd_block_mode_cb = NULL;

	lcd_fb_update(&lcd_data);
}

extern void vdo_get_active_buffer(U8** ptr);

void SF_vdo_screen_update(const lcd_frame_update_struct *lcd_param)
{
	U8 *buf_ptr;
	U8  layer_pos;

	if ((lcd_param->hw_update_layer & LCD_LAYER0_ENABLE) != 0)
		layer_pos = 0;
	else if ((lcd_param->hw_update_layer & LCD_LAYER1_ENABLE) != 0)
		layer_pos = 1;
	else if ((lcd_param->hw_update_layer & LCD_LAYER2_ENABLE) != 0)
		layer_pos = 2;
	else if ((lcd_param->hw_update_layer & LCD_LAYER3_ENABLE) != 0)
		layer_pos = 3;
	else
		MMI_ASSERT(0);

	vdo_get_active_buffer(&buf_ptr);

	if (lcd_param->rotate_value == MDI_VIDEO_LCD_ROTATE_270)
	{
		//{{方案一
		//START_LCD_TRANSFER;
		//}}方案一
		
		//{{方案二
		gdi_layer_blt_previous(lcd_param->lcm_start_y, lcd_param->lcm_start_x, lcd_param->lcm_end_y, lcd_param->lcm_end_x);
		//}}方案二
	}
	else
	{
		LCDDisplay_adrs(lcd_param, buf_ptr, layer_pos);
	}
}

SFBool SFSystem_IsTouchSupported(void)
{
	return SFTrue;
}
#endif