/********************** BEGIN LICENSE BLOCK ************************************
 *
 * JZ4740  mobile_tv  Project  V1.0.0
 * INGENIC CONFIDENTIAL--NOT FOR DISTRIBUTION IN SOURCE CODE FORM
 * Copyright (c) Ingenic Semiconductor Co. Ltd 2005. All rights reserved.
 * 
 * This file, and the files included with this file, is distributed and made 
 * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
 * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
 * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
 * 
 * http://www.ingenic.cn 
 *
 ********************** END LICENSE BLOCK **************************************
 *
 *  Author: <dsqiu@ingenic.cn> <hlyu@ingenic.cn>
 *
 *  Create:   2008-03-04, by dsqiu
 *  Maintain: 2008-06-23, by hlyu
 *            
 *******************************************************************************
 */

#include <string.h>
extern void *Module_alignAlloc(unsigned int align,unsigned int n);
#include "LocalMemMgr.h"


#define CXIMAGE_MEM_SIZE (0.8 * 1024 * 1024)

//#define MP_USER_DRIVER_MEM 0
/*
#if MP_USER_DRIVER_MEM
#define iv_memalign(x,y) alignAlloc(x,y)
#define iv_free(x) deAlloc(x)
#else
*/
#define iv_memalign(x,y) Module_alignAlloc(x,y)
#define iv_free(x) GM_Dealloc(x)
//#endif  


char *iv_memory = NULL;
#define RESEVER_MEM_SIZE (1024) 
static unsigned int get_max_mem()     
{
	int init_mem = CXIMAGE_MEM_SIZE;
	int init_len = CXIMAGE_MEM_SIZE;
	char *mem;
	while(init_len)
	{
		mem = (char *)iv_memalign(32,init_mem);
		if(mem)
		{
			iv_free(mem);
			mem = NULL;
		  if(init_len < RESEVER_MEM_SIZE)
				break;
		  init_mem += init_len;	
		}else
		{
			init_mem -= init_len;
			init_len /= 2;
			init_mem -= init_len;  
		}	
		
		printf("11:%x %x\n",init_mem,init_len);
	}
	if(mem)
		iv_free(mem);
	printf("\n************************************\n");
	printf("    Available mem = %d\n",init_mem);
	printf("\n************************************\n");
	return init_mem;
	
}

int iv_memory_init(int mode)
{
	unsigned int mem_len = 0;
	if(mode == 0)
	{
		iv_memory = (char *)iv_memalign(32,CXIMAGE_MEM_SIZE);
		mem_len = CXIMAGE_MEM_SIZE;
		if(iv_memory == NULL)
		{	
			printf("no alloc mem!\n");
			return 0;
		}
	}
	if(mode == 1)
	{
		Module_EnterExt();
		mem_len = get_max_mem();
		iv_memory = (char *)iv_memalign(32,mem_len);
		if(iv_memory == NULL)
		{
			printf("no alloc mem!\n");	
			return 0;
		}
	}	
	printf("mem addr from %x\n",iv_memory);
	Local_HeapInit((unsigned int)iv_memory,mem_len);
	return 0;
}

void iv_memory_deinit(int mode)
{
	if(iv_memory)
	{
		iv_free(iv_memory);
		iv_memory = NULL;
		if(mode == 1)
			Module_ExitExt();
	}
}


void *iv_uc_malloc(unsigned int size)
{
	return (void *)Local_Alloc((unsigned int)iv_memory,size);
}
void iv_uc_free(void *addr)
{
	if(addr != NULL)
		Local_Dealloc((unsigned int)iv_memory,(unsigned int)addr);
}
void *iv_uc_calloc(unsigned int x,unsigned int n)
{
	return (void *)Local_Calloc((unsigned int)iv_memory,x,n);
}
void *iv_uc_realloc(void *addr,unsigned int size)
{
	return (void *)Local_Realloc((unsigned int)iv_memory,(unsigned int)addr,(unsigned int)size);
}

void *iv_uc_memalign(unsigned int x,unsigned int size)
{
	return (void *)Local_alignAlloc((unsigned int)iv_memory,x,(unsigned int)size);
}
char * iv_uc_strdup(const char *str)
{
   char *p;
   if (!str)
      return(NULL);
   if ((p = (char *)iv_uc_malloc(strlen(str) + 1)) != 0)
      return(strcpy(p,str));
   return(NULL);
}

