graphic_loader.c

sigmadesign smp8623 gui source code ,bingo

		}
	}

	DGifCloseFile(gif_hdr);

	return RM_OK;
}

static void PrintCacheStatys(RMascii* where)
{
//	entry* np;
////	entryLRU* lp;
//	RMuint32 blocks_till_now = g_OSDwidth + ((g_OSDwidth & 0x3F) ? (64 - (g_OSDwidth & 0x3F)) : 0);
//	blocks_till_now *= g_OSDheight + ((g_OSDheight & 0x3F) ? (64 - (g_OSDheight & 0x3F)) : 0);
//	blocks_till_now *= 10;
//	blocks_till_now /= TILESIZE;
//
//	printf("================ %s =================\n",where);
//	printf("================ Cache Begin =================\n\n");
//	for(np = cache.lh_first; np != NULL; np = np->entries.le_next)
//	{
//		RMuint16 blocks = np->size / TILESIZE;
//		RMuint16 i;
//		for(i = 0; i < blocks; i++)
//		{
//			if(np->freeBlock)
//			{
//				printf(".");
//				blocks_till_now --;
//			} else {
//				if(i == 0)
//				{
//					printf("[");
//					blocks_till_now --;
//				} else if(i == blocks - 1)
//				{
//					printf("]");
//					blocks_till_now --;
//				}
//				else
//				{
//					printf("=");
//					blocks_till_now --;
//				}
//			}
//
//			if(!(blocks_till_now % 48))
//				printf("\n");
//		}
////		printf("block: %p next: %p prev: %p\n", np, np->entries.le_next, np->entries.le_prev);
////		printf("begin: %lu end: %lu: size: %lu free: %d locked %d\n", np->begin, np->end, np->size, np->freeBlock, np->locked);
//	}
//	printf("\n================ Cache End ===================\n");

//	printf("================ LRU Begin ===================\n");
//	for(lp = lru.lh_first; lp != NULL; lp = lp->entries.le_next)
//	{
//		printf("block: %p next: %p prev: %p item: %p\n", lp, lp->entries.le_next, lp->entries.le_prev, lp->item);
////		printf("begin: %d end: %d: size: %d free: %d\n", (RMuint16)np->begin, (RMuint16)np->end, (RMuint16)np->size, np->freeBlock);
//	}
//	printf("================ LRU End =====================\n");
}

RMstatus AllocateBuffer(
	RMdrawBuffer *pBuffer,
	RMuint32 size,
	RMbool locked)
{
	RMstatus status = RM_ERROR;
//	RMuint32 limit;
	RMuint32 innersize;
	entry* np = NULL;

	for(np = cache.lh_first; np != NULL; np = np->entries.le_next)
	{
		if(np->size >= size && np->freeBlock)
		{
			innersize = ((size / TILESIZE) + 1) * TILESIZE;
			if(np->size > innersize) {
				entry* n = (entry*) MALLOC (sizeof(entry));
				entryLRU* nlru = (entryLRU*) MALLOC (sizeof(entryLRU));
				n->begin = np->begin;
		//		printf("%lu %lu %d\n", size, innersize, (RMuint16)((size / TILESIZE) + 1));
				n->end = n->begin + innersize;
				n->size = innersize;
				n->freeBlock = FALSE;
				n->locked = locked;

				pBuffer->baseAddr = n->begin;
				pBuffer->size = size;
				pBuffer->limit = n->end;
				pBuffer->offset = 0;
				pBuffer->pMappedAddr = g_BaseBuffer.pMappedAddr + n->begin - g_BaseBuffer.baseAddr;

				np->begin = n->end;
				np->size = np->size - innersize;
				nlru->item = n;

				LIST_INSERT_HEAD(&lru, nlru, entries);

				if(np == cache.lh_first) {
					LIST_INSERT_HEAD(&cache, n, entries);
				} else
				{
					entry* t = np->entries.le_prev;
		//			printf("%p %p %p %p\n", np->entries.le_prev, t, t->entries.le_next, np);
					LIST_INSERT_AFTER(t, n, entries);

					if(np->size == 0) {
						LIST_REMOVE(&cache, np, entries);
						RFREE(np);
					}
				}
				PrintCacheStatys("Allocate Buffer greater");
				return RM_OK;//break;
			} else {
				entryLRU* nlru = (entryLRU*) MALLOC (sizeof(entryLRU));
				np->freeBlock = FALSE;
				np->locked = locked;

				pBuffer->baseAddr = np->begin;
				pBuffer->size = size;
				pBuffer->limit = np->end;
				pBuffer->offset = 0;
				pBuffer->pMappedAddr = g_BaseBuffer.pMappedAddr + np->begin - g_BaseBuffer.baseAddr;

				nlru->item = np;

				LIST_INSERT_HEAD(&lru, nlru, entries);

				PrintCacheStatys("Allocate Buffer equel");

				return RM_OK;//break;
			}
		}
	}

	if(np == NULL)
		return status;

//	if(g_BaseBuffer.baseAddr){
//		limit = g_BaseBuffer.baseAddr + g_BaseBuffer.offset + size;
//		if(limit > g_BaseBuffer.limit){
//			printf("Could not allocate, missing %ld\n", g_BaseBuffer.limit - limit);
//			return RM_ERROR;
//		}
//
//		pBuffer->baseAddr = g_BaseBuffer.baseAddr + g_BaseBuffer.offset;
//		pBuffer->pMappedAddr = g_BaseBuffer.pMappedAddr + g_BaseBuffer.offset;
//		pBuffer->size = size;
//		pBuffer->limit = limit;
//		pBuffer->offset = 0;
//
//		g_BaseBuffer.offset += size;
//
//		status = RM_OK;
////		printf("Allocated %ld, left %ld\n", size, g_BaseBuffer.size - g_BaseBuffer.offset);
//	}

	return status;
}

