开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
ResMemMgr.c
资源名称：mmi.rar　[点击查看]
上传用户：lqx1163
上传日期：2014-08-13
资源大小：9183k
文件大小：54k
源码类别：

MTK

开发平台：

C/C++

ResMemMgr.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  35. /*****************************************************************************
  36.  *
  37.  * Filename:
  38.  * ---------
  39.  *  ResMemMgr.c
  40.  *
  41.  * Project:
  42.  * --------
  43.  *  MAUI
  44.  *
  45.  * Description:
  46.  * ------------
  47.  *  Resource Memory Sharing Manager
  48.  *
  49.  *  It is for resource memory management in Enhanced NFB (ENFB) platform.
  50.  *
  51.  * Author:
  52.  * -------
  53.  * -------
  54.  *                      
  55.  *============================================================================
  56.  *             HISTORY
  57.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  58.  *------------------------------------------------------------------------------
  59.  * removed!
  60.  *
  61.  * removed!
  62.  * removed!
  63.  * removed!
  64.  *
  65.  * removed!
  66.  * removed!
  67.  * removed!
  68.  *
  69.  * removed!
  70.  * removed!
  71.  * removed!
  72.  *
  73.  * removed!
  74.  * removed!
  75.  * removed!
  76.  * removed!
  77.  *
  78.  * removed!
  79.  * removed!
  80.  * removed!
  81.  * removed!
  82.  *
  83.  * removed!
  84.  * removed!
  85.  * removed!
  86.  *
  87.  * removed!
  88.  * removed!
  89.  * removed!
  90.  *
  91.  * removed!
  92.  * removed!
  93.  * removed!
  94.  *
  95.  * removed!
  96.  * removed!
  97.  * removed!
  98.  *
  99.  * removed!
  100.  * removed!
  101.  * removed!
  102.  * removed!
  103.  *
  104.  * removed!
  105.  * removed!
  106.  * removed!
  107.  *
  108.  * removed!
  109.  * removed!
  110.  * removed!
  111.  *
  112.  * removed!
  113.  * removed!
  114.  * removed!
  115.  *
  116.  * removed!
  117.  * removed!
  118.  * removed!
  119.  *
  120.  * removed!
  121.  * removed!
  122.  * removed!
  123.  *
  124.  * removed!
  125.  *
  126.  *------------------------------------------------------------------------------
  127.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  128.  *============================================================================
  129.  ****************************************************************************/
  131. /***************************************************************************** 
  132.  * Include
  133.  *****************************************************************************/
  135. #if !defined(__MTK_TARGET__)
  136. #define UNICODE
  138. #include <stdio.h>
  139. #include "Windows.h"
  140. #endif /* !defined(__MTK_TARGET__) */ 
  142. #if !defined(__MTK_TARGET__)
  143. #define _WINDOWS_       /* to solve redefine prbolem */
  144. #endif 
  146. #include "kal_non_specific_general_types.h"
  147. #include "kal_release.h"
  148. #include "MMI_features.h"
  150. #include "stdC.h"
  151. #include "GlobalDefs.h"
  152. #include "DebugInitDef.h"
  153. #include "ResMemMgrGprot.h"
  154. #include "CustDataRes.h"
  155. #include "gdi_include.h"
  157. #if defined(__MMI_RESOURCE_ENFB_SUPPORT__)
  158. #include "CustENFBStr.h"
  159. #include "nfb_loader.h"
  160. #endif /* defined(__MMI_RESOURCE_ENFB_SUPPORT__) */ 
  162. /***************************************************************************** 
  163.  * Define
  164.  *****************************************************************************/
  166. #define MMI_FRM_RESMEM_CS_ENTER  GDI_LOCK
  167. #define MMI_FRM_RESMEM_CS_LEAVE  GDI_UNLOCK
  169. /* Invalid resoruce ID */
  170. #define MMI_FRM_RESMEM_INVALID_RES_ID          0xFFFF
  172. /*----------------------------------------------------------------*
  173.   Image resource                                                 
  174.  *----------------------------------------------------------------*/
  176. /* Unit test */
  177. // #define MMI_FRM_RESMEM_UNIT_TEST
  179. /* Enable debugging invalid pointer usage by application */
  180. // #define MMI_FRM_RESMEM_DEBUG_DANGLING_POINTER
  182. #if defined(MMI_FRM_RESMEM_DEBUG_DANGLING_POINTER)
  183. #define MMI_FRM_RESMEM_LOAD_ON_DEMAND_SCREEN_NUMBER    5
  184. #define MMI_FRM_RESMEM_SPOT_ICON_RESERVED_SIZE         300
  185. #else /* defined(MMI_FRM_RESMEM_DEBUG_DANGLING_POINTER) */ 
  186. #define MMI_FRM_RESMEM_LOAD_ON_DEMAND_SCREEN_NUMBER    1
  187. #endif /* defined(MMI_FRM_RESMEM_DEBUG_DANGLING_POINTER) */ 
  189. /* size of memory pool
  190.    the size is adjustable */
  191. #define MMI_FRM_RESMEM_POOL_LOD_ON_DEMAND_SIZE  (750 * 1024)    /* 750 K */
  192. #define MMI_FRM_RESMEM_POOL_ALWASY_EXIST_SIZE   (200 * 1024)    /* 200 K */
  194. /* maximum number of records for keeping memory allocation informaitonry
  195.    the number is adjustable */
  196. #define MMI_FRM_RESMEM_LOAD_ON_DEMAND_NUMBER    100
  197. #define MMI_FRM_RESMEM_ALWAYS_EXIST_NUMBER      20
  199. #if !defined(__MTK_TARGET__)
  200. #ifdef MMI_ON_WIN32
  201. #define MMI_FRM_RESMEM_IMAGE_FILE  L"..\..\Customer\CustResource\CustENFBImgData"
  202. #else 
  203. #define MMI_FRM_RESMEM_IMAGE_FILE   L"..\MoDIS\CustENFBImgData"       /* relative to fssim_root_dir (mcuMoDISWIN32FS) */
  204. #endif 
  205. #endif /* !defined(__MTK_TARGET__) */ 
  207. /*----------------------------------------------------------------*
  208.   String resource
  209.  *----------------------------------------------------------------*/
  211. /* The file name of the string raw data */
  212. #if !defined(__MTK_TARGET__)
  213. #ifdef MMI_ON_WIN32
  214. #define MMI_FRM_RESMEM_STRING_FILE     L"..\..\Customer\CustResource\CustENFBStrData"
  215. #else 
  216. #define MMI_FRM_RESMEM_STRING_FILE     L"..\MoDIS\CustENFBStrData"
  217. #endif 
  218. #endif /* !defined(__MTK_TARGET__) */ 
  220. #define MMI_FRM_RESMEM_POOL_STR_RAM_SIZE  (MaxENFBStringSize)   /* bytes */
  222. /***************************************************************************** 
  223.  * Typedef 
  224.  *****************************************************************************/
  226. /*----------------------------------------------------------------*
  227.   Image resource                                                 
  228.  *----------------------------------------------------------------*/
  230. #ifdef MMI_ON_WIN32
  231. typedef void *KAL_ADM_ID;
  232. typedef unsigned char kal_uint8;
  233. typedef unsigned long kal_uint32;
  234. typedef long kal_int32;
  235. typedef BOOL kal_bool;
  236. #endif /* MMI_ON_WIN32 */ 
  238. typedef struct
  239. {
  240.     U16 id;
  241.     U8 *mem_ptr;
  242.     U32 size;
  243. } mmi_frm_resmem_alloc_struct;
  245. /*----------------------------------------------------------------*
  246.   String resource
  247.  *----------------------------------------------------------------*/
  249. /*----------------------------------------------------------------*
  250.   Common
  251.  *----------------------------------------------------------------*/
  252. /* internal contenxt struct */
  253. typedef struct
  254. {
  255.     mmi_frm_resmem_alloc_struct
  256.         lod_ary[MMI_FRM_RESMEM_LOAD_ON_DEMAND_SCREEN_NUMBER][MMI_FRM_RESMEM_LOAD_ON_DEMAND_NUMBER];
  257.     mmi_frm_resmem_alloc_struct always_ary[MMI_FRM_RESMEM_ALWAYS_EXIST_NUMBER];
  258.     U16 always_keep_ID[MMI_FRM_RESMEM_ALWAYS_EXIST_NUMBER];
  259.     KAL_ADM_ID adm_lod_id[MMI_FRM_RESMEM_LOAD_ON_DEMAND_SCREEN_NUMBER];
  260.     KAL_ADM_ID adm_always_id;
  261.     U8 lod_active_screen;
  263.     /* for adjustment */
  264.     U32 lod_mem_using;
  265.     U32 lod_mem_max_used;
  266.     U32 always_mem_using;
  267.     U32 always_mem_max_used;
  269.     /* string part */
  270.     U8 *str_content;
  271.     U8 *str_map;
  272. } mmi_frm_resmem_context_struct;
  274. /*****************************************************************************              
  275.  * Local Variable                                                                    
  276.  *****************************************************************************/
  278. #if defined(__MMI_RESOURCE_ENFB_SUPPORT__)
  280. static mmi_frm_resmem_context_struct g_mmi_frm_resmem_cntx;
  282. /*----------------------------------------------------------------*
  283.   Image resource                                                 
  284.  *----------------------------------------------------------------*/
  285. /* memory pool */
  286. #ifdef __MTK_TARGET__
  287. #pragma arm section zidata = "LARGEPOOL_ZI"
  288. #endif 
  290. static U8
  291.     g_mmi_frm_resmem_lod_pool[MMI_FRM_RESMEM_LOAD_ON_DEMAND_SCREEN_NUMBER][MMI_FRM_RESMEM_POOL_LOD_ON_DEMAND_SIZE];
  292. static U8 g_mmi_frm_resmem_always_pool[MMI_FRM_RESMEM_POOL_ALWASY_EXIST_SIZE];
  294. #ifdef __MTK_TARGET__
  295. #pragma arm section zidata
  296. #endif 
  298. /* for KAL ADM */
  299. static const kal_uint32 g_mmi_frm_resmem_mem_pool_chunk_size[11] = 
  300. {
  301.     16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 0xffffffff, 0
  302. };
  304. /*----------------------------------------------------------------*
  305.   String resource
  306.  *----------------------------------------------------------------*/
  307. #ifdef __MTK_TARGET__
  308. #pragma arm section zidata = "LARGEPOOL_ZI"
  309. #endif 
  311. static U8 g_mmi_frm_resmem_str_pool[MMI_FRM_RESMEM_POOL_STR_RAM_SIZE];
  313. #ifdef __MTK_TARGET__
  314. #pragma arm section zidata
  315. #endif 
  317. /*****************************************************************************              
  318.  * Local Function                                                                    
  319.  *****************************************************************************/
  321. /*----------------------------------------------------------------*
  322.   Image resource                                                 
  323.  *----------------------------------------------------------------*/
  325. #if !defined(__MTK_TARGET__)
  326. // #ifdef MMI_ON_WIN32
  329. /*****************************************************************************
  330.  * FUNCTION
  331.  *  NFB_RES_Load
  332.  * DESCRIPTION
  333.  *  
  334.  * PARAMETERS
  335.  *  cid             [IN]        
  336.  *  dst_addr        [?]         [?]
  337.  *  offset          [IN]        
  338.  *  length          [IN]        
  339.  * RETURNS
  340.  *  
  341.  *****************************************************************************/
  342. static kal_bool NFB_RES_Load(kal_uint8 cid, void *dst_addr, kal_uint32 offset, kal_uint32 length)
  343. {
  344.     /*----------------------------------------------------------------*/
  345.     /* Local Variables                                                */
  346.     /*----------------------------------------------------------------*/
  347. #define TCHAR_BUFFER_SIZE 512
  348.     HANDLE hFile;
  349.     int ret = 0;
  350.     int size = length;
  351.     char *buf = (char*)dst_addr;
  352.     U32 bytesRead;
  353.     TCHAR tchBuffer[TCHAR_BUFFER_SIZE];
  354.     extern TCHAR fssim_root_dir[];
  356.     /*----------------------------------------------------------------*/
  357.     /* Code Body                                                      */
  358.     /*----------------------------------------------------------------*/
  359.     GetCurrentDirectory(TCHAR_BUFFER_SIZE, tchBuffer);
  361.     if (cid == ENFB_CONTENT_IMAGERES)
  362.     {
  363.     #ifdef MMI_ON_WIN32
  364.         wcscpy(tchBuffer, MMI_FRM_RESMEM_IMAGE_FILE);
  365.     #else /* MMI_ON_WIN32 */ 
  366.         wcscpy(tchBuffer, fssim_root_dir);
  367.         wcscat(tchBuffer, MMI_FRM_RESMEM_IMAGE_FILE);
  368.     #endif /* MMI_ON_WIN32 */ 
  370.     }
  371.     else if (cid == ENFB_CONTENT_STRINGRES)
  372.     {
  373.     #ifdef MMI_ON_WIN32
  374.         wcscpy(tchBuffer, MMI_FRM_RESMEM_STRING_FILE);
  375.     #else /* MMI_ON_WIN32 */ 
  376.         wcscpy(tchBuffer, fssim_root_dir);
  377.         wcscat(tchBuffer, MMI_FRM_RESMEM_STRING_FILE);
  378.     #endif /* MMI_ON_WIN32 */ 
  380.     }
  381.     else
  382.     {
  383.         MMI_ASSERT(0);
  384.     }
  386.     hFile = CreateFile(tchBuffer, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  387.     if (hFile == INVALID_HANDLE_VALUE)
  388.     {
  389.         MMI_ASSERT(0);
  390.         exit(1);
  391.     }
  392.     SetFilePointer(hFile, offset, NULL, FILE_BEGIN);
  393.     ret = ReadFile(hFile, dst_addr, (DWORD) length, &bytesRead, NULL);
  395.     CloseHandle(hFile);
  397.     return TRUE;
  398. }
  401. /*****************************************************************************
  402.  * FUNCTION
  403.  *  NFB_RES_Loadv
  404.  * DESCRIPTION
  405.  *  
  406.  * PARAMETERS
  407.  *  cid                 [IN]        
  408.  *  scatter             [?]         [?]
  409.  *  scatter_number      [IN]        
  410.  * RETURNS
  411.  *  
  412.  *****************************************************************************/
  413. static kal_bool NFB_RES_Loadv(kal_uint8 cid, enfb_scatter *scatter, kal_uint32 scatter_number)
  414. {
  415.     /*----------------------------------------------------------------*/
  416.     /* Local Variables                                                */
  417.     /*----------------------------------------------------------------*/
  418.     U8 i;
  420.     /*----------------------------------------------------------------*/
  421.     /* Code Body                                                      */
  422.     /*----------------------------------------------------------------*/
  423.     for (i = 0; i < scatter_number; i++)
  424.     {
  425.         NFB_RES_Load(cid, scatter[i].dst_addr, scatter[i].offset, scatter[i].length);
  426.     }
  428.     return TRUE;
  429. }
  431. #endif /* !defined(__MTK_TARGET__) */ 
  433. #ifdef MMI_ON_WIN32
  436. /*****************************************************************************
  437.  * FUNCTION
  438.  *  kal_adm_create
  439.  * DESCRIPTION
  440.  *  
  441.  * PARAMETERS
  442.  *  mem_addr            [?]         [?]
  443.  *  size                [IN]        
  444.  *  subpool_size        [?]         [?]
  445.  *  islogging           [IN]        
  446.  * RETURNS
  447.  *  
  448.  *****************************************************************************/
  449. static KAL_ADM_ID kal_adm_create(void *mem_addr, kal_uint32 size, kal_uint32 *subpool_size, kal_bool islogging)
  450. {
  451.     /*----------------------------------------------------------------*/
  452.     /* Local Variables                                                */
  453.     /*----------------------------------------------------------------*/
  454.     static int make_compiler_happy = 1;
  456.     /*----------------------------------------------------------------*/
  457.     /* Code Body                                                      */
  458.     /*----------------------------------------------------------------*/
  459.     return &make_compiler_happy;
  460. }
  463. /*****************************************************************************
  464.  * FUNCTION
  465.  *  kal_adm_free
  466.  * DESCRIPTION
  467.  *  
  468.  * PARAMETERS
  469.  *  adm_id          [IN]        
  470.  *  mem_addr        [?]         [?]
  471.  * RETURNS
  472.  *  void
  473.  *****************************************************************************/
  474. static void kal_adm_free(KAL_ADM_ID adm_id, void *mem_addr)
  475. {
  476.     /*----------------------------------------------------------------*/
  477.     /* Local Variables                                                */
  478.     /*----------------------------------------------------------------*/
  480.     /*----------------------------------------------------------------*/
  481.     /* Code Body                                                      */
  482.     /*----------------------------------------------------------------*/
  483.     free(mem_addr);
  484.     return;
  485. }
  488. /*****************************************************************************
  489.  * FUNCTION
  490.  *  kal_adm_internal_alloc
  491.  * DESCRIPTION
  492.  *  
  493.  * PARAMETERS
  494.  *  adm_id          [IN]        
  495.  *  size            [IN]        
  496.  *  filename        [?]         [?]
  497.  *  line            [IN]        
  498.  * RETURNS
  499.  *  void
  500.  *****************************************************************************/
  501. static void *kal_adm_internal_alloc(KAL_ADM_ID adm_id, kal_uint32 size, char *filename, kal_uint32 line)
  502. {
  503.     /*----------------------------------------------------------------*/
  504.     /* Local Variables                                                */
  505.     /*----------------------------------------------------------------*/
  507.     /*----------------------------------------------------------------*/
  508.     /* Code Body                                                      */
  509.     /*----------------------------------------------------------------*/
  510.     return malloc(size);
  511. }
  514. /*****************************************************************************
  515.  * FUNCTION
  516.  *  kal_adm_delete
  517.  * DESCRIPTION
  518.  *  
  519.  * PARAMETERS
  520.  *  adm_id      [IN]        
  521.  * RETURNS
  522.  *  
  523.  *****************************************************************************/
  524. static kal_status kal_adm_delete(KAL_ADM_ID adm_id)
  525. {
  526.     /*----------------------------------------------------------------*/
  527.     /* Local Variables                                                */
  528.     /*----------------------------------------------------------------*/
  530.     /*----------------------------------------------------------------*/
  531.     /* Code Body                                                      */
  532.     /*----------------------------------------------------------------*/
  533.     return KAL_SUCCESS;
  534. }
  535. #endif /* MMI_ON_WIN32 */ 
  538. /*****************************************************************************
  539.  * FUNCTION
  540.  *  mmi_frm_resmem_rec_add
  541.  * DESCRIPTION
  542.  *  add record of resource memory occupation
  543.  * PARAMETERS
  544.  *  mem_type        [IN]        Memory type
  545.  *  id              [IN]        Resource ID
  546.  *  ptr             [IN]        Pointer to resource in RAM
  547.  *  size            [IN]        Size of the resource
  548.  * RETURNS
  549.  *  When succeed MMI_TRUE; otherwise MMI_FALSE
  550.  *****************************************************************************/
  551. static MMI_BOOL mmi_frm_resmem_rec_add(mmi_frm_resmem_enum mem_type, U16 id, U8 *ptr, U32 size)
  552. {
  553.     /*----------------------------------------------------------------*/
  554.     /* Local Variables                                                */
  555.     /*----------------------------------------------------------------*/
  556.     U16 i, number = 0;
  557.     mmi_frm_resmem_alloc_struct *rec = NULL;
  559.     /*----------------------------------------------------------------*/
  560.     /* Code Body                                                      */
  561.     /*----------------------------------------------------------------*/
  562.     MMI_ASSERT(id != MMI_FRM_RESMEM_INVALID_RES_ID);
  563.     MMI_ASSERT(ptr != NULL);
  565.     if (mem_type == MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND)
  566.     {
  567.         number = MMI_FRM_RESMEM_LOAD_ON_DEMAND_NUMBER;
  568.         rec = g_mmi_frm_resmem_cntx.lod_ary[g_mmi_frm_resmem_cntx.lod_active_screen];
  569.     }
  570.     else if (mem_type == MMI_FRM_RESMEM_TYPE_ALWAYS_EXIST)
  571.     {
  572.         number = MMI_FRM_RESMEM_ALWAYS_EXIST_NUMBER;
  573.         rec = g_mmi_frm_resmem_cntx.always_ary;
  574.     }
  575.     else
  576.     {
  577.         MMI_ASSERT(0);
  578.     }
  580.     for (i = 0; i < number; i++, rec++)
  581.     {
  582.         if (rec->mem_ptr == NULL)
  583.         {
  584.             MMI_ASSERT(rec->id == MMI_FRM_RESMEM_INVALID_RES_ID);
  585.             rec->id = id;
  586.             rec->mem_ptr = ptr;
  587.             rec->size = size;
  588.             return MMI_TRUE;
  589.         }
  590.     }
  592.     /* empty item is no found. Call the module's owner to handle this situation */
  593.     MMI_ASSERT(0);
  595.     return MMI_FALSE;
  596. }
  599. /*****************************************************************************
  600.  * FUNCTION
  601.  *  mmi_frm_resmem_rec_del
  602.  * DESCRIPTION
  603.  *  init the module
  604.  * PARAMETERS
  605.  *  mem_type        [IN]        Memory type
  606.  *  id              [IN]        Resource ID
  607.  * RETURNS
  608.  *  resource pointer; NULL if no record allocated
  609.  *****************************************************************************/
  610. static U8 *mmi_frm_resmem_rec_del(mmi_frm_resmem_enum mem_type, U16 id)
  611. {
  612.     /*----------------------------------------------------------------*/
  613.     /* Local Variables                                                */
  614.     /*----------------------------------------------------------------*/
  615.     U16 i, number = 0;
  616.     mmi_frm_resmem_alloc_struct *rec = NULL;
  617.     U8 *ret_ptr;
  619.     /*----------------------------------------------------------------*/
  620.     /* Code Body                                                      */
  621.     /*----------------------------------------------------------------*/
  622.     MMI_ASSERT(id != MMI_FRM_RESMEM_INVALID_RES_ID);
  624.     if (mem_type == MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND)
  625.     {
  626.         number = MMI_FRM_RESMEM_LOAD_ON_DEMAND_NUMBER;
  627.         rec = g_mmi_frm_resmem_cntx.lod_ary[g_mmi_frm_resmem_cntx.lod_active_screen];
  628.     }
  629.     else if (mem_type == MMI_FRM_RESMEM_TYPE_ALWAYS_EXIST)
  630.     {
  631.         number = MMI_FRM_RESMEM_ALWAYS_EXIST_NUMBER;
  632.         rec = g_mmi_frm_resmem_cntx.always_ary;
  633.     }
  634.     else
  635.     {
  636.         MMI_ASSERT(0);
  637.     }
  639.     for (i = 0; i < number; i++, rec++)
  640.     {
  641.         if (rec->id == id)
  642.         {
  643.             rec->id = MMI_FRM_RESMEM_INVALID_RES_ID;
  644.             ret_ptr = rec->mem_ptr;
  645.             rec->mem_ptr = NULL;
  646.             return ret_ptr;
  647.         }
  648.     }
  649.     return NULL;
  650. }
  653. /*****************************************************************************
  654.  * FUNCTION
  655.  *  mmi_frm_resmem_rec_del_one
  656.  * DESCRIPTION
  657.  *  delete one record of resource memory occupation, if available
  658.  * PARAMETERS
  659.  *  mem_type            [IN]        Memory type
  660.  *  which_screen        [IN]        Which screen, indentifying what managment table to do the deleting. only valid for LOD
  661.  *  id                  [OUT]       Which ID. If not interested, pass in NULL
  662.  * RETURNS
  663.  *  resource pointer; NULL if no record allocated
  664.  *****************************************************************************/
  665. static U8 *mmi_frm_resmem_rec_del_one(mmi_frm_resmem_enum mem_type, U16 which_screen, U16 *id)
  666. {
  667.     /*----------------------------------------------------------------*/
  668.     /* Local Variables                                                */
  669.     /*----------------------------------------------------------------*/
  670.     U16 i, number = 0;
  671.     mmi_frm_resmem_alloc_struct *rec = NULL;
  672.     U8 *ret_ptr;
  674.     /*----------------------------------------------------------------*/
  675.     /* Code Body                                                      */
  676.     /*----------------------------------------------------------------*/
  677.     if (mem_type == MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND)
  678.     {
  679.         MMI_ASSERT(which_screen < MMI_FRM_RESMEM_LOAD_ON_DEMAND_SCREEN_NUMBER);
  680.         number = MMI_FRM_RESMEM_LOAD_ON_DEMAND_NUMBER;
  681.         rec = g_mmi_frm_resmem_cntx.lod_ary[which_screen];
  682.     }
  683.     else if (mem_type == MMI_FRM_RESMEM_TYPE_ALWAYS_EXIST)
  684.     {
  685.         number = MMI_FRM_RESMEM_ALWAYS_EXIST_NUMBER;
  686.         rec = g_mmi_frm_resmem_cntx.always_ary;
  687.     }
  688.     else
  689.     {
  690.         MMI_ASSERT(0);
  691.     }
  693.     /* TBD. enhance performance */
  694.     for (i = 0; i < number; i++, rec++)
  695.     {
  696.         if (rec->id != MMI_FRM_RESMEM_INVALID_RES_ID)
  697.         {
  698.             MMI_ASSERT(rec->mem_ptr != NULL);
  700.             if (id != NULL)
  701.             {
  702.                 *id = rec->id;
  703.             }
  704.             ret_ptr = rec->mem_ptr;
  705.             rec->id = MMI_FRM_RESMEM_INVALID_RES_ID;
  706.             rec->mem_ptr = NULL;
  707.             rec->size = 0;
  708.             return ret_ptr;
  709.         }
  710.     }
  711.     return NULL;
  712. }
  715. /*****************************************************************************
  716.  * FUNCTION
  717.  *  mmi_frm_resmem_rec_if_exist
  718.  * DESCRIPTION
  719.  *  query whether the resource is existing in memory based on records
  720.  * PARAMETERS
  721.  *  flag        [IN]        Bit-wise flag: combination of MMI_FRM_RESMEM_MEMORY_LOAD_ON_DEMAND, MMI_FRM_RESMEM_MEMORY_ALWAYS_EXIST
  722.  *  id          [IN]        Resource ID
  723.  *  size        [OUT]       Place to receive resource size. It not of interest, pass in NULL
  724.  * RETURNS
  725.  *  if exist, return the memory pointer; otherwise, NULL
  726.  *****************************************************************************/
  727. static U8 *mmi_frm_resmem_rec_if_exist(U32 flag, U16 id, U32 *size)
  728. {
  729.     /*----------------------------------------------------------------*/
  730.     /* Local Variables                                                */
  731.     /*----------------------------------------------------------------*/
  732.     U16 j, i, number;
  733.     mmi_frm_resmem_alloc_struct *rec;
  735.     /*----------------------------------------------------------------*/
  736.     /* Code Body                                                      */
  737.     /*----------------------------------------------------------------*/
  738.     MMI_ASSERT((flag & (~(MMI_FRM_RESMEM_TYPE_ALWAYS_EXIST | MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND))) == 0);
  739.     MMI_ASSERT(id != MMI_FRM_RESMEM_INVALID_RES_ID);
  741.     for (j = 0;; j++)
  742.     {
  743.         if (j == 0)
  744.         {
  745.             if (flag & MMI_FRM_RESMEM_TYPE_ALWAYS_EXIST)
  746.             {
  747.                 number = MMI_FRM_RESMEM_ALWAYS_EXIST_NUMBER;
  748.                 rec = g_mmi_frm_resmem_cntx.always_ary;
  749.             }
  750.             else
  751.             {
  752.                 continue;
  753.             }
  754.         }
  755.         else if (j == 1)
  756.         {
  757.             if (flag & MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND)
  758.             {
  759.                 number = MMI_FRM_RESMEM_LOAD_ON_DEMAND_NUMBER;
  760.                 rec = g_mmi_frm_resmem_cntx.lod_ary[g_mmi_frm_resmem_cntx.lod_active_screen];
  761.             }
  762.             else
  763.             {
  764.                 continue;
  765.             }
  766.         }
  767.         else
  768.         {
  769.             /* not found */
  770.             break;
  771.         }
  773.         for (i = 0; i < number; i++, rec++)
  774.         {
  775.             if (rec->id == id)
  776.             {
  777.                 if (size != NULL)
  778.                 {
  779.                     *size = rec->size;
  780.                 }
  781.                 return rec->mem_ptr;
  782.             }
  783.         }
  784.     }
  785.     return NULL;
  786. }
  789. /*****************************************************************************
  790.  * FUNCTION
  791.  *  mmi_frm_resmem_if_res_to_always_keep
  792.  * DESCRIPTION
  793.  *  query whether to keep the specified resource
  794.  * PARAMETERS
  795.  *  id      [IN]        Resource ID
  796.  * RETURNS
  797.  *  MMI_TRUE if necessary
  798.  *****************************************************************************/
  799. static MMI_BOOL mmi_frm_resmem_if_res_to_always_keep(U16 id)
  800. {
  801.     /*----------------------------------------------------------------*/
  802.     /* Local Variables                                                */
  803.     /*----------------------------------------------------------------*/
  804.     U16 i;
  806.     /*----------------------------------------------------------------*/
  807.     /* Code Body                                                      */
  808.     /*----------------------------------------------------------------*/
  809.     for (i = 0; i < MMI_FRM_RESMEM_ALWAYS_EXIST_NUMBER; i++)
  810.     {
  811.         if (g_mmi_frm_resmem_cntx.always_keep_ID[i] == id)
  812.         {
  813.             return MMI_TRUE;
  814.         }
  815.     }
  817.     return MMI_FALSE;
  818. }
  820. #ifdef MMI_FRM_RESMEM_UNIT_TEST
  823. /*****************************************************************************
  824.  * FUNCTION
  825.  *  mmi_frm_resmem_unit_test
  826.  * DESCRIPTION
  827.  *  
  828.  * PARAMETERS
  829.  *  void
  830.  * RETURNS
  831.  *  void
  832.  *****************************************************************************/
  833. void mmi_frm_resmem_unit_test(void)
  834. {
  835.     /*----------------------------------------------------------------*/
  836.     /* Local Variables                                                */
  837.     /*----------------------------------------------------------------*/
  838.     U8 *ptr;
  840.     /*----------------------------------------------------------------*/
  841.     /* Code Body                                                      */
  842.     /*----------------------------------------------------------------*/
  843.     mmi_frm_resmem_init();
  845.     /* test case: load single image */
  846.     {
  847.         ptr = mmi_frm_resmem_if_ramed(2);
  848.         mmi_frm_resmem_load_single_image(2, 2000, 22);
  849.         mmi_frm_resmem_load_single_image(4, 4000, 444);
  850.         mmi_frm_resmem_load_single_image(5, 5000, 5555);
  851.         ptr = mmi_frm_resmem_load_single_image(4, 4000, 444);
  852.         ptr = mmi_frm_resmem_if_ramed(2);
  853.     }
  855.     /* test case: reset LOD memory */
  856.     {
  857.         mmi_frm_resmem_reset(MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND);
  858.         ptr = mmi_frm_resmem_if_ramed(2);
  859.     }
  861.     /* test case: load array image */
  862.     {
  863.         static mmi_frm_resmem_res_info_struct info_array[10];
  865.         ptr = mmi_frm_resmem_if_ramed(7);
  866.         info_array[0].id = 1;
  867.         info_array[0].offset = 1000;
  868.         info_array[0].size = 111;
  869.         info_array[1].id = 2;
  870.         info_array[1].offset = 2000;
  871.         info_array[1].size = 222;
  872.         info_array[2].id = 7;
  873.         info_array[2].offset = 7000;
  874.         info_array[2].size = 777;
  875.         info_array[3].id = 8;
  876.         info_array[3].offset = 8000;
  877.         info_array[3].size = 888;
  878.         ptr = mmi_frm_resmem_load_multi_image(7, info_array, 4);
  879.         ptr = mmi_frm_resmem_if_ramed(7);
  880.     }
  882.     /* test case: load single image */
  883.     {
  884.         U16 i;
  886.         ptr = mmi_frm_resmem_if_ramed(15);
  887.         for (i = 1; i < 20; i++)
  888.         {
  889.             mmi_frm_resmem_load_single_image(i, i * 20, i * 20);
  890.         }
  891.         ptr = mmi_frm_resmem_if_ramed(10);
  892.     }
  894.     /* test case: load image to Always Exist area */
  895.     {
  896.         U16 i;
  898.         ptr = mmi_frm_resmem_if_ramed(21);
  899.         for (i = 10; i < 30; i++)
  900.         {
  901.             mmi_frm_resmem_reg_retain(i);
  902.             mmi_frm_resmem_load_single_image(i, i * 20, i * 20);
  903.         }
  904.         ptr = mmi_frm_resmem_if_ramed(21);
  905.     }
  907.     /* test case: remove image from Always Exist area */
  908.     {
  909.         U16 i;
  911.         ptr = mmi_frm_resmem_if_ramed(21);
  912.         for (i = 10; i < 30; i++)
  913.         {
  914.             mmi_frm_resmem_dereg_retain(i);
  915.         }
  916.         ptr = mmi_frm_resmem_if_ramed(21);
  917.     }
  918.     return;
  919. }
  920. #endif /* MMI_FRM_RESMEM_UNIT_TEST */ 
  922. /*****************************************************************************              
  923.  * Extern Global Variable                                                                    
  924.  *****************************************************************************/
  926. /*****************************************************************************              
  927.  * Extern Global Function                                                                    
  928.  *****************************************************************************/
  931. /*****************************************************************************
  932.  * FUNCTION
  933.  *  mmi_frm_resmem_init
  934.  * DESCRIPTION
  935.  *  init the module
  936.  * PARAMETERS
  937.  *  void
  938.  * RETURNS
  939.  *  void
  940.  *****************************************************************************/
  941. void mmi_frm_resmem_init(void)
  942. {
  943.     /*----------------------------------------------------------------*/
  944.     /* Local Variables                                                */
  945.     /*----------------------------------------------------------------*/
  946.     U16 i, j;
  948.     /*----------------------------------------------------------------*/
  949.     /* Code Body                                                      */
  950.     /*----------------------------------------------------------------*/
  951.     memset(&g_mmi_frm_resmem_cntx, 0, sizeof(mmi_frm_resmem_context_struct));
  953.     /* init ID table */
  954.     for (j = 0; j < MMI_FRM_RESMEM_LOAD_ON_DEMAND_SCREEN_NUMBER; j++)
  955.     {
  956.         for (i = 0; i < MMI_FRM_RESMEM_LOAD_ON_DEMAND_NUMBER; i++)
  957.         {
  958.             g_mmi_frm_resmem_cntx.lod_ary[j][i].id = MMI_FRM_RESMEM_INVALID_RES_ID;
  959.         }
  960.     }
  961.     for (i = 0; i < MMI_FRM_RESMEM_ALWAYS_EXIST_NUMBER; i++)
  962.     {
  963.         g_mmi_frm_resmem_cntx.always_ary[i].id = MMI_FRM_RESMEM_INVALID_RES_ID;
  964.     }
  966.     /* init retain-ID registration table */
  967.     for (i = 0; i < MMI_FRM_RESMEM_ALWAYS_EXIST_NUMBER; i++)
  968.     {
  969.         g_mmi_frm_resmem_cntx.always_keep_ID[i] = MMI_FRM_RESMEM_INVALID_RES_ID;
  970.     }
  972.     /* init malloc record table */
  973.     for (i = 0; i < MMI_FRM_RESMEM_LOAD_ON_DEMAND_SCREEN_NUMBER; i++)
  974.     {
  975.         g_mmi_frm_resmem_cntx.adm_lod_id[i] = kal_adm_create(
  976.                                                 g_mmi_frm_resmem_lod_pool[i],
  977.                                                 MMI_FRM_RESMEM_POOL_LOD_ON_DEMAND_SIZE,
  978.                                                 (kal_uint32*) g_mmi_frm_resmem_mem_pool_chunk_size,
  979.                                                 KAL_TRUE);
  980.         MMI_ASSERT(g_mmi_frm_resmem_cntx.adm_lod_id[i] != (KAL_ADM_ID) NULL);
  981.     }
  983.     g_mmi_frm_resmem_cntx.adm_always_id = kal_adm_create(
  984.                                             g_mmi_frm_resmem_always_pool,
  985.                                             MMI_FRM_RESMEM_POOL_ALWASY_EXIST_SIZE,
  986.                                             (kal_uint32*) g_mmi_frm_resmem_mem_pool_chunk_size,
  987.                                             KAL_TRUE);
  988.     MMI_ASSERT(g_mmi_frm_resmem_cntx.adm_always_id != (KAL_ADM_ID) NULL);
  990.     g_mmi_frm_resmem_cntx.lod_active_screen = 0;
  992. #if !defined(__MTK_TARGET__)
  993. #if !defined(MMI_ON_WIN32)
  994.     FS_SanityCheck();
  995. #endif 
  996. #endif /* !defined(__MTK_TARGET__) */ 
  998.     return;
  999. }
  1002. /*****************************************************************************
  1003.  * FUNCTION
  1004.  *  mmi_frm_resmem_if_ramed
  1005.  * DESCRIPTION
  1006.  *  check whether the memory of the specificed resurce is existing in memory.
  1007.  * PARAMETERS
  1008.  *  id      [IN]        Resource ID
  1009.  * RETURNS
  1010.  *  if exist, the pointer of RAM ; otherwise, NULL
  1011.  *****************************************************************************/
  1012. U8 *mmi_frm_resmem_if_ramed(U16 id)
  1013. {
  1014.     /*----------------------------------------------------------------*/
  1015.     /* Local Variables                                                */
  1016.     /*----------------------------------------------------------------*/
  1017.     U8 *ret;
  1019.     /*----------------------------------------------------------------*/
  1020.     /* Code Body                                                      */
  1021.     /*----------------------------------------------------------------*/
  1022.     MMI_FRM_RESMEM_CS_ENTER;
  1023.     MMI_ASSERT(id != MMI_FRM_RESMEM_INVALID_RES_ID);
  1025.     ret = mmi_frm_resmem_rec_if_exist((MMI_FRM_RESMEM_TYPE_ALWAYS_EXIST | MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND), id, NULL);
  1026.     MMI_FRM_RESMEM_CS_LEAVE;
  1027.     return ret;
  1028. }
  1031. /*****************************************************************************
  1032.  * FUNCTION
  1033.  *  mmi_frm_resmem_load_single_image
  1034.  * DESCRIPTION
  1035.  *  load the specificed resurce into memory.
  1036.  * PARAMETERS
  1037.  *  id          [IN]        Resource ID
  1038.  *  offset      [IN]        Offset in bin
  1039.  *  size        [IN]        Resource size
  1040.  * RETURNS
  1041.  *  memory pointer; NULL if not successful
  1042.  *****************************************************************************/
  1043. U8 *mmi_frm_resmem_load_single_image(U16 id, U32 offset, U32 size)
  1044. {
  1045.     /*----------------------------------------------------------------*/
  1046.     /* Local Variables                                                */
  1047.     /*----------------------------------------------------------------*/
  1048.     U32 buf_size;
  1049.     U8 *ret_ptr = NULL;
  1050.     kal_bool kal_rslt;
  1051.     KAL_ADM_ID adm_id;
  1052.     MMI_BOOL ret_bool;
  1053.     mmi_frm_resmem_enum mem_type;
  1055.     /*----------------------------------------------------------------*/
  1056.     /* Code Body                                                      */
  1057.     /*----------------------------------------------------------------*/
  1058.     MMI_FRM_RESMEM_CS_ENTER;
  1060.     MMI_ASSERT(id != MMI_FRM_RESMEM_INVALID_RES_ID);
  1061.     MMI_ASSERT(size != 0);
  1063.     /* PC-Simulator did not call thie init as expected, so do here again */
  1064. #if !defined(__MTK_TARGET__)
  1065. #if defined(MMI_ON_WIN32)
  1066.     if (g_mmi_frm_resmem_cntx.adm_always_id == (KAL_ADM_ID) NULL)
  1067.     {
  1068.         mmi_frm_resmem_init();
  1069.     }
  1070. #endif /* defined(MMI_ON_WIN32) */ 
  1071. #endif /* !defined(__MTK_TARGET__) */ 
  1073.     /* check whether already exist in RAM */
  1074.     ret_ptr = mmi_frm_resmem_if_ramed(id);
  1075.     if (ret_ptr != NULL)
  1076.     {
  1077.         MMI_FRM_RESMEM_CS_LEAVE;
  1078.         return ret_ptr;
  1079.     }
  1081.     /* decide which kind of memory */
  1082.     if (mmi_frm_resmem_if_res_to_always_keep(id) == MMI_TRUE)
  1083.     {
  1084.         mem_type = MMI_FRM_RESMEM_TYPE_ALWAYS_EXIST;
  1085.         adm_id = g_mmi_frm_resmem_cntx.adm_always_id;
  1086.     }
  1087.     else
  1088.     {
  1089.         mem_type = MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND;
  1090.         adm_id = g_mmi_frm_resmem_cntx.adm_lod_id[g_mmi_frm_resmem_cntx.lod_active_screen];
  1091.     }
  1093.     MMI_ASSERT(adm_id != (KAL_ADM_ID) NULL);
  1095.     /* allocate RAM block */
  1096.     buf_size = size;
  1097. #if defined(MMI_FRM_RESMEM_DEBUG_DANGLING_POINTER)
  1098.     buf_size = (buf_size >= MMI_FRM_RESMEM_SPOT_ICON_RESERVED_SIZE ? buf_size : MMI_FRM_RESMEM_SPOT_ICON_RESERVED_SIZE);
  1099. #endif 
  1100.     ret_ptr = kal_adm_alloc(adm_id, buf_size);
  1101.     /* Check memory alloc success or not. 
  1102.        If assertion failure here, maybe result from
  1103.        - image/animation/video size increased, or
  1104.        - more images are added in one screen, or
  1105.        - mmi_frm_resmem_reset() is not called when screen change, or
  1106.        - macro MMI_FRM_RESMEM_POOL_LOD_ON_DEMAND_SIZE value is too small */
  1107.     MMI_ASSERT(ret_ptr != NULL);
  1108.     /* 4-byte alignment for GDI API requirement, at least necessary for target */
  1109.     MMI_ASSERT(((U32) ret_ptr & 0x00000003) == 0);
  1111.     if (mem_type == MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND)
  1112.     {
  1113.         g_mmi_frm_resmem_cntx.lod_mem_using += buf_size;
  1114.         if (g_mmi_frm_resmem_cntx.lod_mem_using > g_mmi_frm_resmem_cntx.lod_mem_max_used)
  1115.         {
  1116.             g_mmi_frm_resmem_cntx.lod_mem_max_used = g_mmi_frm_resmem_cntx.lod_mem_using;
  1117.             MMI_ASSERT(g_mmi_frm_resmem_cntx.lod_mem_max_used < MMI_FRM_RESMEM_POOL_LOD_ON_DEMAND_SIZE);
  1118.         }
  1119.     }
  1120.     else
  1121.     {
  1122.         g_mmi_frm_resmem_cntx.always_mem_using += buf_size;
  1123.         if (g_mmi_frm_resmem_cntx.always_mem_using > g_mmi_frm_resmem_cntx.always_mem_max_used)
  1124.         {
  1125.             g_mmi_frm_resmem_cntx.always_mem_max_used = g_mmi_frm_resmem_cntx.always_mem_using;
  1126.             MMI_ASSERT(g_mmi_frm_resmem_cntx.always_mem_max_used < MMI_FRM_RESMEM_POOL_ALWASY_EXIST_SIZE);
  1127.         }
  1128.     }
  1130.     /* load via driver */
  1131.     kal_rslt = NFB_RES_Load(ENFB_CONTENT_IMAGERES, (void*)ret_ptr, offset, size);
  1132.     MMI_ASSERT(kal_rslt == KAL_TRUE);
  1133.     if (kal_rslt == KAL_FALSE)
  1134.     {
  1135.         kal_adm_free(adm_id, ret_ptr);
  1136.         ret_ptr = NULL;
  1137.         MMI_FRM_RESMEM_CS_LEAVE;
  1138.         return NULL;
  1139.     }
  1141.     /* update managment records */
  1142.     ret_bool = mmi_frm_resmem_rec_add(mem_type, id, ret_ptr, size);
  1143.     MMI_ASSERT(ret_bool == MMI_TRUE);
  1145.     MMI_FRM_RESMEM_CS_LEAVE;
  1146.     return ret_ptr;
  1147. }
  1150. /*****************************************************************************
  1151.  * FUNCTION
  1152.  *  mmi_frm_resmem_load_multi_image
  1153.  * DESCRIPTION
  1154.  *  load the specificed resurce into memory. Since the resource in in a
  1155.  *  multi-res pack, it is better to one, rather than multiple, access to ROM.
  1156.  * PARAMETERS
  1157.  *  id              [IN]        Resource ID
  1158.  *  info_array      [IN]        Array the stores the resource-pack info, which allows single access
  1159.  *  res_cnt         [IN]        The number of resource in info_array
  1160.  * RETURNS
  1161.  *  memory pointer; NULL if not successful
  1162.  *****************************************************************************/
  1163. U8 *mmi_frm_resmem_load_multi_image(U16 id, const mmi_frm_resmem_res_info_struct *info_array, U32 res_cnt)
  1164. {
  1165.     /*----------------------------------------------------------------*/
  1166.     /* Local Variables                                                */
  1167.     /*----------------------------------------------------------------*/
  1168.     U32 buf_size;
  1169.     U8 i;
  1170.     U8 *ret_ptr = 0;
  1171.     static enfb_scatter scatter[MMI_FRM_RESMEM_SCATTER_MAX_NUMBER];
  1172.     kal_bool kal_rslt;
  1173.     KAL_ADM_ID adm_id;
  1174.     MMI_BOOL ret_bool;
  1175.     mmi_frm_resmem_enum mem_type;
  1176.     const mmi_frm_resmem_res_info_struct *info;
  1178.     /*----------------------------------------------------------------*/
  1179.     /* Code Body                                                      */
  1180.     /*----------------------------------------------------------------*/
  1181.     MMI_FRM_RESMEM_CS_ENTER;
  1183.     MMI_ASSERT(id != MMI_FRM_RESMEM_INVALID_RES_ID);
  1184.     MMI_ASSERT(info_array != 0);
  1185.     MMI_ASSERT(res_cnt != 0);
  1186.     MMI_ASSERT(res_cnt < MMI_FRM_RESMEM_SCATTER_MAX_NUMBER);
  1188.     /* check whether already exist in in RAM */
  1189.     ret_ptr = mmi_frm_resmem_if_ramed(id);
  1190.     if (ret_ptr != NULL)
  1191.     {
  1192.         MMI_FRM_RESMEM_CS_LEAVE;
  1193.         return ret_ptr;
  1194.     }
  1196.     /* decide which kind of memory */
  1197.     if (mmi_frm_resmem_if_res_to_always_keep(id) == MMI_TRUE)
  1198.     {
  1199.         mem_type = MMI_FRM_RESMEM_TYPE_ALWAYS_EXIST;
  1200.         adm_id = g_mmi_frm_resmem_cntx.adm_always_id;
  1201.     }
  1202.     else
  1203.     {
  1204.         mem_type = MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND;
  1205.         adm_id = g_mmi_frm_resmem_cntx.adm_lod_id[g_mmi_frm_resmem_cntx.lod_active_screen];
  1206.     }
  1207.     MMI_ASSERT(adm_id != (KAL_ADM_ID) NULL);
  1209.     /* allocate RAM block */
  1210.     for (i = 0, info = info_array; i < res_cnt; i++, info++)
  1211.     {
  1212.         buf_size = info->size;
  1214.     #if defined(MMI_FRM_RESMEM_DEBUG_DANGLING_POINTER)
  1215.         buf_size =
  1216.             (buf_size >= MMI_FRM_RESMEM_SPOT_ICON_RESERVED_SIZE ? buf_size : MMI_FRM_RESMEM_SPOT_ICON_RESERVED_SIZE);
  1217.     #endif /* defined(MMI_FRM_RESMEM_DEBUG_DANGLING_POINTER) */ 
  1218.         ret_ptr = kal_adm_alloc(adm_id, buf_size);
  1219.         MMI_ASSERT(ret_ptr != NULL);
  1220.         /* 4-byte alignment for GDI API requirement, at least necessary for target */
  1221.         MMI_ASSERT(((U32) ret_ptr & 0x00000003) == 0);
  1223.         scatter[i].dst_addr = ret_ptr;
  1224.         scatter[i].offset = info->offset;
  1225.         scatter[i].length = info->size;
  1227.         if (mem_type == MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND)
  1228.         {
  1229.             g_mmi_frm_resmem_cntx.lod_mem_using += buf_size;
  1230.             if (g_mmi_frm_resmem_cntx.lod_mem_using > g_mmi_frm_resmem_cntx.lod_mem_max_used)
  1231.             {
  1232.                 g_mmi_frm_resmem_cntx.lod_mem_max_used = g_mmi_frm_resmem_cntx.lod_mem_using;
  1233.                 MMI_ASSERT(g_mmi_frm_resmem_cntx.lod_mem_max_used < MMI_FRM_RESMEM_POOL_LOD_ON_DEMAND_SIZE);
  1234.             }
  1235.         }
  1236.         else
  1237.         {
  1238.             g_mmi_frm_resmem_cntx.always_mem_using += buf_size;
  1239.             if (g_mmi_frm_resmem_cntx.always_mem_using > g_mmi_frm_resmem_cntx.always_mem_max_used)
  1240.             {
  1241.                 g_mmi_frm_resmem_cntx.always_mem_max_used = g_mmi_frm_resmem_cntx.always_mem_using;
  1242.             }
  1243.             MMI_ASSERT(g_mmi_frm_resmem_cntx.always_mem_max_used < MMI_FRM_RESMEM_POOL_ALWASY_EXIST_SIZE);
  1244.         }
  1245.     }
  1247.     /* load via driver */
  1248.     kal_rslt = NFB_RES_Loadv(ENFB_CONTENT_IMAGERES, scatter, res_cnt);
  1249.     MMI_ASSERT(kal_rslt == KAL_TRUE);
  1250.     if (kal_rslt == KAL_FALSE)
  1251.     {
  1252.         for (i = 0; i < res_cnt; i++)
  1253.         {
  1254.             kal_adm_free(adm_id, scatter[i].dst_addr);
  1255.         }
  1256.         ret_ptr = NULL;
  1257.         MMI_FRM_RESMEM_CS_LEAVE;
  1258.         return NULL;
  1259.     }
  1261.     /* update managment records */
  1262.     for (i = 0, info = info_array; i < res_cnt; i++, info++)
  1263.     {
  1264.         ret_bool = mmi_frm_resmem_rec_add(mem_type, info->id, scatter[i].dst_addr, scatter[i].length);
  1265.         MMI_ASSERT(ret_bool == MMI_TRUE);
  1267.         if (id == info->id)
  1268.         {
  1269.             ret_ptr = scatter[i].dst_addr;
  1270.         }
  1271.     }
  1273.     MMI_FRM_RESMEM_CS_LEAVE;
  1274.     return ret_ptr;
  1275. }
  1278. /*****************************************************************************
  1279.  * FUNCTION
  1280.  *  mmi_frm_resmem_reset
  1281.  * DESCRIPTION
  1282.  *  check whether the memory of the specificed resurce is existing in memory.
  1283.  * PARAMETERS
  1284.  *  flag        [IN]        Bit-wise flag: combination of MMI_FRM_RESMEM_MEMORY_LOAD_ON_DEMAND, MMI_FRM_RESMEM_MEMORY_ALWAYS_EXIST
  1285.  * RETURNS
  1286.  *  void
  1287.  *****************************************************************************/
  1288. void mmi_frm_resmem_reset(U32 flag)
  1289. {
  1290.     /*----------------------------------------------------------------*/
  1291.     /* Local Variables                                                */
  1292.     /*----------------------------------------------------------------*/
  1293.     U8 *mem_addr;
  1295. #if defined(MMI_FRM_RESMEM_DEBUG_DANGLING_POINTER)
  1296.     S32 size;
  1297. #endif 
  1299.     /*----------------------------------------------------------------*/
  1300.     /* Code Body                                                      */
  1301.     /*----------------------------------------------------------------*/
  1302.     MMI_FRM_RESMEM_CS_ENTER;
  1304.     if (flag & MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND)
  1305.     {
  1307.     #if defined(MMI_FRM_RESMEM_DEBUG_DANGLING_POINTER)
  1308.         /* display "X" icon for invlaid pointer usage */
  1309.         U16 i, number;
  1310.         mmi_frm_resmem_alloc_struct *rec;
  1311.     U8 *res_src = NULL;
  1313.         number = MMI_FRM_RESMEM_LOAD_ON_DEMAND_NUMBER;
  1314.         rec = g_mmi_frm_resmem_cntx.lod_ary[g_mmi_frm_resmem_cntx.lod_active_screen];
  1316.         for (i = 0; i < number; i++, rec++)
  1317.         {
  1318.             if (rec->mem_ptr != NULL)
  1319.             {
  1320.                 /* dangling pointer. fill in special icon. this icon is not in 3rd ROM */
  1321.                 res_src = NULL;
  1322.                 res_src = (U8*) GetImage(IMG_GLOBAL_DEFAULT);
  1323.                 MMI_ASSERT(res_src != NULL);
  1324.                 size = ((S32) (res_src[2]) |
  1325.                         (S32) ((S32) res_src[3] << 8) |
  1326.                         (S32) ((S32) res_src[4] << 16) | (S32) ((S32) res_src[5] << 24));
  1327.                 MMI_ASSERT(MMI_FRM_RESMEM_SPOT_ICON_RESERVED_SIZE > size);
  1328.                 memcpy((char*)rec->mem_ptr, res_src, size);
  1329.                 rec->size = size;
  1330.             }
  1331.         }
  1332.         /* prepare the memory for next screen usage */
  1333.         g_mmi_frm_resmem_cntx.lod_active_screen++;
  1334.         g_mmi_frm_resmem_cntx.lod_active_screen %= MMI_FRM_RESMEM_LOAD_ON_DEMAND_SCREEN_NUMBER;
  1336.     #else /* defined(MMI_FRM_RESMEM_DEBUG_DANGLING_POINTER) */ 
  1337.         MMI_ASSERT(g_mmi_frm_resmem_cntx.lod_active_screen == 0);
  1338.     #endif /* defined(MMI_FRM_RESMEM_DEBUG_DANGLING_POINTER) */ 
  1340.         /* delete and create again */
  1341.         do
  1342.         {
  1343.             mem_addr = mmi_frm_resmem_rec_del_one(
  1344.                         MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND,
  1345.                         g_mmi_frm_resmem_cntx.lod_active_screen,
  1346.                         NULL);
  1348.             if (mem_addr == NULL)
  1349.             {
  1350.                 break;
  1351.             }
  1352.             kal_adm_free(g_mmi_frm_resmem_cntx.adm_lod_id[g_mmi_frm_resmem_cntx.lod_active_screen], mem_addr);
  1353.         } while (1);
  1355.         kal_adm_delete(g_mmi_frm_resmem_cntx.adm_lod_id[g_mmi_frm_resmem_cntx.lod_active_screen]);
  1356.         g_mmi_frm_resmem_cntx.adm_lod_id[g_mmi_frm_resmem_cntx.lod_active_screen] = kal_adm_create(
  1357.                                                                                         g_mmi_frm_resmem_lod_pool[g_mmi_frm_resmem_cntx.lod_active_screen],
  1358.                                                                                         MMI_FRM_RESMEM_POOL_LOD_ON_DEMAND_SIZE,
  1359.                                                                                         (kal_uint32*) g_mmi_frm_resmem_mem_pool_chunk_size,
  1360.                                                                                         KAL_TRUE);
  1361.     }
  1363.     g_mmi_frm_resmem_cntx.lod_mem_using = 0;
  1365.     /* should call this to avoid incorrect displaying because of GDI cache */
  1366.     gdi_image_cache_reset();
  1368.     MMI_FRM_RESMEM_CS_LEAVE;
  1369.     return;
  1370. }
  1373. /*****************************************************************************
  1374.  * FUNCTION
  1375.  *  mmi_frm_resmem_reg_retain
  1376.  * DESCRIPTION
  1377.  *  Register what resource to be keept without auto-clear at screen change
  1378.  *  Please note that if the resource is already allocated in LOD, it will
  1379.  *  be moved Always_Exist area.
  1380.  * PARAMETERS
  1381.  *  id      [IN]        Resource ID
  1382.  * RETURNS
  1383.  *  void
  1384.  *****************************************************************************/
  1385. void mmi_frm_resmem_reg_retain(U16 id)
  1386. {
  1387.     /*----------------------------------------------------------------*/
  1388.     /* Local Variables                                                */
  1389.     /*----------------------------------------------------------------*/
  1390.     U16 i;
  1391.     U8 *mem_addr = NULL, *mem_addr_dst;
  1392.     U32 size;
  1393.     MMI_BOOL ret_bool;
  1395.     /*----------------------------------------------------------------*/
  1396.     /* Code Body                                                      */
  1397.     /*----------------------------------------------------------------*/
  1398.     MMI_FRM_RESMEM_CS_ENTER;
  1399.     /* registration */
  1400.     if (mmi_frm_resmem_if_res_to_always_keep(id) == MMI_FALSE)
  1401.     {
  1402.         for (i = 0; i < MMI_FRM_RESMEM_ALWAYS_EXIST_NUMBER; i++)
  1403.         {
  1404.             if (g_mmi_frm_resmem_cntx.always_keep_ID[i] == MMI_FRM_RESMEM_INVALID_RES_ID)
  1405.             {
  1406.                 g_mmi_frm_resmem_cntx.always_keep_ID[i] = id;
  1407.                 break;
  1408.             }
  1409.         }
  1410.     }
  1412.     /* consider already load in memory */
  1413.     /* alreay in Always Exist area? */
  1414.     if (NULL != mmi_frm_resmem_rec_if_exist(MMI_FRM_RESMEM_TYPE_ALWAYS_EXIST, id, NULL))
  1415.     {
  1416.         /* do nothing */
  1417.         MMI_FRM_RESMEM_CS_LEAVE;
  1418.         return;
  1419.     }
  1421.     /* already in LOD area? */
  1422.     mem_addr = mmi_frm_resmem_rec_if_exist(MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND, id, &size);
  1423.     if (mem_addr != NULL)
  1424.     {
  1425.         /* move to Always Exist area */
  1426.         mem_addr_dst = kal_adm_alloc(g_mmi_frm_resmem_cntx.adm_always_id, size);
  1427.         memcpy(mem_addr_dst, mem_addr, size);
  1428.         g_mmi_frm_resmem_cntx.always_mem_using += size;
  1429.         if (g_mmi_frm_resmem_cntx.always_mem_using > g_mmi_frm_resmem_cntx.always_mem_max_used)
  1430.         {
  1431.             g_mmi_frm_resmem_cntx.always_mem_max_used = g_mmi_frm_resmem_cntx.always_mem_using;
  1432.         }
  1433.         MMI_ASSERT(g_mmi_frm_resmem_cntx.always_mem_max_used < MMI_FRM_RESMEM_POOL_ALWASY_EXIST_SIZE);
  1434.         ret_bool = mmi_frm_resmem_rec_add(MMI_FRM_RESMEM_TYPE_ALWAYS_EXIST, id, mem_addr_dst, size);
  1435.         MMI_ASSERT(ret_bool == MMI_TRUE);
  1437.     #if 0
  1438. /* under construction !*/
  1439. /* under construction !*/
  1440. /* under construction !*/
  1441.     #endif /* 0 */ 
  1442.     }
  1443.     MMI_FRM_RESMEM_CS_LEAVE;
  1444.     return;
  1445. }
  1448. /*****************************************************************************
  1449.  * FUNCTION
  1450.  *  mmi_frm_resmem_dereg_retain
  1451.  * DESCRIPTION
  1452.  *  de-register what resource to be keept without auto-clear at screen change
  1453.  *  Please note that the calling will also clear the memory of specified resource.
  1454.  *  So the allocated pointer, if any, will not valid any more.
  1455.  * PARAMETERS
  1456.  *  id      [IN]        Resource ID
  1457.  * RETURNS
  1458.  *  void
  1459.  *****************************************************************************/
  1460. void mmi_frm_resmem_dereg_retain(U16 id)
  1461. {
  1462.     /*----------------------------------------------------------------*/
  1463.     /* Local Variables                                                */
  1464.     /*----------------------------------------------------------------*/
  1465.     U16 i;
  1466.     U8 *mem_addr;
  1467.     U32 size;
  1469.     /*----------------------------------------------------------------*/
  1470.     /* Code Body                                                      */
  1471.     /*----------------------------------------------------------------*/
  1472.     MMI_FRM_RESMEM_CS_ENTER;
  1473.     for (i = 0; i < MMI_FRM_RESMEM_ALWAYS_EXIST_NUMBER; i++)
  1474.     {
  1475.         if (g_mmi_frm_resmem_cntx.always_keep_ID[i] == id)
  1476.         {
  1477.             g_mmi_frm_resmem_cntx.always_keep_ID[i] = MMI_FRM_RESMEM_INVALID_RES_ID;
  1478.             break;
  1479.         }
  1480.     }
  1482.     /* clear those res de-reg always attribute */
  1483.     mem_addr = mmi_frm_resmem_rec_if_exist(MMI_FRM_RESMEM_TYPE_ALWAYS_EXIST, id, &size);
  1484.     if (mem_addr != NULL)
  1485.     {
  1486.         mmi_frm_resmem_rec_del(MMI_FRM_RESMEM_TYPE_ALWAYS_EXIST, id);
  1487.         g_mmi_frm_resmem_cntx.always_mem_using -= size;
  1488.         kal_adm_free(g_mmi_frm_resmem_cntx.adm_always_id, mem_addr);
  1490.         /* should call this to avoid incorrect displaying because of GDI cache */
  1491.         gdi_image_cache_reset();
  1492.     }
  1494.     MMI_FRM_RESMEM_CS_LEAVE;
  1495.     return;
  1496. }
  1498. /*----------------------------------------------------------------*
  1499.   String resource
  1500.  *----------------------------------------------------------------*/
  1503. /*****************************************************************************
  1504.  * FUNCTION
  1505.  *  mmi_frm_resmem_load_str_suite
  1506.  * DESCRIPTION
  1507.  *  load the specificed string resurce suite into memory.
  1508.  * PARAMETERS
  1509.  *  ptr_ary         [OUT]       Array of memory pointers to string suite
  1510.  *  offset_ary      [IN]        Array of offset positions in flash file
  1511.  *  size_ary        [IN]        Array of size in flash file
  1512.  *  ary_count       [IN]        Number of entries in offset_ary and size_ary
  1513.  * RETURNS
  1514.  *  void
  1515.  *****************************************************************************/
  1516. void mmi_frm_resmem_load_str_suite(U8 **ptr_ary, U32 *offset_ary, U32 *size_ary, U32 ary_count)
  1517. {
  1518.     /*----------------------------------------------------------------*/
  1519.     /* Local Variables                                                */
  1520.     /*----------------------------------------------------------------*/
  1522.     /*----------------------------------------------------------------*/
  1523.     /* Code Body                                                      */
  1524.     /*----------------------------------------------------------------*/
  1525.     MMI_ASSERT(ptr_ary != NULL);
  1526.     MMI_ASSERT(offset_ary != NULL);
  1527.     MMI_ASSERT(size_ary != NULL);
  1528.     MMI_ASSERT(ary_count == 2);
  1530.     /* string content part */
  1531.     NFB_RES_Load(ENFB_CONTENT_STRINGRES, g_mmi_frm_resmem_str_pool, offset_ary[0], size_ary[0]);
  1532.     g_mmi_frm_resmem_cntx.str_content = g_mmi_frm_resmem_str_pool;
  1534.     /* string map part */
  1535.     NFB_RES_Load(ENFB_CONTENT_STRINGRES, g_mmi_frm_resmem_str_pool + size_ary[0], offset_ary[1], size_ary[1]);
  1536.     g_mmi_frm_resmem_cntx.str_map = g_mmi_frm_resmem_str_pool + size_ary[0];
  1538.     ptr_ary[0] = g_mmi_frm_resmem_cntx.str_content;
  1539.     ptr_ary[1] = g_mmi_frm_resmem_cntx.str_map;
  1541.     return;
  1542. }
  1544. #endif /* defined(__MMI_RESOURCE_ENFB_SUPPORT__) */