memory.c

adc 3208 上面实现图片旋转的实例

#include "VGSDKpv.h"
#include <stdlib.h>

#define	INTERNAL_MALLOC

#ifdef	INTERNAL_MALLOC
	#define MALLOC	_vgMalloc
	#define FREE	_vgFree
	void*	_vgMalloc( S32 bytesize );
	void	_vgFree( void *pdata );
#else
	#define MALLOC	malloc
	#define FREE	free
#endif

// **********************************************************************
//	vgMalloc
//	Desc: system memory allocation
// **********************************************************************
void*	vgMalloc( S32 bytesize )
{
	void*	result;
	ASSERTFUNC("vgMalloc");
	ASSERT( 0 < bytesize );

#ifndef _DEBUG
	result = MALLOC( (size_t)bytesize );
#else
	bytesize += 3;
	bytesize -= (bytesize%4);
	result = MALLOC( (size_t)bytesize+12 );
	if( result )
	{
		U32 *front;
		U32 *end;
		front = (U32*)result;
		end   = (U32*)((U8*)result+bytesize+8);
		front[0] = 0xfefeacac;
		front[1] = bytesize+8;
		end[0]   = 0x9d9dcaca;
		
		result = (void*)&front[2];
	}
	else
//zy		uartprintf( "vgMalloc: memory allocate ERROR\n" );
#endif
	return result;
}
// **********************************************************************
//	vgFree
//	Desc: system memory free
// **********************************************************************
void	vgFree( void* const pdata )
{
	ASSERTFUNC("vgFree");
	ASSERT( NULL != pdata );
#ifndef _DEBUG
	FREE( pdata );
#else
	{
		U32 *front;
		U32 *end;
		front = (U32*)pdata-2;
		end   = (U32*)((U8*)front+front[1]);
		ASSERTMSG( 0xfefeacac == front[0], "memory block check error at block start" );
		ASSERTMSG( 0x9d9dcaca == end[0], "memory block check error at block end" );
		FREE( front );
	}
#endif
}

#ifdef	INTERNAL_MALLOC


#define BEST_FIT
S32		vgSYSTEM_MEMORY_MAX_SIZE;
void*	vgSYSTEM_MEMORY;

/*
extern unsigned long bottom_of_stack;
#define BOTTOM_OF_RAM	0x027fffff
void _Init_vgMalloc()
{
	unsigned long heap_addr = (unsigned long)(&bottom_of_stack);
	heap_addr += 16;
	heap_addr &= 0xfffffff0;
	vgSYSTEM_MEMORY = (void*)heap_addr;
	vgSYSTEM_MEMORY_MAX_SIZE = BOTTOM_OF_RAM - heap_addr;

	uartprintf("\n-------------------------\n");
	uartprintf("initialize vgMalloc...\n");
	uartprintf("heap size: %d KBytes \n", vgSYSTEM_MEMORY_MAX_SIZE/1024 );
	uartprintf("---------------------------\n");

	*((S32*)vgSYSTEM_MEMORY) = (vgSYSTEM_MEMORY_MAX_SIZE<<1);	
}
*/
#include <unistd.h>
extern unsigned long end;
#define BOTTOM_OF_RAM	0x027fffff
void _Init_vgMalloc()
{
	S32 heap_size = (S32)(&end);
	heap_size = BOTTOM_OF_RAM - heap_size;
	heap_size -= (256*1025); // stack 康开阑 犬焊
	heap_size &= 0xfffffff0;
	vgSYSTEM_MEMORY = (void*)sbrk(heap_size);
	vgSYSTEM_MEMORY_MAX_SIZE = heap_size;
/*zy
	uartprintf("\n-------------------------\n");
	uartprintf("initialize vgMalloc...\n");
	uartprintf("heap size: %d KBytes \n", vgSYSTEM_MEMORY_MAX_SIZE/1024 );
	uartprintf("---------------------------\n");
*/
	*((S32*)vgSYSTEM_MEMORY) = (vgSYSTEM_MEMORY_MAX_SIZE<<1);	
}