/*
#ifndef USE_16M_SDRAM
//-----------------------------drv mem--------------------------------------------
void *iv_uc_malloc_static(unsigned int addr)
{
	return (void *)alloc((unsigned int)addr);
}
void iv_uc_free_static(void *addr)
{
	if(addr != NULL)
		deAlloc((unsigned int)addr);
}
void *iv_uc_calloc_static(unsigned int x,unsigned int n)
{
	return (void *)Drv_calloc(x,n);
}
void *iv_uc_realloc_static(void *addr,unsigned int size)
{
	return (void *)Drv_realloc((unsigned int)addr,(unsigned int)size);
}
void *iv_uc_memalign_static(unsigned int x,unsigned int size)
{
	return (void *)alignAlloc(x,(unsigned int)size);
}
//-------------------------------------------------------------------------
#else
*/
//-----------------------------module mem--------------------------------------------
void *iv_uc_malloc_static(unsigned int size)
{
	return (void *)Local_Alloc((unsigned int)iv_memory,size);
}
void iv_uc_free_static(void *addr)
{
	if(addr != NULL)
		Local_Dealloc((unsigned int)iv_memory,(unsigned int)addr);
}
void *iv_uc_calloc_static(unsigned int x,unsigned int n)
{
	return (void *)Local_Calloc((unsigned int)iv_memory,x,n);
}
void *iv_uc_realloc_static(void *addr,unsigned int size)
{
	return (void *)Local_Realloc((unsigned int)iv_memory,(unsigned int)addr,(unsigned int)size);
}
void *iv_uc_memalign_static(unsigned int x,unsigned int size)
{
	return (void *)Local_alignAlloc((unsigned int)iv_memory,x,(unsigned int)size);
}
//#endif

void dumpdatabuf(unsigned char *buf,unsigned int len)
{
	int i,j;
	printf("\n");
	for(i = 0;i < len / 16;i++)
	{
		printf("%04x: ",i);
		for(j = 0; j < 16; j++)
			printf("%02x ",buf[j + i * 16]);
		printf("\n");	
	}
	if((i & 15) > 0)
	{
			printf("%02x: ",j);
		for(j = 0; j < (i & 15); j++)
			printf("%02x ",buf[j + i * 16]);
		printf("\n");	
	}
}


#define MAX_TEST 8 * 1024 * 1024	
unsigned int findmax_mem(unsigned int dsize)
{
  void * mem,*firstmem;
  unsigned int i;
  firstmem = iv_uc_malloc(4);
  iv_uc_free(firstmem);
	for(i = 0; i < dsize / 4 ;i++)
	{
		mem = iv_uc_malloc(4 * i);
		
		if(mem == 0)
		{
			break;
		}else
			iv_uc_free(mem);	
	}
	return ((unsigned int)mem - (unsigned int)firstmem);
}
/*
void test_mem()
{
	void *mem,*firstmem[100];
	unsigned int dsize = MAX_TEST;
	unsigned int d,memsize[100];
	unsigned int n = 0,i;
	do{
		d = findmax_mem(dsize);
		firstmem[n] = iv_uc_malloc(d);
		memsize[n] = d;
		n++;
		dsize -= d;
		if(dsize <= 1 * 1024 * 1024)
			break;
	}while(n < 100);
	for(i = 0;i < n - 1;i++)
	{
		d = firstmem[i] + memsize[i];
		F("first mem = %x size = %d\n",firstmem[i],memsize[i]);
		F("hold = %x %d\n",d,firstmem[i + 1] - d);
		iv_uc_free(firstmem[i]);
	}
	iv_uc_free(firstmem[i]);
}
*/

/*** 
*qsort.c - quicksort algorithm; qsort() library function for sorting arrays 
* 
* Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved. 
* 
*Purpose: 
* To implement the qsort() routine for sorting arrays. 
* 
*******************************************************************************/ 
/*
#include <cruntime.h> 
#include <stdlib.h> 
#include <search.h>
*/ 

#define __cdecl
/* prototypes for local routines */ 
static void __cdecl shortsort(char *lo, char *hi, unsigned width, 
int (__cdecl *comp)(const void *, const void *)); 
static void __cdecl swap(char *p, char *q, unsigned int width); 

/* this parameter defines the cutoff between using quick sort and 
insertion sort for arrays; arrays with lengths shorter or equal to the 
below value use insertion sort */ 

#define CUTOFF 8 /* testing shows that this is good value */ 


