dwlong.h

这是一个SIGMA方案的PMP播放器的UCLINUX程序,可播放DVD,VCD,CD MP3...有很好的参考价值.

/*****************************************************************************
*  dwordlong.h : Macros for 64 bits integer support
*  REALmagic FMP RTOS Driver
*  Created by Michael Ignaszewski
*  Copyright Sigma Designs Inc
*  Sigma Designs Proprietary and confidential
*  Created on 6/23/99
*****************************************************************************/


#ifdef _NO_64BITS_SUPPORT_

typedef struct tagULONGLONG
{
	unsigned long int	LowPart;
	long int			HighPart;
} ULONGLONG;
typedef ULONGLONG MPEG_SCR;

/////////////////////////////////////////////////////////////////////
// dwlSet
//@func void | dwlSet | assign a dwordlong value to another one.
//@rdesc void.
void PDWORDLONG_Set (MPEG_SCR* pdwlDestination, MPEG_SCR dwlSource);

/////////////////////////////////////////////////////////////////////
// dwlSet
//@func void | PDWORDLONG_Set | assign a dword value to a dwordlong.
//@rdesc void.
void PDWORDLONG_Set_DWORD (MPEG_SCR* pdwlDestination, DWORD dwSource);

/////////////////////////////////////////////////////////////////////
// MakeDWORDLONG
//@func void | PDWORDLONG_MakeDWORDLONG | build a DWORDLONG with 2 DWORDs.
//@rdesc void.
void PDWORDLONG_MakeDWORDLONG(MPEG_SCR* pdwlDestination, DWORD dwLow, DWORD dwHigh);

/////////////////////////////////////////////////////////////////////
// DWORDLONG_Equal_DWORDLONG
//@func BOOL | DWORDLONG_Equal_DWORDLONG| compare two dwordlong values.
//@rdesc TRUE if they are equal.
BOOL DWORDLONG_Equal_DWORDLONG (MPEG_SCR dwlA, MPEG_SCR dwlB);

/////////////////////////////////////////////////////////////////////
// DWORDLONG_Equal_DWORD
//@func BOOL | DWORDLONG_Equal_DWORD| compare a dwordlong to a dword.
//@rdesc TRUE if they are equal.
BOOL DWORDLONG_Equal_DWORD (MPEG_SCR dwlA, DWORD iB);

/////////////////////////////////////////////////////////////////////
// PDWORDLONG_Add_DWORDLONG
//@func void | PDWORDLONG_Add_DWORDLONG| add directly a dwordlong to another (pointer).
//@rdesc void.
void PDWORDLONG_Add_DWORDLONG (MPEG_SCR* pdwlA, MPEG_SCR dwlB);

/////////////////////////////////////////////////////////////////////
// PDWORDLONG_Add_DWORD
//@func void | PDWORDLONG_Add_DWORD| add directly a dword to a dwordlong (pointer).
//@rdesc void.
void PDWORDLONG_Add_DWORD(MPEG_SCR* pdwlA, DWORD iB);

/////////////////////////////////////////////////////////////////////
// PDWORDLONG_Sub_DWORDLONG
//@func void | PDWORDLONG_Sub_DWORDLONG| substract directly a dwordlong to another (pointer).
//@rdesc void.
void PDWORDLONG_Sub_DWORDLONG (MPEG_SCR* pdwlA, MPEG_SCR dwlB);

/////////////////////////////////////////////////////////////////////
// DWORDLONG_Cmp_DWORDLONG
//@func int | DWORDLONG_Cmp_DWORDLONG| compare two DWORDLONG values.
//@rdesc 0, 1 or -1.
int DWORDLONG_Cmp_DWORDLONG (MPEG_SCR dwlA, MPEG_SCR dwlB);

/////////////////////////////////////////////////////////////////////
// DWORDLONG_Cast_DWORD
//@func int | DWORDLONG_Cast_DWORD| cast a DWORDLONG value into a DWORD.
//@rdesc DWORD value.
DWORD DWORDLONG_Cast_DWORD (MPEG_SCR dwlA);

/////////////////////////////////////////////////////////////////////
// DWORDLONG_Cast_HIDWORD
//@func int | DWORDLONG_Cast_HIDWORD| get the high dword value of a DWORDLONG.
//@rdesc DWORD value.
DWORD DWORDLONG_Cast_HIDWORD (MPEG_SCR dwlA);

/////////////////////////////////////////////////////////////////////
// PDWORDLONG_MakeSCR
//@func int | PDWORDLONG_MakeSCR | Transform a DWORDLONG into a SCR (33 bit value).
//@rdesc void.
void PDWORDLONG_MakeSCR (MPEG_SCR* pdwlA);

