codecwizarddlg.h

多种编解码的小程序

// CodecWizardDlg.h : header file
//

#if !defined(AFX_CODECWIZARDDLG_H__945F034D_C3CB_4CCB_8D8A_2B048B70D693__INCLUDED_)
#define AFX_CODECWIZARDDLG_H__945F034D_C3CB_4CCB_8D8A_2B048B70D693__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

/////////////////////////////////////////////////////////////////////////////
// CCodecWizardDlg dialog

#include <assert.h>

#define CSCLSAPI

#define ABORTON(condition) do{if(condition) return;}while(0)
#define ABORTONACT(condition,action) do{if(condition){action;return;}}while(0)
#define EXITON(condition,value) do{if(condition) return (value);}while(0)
#define EXITONACT(condition,value,action) do{if(condition){action;return (value);}}while(0)
#define ACT2(act1,act2) do{act1;act2;}while(0)
#define ACT3(act1,act2,act3) do{act1;act2;act3;}while(0)
#define ACT4(act1,act2,act3,act4) do{act1;act2;act3;act4;}while(0)
#define ACT5(act1,act2,act3,act4,act5) do{act1;act2;act3;act4;act5;}while(0)
#define ZEROA(arr) memset((void *)arr,0,sizeof(arr))
#define ZEROS(str) memset(&str,0,sizeof(str))
#define ZEROP(p,nSize) memset(p,0,(nSize))
#define ENSURE(x) do{BOOL b = x;assert(b);}while(0)
//禁止生成拷贝构造函数
#define NOCPCTOR(c)\
	private:\
	explicit c(const c& Obj);\
c& operator = (const c& Obj)
//创建线程
#define FORK(nStackSize,fn,pThis,nTID)\
(HANDLE)_beginthreadex(NULL,(nStackSize),(unsigned ( __stdcall *)( void * ))&fn,pThis,0,(UINT *)&nTID)
//创建线程，允许指定启动参数
#define FORKEX(nStackSize,fn,pThis,dwFlags,nTID)\
(HANDLE)_beginthreadex(NULL,(nStackSize),(unsigned ( __stdcall *)( void * ))&fn,pThis,dwFlags,(UINT *)&nTID)


class CSCLSAPI CCSAutoMem
{
	CSCLS_NO_COPYCONSTRUCTOR(CCSAutoMem);
public:
	int m_nSize;	//缓冲区大小，字节数
	char *m_pBuf;	//缓冲区指针
public:
	void Free()
	{
		if(m_pBuf) delete [] m_pBuf;
		m_pBuf = NULL;
		m_nSize = 0;
	};
	char* Detach(BOOL bDelete=FALSE)
	{
		PSTR p = m_pBuf;
		m_pBuf = NULL;
		m_nSize = 0;
		if(p && bDelete) Free();
		return p;
	};
	char* Attach(char *strBuf,int nSize=0,BOOL bDeletePrev=TRUE)
	{
		PSTR p = Detach(bDeletePrev);
		m_pBuf = strBuf;
		m_nSize = nSize;
		if(m_nSize<=0 && m_pBuf) m_nSize = strlen(m_pBuf) + 1;
		return p;
	};
	char* Allocate(int nSize)
	{
		Detach(TRUE);
		m_pBuf = new char[nSize];
		if(m_pBuf)
		{
			m_nSize = nSize;
			ZEROP(m_pBuf,nSize);
		}
		return m_pBuf;
	};
	operator PSTR()
	{
		assert(m_pBuf);
		return m_pBuf;
	};
	char& operator[](int nIdx)
	{
		assert(m_pBuf!=NULL && m_nSize>nIdx);
		return m_pBuf[nIdx];
	};
public:
	CCSAutoMem()
	{
		m_nSize = 0;
		m_pBuf = NULL;
	};
	CCSAutoMem(int nSize)
	{
		m_nSize = 0;
		m_pBuf = NULL;
		Allocate(nSize);
	};
	CCSAutoMem(PSTR strBuf,int nSize)
	{
		m_nSize = 0;
		m_pBuf = NULL;
		Attach(strBuf,nSize,TRUE);
	};
	~CCSAutoMem()
	{
		Free();
	};
};