RMstatus AllocateBackBuffer(
	struct RUA* pRua,
	RMdrawBuffer *pBaseBuffer,
	RMuint32 size)
{
	RMstatus status;

	if(pBaseBuffer->baseAddr != 0)
		return RM_ERROR;

	RMMemset(pBaseBuffer, 0, sizeof(RMdrawBuffer));

	pBaseBuffer->baseAddr = RUAMalloc(pRua, 0, RUA_DRAM_UNCACHED, size);
	if(pBaseBuffer->baseAddr == 0)
		return RM_ERROR;

	status = RUALock(pRua, pBaseBuffer->baseAddr, size);
	if(RMFAILED(status)){
		RUAFree(pRua, pBaseBuffer->baseAddr);
		return RM_ERROR;
	}

	pBaseBuffer->pMappedAddr = RUAMap(pRua, pBaseBuffer->baseAddr, size);
	if (pBaseBuffer->pMappedAddr == NULL){
		RUAUnLock(pRua, pBaseBuffer->baseAddr, size);
		RUAFree(pRua, pBaseBuffer->baseAddr);
		return RM_ERROR;
	}

	pBaseBuffer->offset = 0;
	pBaseBuffer->limit = pBaseBuffer->baseAddr + size;
	pBaseBuffer->size = size;

	//RMMemcpy(pBaseBuffer, &g_BaseBuffer, sizeof(RMdrawBuffer));

	return RM_OK;
}

RMstatus AllocateBaseBuffer(
	struct RUA* pRua,
	RMdrawBuffer *pBaseBuffer,
	RMuint32 size)
{
	RMstatus status;
	entry* np;

	if(pBaseBuffer->baseAddr != 0)
		return RM_ERROR;

	LIST_INIT(&cache);
	LIST_INIT(&lru);

	RMMemset(&g_BaseBuffer, 0, sizeof(RMdrawBuffer));

	g_BaseBuffer.baseAddr = RUAMalloc(pRua, 0, RUA_DRAM_UNCACHED, size);
	if(g_BaseBuffer.baseAddr == 0)
		return RM_ERROR;

	status = RUALock(pRua, g_BaseBuffer.baseAddr, size);
	if(RMFAILED(status)){
		RUAFree(pRua, g_BaseBuffer.baseAddr);
		return RM_ERROR;
	}

	g_BaseBuffer.pMappedAddr = RUAMap(pRua, g_BaseBuffer.baseAddr, size);
	if (g_BaseBuffer.pMappedAddr == NULL){
		RUAUnLock(pRua, g_BaseBuffer.baseAddr, size);
		RUAFree(pRua, g_BaseBuffer.baseAddr);
		return RM_ERROR;
	}

	np = (entry*) MALLOC(sizeof(entry));
	np->begin = g_BaseBuffer.baseAddr;
	np->end = g_BaseBuffer.baseAddr + size;
	np->size = size;
	np->freeBlock = TRUE;

	RMASSERT(np != NULL);

	LIST_INSERT_HEAD(&cache, np, entries);
//	PrintCacheStatys("Allocate Base Buffer");

	g_BaseBuffer.offset = 0;
	g_BaseBuffer.limit = g_BaseBuffer.baseAddr + size;
	g_BaseBuffer.size = size;

	RMMemcpy(pBaseBuffer, &g_BaseBuffer, sizeof(RMdrawBuffer));

	return RM_OK;
}