//long malloc_memsize=0;
void*	_vgMalloc( S32 bytesize )
{
	S32	*mcb;
	S32	*bestfit;
	static U32 iscalled=0;
	ASSERTFUNC("vgMalloc");

	if( iscalled==0 )
	{
		_Init_vgMalloc();
		iscalled = 1;
	}
	if( bytesize<=0 )
	{
//zy		uartprintf( "vgMalloc: memory allocate ERROR\n" );
		return NULL;
	}
	
	mcb = (S32*)vgSYSTEM_MEMORY;
	bestfit=NULL;
	
	// 4 byte 沥纺.
	bytesize = (bytesize+3) & 0xfffffffc;
	
//	uartprintf( "vgMalloc: %d", (bytesize+4) );
//	malloc_memsize += (bytesize+4);

	bytesize = (bytesize + sizeof( S32 ))<<1;

	while( ((char*)mcb) - (char*)vgSYSTEM_MEMORY < vgSYSTEM_MEMORY_MAX_SIZE )
	{
		if( ((*mcb)&1) == 0 )
		{
			if( (*mcb) == bytesize )
			{
//				uartprintf( " (%d)\n", ((char*)mcb)-((char*)vgSYSTEM_MEMORY) );

				(*mcb) |= 1;
				return (void*)((char*)mcb + sizeof( S32 ));
			}
			else if( (*mcb) > bytesize ) 
			{
#ifdef	BEST_FIT // best fit
				if( bestfit==NULL ) bestfit = mcb;
				else if( (*bestfit) > *mcb ) bestfit = mcb;
#else // first fit
				bestfit = mcb;
				break;
#endif
			}
		}
		ASSERT( mcb < (S32*)((char*)mcb+(*mcb>>1)) );
		mcb = (S32*)((char*)mcb+(*mcb>>1));
	}

	if( bestfit==NULL )
	{
//zy		uartprintf( "vgMalloc: memory allocate ERROR\n" );
		return NULL;
	}

	if( ((*bestfit-bytesize)>>1) >= sizeof( S32 ) )
	{
		mcb = (S32*)((char*)bestfit + (bytesize>>1));
		
		if( ((char*)mcb) - (char*)vgSYSTEM_MEMORY < vgSYSTEM_MEMORY_MAX_SIZE )
		{
			*mcb = (*bestfit - bytesize);
			*bestfit = bytesize;
		}
	}

//	uartprintf( " (%d)\n", ((char*)bestfit)-((char*)vgSYSTEM_MEMORY) );
	
	*bestfit |= 1;
	return (void*)((char*)bestfit + sizeof( S32 ));
} 

void	_vgFree( void *pdata )
{
	S32	*mcb = (S32*)vgSYSTEM_MEMORY;
	S32	*freeblock = (S32*)((char*)pdata - sizeof(S32));
	S32	*tempmcb;
	ASSERTFUNC("vgFree");
	
//	uartprintf( "vgFree: %d (%d)\n", (*freeblock>>1), ((char*)freeblock)-((char*)vgSYSTEM_MEMORY) );
//	malloc_memsize -= (*freeblock>>1);
	
	*freeblock &= 0xfffffffe;

	tempmcb = (S32*)((char*)freeblock + (*freeblock>>1));
	ASSERT( freeblock < tempmcb );	
	if( ((char*)tempmcb) - (char*)vgSYSTEM_MEMORY < vgSYSTEM_MEMORY_MAX_SIZE )
		if( (*tempmcb&1)==0 )	*freeblock += *tempmcb;

	tempmcb = NULL;
	while( ((char*)mcb) - (char*)vgSYSTEM_MEMORY < vgSYSTEM_MEMORY_MAX_SIZE )
	{
		if( mcb == freeblock ) break;
		tempmcb = mcb;
		ASSERT( mcb < (S32*)((char*)mcb+(*mcb>>1)) );
		mcb = (S32*)((char*)mcb+(*mcb>>1));
	}

	if( tempmcb != NULL )
		if( (*tempmcb&1)==0 ) *tempmcb += *freeblock;
} 

#endif