codecwizarddlg.h

多种编解码的小程序

			bi.InputQuart(y);
			--nInputSize;
			if(x<=0x08)
			{
				
#ifdef CSLCS_TRACE_CODEC
				sprintf(g_buf,"■发现%02x个相同的数据:%02x\n",x,y);
				TraceFile.Write(g_buf);
#endif
				for(;x>0;--x) bo.OutputQuart((BYTE)(y<<4));
			}
			else
			{
				x -= 0x08;
				assert(nInputSize>=x);
#ifdef CSLCS_TRACE_CODEC
				sprintf(g_buf,"☆发现%02x个不相同的数据:%02x",x,y);
				TraceFile.Write(g_buf);
#endif
				nInputSize -= x;
				for(;x>0;--x)
				{
					bi.InputQuart(y);
					bo.OutputQuart((BYTE)(y<<4));
				}
#ifdef CSLCS_TRACE_CODEC
				sprintf(g_buf,"-%02x\n",y);
				TraceFile.Write(g_buf);
#endif
			}
		}
		bi.InputQuart(x);
		if(x) bo.DiscardBits(x);
		bo.FlushOutput();
		byOutput.Append(bo.GetDataPBYTE(),bo.GetDataSize());
		return nEncodedSize;
	};
public:
	RLEHexCodec()
	{
#ifdef CSLCS_TRACE_CODEC
		TraceFile.Write("RLEHexCodec\n");
#endif
	};
	~RLEHexCodec()
	{
	};
};
//===RLEHexCodec===

class HexLine
{
protected:
	BYTE *m_byData;
	int m_nDataSize;
public:
	int GetDataSize() const
	{
		return m_nDataSize;
	};
	BYTE* GetData() const
	{
		return m_byData;
	};
protected:
	BOOL IsHex(char c)
	{
		return c>='0' && c<='9' || c>='A' && c<='F' || c>='a' && c<='f';
	};
	BYTE ToHex(char c)
	{
		return c<='9' ? c - '0' : c<='F' ? c - 'A' + 10 : c - 'a' + 10;
	};
	BYTE GetByte(LPCSTR& strHex)
	{
		if(!IsHex(*strHex)) return 0;
		BYTE by = ToHex(*strHex);
		++strHex;
		if(!IsHex(*strHex)) return by;
		by <<= 4;
		by |= ToHex(*strHex);
		++strHex;
		return by;
	};
public:
	void Free()
	{
		delete [] m_byData;
		m_byData = NULL;
		m_nDataSize = 0;
	};
	BOOL LoadLine(LPCSTR& strHexLine)
	{
		Free();
		for(;*strHexLine==' ' || *strHexLine=='\r' || *strHexLine=='\n';++strHexLine);
		if(!*strHexLine) return FALSE;
		if(*strHexLine==':') ++strHexLine;
		LPCSTR p = strstr(strHexLine,"\r\n");
		if(!p) p = strHexLine + strlen(strHexLine);
		LPCSTR q = strHexLine;
		for(;q<p;++q) if(!IsHex(*q)) return FALSE;
		m_nDataSize = p - strHexLine;
		BOOL bSingle = m_nDataSize % 2;
		if(bSingle) ++m_nDataSize;
		m_nDataSize >>= 1;
		m_byData = new BYTE[m_nDataSize];
		if(!m_byData)
		{
			m_nDataSize = 0;
			return FALSE;
		}
		int i = 0;
		q = strHexLine;
		strHexLine = p;
		if(bSingle) m_byData[i++] = ToHex(*q++);
		for(;q<p;i)
		{
			m_byData[i] = ToHex(*q++);
			m_byData[i] <<= 4;
			m_byData[i++] |= ToHex(*q++);
		}
		return TRUE;
	};
public:
	HexLine()
	{
		m_byData = NULL;
		m_nDataSize = 0;
	};
	~HexLine()
	{
		Free();
	};
};