RMstatus FreeBackBuffer(struct RUA* pRua, RMdrawBuffer *pBaseBuffer)
{
	// free drawing buffer
	if(pBaseBuffer->baseAddr != 0){
		RUAUnMap(pRua, pBaseBuffer->pMappedAddr, pBaseBuffer->size);
		RUAUnLock(pRua, pBaseBuffer->baseAddr, pBaseBuffer->size);
		RUAFree(pRua, pBaseBuffer->baseAddr);
		pBaseBuffer->baseAddr = 0;

		return RM_OK;
	}

	return RM_ERROR;
}


RMstatus FreeBaseBuffer(struct RUA* pRua)
{
	// free drawing buffer
	if(g_BaseBuffer.baseAddr != 0){
		RUAUnMap(pRua, g_BaseBuffer.pMappedAddr, g_BaseBuffer.size);
		RUAUnLock(pRua, g_BaseBuffer.baseAddr, g_BaseBuffer.size);
		RUAFree(pRua, g_BaseBuffer.baseAddr);
		g_BaseBuffer.baseAddr = 0;

		while (cache.lh_first != NULL)
			{
				entry* n = cache.lh_first;
				LIST_REMOVE(&cache, cache.lh_first, entries);
//				printf("remove: %p\n", n);
				RFREE(n);
			}

			while (lru.lh_first != NULL)
			{
				entryLRU* n = lru.lh_first;
				LIST_REMOVE(&lru, lru.lh_first, entries);
//				printf("remove: %p\n", n);
				RFREE(n);
			}

//			PrintCacheStatys("FreeBaseBuffer");

		return RM_OK;
	}

	return RM_ERROR;
}

RMstatus ResetBuffer(RMdrawBuffer *pBaseBuffer)
{
	entry* n = cache.lh_first->entries.le_next;
	entryLRU* nlru = lru.lh_first;

	while (n->entries.le_next != NULL)
	{
		if(n->begin == pBaseBuffer->baseAddr)
		{
//		if(cache.lh_first->freeBlock) {
			if(n->entries.le_next && n->entries.le_next->freeBlock && n->entries.le_prev && n->entries.le_prev->freeBlock)
			{
				entry* n_end = n->entries.le_next;
				entry* _n = n;
				LIST_REMOVE(&cache, n, entries);
				n->entries.le_prev->end = n->entries.le_next->end;
				n->entries.le_prev->size += n->size + n_end->size;
				LIST_REMOVE(&cache, n_end, entries);

				while(nlru->entries.le_next)
				{
					if(nlru->item == n)
					{
						entryLRU* _nlru = nlru;
						LIST_REMOVE(&lru, nlru, entries);
						nlru = nlru->entries.le_next;
						RFREE(_nlru);
						break;
					}
					nlru = nlru->entries.le_next;
				}

				n = n_end->entries.le_next;
				RFREE(n_end);
				RFREE(_n);
				break;
			}
			else if(n->entries.le_next && n->entries.le_next->freeBlock)
			{
				LIST_REMOVE(&cache, n, entries);
				n->entries.le_next->begin = n->begin;
				n->entries.le_next->size += n->size;
				while(nlru->entries.le_next)
				{
					if(nlru->item == n)
					{
						entryLRU* _nlru = nlru;
						LIST_REMOVE(&lru, nlru, entries);
						nlru = nlru->entries.le_next;
						RFREE(_nlru);
						break;
					}
					nlru = nlru->entries.le_next;
				}
				RFREE(n);
				break;
			}
			else if(n->entries.le_prev && n->entries.le_prev->freeBlock)
			{
				LIST_REMOVE(&cache, n, entries);
				n->entries.le_prev->end = n->end;
				n->entries.le_prev->size += n->size;
				while(nlru->entries.le_next)
				{
					if(nlru->item == n)
					{
						entryLRU* _nlru = nlru;
						LIST_REMOVE(&lru, nlru, entries);
						nlru = nlru->entries.le_next;
						RFREE(_nlru);
						break;
					}
					nlru = nlru->entries.le_next;
				}
				RFREE(n);
				break;
			}
			else
			{
				n->freeBlock = TRUE;
				while(nlru->entries.le_next)
				{
					if(nlru->item == n)
					{
						entryLRU* _nlru = nlru;
						LIST_REMOVE(&lru, nlru, entries);
						nlru = nlru->entries.le_next;
						RFREE(_nlru);
						break;
					}
					nlru = nlru->entries.le_next;
				}
				break;
			}
		}

		n = n->entries.le_next;
	}

	PrintCacheStatys("Reset Buffer");

	return RM_OK;
}