class DiskFile
{
public:
	HANDLE m_hFile;
public:
	void Close()
	{
		if(m_hFile!=INVALID_HANDLE_VALUE) CloseHandle(m_hFile);
		m_hFile = INVALID_HANDLE_VALUE;
	};
	BOOL Open(LPCSTR strFileName,DWORD dwAccess,DWORD dwOpen,DWORD dwShare=FILE_SHARE_READ)
	{
		Close();
		m_hFile	= CreateFile(strFileName,dwAccess,dwShare,NULL,dwOpen,0,NULL);
		return m_hFile!=INVALID_HANDLE_VALUE;
	};
	DWORD Read(PVOID pvBuf,int nBufSize)
	{
		if(m_hFile==INVALID_HANDLE_VALUE) return 0;
		DWORD dw = 0;
		if(!ReadFile(m_hFile,pvBuf,nBufSize,&dw,NULL)) return 0;
		return dw;
	};
	DWORD Write(PVOID pvData,int nDataSize)
	{
		if(m_hFile==INVALID_HANDLE_VALUE) return 0;
		DWORD dw = 0;
		if(!WriteFile(m_hFile,pvData,nDataSize,&dw,NULL)) return 0;
		return dw;
	};
	DWORD Write(LPCSTR strData)
	{
		return Write((PVOID)strData,strlen(strData));
	};
	BOOL Rewind()
	{
		if(m_hFile==INVALID_HANDLE_VALUE) return FALSE;
		SetFilePointer(m_hFile,0,NULL,FILE_BEGIN);
		return TRUE;
	};
	BOOL GoToEnd()
	{
		if(m_hFile==INVALID_HANDLE_VALUE) return FALSE;
		SetFilePointer(m_hFile,0,NULL,FILE_END);
		return TRUE;
	};
	DWORD GetSize()
	{
		if(m_hFile==INVALID_HANDLE_VALUE) return 0;
		return GetFileSize(m_hFile,NULL);
	};
	BOOL Seek(LONG lngOffset,BOOL bFromBegin)
	{
		if(m_hFile==INVALID_HANDLE_VALUE) return FALSE;
		SetFilePointer(m_hFile,lngOffset,NULL,bFromBegin ? FILE_BEGIN : FILE_END);
		return TRUE;
	};
	BOOL Empty()
	{
		if(m_hFile==INVALID_HANDLE_VALUE) return FALSE;
		SetFilePointer(m_hFile,0,NULL,FILE_BEGIN);
		SetEndOfFile(m_hFile);
		return TRUE;
	};
public:
	DiskFile()
	{
		m_hFile = INVALID_HANDLE_VALUE;
	};
	DiskFile(LPCSTR strFileName,DWORD dwAccess,DWORD dwOpen,DWORD dwShare)
	{
		Open(strFileName,dwAccess,dwShare);
	};
	~DiskFile()
	{
		Close();
	};
};

template <class T>
class GMemory
{
public:
	int m_nSize;
	T *m_pT;
public:
	void Free()
	{
		if(m_pT) GlobalFree((HGLOBAL)m_pT);
		m_pT = NULL;
		m_nSize = 0;
	};
	T* Alloc(int nSize)
	{
		Free();
		m_pT = (T *)GlobalAlloc(GMEM_FIXED|GMEM_ZEROINIT,nSize);
		m_nSize = nSize;
		return m_pT;
	};
	T* Detach()
	{
		T *pT = m_pT;
		m_pT = NULL;
		m_nSize = 0;
		return pT;
	};
	void Attach(T *pT,int nSize)
	{
		Free();
		m_pT = pT;
		m_nSize = nSize;
	};
public:
	GMemory()
	{
		m_pT = NULL;
		m_nSize = 0;
	};
	GMemory(int nSize)
	{
		Alloc(nSize);
	};
	~GMemory()
	{
		Free();
	};
};

