resmemmgr.c

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

    {
        MMI_ASSERT(0);
        exit(1);
    }
    SetFilePointer(hFile, offset, NULL, FILE_BEGIN);
    ret = ReadFile(hFile, dst_addr, (DWORD) length, &bytesRead, NULL);

    CloseHandle(hFile);

    return TRUE;
}


/*****************************************************************************
 * FUNCTION
 *  NFB_RES_Loadv
 * DESCRIPTION
 *  
 * PARAMETERS
 *  cid                 [IN]        
 *  scatter             [?]         [?]
 *  scatter_number      [IN]        
 * RETURNS
 *  
 *****************************************************************************/
static kal_bool NFB_RES_Loadv(kal_uint8 cid, enfb_scatter *scatter, kal_uint32 scatter_number)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U8 i;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    for (i = 0; i < scatter_number; i++)
    {
        NFB_RES_Load(cid, scatter[i].dst_addr, scatter[i].offset, scatter[i].length);
    }

    return TRUE;
}

#endif /* !defined(__MTK_TARGET__) */ 

#ifdef MMI_ON_WIN32


/*****************************************************************************
 * FUNCTION
 *  kal_adm_create
 * DESCRIPTION
 *  
 * PARAMETERS
 *  mem_addr            [?]         [?]
 *  size                [IN]        
 *  subpool_size        [?]         [?]
 *  islogging           [IN]        
 * RETURNS
 *  
 *****************************************************************************/
static KAL_ADM_ID kal_adm_create(void *mem_addr, kal_uint32 size, kal_uint32 *subpool_size, kal_bool islogging)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    static int make_compiler_happy = 1;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    return &make_compiler_happy;
}


/*****************************************************************************
 * FUNCTION
 *  kal_adm_free
 * DESCRIPTION
 *  
 * PARAMETERS
 *  adm_id          [IN]        
 *  mem_addr        [?]         [?]
 * RETURNS
 *  void
 *****************************************************************************/
static void kal_adm_free(KAL_ADM_ID adm_id, void *mem_addr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    free(mem_addr);
    return;
}


/*****************************************************************************
 * FUNCTION
 *  kal_adm_internal_alloc
 * DESCRIPTION
 *  
 * PARAMETERS
 *  adm_id          [IN]        
 *  size            [IN]        
 *  filename        [?]         [?]
 *  line            [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
static void *kal_adm_internal_alloc(KAL_ADM_ID adm_id, kal_uint32 size, char *filename, kal_uint32 line)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    return malloc(size);
}


/*****************************************************************************
 * FUNCTION
 *  kal_adm_delete
 * DESCRIPTION
 *  
 * PARAMETERS
 *  adm_id      [IN]        
 * RETURNS
 *  
 *****************************************************************************/
static kal_status kal_adm_delete(KAL_ADM_ID adm_id)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    return KAL_SUCCESS;
}
#endif /* MMI_ON_WIN32 */ 


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_resmem_rec_add
 * DESCRIPTION
 *  add record of resource memory occupation
 * PARAMETERS
 *  mem_type        [IN]        Memory type
 *  id              [IN]        Resource ID
 *  ptr             [IN]        Pointer to resource in RAM
 *  size            [IN]        Size of the resource
 * RETURNS
 *  When succeed MMI_TRUE; otherwise MMI_FALSE
 *****************************************************************************/
static MMI_BOOL mmi_frm_resmem_rec_add(mmi_frm_resmem_enum mem_type, U16 id, U8 *ptr, U32 size)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U16 i, number = 0;
    mmi_frm_resmem_alloc_struct *rec = NULL;

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

    if (mem_type == MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND)
    {
        number = MMI_FRM_RESMEM_LOAD_ON_DEMAND_NUMBER;
        rec = g_mmi_frm_resmem_cntx.lod_ary[g_mmi_frm_resmem_cntx.lod_active_screen];
    }
    else if (mem_type == MMI_FRM_RESMEM_TYPE_ALWAYS_EXIST)
    {
        number = MMI_FRM_RESMEM_ALWAYS_EXIST_NUMBER;
        rec = g_mmi_frm_resmem_cntx.always_ary;
    }
    else
    {
        MMI_ASSERT(0);
    }

    for (i = 0; i < number; i++, rec++)
    {
        if (rec->mem_ptr == NULL)
        {
            MMI_ASSERT(rec->id == MMI_FRM_RESMEM_INVALID_RES_ID);
            rec->id = id;
            rec->mem_ptr = ptr;
            rec->size = size;
            return MMI_TRUE;
        }
    }

    /* empty item is no found. Call the module's owner to handle this situation */
    MMI_ASSERT(0);

    return MMI_FALSE;
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_resmem_rec_del
 * DESCRIPTION
 *  init the module
 * PARAMETERS
 *  mem_type        [IN]        Memory type
 *  id              [IN]        Resource ID
 * RETURNS
 *  resource pointer; NULL if no record allocated
 *****************************************************************************/