/////////////////////////////////////////////////////////////////////
// DWORDLONG_ShiftRight
//@func int | DWORDLONG_ShiftRight | Shift a MPEG_SCR value right by n bits, and return the lower 32 bits
//@rdesc the lower 32 bits.
DWORD DWORDLONG_ShiftRight (MPEG_SCR dwlA, ULONG n);

/////////////////////////////////////////////////////////////////////
// PDWORDLONG_ShiftRight
//@func int | PDWORDLONG_ShiftRight | Shift a MPEG_SCR value right by n bits
//@rdesc the lower 32 bits.
void PDWORDLONG_ShiftRight (MPEG_SCR* pdwlA, ULONG n);

/////////////////////////////////////////////////////////////////////
// DWORDLONG_ShiftLeft
//@func int | DWORDLONG_ShiftLeft | Shift a MPEG_SCR value Left by n bits, and return the lower 32 bits
//@rdesc the lower 32 bits.
DWORD DWORDLONG_ShiftLeft (MPEG_SCR dwlA, ULONG n);

/////////////////////////////////////////////////////////////////////
// PDWORDLONG_ShiftLeft
//@func int | PDWORDLONG_ShiftLeft | Shift a MPEG_SCR value left by n bits
//@rdesc the lower 32 bits.
void PDWORDLONG_ShiftLeft (MPEG_SCR* pdwlA, ULONG n);

/////////////////////////////////////////////////////////////////////
// PDWORDLONG_Multiply
//@func int | PDWORDLONG_Multiply | Multiply two DWORDLONG values.
void PDWORDLONG_Multiply (ULONGLONG* pdwlC, ULONGLONG dwlA, ULONGLONG dwlB);

/////////////////////////////////////////////////////////////////////
// PDWORDLONG_Divide
//@func int | PDWORDLONG_Divide | Divide two DWORDLONG values.
void PDWORDLONG_Divide (ULONGLONG* pdwlQ, ULONGLONG dwlA, ULONGLONG dwlB);

#else
// MPEG_SCR is supposed to be already defined
#define PDWORDLONG_Set(pdwlDestination,dwlSource) *pdwlDestination = dwlSource
#define PDWORDLONG_Set_DWORD(pdwlDestination,dwSource) *pdwlDestination = dwSource
#define PDWORDLONG_MakeDWORDLONG(pdwlDestination,dwLow,dwHigh) *pdwlDestination = ((DWORDLONG)(((DWORD)(dwLow)) | ((DWORDLONG)((DWORD)(dwHigh))) << 32))
#define DWORDLONG_Equal_DWORDLONG(dwlA,dwlB) dwlA == dwlB
#define DWORDLONG_Equal_DWORD(dwlA,dwB) dwlA == dwB
#define PDWORDLONG_Add_DWORDLONG(pdwlA,dwlB) *pdwlA += dwlB
#define PDWORDLONG_Add_DWORD(pdwlA,iB) *pdwlA += iB
#define PDWORDLONG_Sub_DWORDLONG(pdwlA,dwlB) *pdwlA -= dwlB
#define DWORDLONG_Cmp_DWORDLONG(dwlA,dwlB) (dwlA == dwlB) ? 0 : ((dwlA > dwlB) ? 1 : -1)
#define DWORDLONG_Cast_DWORD(dwlA) (DWORD) dwlA
#define DWORDLONG_Cast_HIDWORD(dwlA) (DWORD) ((DWORD)(((DWORDLONG)(dwlA) >> 32) & 0xFFFFFFFF))
#define PDWORDLONG_MakeSCR(pdwlA) *pdwlA = (*pdwlA & (((DWORDLONG) 1<<32) | (DWORDLONG) 0xFFFFFFFF))
#define DWORDLONG_ShiftRight(dwlA, n) (DWORD)(dwlA >> n)
#define PDWORDLONG_ShiftRight(pdwlA, n) *pdwlA = *pdwlA >> n
#define DWORDLONG_ShiftLeft(dwlA, n) (DWORD)(dwlA << n)
#define PDWORDLONG_ShiftLeft(pdwlA, n) *pdwlA = *pdwlA << n
#define PDWORDLONG_Multiply(pdwlC, dwlA, dwlB) *pdwlC = (DWORDLONG)dwlA * (DWORDLONG)dwlB
#ifndef PDWORDLONG_Divide	// it should be defined in osinc.h
	#define PDWORDLONG_Divide(pdwlQ, dwlA, dwlB) *pdwlQ = (DWORDLONG)dwlA / (DWORDLONG)dwlB
#endif

#endif /*_NO_64BITS_SUPPORT_*/