resmemmgr.c

MTK手机平台的MMI部分的源代码

            if (rec->id == id)
            {
                if (size != NULL)
                {
                    *size = rec->size;
                }
                return rec->mem_ptr;
            }
        }
    }
    return NULL;
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_resmem_if_res_to_always_keep
 * DESCRIPTION
 *  query whether to keep the specified resource
 * PARAMETERS
 *  id      [IN]        Resource ID
 * RETURNS
 *  MMI_TRUE if necessary
 *****************************************************************************/
static MMI_BOOL mmi_frm_resmem_if_res_to_always_keep(U16 id)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U16 i;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    for (i = 0; i < MMI_FRM_RESMEM_ALWAYS_EXIST_NUMBER; i++)
    {
        if (g_mmi_frm_resmem_cntx.always_keep_ID[i] == id)
        {
            return MMI_TRUE;
        }
    }

    return MMI_FALSE;
}

#ifdef MMI_FRM_RESMEM_UNIT_TEST


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_resmem_unit_test
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_frm_resmem_unit_test(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U8 *ptr;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    mmi_frm_resmem_init();

    /* test case: load single image */
    {
        ptr = mmi_frm_resmem_if_ramed(2);
        mmi_frm_resmem_load_single_image(2, 2000, 22);
        mmi_frm_resmem_load_single_image(4, 4000, 444);
        mmi_frm_resmem_load_single_image(5, 5000, 5555);
        ptr = mmi_frm_resmem_load_single_image(4, 4000, 444);
        ptr = mmi_frm_resmem_if_ramed(2);
    }

    /* test case: reset LOD memory */
    {
        mmi_frm_resmem_reset(MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND);
        ptr = mmi_frm_resmem_if_ramed(2);
    }

    /* test case: load array image */
    {
        static mmi_frm_resmem_res_info_struct info_array[10];

        ptr = mmi_frm_resmem_if_ramed(7);
        info_array[0].id = 1;
        info_array[0].offset = 1000;
        info_array[0].size = 111;
        info_array[1].id = 2;
        info_array[1].offset = 2000;
        info_array[1].size = 222;
        info_array[2].id = 7;
        info_array[2].offset = 7000;
        info_array[2].size = 777;
        info_array[3].id = 8;
        info_array[3].offset = 8000;
        info_array[3].size = 888;
        ptr = mmi_frm_resmem_load_multi_image(7, info_array, 4);
        ptr = mmi_frm_resmem_if_ramed(7);
    }

    /* test case: load single image */
    {
        U16 i;

        ptr = mmi_frm_resmem_if_ramed(15);
        for (i = 1; i < 20; i++)
        {
            mmi_frm_resmem_load_single_image(i, i * 20, i * 20);
        }
        ptr = mmi_frm_resmem_if_ramed(10);
    }

    /* test case: load image to Always Exist area */
    {
        U16 i;

        ptr = mmi_frm_resmem_if_ramed(21);
        for (i = 10; i < 30; i++)
        {
            mmi_frm_resmem_reg_retain(i);
            mmi_frm_resmem_load_single_image(i, i * 20, i * 20);
        }
        ptr = mmi_frm_resmem_if_ramed(21);
    }

    /* test case: remove image from Always Exist area */
    {
        U16 i;

        ptr = mmi_frm_resmem_if_ramed(21);
        for (i = 10; i < 30; i++)
        {
            mmi_frm_resmem_dereg_retain(i);
        }
        ptr = mmi_frm_resmem_if_ramed(21);
    }
    return;
}
#endif /* MMI_FRM_RESMEM_UNIT_TEST */ 

/*****************************************************************************              
 * Extern Global Variable                                                                    
 *****************************************************************************/

