/**
********************************************************************************
* @fn _ALG_allocMemory(IALG_MemRec memTab[], Int n)
*
* @brief This function allocates the specified number of memory blocks with
* alignment.
*
* @param[in] memTab : Array containing the base address
*
* @param[in] n : Number of Memory instance to be freed
*
* @return TRUE if allocated else FALSE
********************************************************************************
*/
Bool _ALG_allocMemory(IALG_MemRec memTab[], Int n)
{
Int idx;
for (idx = 0; idx < n; idx++)
{
memTab[idx].base = (void *)myMemalign(memTab[idx].alignment,
memTab[idx].size);
if (memTab[idx].base == NULL)
{
_ALG_freeMemory(memTab, idx);
return (FALSE);
}
else
{
if (0 == idx)
{
/* As per xdaised standard, memTab[0] is guaranteed to be
* initialized to zero.
*/
memset(memTab[idx].base,0,memTab[idx].size);
}
}
}
return (TRUE);
}
/*
* ======== ALG_create ========
*/
ALG_Handle ALG_create(IALG_Fxns *fxns, IALG_Handle p, IALG_Params *pParams)
{
IALG_MemRec memTab[ JPEGDEC_MEM_NUMBER ];
Int n;
ALG_Handle alg;
IALG_Fxns *fxnsPtr;
if (fxns != NULL)
{
n = fxns->algNumAlloc != NULL ? fxns->algNumAlloc() : IALG_DEFMEMRECS;
memset( memTab, 0, JPEGDEC_MEM_NUMBER * sizeof( IALG_MemRec ) );
n = fxns->algAlloc(pParams, &fxnsPtr, memTab);
if (( n <= 0 ) )
{
return (NULL);
}
if (_ALG_allocMemory(memTab, n))
{
alg = (IALG_Handle)memTab[0].base;
alg->fxns = fxns;
if (fxns->algInit(alg, memTab, p, pParams) == IALG_EOK)
{
return (alg);
}
fxns->algFree(alg, memTab);
_ALG_freeMemory(memTab, n);
}
}
return (NULL);
}
/*
* ======== ALG_create ========
*/
ALG_Handle ALG_create(IALG_Fxns *fxns, IALG_Handle p, IALG_Params *params)
{
IALG_MemRec *memTab;
Int n;
ALG_Handle alg;
IALG_Fxns *fxnsPtr;
if (fxns != NULL) {
n = fxns->algNumAlloc != NULL ? fxns->algNumAlloc() : IALG_DEFMEMRECS;
if ((memTab = (IALG_MemRec *)malloc(n * sizeof (IALG_MemRec)))) {
n = fxns->algAlloc(params, &fxnsPtr, memTab);
if (n <= 0) {
return (NULL);
}
if (_ALG_allocMemory(memTab, n)) {
alg = (IALG_Handle)memTab[0].base;
alg->fxns = fxns;
if (fxns->algInit(alg, memTab, p, params) == IALG_EOK) {
free(memTab);
return (alg);
}
fxns->algFree(alg, memTab);
_ALG_freeMemory(memTab, n);
}
free(memTab);
}
}
return (NULL);
}
Bool _ALG_allocMemory(IALG_MemRec memTab[], Int n)
{
Int i;
for (i = 0; i < n; i++) {
memTab[i].base = NULL;
allocateMemTabRequest( &memTab[i]);
if (memTab[i].base == NULL) {
_ALG_freeMemory( memTab, n );
return (FALSE);
}
}
return (TRUE);
}
/*
* ======== ALG_delete ========
*/
Void ALG_delete(ALG_Handle alg)
{
IALG_MemRec memTab[ JPEGDEC_MEM_NUMBER ];
Int n;
IALG_Fxns *fxns;
if (alg != NULL && alg->fxns != NULL) {
fxns = alg->fxns;
n = fxns->algNumAlloc != NULL ? fxns->algNumAlloc() : IALG_DEFMEMRECS;
memset( memTab, 0, JPEGDEC_MEM_NUMBER * sizeof( IALG_MemRec ) );
memTab[0].base = alg;
n = fxns->algFree(alg, memTab);
_ALG_freeMemory(memTab, n);
}
}
/*
* ======== ALG_delete ========
*/
Void ALG_delete(ALG_Handle alg)
{
IALG_MemRec *memTab;
Int n;
IALG_Fxns *fxns;
if (alg != NULL && alg->fxns != NULL) {
fxns = alg->fxns;
n = fxns->algNumAlloc != NULL ? fxns->algNumAlloc() : IALG_DEFMEMRECS;
if ((memTab = (IALG_MemRec *)malloc(n * sizeof (IALG_MemRec)))) {
memTab[0].base = alg;
n = fxns->algFree(alg, memTab);
_ALG_freeMemory(memTab, n);
free(memTab);
}
}
}
/*
* ======== _ALG_allocMemory ========
*/
Bool _ALG1_allocMemory(IALG_MemRec memTab[], Int n)
{
Int i;
for (i = 0; i < n; i++) {
memTab[i].base = (void *)CMEM_alloc( memTab[i].size, &memParams);
if (memTab[i].base == NULL) {
_ALG_freeMemory(memTab, i);
return (FALSE);
}
/*------------------------------------------------------------------*/
/* Recommended to work with out memset 0. */
/*------------------------------------------------------------------*/
//memset(memTab[i].base, 0, memTab[i].size);
}
return (TRUE);
}
/**
********************************************************************************
* @fn _ALG_allocMemory(IALG_MemRec memTab[], Int n)
*
* @brief This function allocates the specified number of memory blocks with
* alignment.
*
* @param[in] memTab : Array containing the base address
*
* @param[in] n : Number of Memory instance to be freed
*
* @return TRUE if allocated else FALSE
********************************************************************************
*/
Bool _ALG_allocMemory(IALG_MemRec memTab[], Int n)
{
Int idx;
for (idx = 0; idx < n; idx++)
{
memTab[idx].base = (void *)myMemalign(memTab[idx].alignment,
memTab[idx].size);
if (memTab[idx].base == NULL)
{
_ALG_freeMemory(memTab, idx);
return (FALSE);
}
else
{
/* Nothing to execute*/
}
}
return (TRUE);
}
/*
* ======== _ALG_allocMemory ========
*/
Bool _ALG1_allocMemory(IALG_MemRec memTab[], Int n)
{
Int i;
for (i = 0; i < n; i++) {
#ifdef ON_LINUX
printf("\n memTab[%d].size = %d", i, memTab[i].size);
memTab[i].base = (void *)CMEM_alloc( memTab[i].size, &memParams);
#else
memTab[i].base = (void *)myMemalign(memTab[i].alignment, memTab[i].size);
#endif
if (memTab[i].base == NULL) {
_ALG_freeMemory(memTab, i);
return (FALSE);
}
/*------------------------------------------------------------------*/
/* Recommended to work with out memset 0. */
/*------------------------------------------------------------------*/
//memset(memTab[i].base, 0, memTab[i].size);
}
return (TRUE);
}
