util.c

代码有点长,需细心阅读,仅供影音视听类产品的开发人员参考

/*
** FILE
** util.c
**
** DESCRIPTION
** provide some general utilities.
**
*/
#include "global.h"
#include "fastmath.h"
#include "util.h"

#ifdef  USE_DIV
#include "stdlib.h"
#endif

/*
** FUNCTION
** bin2bcd(BYTE x)
**
** DESCRIPTION
** transform a binary-represented number into packed BCD.
**
** 0x0c(12) -> 0x12
** 0x20(32) -> 0x32
**
** *NOTE*
** we used fast dividing-by-10 function to generate the result.
*/
int bin2bcd(BYTE x)
{
#ifdef  USE_DIV
	div_t   res;

	res = div(x, 10);
	return (res.quot << 4) | (res.rem);
#else
#if 1
	int     Q = DIV10(x);
	int     R = x - 10 * Q;

	return (Q << 4) | R;
#else
	return ((x / 10) << 4) | (x % 10);
#endif
#endif
}


/*
** FUNCTION
** bcd2bin(BYTE x)
**
** DESCRIPTION
** transform a bcd-number into binary-represented
*/
int bcd2bin(BYTE x)
{
	/*
	 ** for mips, a optimized version might be obtained using:
	 **
	 ** use CE (slower)
	 **    li  %1, 10
	 **    shr %2, %0, 4
	 **    multu   %1, %2
	 **    andi    %1, %0, 0x000f
	 **    mflo    %2
	 **    addu    %1, %2
	 **
	 ** or
	 **    shr %1, %0, 4   // >>4
	 **    addu    %2, %1, %1  // (2) = *2
	 **    shl %1, %2, 2   // (1) = (2)*4
	 **    addu    %1, %2      // (1) = (1)+(2)
	 **    andi    %2, %0, 0x000f  // (2) = (0)&0x000f
	 **    addu    %1, %2      // (1) = (1)+(2)
	 **
	 */
	return (x >> 4) * 10 + (x & 0x0f);
}


/*
** FUNCTION
** l2msf(UINT32 l)
**
** DESCRIPTION
** map a linear address of CDROM into MSF addressing
**
** *NOTE*
** msf is packed 4-byte structure with format
** [CI:MM:SS:FF], where MM/SS/FF is in binary.
*/
UINT32 l2msf(UINT32 l)
{
	UINT32  ss, ff;
	UINT32  l_75, l_4500;

	l += 150;
	l_75 = l / 75;
	l_4500 = l_75 / 60;

	ff = l - 75 * l_75;
	ss = l_75 - 60 * l_4500;

	return (l_4500 << 16) | (ss << 8) | (ff);
}


/*
** FUNCTION
** msf2l(UINT32 msf)
**
** DESCRIPTION
** map a MSF addressing into linear addressing
**
** *NOTE*
** (UINT32)msf is packed 4-byte structure with format
** [00:MM:SS:FF], where MM/SS/FF is in binary.
*/
UINT32 msf2l(UINT32 msf)
{
	return MSF2l(msf_mm(msf), msf_ss(msf), msf_ff(msf));
}


/*
** FUNCTION
** addmsf_ss(UINT32 msf, int inc_s)
**
** DESCRIPTION
** adjust MSF address by (inc_s) seconds
*/
#define MSF_SECONDS 60
#define MSF_FRAMES  75

#define FIRST_FRAME 0x000200

UINT32 addmsf_ss(UINT32 msf, int inc_s)
{
	UINT32  ret_msf;
	int     mm = msf_mm(msf);
	int     ss = msf_ss(msf) + inc_s;
	int     ff = msf_ff(msf);

	while(ss < 0)
	{
		ss += MSF_SECONDS;
		mm--;
	}
	while(ss >= MSF_SECONDS)
	{
		ss -= MSF_SECONDS;
		mm++;
	}
	ret_msf = MSF(mm, ss, ff);
	if(mm < 0)
		ret_msf = 0x000200;
	return ret_msf;
}


/*
** FUNCTION
** addmsf(UINT32 msf, int inc_f)
**
** DESCRIPTION
** adjust MSF address by #inc_f frames
*/
UINT32 addmsf(UINT32 msf, int inc_f)
{
	UINT32  ret_msf;
	int     mm = msf_mm(msf);
	int     ss = msf_ss(msf);
	int     ff = msf_ff(msf) + inc_f;

	while(ff < 0)
	{
		ff += 75;
		ss--;
	}
	while(ff >= 75)
	{
		ff -= 75;
		ss++;
	}
	while(ss < 0)
	{
		ss += 60;
		mm--;
	}
	while(ss >= 60)
	{
		ss -= 60;
		mm++;
	}

	ret_msf = MSF(mm, ss, ff);
	if(mm < 0)
		ret_msf = 0x000200;
	if(ret_msf < 0x000200)
		ret_msf = 0x000200;

	return ret_msf;
}

UINT32 endian_swap_32(UINT32 original)
{
	int     result;

	result = 0;
	result += (original << 24);
	result += (((original >> 8) << 24) >> 8);
	result += (((original >> 16) << 24) >> 16);
	result += (original >> 24);
	return result;
}

UINT16 endian_swap_16(UINT16 original)
{
	int     result;

	result = 0;
	result += (original << 8);
	result += (original >> 8);
	return result;
}

/*
**
*/
char   *strcat(s, append)
		 register char *s;
		 register const char *append;
{
	char   *save = s;

	for(; *s; ++s);
	//while (*s++ = *append++);
	while((BYTE) (*(s++) = *(append++)));
	return (save);
}

/*
**
*/
char   *strcpy(to, from)
		 register char *to;
		 register const char *from;
{
	char   *save = to;

	for(; (char)(*to = *from); ++from, ++to);
	return (save);
}

/****************************************************************************/
/*   Chaneg msf to lba                                                      */
/*                                                                          */
/****************************************************************************/
//move out from servo code
UINT32 Msf2lba(BYTE min, BYTE sec, BYTE frame)
{
    return (((UINT32) min * (UINT16) 4500) + ((UINT16) sec * (UINT16) 75) +
                    ((UINT16) frame - 0));
}