/*****************************************************************************              
 * Extern Global Function                                                                    
 *****************************************************************************/


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_resmem_init
 * DESCRIPTION
 *  init the module
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_frm_resmem_init(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U16 i, j;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    memset(&g_mmi_frm_resmem_cntx, 0, sizeof(mmi_frm_resmem_context_struct));

    /* init ID table */
    for (j = 0; j < MMI_FRM_RESMEM_LOAD_ON_DEMAND_SCREEN_NUMBER; j++)
    {
        for (i = 0; i < MMI_FRM_RESMEM_LOAD_ON_DEMAND_NUMBER; i++)
        {
            g_mmi_frm_resmem_cntx.lod_ary[j][i].id = MMI_FRM_RESMEM_INVALID_RES_ID;
        }
    }
    for (i = 0; i < MMI_FRM_RESMEM_ALWAYS_EXIST_NUMBER; i++)
    {
        g_mmi_frm_resmem_cntx.always_ary[i].id = MMI_FRM_RESMEM_INVALID_RES_ID;
    }

    /* init retain-ID registration table */
    for (i = 0; i < MMI_FRM_RESMEM_ALWAYS_EXIST_NUMBER; i++)
    {
        g_mmi_frm_resmem_cntx.always_keep_ID[i] = MMI_FRM_RESMEM_INVALID_RES_ID;
    }

    /* init malloc record table */
    for (i = 0; i < MMI_FRM_RESMEM_LOAD_ON_DEMAND_SCREEN_NUMBER; i++)
    {
        g_mmi_frm_resmem_cntx.adm_lod_id[i] = kal_adm_create(
                                                g_mmi_frm_resmem_lod_pool[i],
                                                MMI_FRM_RESMEM_POOL_LOD_ON_DEMAND_SIZE,
                                                (kal_uint32*) g_mmi_frm_resmem_mem_pool_chunk_size,
                                                KAL_TRUE);
        MMI_ASSERT(g_mmi_frm_resmem_cntx.adm_lod_id[i] != (KAL_ADM_ID) NULL);
    }

    g_mmi_frm_resmem_cntx.adm_always_id = kal_adm_create(
                                            g_mmi_frm_resmem_always_pool,
                                            MMI_FRM_RESMEM_POOL_ALWASY_EXIST_SIZE,
                                            (kal_uint32*) g_mmi_frm_resmem_mem_pool_chunk_size,
                                            KAL_TRUE);
    MMI_ASSERT(g_mmi_frm_resmem_cntx.adm_always_id != (KAL_ADM_ID) NULL);

    g_mmi_frm_resmem_cntx.lod_active_screen = 0;

#if !defined(__MTK_TARGET__)
#if !defined(MMI_ON_WIN32)
    FS_SanityCheck();
#endif 
#endif /* !defined(__MTK_TARGET__) */ 

    return;
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_resmem_if_ramed
 * DESCRIPTION
 *  check whether the memory of the specificed resurce is existing in memory.
 * PARAMETERS
 *  id      [IN]        Resource ID
 * RETURNS
 *  if exist, the pointer of RAM ; otherwise, NULL
 *****************************************************************************/
U8 *mmi_frm_resmem_if_ramed(U16 id)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U8 *ret;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_FRM_RESMEM_CS_ENTER;
    MMI_ASSERT(id != MMI_FRM_RESMEM_INVALID_RES_ID);

    ret = mmi_frm_resmem_rec_if_exist((MMI_FRM_RESMEM_TYPE_ALWAYS_EXIST | MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND), id, NULL);
    MMI_FRM_RESMEM_CS_LEAVE;
    return ret;
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_resmem_load_single_image
 * DESCRIPTION
 *  load the specificed resurce into memory.
 * PARAMETERS
 *  id          [IN]        Resource ID
 *  offset      [IN]        Offset in bin
 *  size        [IN]        Resource size
 * RETURNS
 *  memory pointer; NULL if not successful
 *****************************************************************************/
U8 *mmi_frm_resmem_load_single_image(U16 id, U32 offset, U32 size)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U32 buf_size;
    U8 *ret_ptr = NULL;
    kal_bool kal_rslt;
    KAL_ADM_ID adm_id;
    MMI_BOOL ret_bool;
    mmi_frm_resmem_enum mem_type;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_FRM_RESMEM_CS_ENTER;

    MMI_ASSERT(id != MMI_FRM_RESMEM_INVALID_RES_ID);
    MMI_ASSERT(size != 0);

    /* PC-Simulator did not call thie init as expected, so do here again */
#if !defined(__MTK_TARGET__)
#if defined(MMI_ON_WIN32)
    if (g_mmi_frm_resmem_cntx.adm_always_id == (KAL_ADM_ID) NULL)
    {
        mmi_frm_resmem_init();
    }
#endif /* defined(MMI_ON_WIN32) */ 
#endif /* !defined(__MTK_TARGET__) */ 

    /* check whether already exist in RAM */
    ret_ptr = mmi_frm_resmem_if_ramed(id);
    if (ret_ptr != NULL)
    {
        MMI_FRM_RESMEM_CS_LEAVE;
        return ret_ptr;
    }

    /* decide which kind of memory */
    if (mmi_frm_resmem_if_res_to_always_keep(id) == MMI_TRUE)
    {
        mem_type = MMI_FRM_RESMEM_TYPE_ALWAYS_EXIST;
        adm_id = g_mmi_frm_resmem_cntx.adm_always_id;
    }
    else
    {
        mem_type = MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND;
        adm_id = g_mmi_frm_resmem_cntx.adm_lod_id[g_mmi_frm_resmem_cntx.lod_active_screen];
    }

    MMI_ASSERT(adm_id != (KAL_ADM_ID) NULL);

    /* allocate RAM block */
    buf_size = size;
#if defined(MMI_FRM_RESMEM_DEBUG_DANGLING_POINTER)
    buf_size = (buf_size >= MMI_FRM_RESMEM_SPOT_ICON_RESERVED_SIZE ? buf_size : MMI_FRM_RESMEM_SPOT_ICON_RESERVED_SIZE);
#endif 
    ret_ptr = kal_adm_alloc(adm_id, buf_size);
    /* Check memory alloc success or not. 
       If assertion failure here, maybe result from
       - image/animation/video size increased, or
       - more images are added in one screen, or
       - mmi_frm_resmem_reset() is not called when screen change, or
       - macro MMI_FRM_RESMEM_POOL_LOD_ON_DEMAND_SIZE value is too small */
    MMI_ASSERT(ret_ptr != NULL);
    /* 4-byte alignment for GDI API requirement, at least necessary for target */
    MMI_ASSERT(((U32) ret_ptr & 0x00000003) == 0);

    if (mem_type == MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND)
    {
        g_mmi_frm_resmem_cntx.lod_mem_using += buf_size;
        if (g_mmi_frm_resmem_cntx.lod_mem_using > g_mmi_frm_resmem_cntx.lod_mem_max_used)
        {
            g_mmi_frm_resmem_cntx.lod_mem_max_used = g_mmi_frm_resmem_cntx.lod_mem_using;
            MMI_ASSERT(g_mmi_frm_resmem_cntx.lod_mem_max_used < MMI_FRM_RESMEM_POOL_LOD_ON_DEMAND_SIZE);
        }
    }
    else
    {
        g_mmi_frm_resmem_cntx.always_mem_using += buf_size;
        if (g_mmi_frm_resmem_cntx.always_mem_using > g_mmi_frm_resmem_cntx.always_mem_max_used)
        {
            g_mmi_frm_resmem_cntx.always_mem_max_used = g_mmi_frm_resmem_cntx.always_mem_using;
            MMI_ASSERT(g_mmi_frm_resmem_cntx.always_mem_max_used < MMI_FRM_RESMEM_POOL_ALWASY_EXIST_SIZE);
        }
    }

    /* load via driver */
    kal_rslt = NFB_RES_Load(ENFB_CONTENT_IMAGERES, (void*)ret_ptr, offset, size);
    MMI_ASSERT(kal_rslt == KAL_TRUE);
    if (kal_rslt == KAL_FALSE)
    {
        kal_adm_free(adm_id, ret_ptr);
        ret_ptr = NULL;
        MMI_FRM_RESMEM_CS_LEAVE;
        return NULL;
    }

    /* update managment records */
    ret_bool = mmi_frm_resmem_rec_add(mem_type, id, ret_ptr, size);
    MMI_ASSERT(ret_bool == MMI_TRUE);

    MMI_FRM_RESMEM_CS_LEAVE;
    return ret_ptr;
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_resmem_load_multi_image
 * DESCRIPTION
 *  load the specificed resurce into memory. Since the resource in in a
 *  multi-res pack, it is better to one, rather than multiple, access to ROM.
 * PARAMETERS
 *  id              [IN]        Resource ID
 *  info_array      [IN]        Array the stores the resource-pack info, which allows single access
 *  res_cnt         [IN]        The number of resource in info_array
 * RETURNS
 *  memory pointer; NULL if not successful