class IntelHex
{
public:
	int m_nImgType;
	int m_nStartAddr;
	ByteArray m_baData;
public:
	int GetImgType() const
	{
		return m_nImgType;
	};
	void SetImgType(int nImgType)
	{
		assert(nImgType<=4);
		m_nImgType = nImgType;
	};
	int GetStartAddress() const
	{
		return m_nStartAddr;
	};
	void SetStartAddress(int nStartAddr)
	{
		assert(nStartAddr>=0 && nStartAddr<64*1024);
		m_nStartAddr = nStartAddr;
	};
	int GetDataSize() const
	{
		return m_baData.GetDataSize();
	};
	BYTE* GetData() const
	{
		return m_baData.GetDataPBYTE();
	};
	BOOL SetData(LPCVOID pvData,int nDataSize)
	{
		return m_baData.Clone(pvData,nDataSize);
	};
	BOOL ReplaceAt(int nPos,LPCVOID pvData,int nDataSize)
	{
		return m_baData.ReplaceAt(nPos,pvData,nDataSize);
	};
	void Empty()
	{
		m_baData.Free();
	};
	void Reset()
	{
		m_baData.Free();
		m_nImgType = 0;
		m_nStartAddr = 0;
	};
protected:
	BOOL IsValidLine(BYTE *byData,int nSize) const
	{
		if(nSize<5) return FALSE;
		if(byData[0]!=nSize-5) return FALSE;
		if(byData[3]>(BYTE)5) return FALSE;
		BYTE by = 0;
		for(int i=0;i<nSize-1;++i) by += byData[i];
		by = ~by;
		++by;
		return (by==byData[nSize-1]);//checksum
	};
	BYTE DoChecksum(BYTE *byData,int nSize) const
	{
		BYTE by = 0;
		for(;nSize>0;by += *byData++);
		by = ~by;
		++by;
		return by;
	};
public:
	BOOL Load(LPCSTR strFilePath)
	{
		DiskFile df;
		if(!df.Open(strFilePath,GENERIC_READ,OPEN_EXISTING)) return FALSE;
		DWORD dw = df.GetSize();
		GMemory<char>gm(dw + 4);
		if(!gm.m_pT) return FALSE;
		if(df.Read(gm.m_pT,dw)!=dw) return FALSE;
		Reset();
		LPCSTR p = (LPCSTR)gm.m_pT;
		HexLine hl;
		BYTE *by = NULL;
		int nSize;
		DWORD dwOffset = 0;
		for(;hl.LoadLine(p);)
		{
			by = hl.GetData();
			nSize = hl.GetDataSize();
			if(IsValidLine(by,nSize))
			{
				switch(by[3])
				{
				case 0:
					if(m_nImgType==0)
					{
						//TRACE("bad img type\n");
						return FALSE;//unknow img
					}
					if((DWORD)(by[1]<<8 | by[2]) != dwOffset)
					{
						//TRACE("bad offset\n");
						return FALSE;//there is a hole in memory
					}
					if(!m_baData.Append(by+4,by[0])) assert(FALSE);
					dwOffset+=by[0];
					break;
				case 1:
					return TRUE;
				default:
					assert(by[0]==2);
					assert(m_nImgType==0 && m_nStartAddr==0);
					if(by[0]!=2 || m_nImgType!=0 && m_nStartAddr!=0)
					{
						//TRACE("multiple img type\n");
						return FALSE;
					}
					m_nImgType = by[3];
					m_nStartAddr = (int)((by[4] << 8) | by[5]);
				}
			}
		}
		//TRACE("no end line\n");
		return FALSE;//no end line found
	};
	BOOL Save(LPCSTR strFilePath)
	{
		if(m_baData.GetDataSize()<=0) return FALSE;//empty file
		DiskFile df;
		if(!df.Open(strFilePath,GENERIC_WRITE,CREATE_ALWAYS)) return FALSE;
		df.Empty();
		char buf[128];
		BYTE temp[16];
		memset(buf,0,sizeof(buf));
		memset(temp,0,sizeof(temp));
		temp[0] = 0x02;
		temp[1] = 0x00;
		temp[2] = 0x00;
		temp[3] = (BYTE)m_nImgType;
		temp[4] = (BYTE)(m_nStartAddr>>8);
		temp[5] = (BYTE)m_nStartAddr;
		sprintf(buf,":020000%02X%04X%02X\r\n",(BYTE)m_nImgType,(WORD)m_nStartAddr,DoChecksum(temp,6));
		if(df.Write(buf)!=strlen(buf)) return FALSE;//write error
		BYTE *by = m_baData.GetDataPBYTE();
		int nLen = m_baData.GetDataSize();
		DWORD dwOffset = 0;
		for(;nLen>=16;nLen-=16,dwOffset+=16,by+=16)
		{
			sprintf(buf,":10%04X00%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X\r\n",
				dwOffset,by[0],by[1],by[2],by[3],by[4],by[5],by[6],by[7],by[8],by[9],by[10],by[11],
				by[12],by[13],by[14],by[15],
				DoChecksum(by,16));
			if(df.Write(buf)!=strlen(buf)) return FALSE;//write error
		}
		if(nLen>0)
		{
			char *p = buf;
			sprintf(p,":%02X%04X00",(BYTE)nLen,dwOffset);
			BYTE byChecksum = DoChecksum(by,nLen);
			for(p+=strlen(p);nLen>0;--nLen,p+=strlen(p)) sprintf(p,"%02X",*by++);
			sprintf(p,"%02X\r\n",byChecksum);
			if(df.Write(buf)!=strlen(buf)) return FALSE;//write error
		}
		if(df.Write(":00000001FF\r\n")!=strlen(":00000001FF\r\n")) return FALSE;
		return TRUE;
	};
public:
	IntelHex()
	{
		m_baData.SetGrowSize(1024);
	};
	IntelHex& operator=(const IntelHex& aih)
	{
		m_nImgType = aih.m_nImgType;
		m_nStartAddr = aih.m_nStartAddr;
		m_baData = aih.m_baData;
		return *this;
	};
	IntelHex(const IntelHex& aih)
	{
		*this = aih;
	};
	BOOL operator==(const IntelHex& aih)
	{
		return m_nImgType==aih.m_nImgType
			&& m_nStartAddr==aih.m_nStartAddr
			&& m_baData==aih.m_baData;
	};
	BOOL operator!=(const IntelHex& aih)
	{
		return !(*this==aih);
	};
	~IntelHex(){};
};