RMstatus ResetBaseBuffer(RMdrawBuffer *pBaseBuffer)
{
	RMMemcpy(&g_BaseBuffer, pBaseBuffer, sizeof(RMdrawBuffer));

//	PrintCacheStatys("Reset Base Buffer");

	while (cache.lh_first->entries.le_next != NULL)
	{
		entry* n = cache.lh_first->entries.le_next;
		LIST_REMOVE(&cache, n, entries);
//		if(cache.lh_first->freeBlock) {
			cache.lh_first->end = n->end;
			cache.lh_first->size += n->size;
			cache.lh_first->freeBlock = TRUE;
			cache.lh_first->locked = FALSE;
//		}

		RFREE(n);
//		PrintCacheStatys("Reset Base Buffer");
	}

	while (lru.lh_first != NULL)
	{
			entryLRU* n = lru.lh_first;
			LIST_REMOVE(&lru, lru.lh_first, entries);
//			printf("remove: %p\n", n);
			RFREE(n);
	}

//	PrintCacheStatys("Reset Base Buffer");

	return RM_OK;
}

void UpdateCache(RMuint8 i)
{
	entryLRU* nlru = lru.lh_first;

//	printf("bitmap base addres: %lu\n", g_bitmaps[i].pBmpAddr);

	while(nlru->entries.le_next)
	{
		if(nlru->item->begin == g_bitmaps[i].pBmpAddr)
			break;

		nlru = nlru->entries.le_next;
	}

	if(i == 0)
		nlru->item->locked = TRUE;

//	if(nlru == NULL)
//		RMASSERT(FALSE);

	LIST_REMOVE(&lru, nlru, entries);
	LIST_INSERT_HEAD(&lru, nlru, entries);

//	PrintCacheStatys("UpdateCache");

}

void CacheFlush()
{
	entry* n = cache.lh_first;
	entryLRU* l = lru.lh_first;


	printf("CACHE FLUSH!!!!!! \n");

	while (n->entries.le_next != NULL)
	{
		if(n->entries.le_next->locked) {
			n->freeBlock = TRUE;
			n = n->entries.le_next;
		} else {
			entry* t = n->entries.le_next;
			LIST_REMOVE(&cache, t, entries);
	//			if(cache.lh_first->freeBlock) {
			n->end = t->end;
			n->size += t->size;
			n->freeBlock = TRUE;
			n->locked = FALSE;
	//		}

			RFREE(t);

			if(n->entries.le_next != NULL)
				n = n->entries.le_next;
			else
				break;
		}
	//		PrintCacheStatys("Reset Base Buffer");
	}
	printf("CACHE FLUSH!!!!!! \n");

	while (l->entries.le_next != NULL)
	{
		if(l->item->locked)
		{
			l = l->entries.le_next;
		} else {
			entryLRU* t = l;
			l = l->entries.le_next;

			LIST_REMOVE(&lru, t, entries);
	//			printf("remove: %p\n", n);
			RFREE(t);
		}
	}
	printf("CACHE FLUSH!!!!!! \n");
}

RMstatus FindFreeSpace(RMuint32 size, RMuint8* newindex)
{
	entryLRU* nlru = lru.lh_first;
	RMint8 i;