class GMLock
{
	BOOL m_bLocked;
	PSTR m_strBuf;
	HGLOBAL m_hMem;
	int m_nDataSize;
public:
	HGLOBAL GetHandle() const
	{
		return m_hMem;
	};
	int GetDataSize() const
	{
		return m_nDataSize;
	};
	PSTR GetBuffer() const
	{
		return m_strBuf;
	};
public:
	PSTR Lock()
	{
		if(!m_hMem) return NULL;
		if(m_bLocked) return m_strBuf;
		m_nDataSize = (int)GlobalSize(m_hMem);
		if(m_nDataSize<=0) return NULL;
		m_strBuf = (PSTR)GlobalLock(m_hMem);
		m_bLocked = m_strBuf!=NULL;
		return m_strBuf;
	};
	void Unlock()
	{
		if(m_bLocked && m_hMem) GlobalUnlock(m_hMem);
		m_strBuf = NULL;
		m_nDataSize = 0;
		m_bLocked = FALSE;
	};
public:
	GMLock(HGLOBAL hMem)
	{
		m_hMem = hMem;
		m_bLocked = FALSE;
		m_strBuf = NULL;
		m_nDataSize = 0;
		Lock();
	};
	~GMLock()
	{
		Unlock();
	}
};

class GMAllocator
{
	HGLOBAL m_hMem;
public:
	HGLOBAL GetHandle() const
	{
		return m_hMem;
	};
	void Free()
	{
		if(m_hMem) GlobalFree(m_hMem);
		m_hMem = NULL;
	};
	HGLOBAL Allocate(PSTR strData,int nDataSize)
	{
		Free();
		if(!strData || nDataSize<=0) return NULL;
		m_hMem = GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT,(DWORD)nDataSize);
		if(m_hMem)
		{
			GMLock gl(m_hMem);
			memcpy(gl.GetBuffer(),strData,nDataSize);
		}
		return m_hMem;
	};
	HGLOBAL Detach()
	{
		HGLOBAL h = m_hMem;
		m_hMem = NULL;
		return h;
	};
public:
	GMAllocator()
	{
		m_hMem = NULL;
	};
	~GMAllocator()
	{
		Free();
	};
};

template <class T>
class NMemory
{
public:
	int m_nSize;
	T *m_pT;
public:
	void Free()
	{
		if(m_pT) delete [] m_pT;
		m_pT = NULL;
		m_nSize = 0;
	};
	T* Alloc(int nSize)
	{
		Free();
		m_pT = (T *)new char[nSize];
		m_nSize = nSize;
		if(m_pT) memset(m_pT,0,nSize);
		return m_pT;
	};
	T* Detach()
	{
		T *pT = m_pT;
		m_pT = NULL;
		m_nSize = 0;
		return pT;
	};
	void Attach(T *pT,int nSize)
	{
		Free();
		m_pT = pT;
		m_nSize = nSize;
	};
public:
	NMemory()
	{
		m_pT = NULL;
		m_nSize = 0;
	};
	NMemory(int nSize)
	{
		Alloc(nSize);
	};
	~NMemory()
	{
		Free();
	};
};

template <class T>
class Object
{
public:
	T *m_pT;
public:
	void Free()
	{
		if(m_pT) delete m_pT;
		m_pT = NULL;
	};
	T* Alloc()
	{
		Free();
		m_pT = new T;
		return m_pT;
	};
	T* Detach()
	{
		T *pT = m_pT;
		m_pT = NULL;
		return pT;
	};
	void Attach(T *pT)
	{
		Free();
		m_pT = pT;
	};
	T* operator->()
	{
		assert(m_pT);
		return m_pT;
	};
public:
	Object()
	{
		m_pT = NULL;
		Alloc();
	};
	~Object()
	{
		Free();
	};
};

template<class T>
class Destructor
{
	T *m_pT;
public:
	Destructor(T& t)
	{
		m_pT = &t;
	};
	~Destructor()
	{
		if(m_pT) delete m_pT;
	};
	T* operator->()
	{
		return m_pT;
	};
};