class DllLoader
{
public:
	HMODULE m_hLib;
public:
	void Unload()
	{
		if(m_hLib) FreeLibrary(m_hLib);
		m_hLib = NULL;
	};
	BOOL Load(LPCSTR strDllName)
	{
		m_hLib = LoadLibrary(strDllName);
		return m_hLib!=NULL;
	};
	HMODULE Detach()
	{
		HMODULE hLib = m_hLib;
		m_hLib = NULL;
		return hLib;
	};
	HMODULE GetHandle() const
	{
		return m_hLib;
	};
	void Attach(HMODULE hLib)
	{
		Unload();
		m_hLib = hLib;
	};
	operator HMODULE()
	{
		return m_hLib;
	};
public:
	DllLoader()
	{
		m_hLib = NULL;
	};
	DllLoader(LPCSTR strDllName)
	{
		Load(strDllName);
	};
	~DllLoader()
	{
		Unload();
	};
};

template<class T>
T FnFinder(HMODULE hLib,LPCSTR strFnName)
{
	if(!hLib) return NULL;
	return (T)GetProcAddress(hLib,strFnName);
};

class FileVerifier
{
public:
	FileVerifier(){};
	~FileVerifier(){};
public:
	BOOL IsExisting(LPCSTR strFileName) const
	{
		WIN32_FIND_DATA fd;
		HANDLE h = FindFirstFile(strFileName,&fd);
		if(h) FindClose(h);
		return h!=NULL;
	};
	BOOL IsNonempty(LPCSTR strFileName) const
	{
		WIN32_FIND_DATA fd;
		HANDLE h = FindFirstFile(strFileName,&fd);
		if(!h) return FALSE;
		DWORD dw = GetFileSize(h,NULL);
		FindClose(h);
		return (dw!=0);
	};
};

enum CODECMOTHOD
{
	CODEC_HEX,
	CODEC_HEX2C,
	CODEC_URL,
	CODEC_UTF7,	//SE64
	CODEC_RLE,
	CODEC_RLEHEX,
	CODEC_TRANS8,
	CODEC_TRANS2S,
	CODEC_TRANS1CYCLE,
	CODEC_UTF8,
	CODEC_ZIP,
	CODEC_RAR,
	CODEC_UU,
	CODEC_CAB,
	CODEC_ACE,
	CODEC_BZ2,
	CODEC_LZW,
	CODEC_LZ77,
};

class Hotkey
{
	ATOM m_hAtom;
	HWND m_hWnd;
	BOOL m_bRegistered;
	UINT m_nCmdID;
public:
	BOOL IsRegistered() const
	{
		return m_bRegistered;
	};
	void Unregister()
	{
		if(m_bRegistered) UnregisterHotKey(m_hWnd,m_hAtom);
		DeleteAtom(m_hAtom);
		m_nCmdID = 0;
		m_bRegistered = FALSE;
		m_hAtom = 0;
		m_hWnd = NULL;
	};
	BOOL Register(HWND hWnd,UINT unModifier,UINT unVirtualKey,UINT nCmdID)
	{
		char buf[128];
		sprintf(buf,"%p%d%d",hWnd,unModifier,unVirtualKey);
		m_hAtom = AddAtom(buf);
		if(!m_hAtom) return FALSE;
		m_hWnd = hWnd;
		m_nCmdID = nCmdID;
		ASSERT(nCmdID);
		m_bRegistered = RegisterHotKey(hWnd,m_hAtom,unModifier,unVirtualKey);
		return m_bRegistered;
	};
	BOOL ProcessCmd(ATOM hAtom)
	{
		if(hAtom==m_hAtom) return PostMessage(m_hWnd,WM_COMMAND,m_nCmdID,0);
		return FALSE;
	};
public:
	Hotkey()
	{
		m_nCmdID = 0;
		m_bRegistered = FALSE;
		m_hAtom = 0;
		m_hWnd = NULL;
	};
	~Hotkey()
	{
		Unregister();
	};
};

