graphic_loader.c

sigmadesign smp8623 gui source code ,bingo

	}

	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;

	//find last item
	while(nlru->entries.le_next)
	{
		nlru = nlru->entries.le_next;
	}

//	do
//	{
//		if(nlru->item->size < size)
//		{
//			nlru = nlru->entries.le_prev;
//			printf("next\n");
//			printf("item size: %lu", nlru->item->size);
//			if(nlru->item == cache.lh_first)
//			{
//					return RM_ERROR;
//			}
//			else{
//				entry* prev = (nlru->item->entries.le_prev);
//
//				for(i = 0; i < MAX_BITMAPS; i ++)
//				{
//					if(g_bitmaps[i].pBmpAddr == prev->begin)
//					{
//						RMMemset(&g_bitmaps[i], 0, sizeof(RMbitmapdata));
//						*newindex = i;
//						break;
//					}
//				}
//
//				prev->end = nlru->item->end;
//				prev->size += nlru->item->size;
//				prev->entries.le_next = nlru->item->entries.le_next;
//				LIST_REMOVE(&cache, nlru->item, entries);
//				RFREE(nlru->item);
//				printf("item size: %lu", prev->size);
//				nlru->item = prev;
//			}
//		} else {
//			printf("clear\n");
//
//		}
//	} while (nlru->item->size < size);
//again:
	while((nlru->entries.le_prev && nlru->item->size < size) || (nlru->item->locked))
	{
		if(nlru == lru.lh_first && nlru->item->size < size)
			return RM_ERROR;

		nlru = nlru->entries.le_prev;
	}

//	RMASSERT( nlru != lru.lh_first);

//	{
//		RMuint32 innersize = ((size / TILESIZE) + 1) * TILESIZE;
//		if(innersize < nlru->item->size)
//		{
//			printf("size: %lu, innersize %lu\n", nlru->item->size, innersize);
//			if(nlru->item->entries.le_next && nlru->item->entries.le_next->freeBlock) {
//				nlru->item->size = innersize;
//				nlru->item->end = nlru->item->begin + innersize;
//				nlru->item->entries.le_next->begin = nlru->item->end;
//				nlru->item->entries.le_next->size = nlru->item->entries.le_next->end - nlru->item->entries.le_next->begin;
//
//			} else {
//				entry* np = (entry*) MALLOC(sizeof(entry));
//
//				nlru->item->size = innersize;
//				np->end = nlru->item->end;
//				nlru->item->end = nlru->item->begin + innersize;
//				np->begin = nlru->item->end;
//				np->freeBlock = TRUE;
//				np->locked = FALSE;
//				np->size = np->end - np->begin;
//
//				LIST_INSERT_AFTER(nlru->item, np, entries);
//
//			}
//		}
//	}

	for(i = 0; i < MAX_BITMAPS; i ++)
	{
		if(g_bitmaps[i].pBmpAddr == nlru->item->begin)
		{
			printf("%s\n", g_bitmaps[i].path);
			RMMemset(&g_bitmaps[i], 0, sizeof(RMbitmapdata));
			nlru->item->freeBlock = TRUE;
			*newindex = i;
			break;
		}
	}

//	if(i > MAX_BITMAP)


	printf("new index is: %d size %lu\n", *newindex, nlru->item->size);

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

	return RM_OK;
}

RMstatus ResetUsedBuffer(RMuint32 offset)
{
//	if(g_BaseBuffer.offset > offset){
///		g_BaseBuffer.offset -= offset;
//		return RM_OK;
//	}
	entryLRU* lp;
	entry* np;

	for(np = cache.lh_first; np != NULL; np = np->entries.le_next)
	{
		if(np->begin != g_bitmaps[0].pBmpAddr && np->locked == FALSE) {
			np->freeBlock = TRUE;

			if(np->entries.le_prev && np->entries.le_prev->freeBlock) {
				entry* t = np;

				np->entries.le_prev->end = np->end;
				np->entries.le_prev->size += np->size;
				np->entries.le_prev->locked = FALSE;

				np = np->entries.le_prev;
				LIST_REMOVE(&cache, t, entries);
				RFREE(t);

			}
		}
	}

	lp = lru.lh_first;

	while(lp->entries.le_next) {
		entryLRU* t = lp;
		lp = lp->entries.le_next;

		if(t->item->begin != g_bitmaps[0].pBmpAddr)
		{
			LIST_REMOVE(&lru, t, entries);
			RFREE(t);
		}
	}

	PrintCacheStatys("Reset Used Buffer");

	return RM_ERROR;
}

RMbool CanReuseBuffer(
	RMuint32 used,
	RMuint32 needed)
{
	RMuint32 limit;

	if(g_BaseBuffer.baseAddr){
		limit = g_BaseBuffer.baseAddr + g_BaseBuffer.offset - used + needed;
		return (limit <= g_BaseBuffer.limit);
	}
	return FALSE;
}

RMstatus convertCodepage(RMascii *text)
{
	RMascii tempString[MAX_STR_LENGTH];
	RMuint8 position = 0;
	RMuint8 skipBytes = 0;
	RMuint8 i;

	for(i=0; i < strlen(text); i++){
		if(skipBytes != 0){
			skipBytes--;
		}
		else{
			if((RMuint8)text[i] > 0x80){
				if((text[i] & 0xe0) == 0xc0){
					tempString[position] = (((text[i] - 0xc0)<<6) + (text[i+1] - 0x80));
					skipBytes = 1;
				}//3 byte Chars are not yet supported (only 2 byte special chars. (1 byte chars are passed thru)
			}
			else{
				tempString[position] = text[i];
			}
			position++;
		}
	}
	tempString[position] = '\0';

	//fprintf(stderr, "Original string: %s, length: %ld\n", text, strlen(text));
	//fprintf(stderr, "Converted string: %s, length: %ld\n", tempString, strlen(tempString));

	RMCopyAscii(text, tempString);

	return RM_OK;
}