mfm.c

好记星的控件,包括button,list,对文件操作

#define __OS_SOURCE_FILE__

/* 包含所需头文件 */
#include "kernel.h"

#define	MEDIAFILE_OPEN_MAX	4

#define	MEDIAFILE_MODE_FILE	     1
#define	MEDIAFILE_MODE_MEM	     2
#define	MEDIAFILE_MODE_IO	     4
#define MEDIAFILE_MODE_CALLBACK  8

typedef UINT32 (* GETFILEDATACALLBACK)(BYTE *,INT,INT);

typedef struct	tagMediaFileParam
{
	BOOL		bIsOpen;
	UINT32		dwMode;
	UINT8*		pszFileName;
	INT			hFile;
	MMIOINFO*	lpmmioinfo;
	DWORD		dwOpenFlags;
}	MediaFileParam;


//	AAAAAAAA AAABBCCD EEEEFFGH IIJJKLMM 
typedef struct tagMpegFrameHeader
{
//	unsigned framesync : 11;		// A
	unsigned framesync1 : 8;		// A

	unsigned hascrc : 1;			// D
	unsigned mpeglayer : 2;			// C
	unsigned mpegver : 2;			// B
	unsigned framesync2 : 3;		// A
	
	unsigned privbit : 1;			// H
	unsigned padding : 1;			// G
	unsigned samplerate : 2;		// F
	unsigned bitrate : 4;			// E

	unsigned emphasis : 2;			// M
	unsigned original : 1;			// L
	unsigned copyright : 1;			// K
	unsigned modeext : 2;			// J
	unsigned chanmode : 2;			// I
}	MpegFrameHeader;

// MPEGVER enumeration
enum MpegVersion
{
	MPEGVER_NA,		// reserved, N/A
	MPEGVER_25,		// 2.5
	MPEGVER_2,		// 2.0 (ISO/IEC 13818-3)
	MPEGVER_1		// 1.0 (ISO/IEC 11172-3)
};

UINT MediaFileGetWMAFormat(HMEDIAFILE hmmio, WAVEFORMATEX *pWfx, UINT32 *pdwTimeLength);


MediaFileParam	g_MediaFileOpen[MEDIAFILE_OPEN_MAX];

VOID MediaFileInit()
{
	UINT32	i;

	for(i = 0; i < MEDIAFILE_OPEN_MAX; i ++)
		g_MediaFileOpen[i].bIsOpen = FALSE;
}

INT32	MediaFileHandleFind(HMEDIAFILE hmmio)
{
	UINT32	i;

	for(i = 0; i < MEDIAFILE_OPEN_MAX; i ++)
	{
		if((g_MediaFileOpen[i].bIsOpen == TRUE) && (&g_MediaFileOpen[i] == hmmio))
			return i;
	}
	return -1;
}

HMEDIAFILE MediaFileOpen(char *szFileName, MMIOINFO *lpmmioinfo, DWORD dwOpenFlags)
{
	UINT32	i;
	UINT32	dwOpenMode;

	for(i = 0; i < MEDIAFILE_OPEN_MAX; i ++)
	{
		if(g_MediaFileOpen[i].bIsOpen == FALSE)
			break;
	}
	if(i >= MEDIAFILE_OPEN_MAX)
		return NULL;

	if(dwOpenFlags == (MMIO_DENYWRITE | MMIO_ALLOCBUF))
		dwOpenMode = FILEMODE_NOSHAREWRITE;
	else if(dwOpenFlags == (MMIO_READ | MMIO_ALLOCBUF))
		dwOpenMode = FILEMODE_READONLY;

	if(szFileName[0] != 0x00)
	{
		g_MediaFileOpen[i].dwMode = MEDIAFILE_MODE_FILE;
        g_MediaFileOpen[i].pszFileName = (UINT8 *)szFileName;
		g_MediaFileOpen[i].hFile = FileOpen(g_MediaFileOpen[i].pszFileName, (UINT8)dwOpenMode);
		if(g_MediaFileOpen[i].hFile < 0)
			return NULL;
	}
	else if(szFileName[1] == 0x01){
		g_MediaFileOpen[i].dwMode              = MEDIAFILE_MODE_CALLBACK;
		g_MediaFileOpen[i].pszFileName         = NULL;
		g_MediaFileOpen[i].hFile               = NULL;
		g_MediaFileOpen[i].lpmmioinfo          = lpmmioinfo;
		g_MediaFileOpen[i].lpmmioinfo->pchNext = 0;
	}
	else /*if(szFileName[1] == 0x02)*/
	{
		g_MediaFileOpen[i].dwMode = MEDIAFILE_MODE_MEM;
		g_MediaFileOpen[i].pszFileName = NULL;
		g_MediaFileOpen[i].hFile = NULL;
		g_MediaFileOpen[i].lpmmioinfo = lpmmioinfo;
		g_MediaFileOpen[i].lpmmioinfo->pchNext = g_MediaFileOpen[i].lpmmioinfo->pchBuffer;
	}

	g_MediaFileOpen[i].bIsOpen = TRUE;
	
	return &g_MediaFileOpen[i];

//	return mmioOpen(szFileName, lpmmioinfo, dwOpenFlags);
}