class Clipper
{
	BOOL m_bOpened;
public:
	void Close()
	{
		if(m_bOpened) CloseClipboard();
		m_bOpened = FALSE;
	};
	BOOL Open()
	{
		Close();
		m_bOpened = OpenClipboard(NULL);
		return m_bOpened;
	};
public:
	Clipper()
	{
		m_bOpened = FALSE;
	};
	~Clipper()
	{
		Close();
	};
};

class ClipperData
{
	UINT m_nFormat;
	int m_nDataLen;
	PSTR m_strData;
public:
	UINT GetDataFormat() const
	{
		return m_nFormat;
	};
	PSTR GetBuffer() const
	{
		return m_strData;
	};
	int GetDataSize() const
	{
		return m_nDataLen;
	};
	void Free()
	{
		if(m_strData) delete [] m_strData;
		m_strData = NULL;
		m_nDataLen = 0;
	};
	PSTR Dumplicate()
	{
		Free();
		Clipper c;
		if(!c.Open()) return NULL;
		m_nFormat = EnumClipboardFormats(0);
		if(!m_nFormat) return NULL;
		GMLock gl(GetClipboardData(m_nFormat));
		if(!gl.GetHandle() || gl.GetDataSize()<=0) return NULL;
		m_nDataLen = gl.GetDataSize();
		CCSAutoMem m;
		if(!m.Allocate(m_nDataLen)) return NULL;
		memcpy(m.m_pBuf,gl.GetBuffer(),m_nDataLen);
		m_strData = m.Detach(FALSE);
		return m_strData;
	};
	BOOL SetClipData(PSTR strData,int nDataLen,int nFormat)
	{
		GMAllocator ga;
		if(!ga.Allocate(strData,nDataLen)) return FALSE;
		Clipper c;
		if(!c.Open()) return FALSE;
		if(SetClipboardData(nFormat,ga.GetHandle()))
		{
			ga.Detach();
			return TRUE;
		}
		return FALSE;
	};
	BOOL SetClipData(PSTR strData,int nDataLen,LPCSTR strFormatName)
	{
		UINT nFormat = RegisterClipboardFormat(strFormatName);
		if(!nFormat) return FALSE;
		return SetClipData(strData,nDataLen,nFormat);
	};
	CCSAutoMem& Detach()
	{
		CCSAutoMem& m = *(new CCSAutoMem);
		if(m_strData && m_nDataLen) m.Attach(m_strData,m_nDataLen,TRUE);
		m_strData = NULL;
		m_nFormat = 0;
		m_nDataLen = 0;
		return m;
	};
public:
	ClipperData()
	{
		m_nFormat = 0;
		m_nDataLen = 0;
		m_strData = NULL;
	};
	~ClipperData()
	{
		Free();
	};
};

class CCodecWizardDlg : public CDialog
{
// Construction
	int m_nMinHeight;
	int m_nMinWidth;
	Hotkey m_hotKey;
	Hotkey m_Encode;
	Hotkey m_Decode;
public:
	void SetOutput(ByteArray& mem,int nMethod,BOOL bEncode);
	CCSAutoMem& GetInput(int nMethod,BOOL bEncode);
	void ClearAll();
	BOOL TryGetText(CCSAutoMem& m);
	CCSAutoMem& TryGetBin(CCSAutoMem& m);
	BOOL m_bInitOK;
	HACCEL m_hAccel;
	CCodecWizardDlg(CWnd* pParent = NULL);	// standard constructor

// Dialog Data
	//{{AFX_DATA(CCodecWizardDlg)
	enum { IDD = IDD_CODECWIZARD_DIALOG };
		// NOTE: the ClassWizard will add data members here
	//}}AFX_DATA

	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CCodecWizardDlg)
	public:
	virtual BOOL PreTranslateMessage(MSG* pMsg);
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);	// DDX/DDV support
	//}}AFX_VIRTUAL

// Implementation
protected:
	HICON m_hIcon;

	// Generated message map functions
	//{{AFX_MSG(CCodecWizardDlg)
	virtual BOOL OnInitDialog();
	afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
	afx_msg void OnPaint();
	afx_msg HCURSOR OnQueryDragIcon();
	virtual void OnCancel();
	afx_msg void OnPaste();
	afx_msg void OnCopy();
	virtual void OnOK();
	afx_msg void OnDecode();
	afx_msg void OnSize(UINT nType, int cx, int cy);
	afx_msg void OnSizing(UINT fwSide, LPRECT pRect);
	afx_msg void OnAlldone();
	afx_msg void OnAllundo();
	afx_msg void OnShow();
	afx_msg void OnHotkey(ATOM hAtom,DWORD dwKey);
	afx_msg void OnFile();
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_CODECWIZARDDLG_H__945F034D_C3CB_4CCB_8D8A_2B048B70D693__INCLUDED_)