/*** 
*qsort(base, num, wid, comp) - quicksort function for sorting arrays 
* 
*Purpose: 
* quicksort the array of elements 
* side effects: sorts in place 
* 
*Entry: 
* char *base = pointer to base of array 
* unsigned num = number of elements in the array 
* unsigned width = width in bytes of each array element 
* int (*comp)() = pointer to function returning analog of strcmp for 
* strings, but supplied by user for comparing the array elements. 
* it accepts 2 pointers to elements and returns neg if 1<2, 0 if 
* 1=2, pos if 1>2. 
* 
*Exit: 
* returns void 
* 
*Exceptions: 
* 
*******************************************************************************/ 

/* sort the array between lo and hi (inclusive) */ 

void __cdecl qsort ( 
void *base, 
unsigned num, 
unsigned width, 
int (__cdecl *comp)(const void *, const void *) 
) 
{ 
	char *lo, *hi; /* ends of sub-array currently sorting */ 
	char *mid; /* points to middle of subarray */ 
	char *loguy, *higuy; /* traveling pointers for partition step */ 
	unsigned size; /* size of the sub-array */ 
	char *lostk[30], *histk[30]; 

	int stkptr; /* stack for saving sub-array to be processed */ 
	/* Note: the number of stack entries required is no more than 
	1 + log2(size), so 30 is sufficient for any array */ 
	
	if (num < 2 || width == 0) 
		return; /* nothing to do */ 
	
	stkptr = 0; /* initialize stack */ 
	
	lo = (char *)base; 
	hi = (char *)base + width * (num-1); /* initialize limits */ 
	
	/* this entry point is for pseudo-recursion calling: setting 
	lo and hi and jumping to here is like recursion, but stkptr is 
	prserved, locals aren't, so we preserve stuff on the stack */ 
	recurse: 
	
	size = (hi - lo) / width + 1; /* number of el's to sort */ 
	
	/* below a certain size, it is faster to use a O(n^2) sorting method */ 
	if (size <= CUTOFF) { 
		shortsort(lo, hi, width, comp); 
	} 
	else { 
		/* First we pick a partititioning element. The efficiency of the 
		algorithm demands that we find one that is approximately the 
		median of the values, but also that we select one fast. Using 
		the first one produces bad performace if the array is already 
		sorted, so we use the middle one, which would require a very 
		wierdly arranged array for worst case performance. Testing shows 
		that a median-of-three algorithm does not, in general, increase 
		performance. */ 
		
		mid = lo + (size / 2) * width; /* find middle element */ 
		swap(mid, lo, width); /* swap it to beginning of array */ 
		
		/* We now wish to partition the array into three pieces, one 
		consisiting of elements <= partition element, one of elements 
		equal to the parition element, and one of element >= to it. This 
		is done below; comments indicate conditions established at every 
		step. */ 
		
		loguy = lo; 
		higuy = hi + width; 
		
		/* Note that higuy decreases and loguy increases on every iteration, 
		so loop must terminate. */ 
		for (;;) { 
			/* lo <= loguy < hi, lo < higuy <= hi + 1, 
			A[i] <= A[lo] for lo <= i <= loguy, 
			A[i] >= A[lo] for higuy <= i <= hi */ 
			
			 do { 
					loguy += width; 
				} while (loguy <= hi && comp(loguy, lo) <= 0); 
			
			/* lo < loguy <= hi+1, A[i] <= A[lo] for lo <= i < loguy, 
			either loguy > hi or A[loguy] > A[lo] */ 
			
			do { 
				higuy -= width; 
			} while (higuy > lo && comp(higuy, lo) >= 0); 
			
			/* lo-1 <= higuy <= hi, A[i] >= A[lo] for higuy < i <= hi, 
			either higuy <= lo or A[higuy] < A[lo] */ 
			
			if (higuy < loguy) 
				break; 
			
			/* if loguy > hi or higuy <= lo, then we would have exited, so 
			A[loguy] > A[lo], A[higuy] < A[lo], 
			loguy < hi, highy > lo */ 
			
			swap(loguy, higuy, width); 
			
			/* A[loguy] < A[lo], A[higuy] > A[lo]; so condition at top 
			of loop is re-established */ 
		} 
		
		/* A[i] >= A[lo] for higuy < i <= hi, 
		A[i] <= A[lo] for lo <= i < loguy, 
		higuy < loguy, lo <= higuy <= hi 
		implying: 
		A[i] >= A[lo] for loguy <= i <= hi, 
		A[i] <= A[lo] for lo <= i <= higuy, 
		A[i] = A[lo] for higuy < i < loguy */ 
		
		swap(lo, higuy, width); /* put partition element in place */ 
		
		/* OK, now we have the following: 
		A[i] >= A[higuy] for loguy <= i <= hi, 
		A[i] <= A[higuy] for lo <= i < higuy 
		A[i] = A[lo] for higuy <= i < loguy */ 
		
		/* We've finished the partition, now we want to sort the subarrays 
		[lo, higuy-1] and [loguy, hi]. 
		We do the smaller one first to minimize stack usage. 
		We only sort arrays of length 2 or more.*/ 
		
		if ( higuy - 1 - lo >= hi - loguy ) { 
			if (lo + width < higuy) { 
				lostk[stkptr] = lo; 
				histk[stkptr] = higuy - width; 
				++stkptr; 
			} /* save big recursion for later */ 
			
			if (loguy < hi) { 
				lo = loguy; 
				goto recurse; /* do small recursion */ 
			} 
		} 
		else { 
			if (loguy < hi) { 
				lostk[stkptr] = loguy; 
				histk[stkptr] = hi; 
				++stkptr; /* save big recursion for later */ 
			} 
			
			if (lo + width < higuy) { 
				hi = higuy - width; 
				goto recurse; /* do small recursion */ 
			} 
		} 
	} 
	
	/* We have sorted the array, except for any pending sorts on the stack. 
	Check if there are any, and do them. */ 
	
	--stkptr; 
	if (stkptr >= 0) { 
		lo = lostk[stkptr]; 
		hi = histk[stkptr]; 
		goto recurse; /* pop subarray from stack */ 
	} 
	/* all subarrays done */ 

} 