UINT MediaFileClose(HMEDIAFILE hmmio, UINT wFlags)
{
	INT32	i;

	i = MediaFileHandleFind(hmmio);
	if(i < 0)
		return 0;

	if(g_MediaFileOpen[i].dwMode == MEDIAFILE_MODE_FILE)
		FileClose(g_MediaFileOpen[i].hFile);

	g_MediaFileOpen[i].bIsOpen = FALSE;

	return 0;

//	return mmioClose(hmmio, wFlags);
}

INT MediaFileRead(HMEDIAFILE hmmio, BYTE *pch, INT cch)
{
	INT32	i;
	GETFILEDATACALLBACK GetData;

	i = MediaFileHandleFind(hmmio);
	if(i < 0)
		return 0;

	if(g_MediaFileOpen[i].dwMode == MEDIAFILE_MODE_FILE){
		return FileRead(g_MediaFileOpen[i].hFile, (INT8 *)pch, cch);
	}
	else if(g_MediaFileOpen[i].dwMode == MEDIAFILE_MODE_CALLBACK){
		INT nRet;
		
		GetData = (GETFILEDATACALLBACK)g_MediaFileOpen[i].lpmmioinfo->pchBuffer;
		if((INT)g_MediaFileOpen[i].lpmmioinfo->pchNext+cch > (INT)g_MediaFileOpen[i].lpmmioinfo->cchBuffer){
			cch = (INT)g_MediaFileOpen[i].lpmmioinfo->cchBuffer - (INT)g_MediaFileOpen[i].lpmmioinfo->pchNext;
		}
		nRet = GetData(pch,(INT)g_MediaFileOpen[i].lpmmioinfo->pchNext,cch);
		g_MediaFileOpen[i].lpmmioinfo->pchNext += nRet;

		return nRet;
	}
	else
	{
        memcpy(pch, g_MediaFileOpen[i].lpmmioinfo->pchNext, cch);
		g_MediaFileOpen[i].lpmmioinfo->pchNext +=cch;
		return cch;
    }

//	return mmioRead(hmmio, (HPSTR)pch, cch);
}

INT MediaFileWrite(HMEDIAFILE hmmio, BYTE *pch, INT cch)
{
	return 0;

//	return mmioWrite(hmmio, (HPSTR)pch, cch);
}

INT MediaFileSeek(HMEDIAFILE hmmio, INT lOffset, int iOrigin)
{
	INT32	i;

	i = MediaFileHandleFind(hmmio);
	if(i < 0)
		return 0;

	if(g_MediaFileOpen[i].dwMode == MEDIAFILE_MODE_FILE)
		return FileSeek(g_MediaFileOpen[i].hFile, lOffset, (UINT16)iOrigin);
	else if(g_MediaFileOpen[i].dwMode == MEDIAFILE_MODE_CALLBACK){
		if(iOrigin == SEEK_SET){
			g_MediaFileOpen[i].lpmmioinfo->pchNext = (CHAR*)lOffset;
		}
		else if(iOrigin == SEEK_CUR){
			g_MediaFileOpen[i].lpmmioinfo->pchNext += lOffset;
			if((INT)g_MediaFileOpen[i].lpmmioinfo->pchNext > (INT)g_MediaFileOpen[i].lpmmioinfo->cchBuffer){
				g_MediaFileOpen[i].lpmmioinfo->pchNext = (CHAR*)g_MediaFileOpen[i].lpmmioinfo->cchBuffer;
			}
		}
		else if(iOrigin == SEEK_END){
			g_MediaFileOpen[i].lpmmioinfo->pchNext = (CHAR*)(g_MediaFileOpen[i].lpmmioinfo->cchBuffer + lOffset);
		}
		
		return (INT)g_MediaFileOpen[i].lpmmioinfo->pchNext;
	}
	else
	{
		if(iOrigin == SEEK_SET)
			g_MediaFileOpen[i].lpmmioinfo->pchNext = 
			g_MediaFileOpen[i].lpmmioinfo->pchBuffer + lOffset;
		else if(iOrigin == SEEK_CUR)
			g_MediaFileOpen[i].lpmmioinfo->pchNext += lOffset;
		else if(iOrigin == SEEK_END)
			g_MediaFileOpen[i].lpmmioinfo->pchNext = 
			g_MediaFileOpen[i].lpmmioinfo->pchBuffer + 
			g_MediaFileOpen[i].lpmmioinfo->cchBuffer + lOffset;
		return (g_MediaFileOpen[i].lpmmioinfo->pchNext - g_MediaFileOpen[i].lpmmioinfo->pchBuffer);
    }

//	return mmioSeek(hmmio, lOffset, iOrigin);
}