static U8 *mmi_frm_resmem_rec_del(mmi_frm_resmem_enum mem_type, U16 id)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U16 i, number = 0;
    mmi_frm_resmem_alloc_struct *rec = NULL;
    U8 *ret_ptr;

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

    if (mem_type == MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND)
    {
        number = MMI_FRM_RESMEM_LOAD_ON_DEMAND_NUMBER;
        rec = g_mmi_frm_resmem_cntx.lod_ary[g_mmi_frm_resmem_cntx.lod_active_screen];
    }
    else if (mem_type == MMI_FRM_RESMEM_TYPE_ALWAYS_EXIST)
    {
        number = MMI_FRM_RESMEM_ALWAYS_EXIST_NUMBER;
        rec = g_mmi_frm_resmem_cntx.always_ary;
    }
    else
    {
        MMI_ASSERT(0);
    }

    for (i = 0; i < number; i++, rec++)
    {
        if (rec->id == id)
        {
            rec->id = MMI_FRM_RESMEM_INVALID_RES_ID;
            ret_ptr = rec->mem_ptr;
            rec->mem_ptr = NULL;
            return ret_ptr;
        }
    }
    return NULL;
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_resmem_rec_del_one
 * DESCRIPTION
 *  delete one record of resource memory occupation, if available
 * PARAMETERS
 *  mem_type            [IN]        Memory type
 *  which_screen        [IN]        Which screen, indentifying what managment table to do the deleting. only valid for LOD
 *  id                  [OUT]       Which ID. If not interested, pass in NULL
 * RETURNS
 *  resource pointer; NULL if no record allocated
 *****************************************************************************/
static U8 *mmi_frm_resmem_rec_del_one(mmi_frm_resmem_enum mem_type, U16 which_screen, U16 *id)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U16 i, number = 0;
    mmi_frm_resmem_alloc_struct *rec = NULL;
    U8 *ret_ptr;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (mem_type == MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND)
    {
        MMI_ASSERT(which_screen < MMI_FRM_RESMEM_LOAD_ON_DEMAND_SCREEN_NUMBER);
        number = MMI_FRM_RESMEM_LOAD_ON_DEMAND_NUMBER;
        rec = g_mmi_frm_resmem_cntx.lod_ary[which_screen];
    }
    else if (mem_type == MMI_FRM_RESMEM_TYPE_ALWAYS_EXIST)
    {
        number = MMI_FRM_RESMEM_ALWAYS_EXIST_NUMBER;
        rec = g_mmi_frm_resmem_cntx.always_ary;
    }
    else
    {
        MMI_ASSERT(0);
    }

    /* TBD. enhance performance */
    for (i = 0; i < number; i++, rec++)
    {
        if (rec->id != MMI_FRM_RESMEM_INVALID_RES_ID)
        {
            MMI_ASSERT(rec->mem_ptr != NULL);

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


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_resmem_rec_if_exist
 * DESCRIPTION
 *  query whether the resource is existing in memory based on records
 * PARAMETERS
 *  flag        [IN]        Bit-wise flag: combination of MMI_FRM_RESMEM_MEMORY_LOAD_ON_DEMAND, MMI_FRM_RESMEM_MEMORY_ALWAYS_EXIST
 *  id          [IN]        Resource ID
 *  size        [OUT]       Place to receive resource size. It not of interest, pass in NULL
 * RETURNS
 *  if exist, return the memory pointer; otherwise, NULL
 *****************************************************************************/
static U8 *mmi_frm_resmem_rec_if_exist(U32 flag, U16 id, U32 *size)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U16 j, i, number;
    mmi_frm_resmem_alloc_struct *rec;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_ASSERT((flag & (~(MMI_FRM_RESMEM_TYPE_ALWAYS_EXIST | MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND))) == 0);
    MMI_ASSERT(id != MMI_FRM_RESMEM_INVALID_RES_ID);

    for (j = 0;; j++)
    {
        if (j == 0)
        {
            if (flag & MMI_FRM_RESMEM_TYPE_ALWAYS_EXIST)
            {
                number = MMI_FRM_RESMEM_ALWAYS_EXIST_NUMBER;
                rec = g_mmi_frm_resmem_cntx.always_ary;
            }
            else
            {
                continue;
            }
        }
        else if (j == 1)
        {
            if (flag & MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND)
            {
                number = MMI_FRM_RESMEM_LOAD_ON_DEMAND_NUMBER;
                rec = g_mmi_frm_resmem_cntx.lod_ary[g_mmi_frm_resmem_cntx.lod_active_screen];
            }
            else
            {
                continue;
            }
        }
        else
        {
            /* not found */
            break;
        }

        for (i = 0; i < number; i++, rec++)
        {