/*** 
*shortsort(hi, lo, width, comp) - insertion sort for sorting short arrays 
* 
*Purpose: 
* sorts the sub-array of elements between lo and hi (inclusive) 
* side effects: sorts in place 
* assumes that lo < hi 
* 
*Entry: 
* char *lo = pointer to low element to sort 
* char *hi = pointer to high element to sort 
* unsigned width = width in bytes of each array element 
* int (*comp)() = pointer to function returning analog of strcmp for 
* strings, but supplied by user for comparing the array elements. 
* it accepts 2 pointers to elements and returns neg if 1<2, 0 if 
* 1=2, pos if 1>2. 
* 
*Exit: 
* returns void 
* 
*Exceptions: 
* 
*******************************************************************************/ 

static void __cdecl shortsort ( 
char *lo, 
char *hi, 
unsigned width, 
int (__cdecl *comp)(const void *, const void *) 
) 
{ 
		char *p, *max; 
		
		/* Note: in assertions below, i and j are alway inside original bound of 
		array to sort. */ 
		
		while (hi > lo) { 
		/* A[i] <= A[j] for i <= j, j > hi */ 
		max = lo; 
		for (p = lo+width; p <= hi; p += width) { 
			/* A[i] <= A[max] for lo <= i < p */ 
			if (comp(p, max) > 0) { 
				max = p; 
			} 
			/* A[i] <= A[max] for lo <= i <= p */ 
		} 
		
		/* A[i] <= A[max] for lo <= i <= hi */ 
		
		swap(max, hi, width); 
		
		/* A[i] <= A[hi] for i <= hi, so A[i] <= A[j] for i <= j, j >= hi */ 
		
		hi -= width; 
		
		/* A[i] <= A[j] for i <= j, j > hi, loop top condition established */ 
		} 
		/* A[i] <= A[j] for i <= j, j > lo, which implies A[i] <= A[j] for i < j, 
		so array is sorted */ 
} 


/*** 
*swap(a, b, width) - swap two elements 
* 
*Purpose: 
* swaps the two array elements of size width 
* 
*Entry: 
* char *a, *b = pointer to two elements to swap 
* unsigned width = width in bytes of each array element 
* 
*Exit: 
* returns void 
* 
*Exceptions: 
* 
*******************************************************************************/ 

static void __cdecl swap ( 
char *a, 
char *b, 
unsigned width 
) 
{ 
	char tmp; 
	
	if ( a != b ) 
	/* Do the swap one character at a time to avoid potential alignment 
	problems. */ 
	while ( width-- ) { 
		tmp = *a; 
		*a++ = *b; 
		*b++ = tmp; 
	} 
}