INT MediaFileLength(HMEDIAFILE hmmio)
{
	INT32	i;

	i = MediaFileHandleFind(hmmio);
	if(i < 0)
		return 0;

	if(g_MediaFileOpen[i].dwMode == MEDIAFILE_MODE_FILE)
		return FileLength(g_MediaFileOpen[i].hFile);
	else if(g_MediaFileOpen[i].dwMode == MEDIAFILE_MODE_CALLBACK){
		return (INT)g_MediaFileOpen[i].lpmmioinfo->cchBuffer;
	}
	else{
		return (INT)(g_MediaFileOpen[i].lpmmioinfo->pchBuffer + 
			g_MediaFileOpen[i].lpmmioinfo->cchBuffer);
	}

//	return mmioSeek(hmmio, lOffset, iOrigin);
}

UINT MediaFileGetInfo(HMEDIAFILE hmmio, MMIOINFO *lpmmioinfo, UINT wFlags)
{
	return 0;

//	return mmioGetInfo(hmmio, lpmmioinfo, wFlags);
}

UINT MediaFileSetInfo(HMEDIAFILE hmmio, MMIOINFO *lpmmioinfo, UINT wFlags)
{
	return 0;

//	return mmioSetInfo(hmmio, lpmmioinfo, wFlags);
}

UINT MediaFileDescend(HMEDIAFILE hmmio, MMCKINFO *lpck, MMCKINFO *lpckParent, UINT wFlags)
{
	UINT8	ch[4];
	UINT8	chunkLen[4];
	UINT32	dwChunkLen;

	if(lpckParent == NULL && wFlags == MMIO_FINDRIFF)
	{
		MediaFileSeek(hmmio, 0, SEEK_SET);
		MediaFileRead(hmmio, ch, 4);
		lpck->ckid = MediaFileStrToFourCC((INT8 *)ch, 0);
		MediaFileRead(hmmio, chunkLen, 4);
		lpck->cksize = MediaFileStrToFourCC((INT8 *)chunkLen, 0);
		MediaFileRead(hmmio, ch, 4);
		if(lpck->fccType != MediaFileStrToFourCC((INT8 *)ch, 0))
			return MMIOERR_CHUNKNOTFOUND;
		lpck->dwDataOffset = MediaFileSeek(hmmio, 0, SEEK_CUR);
		lpck->dwFlags = 0;
		return MMSYSERR_NOERROR;
	}
	else if(lpckParent != NULL && wFlags == MMIO_FINDCHUNK)
	{
		MediaFileSeek(hmmio, lpckParent->dwDataOffset, SEEK_SET);
		while(1)
		{
		    if(MediaFileRead(hmmio, ch, 4) != 4)
			    return MMIOERR_CHUNKNOTFOUND;
			if(MediaFileRead(hmmio, chunkLen, 4) != 4)
				return MMIOERR_CHUNKNOTFOUND;
			dwChunkLen = MediaFileStrToFourCC((INT8 *)chunkLen, 0);

	        if(lpck->ckid == MediaFileStrToFourCC((INT8 *)ch, 0))
		    {
				lpck->fccType = 0;
				lpck->cksize = dwChunkLen;
				lpck->dwDataOffset = MediaFileSeek(hmmio, 0, SEEK_CUR);
				lpck->dwFlags = 0;
				return MMSYSERR_NOERROR;
			}
		    else
			    MediaFileSeek(hmmio, dwChunkLen, SEEK_CUR);
		}
    }
	else
		return MMIOERR_CHUNKNOTFOUND;

//	return mmioDescend(hmmio, lpck, lpckParent, wFlags);
}

UINT MediaFileAscend(HMEDIAFILE hmmio, MMCKINFO *lpck, UINT wFlags)
{
	return 0;

//	return mmioAscend(hmmio, lpck, wFlags);
}

FOURCC MediaFileStrToFourCC(char *sz, UINT wFlags)
{
	return mmioFOURCC(sz[0], sz[1], sz[2], sz[3]);

	//	return mmioStringToFOURCC(sz, wFlags);
}



#define MP3_BLOCK_SIZE 522

const int BitrateTable[2][3][16] =	{
	{ // MPEG-1
		{ 0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,0 },	// 32000Hz(layer1)
		{ 0,32,48,56, 64, 80, 96,112,128,160,192,224,256,320,384,0 },	// 44100Hz(layer2)
		{ 0,32,40,48, 56, 64, 80, 96,112,128,160,192,224,256,320,0 },	// 48000Hz(layer3)
	},
	{ // MPEG-2
		{ 0,32,48,56, 64, 80, 96,112,128,144,160,176,192,224,256,0 },	// 32000Hz(layer1)
		{ 0, 8,16,24, 32, 40, 48, 56, 64, 80, 96,112,128,144,160,0 },	// 44100Hz(layer2)
		{ 0, 8,16,24, 32, 40, 48, 56, 64, 80, 96,112,128,144,160,0 },	// 48000Hz(layer3)
	}
};

const int FreqTable[3][4] = {
	{ 44100,48000,32000,0 },
	{ 22050,24000,16000,0 },