//===ByteArray===
enum BITARRAYOPTIONS
{
	_DEFAULT_GROWSIZE = 16,
};
class CSCLSAPI ByteArray
{
	int m_nGrowSize;		//当内部缓冲区不够大时，每次增长的字节数
	int m_nDataSize;		//有效数据的字节数
	int m_nTotalSize;		//内部缓冲区的字节数
	BYTE *m_byData;		//内部缓冲区的指针
public:
	int GetDataSize() const{return m_nDataSize;};
	int GetTotalSize() const{return m_nTotalSize;};
	int GetGrowSize() const{return m_nGrowSize;};
	PSTR GetDataPSTR() const{return (PSTR)m_byData;};
	PCSTR GetDataPCSTR() const{return (PCSTR)m_byData;};
	PBYTE GetDataPBYTE() const{return m_byData;};
	void SetGrowSize(int nGrowSize=_DEFAULT_GROWSIZE)
	{
		assert(nGrowSize>0);
		m_nGrowSize = nGrowSize;
	};
	void SetDataSize(int nDataSize)
	{
		assert(nDataSize<=m_nTotalSize && nDataSize>=0);
		m_nDataSize = nDataSize;
	};
	void Clear()
	{
		m_nDataSize = 0;
		if(m_nTotalSize>0) ZEROP(m_byData,m_nTotalSize);
	};
	BOOL TrimLeft(int nTrimSize)
	{
		assert(nTrimSize>=0);
		EXITON(m_nDataSize<nTrimSize,FALSE);
		m_nDataSize -= nTrimSize;
		if(m_nDataSize>0) memcpy(m_byData,m_byData+nTrimSize,m_nDataSize);
		return TRUE;
	};
	BOOL TrimRight(int nTrimSize)
	{
		assert(nTrimSize>=0);
		EXITONACT(m_nDataSize<=nTrimSize,TRUE,m_nDataSize=0);
		m_nDataSize -= nTrimSize;
		return TRUE;
	};
	BOOL TrimRightFrom(int nFromPos)
	{
		assert(nFromPos>=0);
		return TrimRight(m_nDataSize - nFromPos + 1);
	};
	BOOL TrimRange(int nFromPos,int nBeforePos)
	{
		assert(nFromPos>=0 && nBeforePos>=nFromPos);
		int nTrimSize = nBeforePos - nFromPos;
		EXITON(nTrimSize<=0,TRUE);
		EXITONACT(m_nDataSize<=nTrimSize,TRUE,m_nDataSize=0);
		m_nDataSize -= nTrimSize;
		if(m_nDataSize>nFromPos+1) memmove(m_byData+nFromPos,m_byData+nBeforePos,m_nDataSize-nFromPos-1);
		return TRUE;
	};
	BYTE* Detach(int *pnTotalSize,int *pnDataSize)
	{
		if(pnTotalSize) *pnTotalSize = m_nTotalSize;
		if(pnDataSize) *pnDataSize = m_nDataSize;
		BYTE *by = m_byData;
		m_byData = NULL;
		m_nTotalSize = 0;
		m_nDataSize = 0;
		return by;
	};
public:
	void Free()
	{
		if(m_byData) delete [] m_byData;
		m_byData = NULL;
		m_nTotalSize = 0;
		m_nDataSize = 0;
	};
	BOOL Grow(int nGrowSize)
	{
		assert(m_nTotalSize>=0 && m_nDataSize>=0 && m_nGrowSize>0);
		EXITON(nGrowSize<=0,TRUE);
		nGrowSize += m_nGrowSize - (nGrowSize % m_nGrowSize);
		BYTE *by = new BYTE[m_nTotalSize + nGrowSize];
		EXITON(by==NULL,FALSE);
		ZEROP(by,m_nTotalSize + nGrowSize);
		if(m_nDataSize>0 && m_byData) memcpy(by,m_byData,m_nDataSize);
		if(m_byData) delete [] m_byData;
		m_byData = by;
		m_nTotalSize += nGrowSize;
		return TRUE;
	};
	BOOL Alloc(int nTotalSize)
	{
		assert(nTotalSize>0);
		EXITON(m_nTotalSize>=nTotalSize,TRUE);
		Free();
		return Grow(nTotalSize);
	};
	void Attach(BYTE *byData,int nTotalSize,int nDataSize)
	{
		Free();
		m_byData = byData;
		m_nTotalSize = nTotalSize;
		m_nDataSize = nDataSize;
	};
	BOOL EnsureAlloced(int nTotalSize)
	{
		EXITON(m_nTotalSize>=nTotalSize,TRUE);
		return Grow(nTotalSize - m_nTotalSize);
	};
	BOOL TrimBlank()
	{
		EXITON(m_nTotalSize-m_nDataSize<m_nGrowSize || m_nTotalSize==0,TRUE);
		EXITONACT(m_nDataSize<=0,TRUE,Free());
		int nNeededSize = m_nDataSize;
		assert(m_nGrowSize>0);
		nNeededSize += m_nGrowSize - (m_nDataSize % m_nGrowSize);
		int nDataSize = m_nDataSize;
		int nTotalSize = m_nTotalSize;
		BYTE *by = m_byData;
		m_byData = NULL;
		m_nDataSize = 0;
		m_nTotalSize = 0;
		EXITONACT(Grow(nNeededSize)==FALSE,FALSE,ACT3(m_byData=by,m_nDataSize=nDataSize,m_nTotalSize=nTotalSize));
		if(nDataSize>0 && by) memcpy(m_byData,by,nDataSize);
		m_nDataSize = nDataSize;
		if(by) delete [] by;
		return TRUE;
	};
	BYTE& operator[](int nIdx)
	{
		ENSURE(EnsureAlloced(nIdx+1));
		return m_byData[nIdx];
	};
	BOOL Clone(LPCVOID pvData,int nDataSize)
	{
		Free();
		EXITON(pvData==NULL || nDataSize<=0 || Grow(nDataSize)==FALSE,FALSE);
		memcpy(m_byData,pvData,nDataSize);
		m_nDataSize = nDataSize;
		return TRUE;
	};
	BOOL Clone(LPCSTR strData)
	{
		EXITONACT(strData==NULL,TRUE,Free());
		return Clone((LPCVOID)strData,(int)strlen(strData));
	};
	ByteArray& operator=(LPCSTR strData){Clone(strData);return *this;};
	BOOL Clone(const ByteArray& a)
	{
		EXITONACT(a.m_nDataSize<=0,TRUE,Free());
		m_nGrowSize = a.m_nGrowSize;
		return Clone(a.m_byData,a.m_nDataSize);
	};
	ByteArray& operator=(const ByteArray& a){Clone(a);return *this;};
	BOOL Append(LPCVOID pvData,int nDataSize)
	{
		EXITON(pvData==NULL || nDataSize<=0,FALSE);
		EXITON(EnsureAlloced(m_nDataSize+nDataSize)==FALSE,FALSE);
		memcpy(m_byData+m_nDataSize,pvData,nDataSize);
		m_nDataSize += nDataSize;
		return TRUE;
	};
	BOOL Append(LPCSTR strData)
	{
		EXITON(strData==NULL,FALSE);
		return Append((LPCVOID)strData,(int)strlen(strData));
	};
	ByteArray& operator+=(LPCSTR strData){Append(strData);return *this;};
	ByteArray& operator+=(BYTE by){Append(&by,1);return *this;};
	ByteArray& operator+=(WORD w){Append(&w,2);return *this;};
	ByteArray& operator+=(DWORD dw){Append(&dw,4);return *this;};
	ByteArray& operator+=(char c){return *this+=(BYTE)c;};
	ByteArray& operator+=(short sn){return *this+=(WORD)sn;};
	ByteArray& operator+=(int n){return *this+=(DWORD)n;};
	ByteArray& operator+=(unsigned int un){return *this+=(DWORD)un;};
	BOOL ReplaceAt(int nIdx,BYTE by)
	{
		EXITON(nIdx<0 || m_nDataSize<nIdx,FALSE);
		if(m_nDataSize==nIdx)
		{
			EXITON(EnsureAlloced(m_nDataSize+1),FALSE);
			++m_nDataSize;
		}
		m_byData[nIdx] = by;
		return TRUE;
	};
	BOOL ReplaceAt(int nIdx,WORD w)
	{
		EXITON(nIdx<0 || m_nDataSize<nIdx,FALSE);
		if(m_nDataSize==nIdx)
		{
			EXITON(EnsureAlloced(m_nDataSize+2),FALSE);
			m_nDataSize = 2;
		}
		*((WORD *)(m_byData + nIdx)) = w;
		return TRUE;
	};
	BOOL ReplaceAt(int nIdx,DWORD dw)
	{
		EXITON(nIdx<0 || m_nDataSize<nIdx,FALSE);