Archived News
Search News Discussion Forum
Old Forum Install Programs More Downloads...
Troubleshooting Source Code
Format Specs.
Misc. Information
Non-SF Stuff
Links
Small banner for links to this site:
diff --git a/grpapi/grpapi.cpp b/grpapi/grpapi.cpp
--- a/grpapi/grpapi.cpp
+++ b/grpapi/grpapi.cpp
#include "grpapi.h"\r
-#include "..\\LoadStorm\\storm.h"\r
+#include "../LoadStorm/storm.h"\r
#include <malloc.h>\r
\r
#ifdef GRPAPI_STATIC\r
DWORD Offset;\r
} FRAMEHEADER;\r
\r
-void __inline SetPix(HDC hDC, int X, int Y, COLORREF clrColor, DWORD dwFlags, DWORD dwAlpha);\r
+typedef struct {\r
+ WORD *lpRowOffsets;\r
+ WORD *lpRowSizes;\r
+ LPBYTE *lpRowData;\r
+} FRAMEDATA;\r
+\r
+GETPIXELPROC MyGetPixel = GetPixel;\r
+SETPIXELPROC MySetPixel = (SETPIXELPROC)SetPixelV;\r
+\r
+void __inline SetPix(HDC hDC, int X, int Y, COLORREF clrColor, DWORD *dwPalette, DWORD dwFlags, DWORD dwAlpha);\r
+void EncodeFrameData(signed short *lpImageData, WORD nFrame, GRPHEADER *lpGrpHeader, FRAMEHEADER *lpFrameHeader, FRAMEDATA *lpFrameData);\r
+BOOL VerifyRow(signed short *lpRawRow, int nWidth, LPBYTE lpEncRow, int nSize);\r
\r
extern HINSTANCE hStorm;\r
\r
\r
BOOL GRPAPI WINAPI LoadGrpApi()\r
{\r
- if (hStorm==0) return FALSE;\r
+ if (!hStorm) return FALSE;\r
else return TRUE;\r
}\r
\r
{\r
}\r
\r
+/*\r
+HANDLE hProcessHeap = NULL;\r
+\r
+void * SFAlloc(size_t nSize)\r
+{\r
+ if (!hProcessHeap) hProcessHeap = GetProcessHeap();\r
+ if (hProcessHeap) return HeapAlloc(hProcessHeap, 0, nSize);\r
+ else return NULL;\r
+}\r
+\r
+void SFFree(void *lpMem)\r
+{\r
+ if (!hProcessHeap) hProcessHeap = GetProcessHeap();\r
+ if (hProcessHeap) HeapFree(hProcessHeap, 0, lpMem);\r
+}\r
+*/\r
+\r
+BOOL GRPAPI WINAPI SetMpqDll(LPCSTR lpDllFileName)\r
+{\r
+ if (LoadStorm((char *)lpDllFileName)) return TRUE;\r
+ else return FALSE;\r
+}\r
+\r
BOOL GRPAPI WINAPI LoadPalette(LPCSTR lpFileName, DWORD *dwPaletteBuffer)\r
{\r
- if (lpFileName==0 || dwPaletteBuffer==0) return FALSE;\r
+ if (!lpFileName || !dwPaletteBuffer) return FALSE;\r
HANDLE hFile;\r
- if (SFileOpenFileEx!=0 && SFileGetFileSize!=0\r
- && SFileSetFilePointer!=0 && SFileReadFile!=0\r
- && SFileCloseFile!=0) {\r
- if (SFileOpenFileEx(0,lpFileName,1,&hFile)==0) return FALSE;\r
+ if (SFileOpenFileEx && SFileGetFileSize\r
+ && SFileSetFilePointer && SFileReadFile\r
+ && SFileCloseFile) {\r
+ if (!SFileOpenFileEx(0,lpFileName,1,&hFile)) return FALSE;\r
DWORD fsz = SFileGetFileSize(hFile,0);\r
SFileSetFilePointer(hFile,0,0,FILE_BEGIN);\r
if (fsz>=1024) {\r
\r
HANDLE GRPAPI WINAPI LoadGrp(LPCSTR lpFileName)\r
{\r
- if (lpFileName==0) return (HANDLE)-1;\r
+ if (!lpFileName) return (HANDLE)-1;\r
HANDLE hFile;\r
char *GrpFile;\r
- if (SFileOpenFileEx!=0 && SFileGetFileSize!=0\r
- && SFileSetFilePointer!=0 && SFileReadFile!=0\r
- && SFileCloseFile!=0) {\r
- if (SFileOpenFileEx(0,lpFileName,1,&hFile)==0) return (HANDLE)-1;\r
+ if (SFileOpenFileEx && SFileGetFileSize\r
+ && SFileSetFilePointer && SFileReadFile\r
+ && SFileCloseFile) {\r
+ if (!SFileOpenFileEx(0,lpFileName,1,&hFile)) return (HANDLE)-1;\r
DWORD fsz = SFileGetFileSize(hFile,0);\r
if (fsz<6) {\r
SFileCloseFile(hFile);\r
return (HANDLE)-1;\r
}\r
- GrpFile = (char *)VirtualAlloc(0,fsz,MEM_COMMIT,PAGE_READWRITE);\r
- if (GrpFile!=0) {\r
+ GrpFile = (char *)malloc(fsz);\r
+ if (GrpFile) {\r
SFileSetFilePointer(hFile,0,0,FILE_BEGIN);\r
SFileReadFile(hFile,GrpFile,fsz,0,0);\r
}\r
CloseHandle(hFile);\r
return (HANDLE)-1;\r
}\r
- GrpFile = (char *)VirtualAlloc(0,fsz,MEM_COMMIT,PAGE_READWRITE);\r
- if (GrpFile!=0) {\r
+ GrpFile = (char *)malloc(fsz);\r
+ if (GrpFile) {\r
SetFilePointer(hFile,0,0,FILE_BEGIN);\r
ReadFile(hFile,GrpFile,fsz,&tsz,0);\r
}\r
\r
BOOL GRPAPI WINAPI DestroyGrp(HANDLE hGrp)\r
{\r
- if (hGrp==0 || hGrp==INVALID_HANDLE_VALUE) return FALSE;\r
- VirtualFree(hGrp,0,MEM_RELEASE);\r
+ if (!hGrp || hGrp==INVALID_HANDLE_VALUE) return FALSE;\r
+ free(hGrp);\r
return TRUE;\r
}\r
\r
BOOL GRPAPI WINAPI DrawGrp(HANDLE hGrp, HDC hdcDest, int nXDest, int nYDest, WORD nFrame, DWORD *dwPalette, DWORD dwFlags, DWORD dwAlpha)\r
{\r
- if (hGrp==0 || hGrp==INVALID_HANDLE_VALUE || hdcDest==0 || dwPalette==0) return FALSE;\r
+ if (!hGrp || hGrp==INVALID_HANDLE_VALUE || hdcDest==0 || (!dwPalette && !(dwFlags&USE_INDEX))) return FALSE;\r
GRPHEADER *GrpFile = (GRPHEADER *)hGrp;\r
nFrame %= GrpFile->nFrames;\r
FRAMEHEADER *GrpFrame = &((FRAMEHEADER *)(((char *)GrpFile)+6))[nFrame];\r
+ FRAMEHEADER *GrpFrames = &((FRAMEHEADER *)(((char *)GrpFile)+6))[0];\r
+ int FrameSize = 0xFFFFFF;\r
DWORD Right,Bottom;\r
if (dwFlags&HORIZONTAL_FLIP) Right = nXDest+GrpFile->wMaxWidth-1-GrpFrame->Left;\r
if (dwFlags&VERTICAL_FLIP) Bottom = nYDest+GrpFile->wMaxHeight-1-GrpFrame->Top;\r
nXDest += GrpFrame->Left;\r
nYDest += GrpFrame->Top;\r
WORD *GrpOffsets = ((WORD *)(((char *)GrpFile)+GrpFrame->Offset));\r
- for (DWORD y=0;y<GrpFrame->Height;y++) {\r
- BYTE *RowData = ((BYTE *)(((char *)GrpOffsets)+GrpOffsets[y]));\r
- WORD x=0,ofs=0;\r
- while (x<GrpFrame->Width) {\r
- if (RowData[ofs]<=64) {\r
- if ((dwFlags&HORIZONTAL_FLIP)==0 && (dwFlags&VERTICAL_FLIP)==0) {\r
- for (WORD i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
- SetPix(hdcDest,nXDest+x,nYDest+y,dwPalette[RowData[ofs+i]],dwFlags,dwAlpha);\r
- x++;\r
+ BYTE *GrpRaw = (BYTE *)GrpOffsets;\r
+ BYTE *RowData;\r
+ WORD x,ofs;\r
+ DWORD y;\r
+ WORD i;\r
+ int j;\r
+ if (nFrame + 1 < GrpFile->nFrames) {\r
+ for (i = 0; i + 1 < GrpFile->nFrames; i++) {\r
+ j = GrpFrames[i].Offset - GrpFrame->Offset;\r
+ if (j > 0 && j < FrameSize)\r
+ FrameSize = j;\r
+ }\r
+ }\r
+ if (FrameSize == 0xFFFFFF || FrameSize == GrpFrame->Width * GrpFrame->Height) {\r
+ FrameSize = 0xFFFFFF;\r
+ for (i = 0; i + 1 < GrpFile->nFrames; i++) {\r
+ j = GrpFrames[i].Offset - GrpFrames[0].Offset;\r
+ if (j > 0 && j < FrameSize)\r
+ FrameSize = j;\r
+ }\r
+ if (FrameSize == GrpFrames[0].Width * GrpFrames[0].Height)\r
+ FrameSize = GrpFrame->Width * GrpFrame->Height;\r
+ }\r
+ if (!(dwFlags&HORIZONTAL_FLIP) && !(dwFlags&VERTICAL_FLIP)) {\r
+ if (FrameSize != GrpFrame->Width * GrpFrame->Height) {\r
+ for (y=0;y<GrpFrame->Height;y++) {\r
+ RowData = ((BYTE *)(((char *)GrpOffsets)+GrpOffsets[y]));\r
+ x=0; ofs=0;\r
+ while (x<GrpFrame->Width) {\r
+ if (!(RowData[ofs] & 0x80)) {\r
+ if (!(RowData[ofs] & 0x40)) {\r
+ for (i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
+ SetPix(hdcDest,nXDest+x,nYDest+y,RowData[ofs+i],dwPalette,dwFlags,dwAlpha);\r
+ x++;\r
+ }\r
+ ofs+=RowData[ofs]+1;\r
+ }\r
+ else {\r
+ for (i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
+ SetPix(hdcDest,nXDest+x,nYDest+y,RowData[ofs+1],dwPalette,dwFlags,dwAlpha);\r
+ x++;\r
+ }\r
+ ofs+=2;\r
+ }\r
}\r
- }\r
- else if (dwFlags&HORIZONTAL_FLIP && (dwFlags&VERTICAL_FLIP)==0) {\r
- for (WORD i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
- SetPix(hdcDest,Right-x,nYDest+y,dwPalette[RowData[ofs+i]],dwFlags,dwAlpha);\r
- x++;\r
+ else {\r
+ x+=RowData[ofs]-128;\r
+ ofs++;\r
}\r
}\r
- else if ((dwFlags&HORIZONTAL_FLIP)==0 && dwFlags&VERTICAL_FLIP) {\r
- for (WORD i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
- SetPix(hdcDest,nXDest+x,Bottom-y,dwPalette[RowData[ofs+i]],dwFlags,dwAlpha);\r
- x++;\r
- }\r
+ }\r
+ }\r
+ else {\r
+ for (y=0;y<GrpFrame->Height;y++) {\r
+ for (x=0;x<GrpFrame->Width;x++) {\r
+ SetPix(hdcDest,nXDest+x,nYDest+y,GrpRaw[y * GrpFrame->Width + x],dwPalette,dwFlags,dwAlpha);\r
}\r
- else {\r
- for (WORD i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
- SetPix(hdcDest,Right-x,Bottom-y,dwPalette[RowData[ofs+i]],dwFlags,dwAlpha);\r
- x++;\r
+ }\r
+ }\r
+ }\r
+ else if (dwFlags&HORIZONTAL_FLIP && !(dwFlags&VERTICAL_FLIP)) {\r
+ if (FrameSize != GrpFrame->Width * GrpFrame->Height) {\r
+ for (y=0;y<GrpFrame->Height;y++) {\r
+ RowData = ((BYTE *)(((char *)GrpOffsets)+GrpOffsets[y]));\r
+ x=0; ofs=0;\r
+ while (x<GrpFrame->Width) {\r
+ if (!(RowData[ofs] & 0x80)) {\r
+ if (!(RowData[ofs] & 0x40)) {\r
+ for (i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
+ SetPix(hdcDest,Right-x,nYDest+y,RowData[ofs+i],dwPalette,dwFlags,dwAlpha);\r
+ x++;\r
+ }\r
+ ofs+=RowData[ofs]+1;\r
+ }\r
+ else {\r
+ for (i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
+ SetPix(hdcDest,Right-x,nYDest+y,RowData[ofs+1],dwPalette,dwFlags,dwAlpha);\r
+ x++;\r
+ }\r
+ ofs+=2;\r
+ }\r
+ }\r
+ else {\r
+ x+=RowData[ofs]-128;\r
+ ofs++;\r
}\r
}\r
- ofs+=RowData[ofs]+1;\r
}\r
- else if (RowData[ofs]<=128) {\r
- if ((dwFlags&HORIZONTAL_FLIP)==0 && (dwFlags&VERTICAL_FLIP)==0) {\r
- for (WORD i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
- SetPix(hdcDest,nXDest+x,nYDest+y,dwPalette[RowData[ofs+1]],dwFlags,dwAlpha);\r
- x++;\r
- }\r
+ }\r
+ else {\r
+ for (y=0;y<GrpFrame->Height;y++) {\r
+ for (x=0;x<GrpFrame->Width;x++) {\r
+ SetPix(hdcDest,Right-x,nYDest+y,GrpRaw[y * GrpFrame->Width + x],dwPalette,dwFlags,dwAlpha);\r
}\r
- else if (dwFlags&HORIZONTAL_FLIP && (dwFlags&VERTICAL_FLIP)==0) {\r
- for (WORD i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
- SetPix(hdcDest,Right-x,nYDest+y,dwPalette[RowData[ofs+1]],dwFlags,dwAlpha);\r
- x++;\r
+ }\r
+ }\r
+ }\r
+ else if (!(dwFlags&HORIZONTAL_FLIP) && dwFlags&VERTICAL_FLIP) {\r
+ if (FrameSize != GrpFrame->Width * GrpFrame->Height) {\r
+ for (y=0;y<GrpFrame->Height;y++) {\r
+ RowData = ((BYTE *)(((char *)GrpOffsets)+GrpOffsets[y]));\r
+ x=0; ofs=0;\r
+ while (x<GrpFrame->Width) {\r
+ if (!(RowData[ofs] & 0x80)) {\r
+ if (!(RowData[ofs] & 0x40)) {\r
+ for (i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
+ SetPix(hdcDest,nXDest+x,Bottom-y,RowData[ofs+i],dwPalette,dwFlags,dwAlpha);\r
+ x++;\r
+ }\r
+ ofs+=RowData[ofs]+1;\r
+ }\r
+ else {\r
+ for (i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
+ SetPix(hdcDest,nXDest+x,Bottom-y,RowData[ofs+1],dwPalette,dwFlags,dwAlpha);\r
+ x++;\r
+ }\r
+ ofs+=2;\r
+ }\r
}\r
- }\r
- else if ((dwFlags&HORIZONTAL_FLIP)==0 && dwFlags&VERTICAL_FLIP) {\r
- for (WORD i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
- SetPix(hdcDest,nXDest+x,Bottom-y,dwPalette[RowData[ofs+1]],dwFlags,dwAlpha);\r
- x++;\r
+ else {\r
+ x+=RowData[ofs]-128;\r
+ ofs++;\r
}\r
}\r
- else {\r
- for (WORD i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
- SetPix(hdcDest,Right-x,Bottom-y,dwPalette[RowData[ofs+1]],dwFlags,dwAlpha);\r
- x++;\r
+ }\r
+ }\r
+ else {\r
+ for (y=0;y<GrpFrame->Height;y++) {\r
+ for (x=0;x<GrpFrame->Width;x++) {\r
+ SetPix(hdcDest,nXDest+x,Bottom-y,GrpRaw[y * GrpFrame->Width + x],dwPalette,dwFlags,dwAlpha);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ else {\r
+ if (FrameSize != GrpFrame->Width * GrpFrame->Height) {\r
+ for (y=0;y<GrpFrame->Height;y++) {\r
+ RowData = ((BYTE *)(((char *)GrpOffsets)+GrpOffsets[y]));\r
+ x=0; ofs=0;\r
+ while (x<GrpFrame->Width) {\r
+ if (!(RowData[ofs] & 0x80)) {\r
+ if (!(RowData[ofs] & 0x40)) {\r
+ for (i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
+ SetPix(hdcDest,Right-x,Bottom-y,RowData[ofs+i],dwPalette,dwFlags,dwAlpha);\r
+ x++;\r
+ }\r
+ ofs+=RowData[ofs]+1;\r
+ }\r
+ else {\r
+ for (i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
+ SetPix(hdcDest,Right-x,Bottom-y,RowData[ofs+1],dwPalette,dwFlags,dwAlpha);\r
+ x++;\r
+ }\r
+ ofs+=2;\r
+ }\r
+ }\r
+ else {\r
+ x+=RowData[ofs]-128;\r
+ ofs++;\r
}\r
}\r
- ofs+=2;\r
}\r
- else {\r
- x+=RowData[ofs]-128;\r
- ofs++;\r
+ }\r
+ else {\r
+ for (y=0;y<GrpFrame->Height;y++) {\r
+ for (x=0;x<GrpFrame->Width;x++) {\r
+ SetPix(hdcDest,Right-x,Bottom-y,GrpRaw[y * GrpFrame->Width + x],dwPalette,dwFlags,dwAlpha);\r
+ }\r
}\r
}\r
}\r
@@ -253,46 +396,356 @@ BOOL GRPAPI WINAPI DrawGrp(HANDLE hGrp, HDC hdcDest, int nXDest, int nYDest, WOR
\r
BOOL GRPAPI WINAPI GetGrpInfo(HANDLE hGrp, GRPHEADER *GrpInfo)\r
{\r
- if (hGrp==0 || hGrp==INVALID_HANDLE_VALUE || GrpInfo==0) return FALSE;\r
+ if (!hGrp || hGrp==INVALID_HANDLE_VALUE || !GrpInfo) return FALSE;\r
memcpy(GrpInfo,hGrp,6);\r
return TRUE;\r
}\r
\r
-void __inline SetPix(HDC hDC, int X, int Y, COLORREF clrColor, DWORD dwFlags, DWORD dwAlpha)\r
+BOOL GRPAPI WINAPI GetGrpFrameInfo(HANDLE hGrp, WORD nFrame, DWORD *nLeft, DWORD *nTop, DWORD *nWidth, DWORD *nHeight)\r
{\r
- if (dwFlags&SHADOW_COLOR) {\r
- ((BYTE *)&clrColor)[0] = ((BYTE *)&dwFlags)[1];\r
- ((BYTE *)&clrColor)[1] = ((BYTE *)&dwFlags)[2];\r
- ((BYTE *)&clrColor)[2] = ((BYTE *)&dwFlags)[3];\r
- ((BYTE *)&clrColor)[3] = 0;\r
+ if (!hGrp || hGrp==INVALID_HANDLE_VALUE) return FALSE;\r
+ FRAMEHEADER *GrpFrame = &((FRAMEHEADER *)(((char *)hGrp)+6))[nFrame];\r
+\r
+ if (nLeft) *nLeft = GrpFrame->Left;\r
+ if (nTop) *nTop = GrpFrame->Top;\r
+ if (nWidth) *nWidth = GrpFrame->Width;\r
+ if (nHeight) *nHeight = GrpFrame->Height;\r
+\r
+ return TRUE;\r
+}\r
+\r
+void GRPAPI WINAPI SetFunctionGetPixel(GETPIXELPROC lpGetPixelProc)\r
+{\r
+ if (!lpGetPixelProc)\r
+ MyGetPixel = GetPixel;\r
+ else\r
+ MyGetPixel = lpGetPixelProc;\r
+}\r
+\r
+void GRPAPI WINAPI SetFunctionSetPixel(SETPIXELPROC lpSetPixelProc)\r
+{\r
+ if (!lpSetPixelProc)\r
+ MySetPixel = (SETPIXELPROC)SetPixelV;\r
+ else\r
+ MySetPixel = lpSetPixelProc;\r
+}\r
+\r
+void __inline SetPix(HDC hDC, int X, int Y, COLORREF clrColor, DWORD *dwPalette, DWORD dwFlags, DWORD dwAlpha)\r
+{\r
+ if (!(dwFlags&USE_INDEX)) {\r
+ if (dwFlags&SHADOW_COLOR) {\r
+ clrColor = (dwFlags >> 8) & 0x00FFFFFF;\r
+ }\r
+ else {\r
+ clrColor = dwPalette[clrColor];\r
+ }\r
+ if (dwFlags&ALPHA_BLEND) {\r
+ DWORD dwColor = MyGetPixel(hDC,X,Y);\r
+\r
+ // Old alpha\r
+ /*((BYTE *)&dwColor)[0]*=1-((float)((BYTE *)&dwAlpha)[0]/256);\r
+ ((BYTE *)&dwColor)[1]*=1-((float)((BYTE *)&dwAlpha)[1]/256);\r
+ ((BYTE *)&dwColor)[2]*=1-((float)((BYTE *)&dwAlpha)[2]/256);\r
+ ((BYTE *)&clrColor)[0]*=(float)((BYTE *)&dwAlpha)[0]/256;\r
+ ((BYTE *)&clrColor)[1]*=(float)((BYTE *)&dwAlpha)[1]/256;\r
+ ((BYTE *)&clrColor)[2]*=(float)((BYTE *)&dwAlpha)[2]/256;\r
+ ((BYTE *)&clrColor)[0]+=((BYTE *)&dwColor)[0];\r
+ ((BYTE *)&clrColor)[1]+=((BYTE *)&dwColor)[1];\r
+ ((BYTE *)&clrColor)[2]+=((BYTE *)&dwColor)[2];*/\r
+\r
+ /* blendedcolor =\r
+ ( ( forecolor * ( 1 - alpha ) ) >> 8 )\r
+ + ( ( backcolor * ( 256 - alpha ) ) >> 8 ) */\r
+ ((BYTE *)&clrColor)[0] =\r
+ ( ( ((BYTE *)&clrColor)[0] * ( ((BYTE *)&dwAlpha)[0] + 1 ) ) >> 8 )\r
+ + ( ( ((BYTE *)&dwColor)[0] * ( 256 - ((BYTE *)&dwAlpha)[0] ) ) >> 8 );\r
+ ((BYTE *)&clrColor)[1] =\r
+ ( ( ((BYTE *)&clrColor)[1] * ( ((BYTE *)&dwAlpha)[1] + 1 ) ) >> 8 )\r
+ + ( ( ((BYTE *)&dwColor)[1] * ( 256 - ((BYTE *)&dwAlpha)[1] ) ) >> 8 );\r
+ ((BYTE *)&clrColor)[2] =\r
+ ( ( ((BYTE *)&clrColor)[2] * ( ((BYTE *)&dwAlpha)[2] + 1 ) ) >> 8 )\r
+ + ( ( ((BYTE *)&dwColor)[2] * ( 256 - ((BYTE *)&dwAlpha)[2] ) ) >> 8 );\r
+ }\r
}\r
- if (dwFlags&ALPHA_BLEND) {\r
- DWORD dwColor = GetPixel(hDC,X,Y);\r
-\r
- // Old alpha\r
- /*((BYTE *)&dwColor)[0]*=1-((float)((BYTE *)&dwAlpha)[0]/256);\r
- ((BYTE *)&dwColor)[1]*=1-((float)((BYTE *)&dwAlpha)[1]/256);\r
- ((BYTE *)&dwColor)[2]*=1-((float)((BYTE *)&dwAlpha)[2]/256);\r
- ((BYTE *)&clrColor)[0]*=(float)((BYTE *)&dwAlpha)[0]/256;\r
- ((BYTE *)&clrColor)[1]*=(float)((BYTE *)&dwAlpha)[1]/256;\r
- ((BYTE *)&clrColor)[2]*=(float)((BYTE *)&dwAlpha)[2]/256;\r
- ((BYTE *)&clrColor)[0]+=((BYTE *)&dwColor)[0];\r
- ((BYTE *)&clrColor)[1]+=((BYTE *)&dwColor)[1];\r
- ((BYTE *)&clrColor)[2]+=((BYTE *)&dwColor)[2];*/\r
-\r
- /* blendedcolor =\r
- ( ( forecolor * ( 1 - alpha ) ) >> 8 )\r
- + ( ( backcolor * ( 256 - alpha ) ) >> 8 ) */\r
- ((BYTE *)&clrColor)[0] =\r
- ( ( ((BYTE *)&clrColor)[0] * ( ((BYTE *)&dwAlpha)[0] + 1 ) ) >> 8 )\r
- + ( ( ((BYTE *)&dwColor)[0] * ( 256 - ((BYTE *)&dwAlpha)[0] ) ) >> 8 );\r
- ((BYTE *)&clrColor)[1] =\r
- ( ( ((BYTE *)&clrColor)[1] * ( ((BYTE *)&dwAlpha)[1] + 1 ) ) >> 8 )\r
- + ( ( ((BYTE *)&dwColor)[1] * ( 256 - ((BYTE *)&dwAlpha)[1] ) ) >> 8 );\r
- ((BYTE *)&clrColor)[2] =\r
- ( ( ((BYTE *)&clrColor)[2] * ( ((BYTE *)&dwAlpha)[2] + 1 ) ) >> 8 )\r
- + ( ( ((BYTE *)&dwColor)[2] * ( 256 - ((BYTE *)&dwAlpha)[2] ) ) >> 8 );\r
+ MySetPixel(hDC,X,Y,clrColor);\r
+}\r
+\r
+HANDLE GRPAPI WINAPI CreateGrp(signed short *lpImageData, WORD nFrames, WORD wMaxWidth, WORD wMaxHeight, BOOL bNoCompress, DWORD *nGrpSize)\r
+{\r
+ GRPHEADER GrpHeader;\r
+ FRAMEHEADER *lpFrameHeaders;\r
+ FRAMEDATA *lpFrameData;\r
+ LPBYTE lpGrpData;\r
+ int i, j, x, y, x1, x2, y1, y2;\r
+ DWORD nLastOffset;\r
+\r
+ if (!lpImageData || !nGrpSize) return (HANDLE)-1;\r
+\r
+ GrpHeader.nFrames = nFrames;\r
+ GrpHeader.wMaxWidth = wMaxWidth;\r
+ GrpHeader.wMaxHeight = wMaxHeight;\r
+ lpFrameHeaders = (FRAMEHEADER *)malloc(nFrames * sizeof(FRAMEHEADER));\r
+ lpFrameData = (FRAMEDATA *)malloc(nFrames * sizeof(FRAMEDATA));\r
+ nLastOffset = sizeof(GRPHEADER) + nFrames * sizeof(FRAMEHEADER);\r
+\r
+ for (i = 0; i < nFrames; i++) {\r
+ // Search for duplicate frames\r
+ for (j = 0; j < i; j++) {\r
+ if (memcmp(&lpImageData[i * wMaxWidth * wMaxHeight],\r
+ &lpImageData[j * wMaxWidth * wMaxHeight],\r
+ wMaxWidth * wMaxHeight * sizeof(short)) == 0)\r
+ break;\r
+ }\r
+\r
+ if (j < i) {\r
+ memcpy(&lpFrameHeaders[i], &lpFrameHeaders[j], sizeof(FRAMEHEADER));\r
+ lpFrameData[i].lpRowOffsets = 0;\r
+ continue;\r
+ }\r
+\r
+ if (i == 0) {\r
+ lpFrameHeaders[i].Offset = sizeof(GRPHEADER) + nFrames * sizeof(FRAMEHEADER);\r
+ }\r
+ else {\r
+ lpFrameHeaders[i].Offset = nLastOffset;\r
+ }\r
+\r
+ // Scan frame to find dimensions of used part\r
+ x1 = y1 = 0x10000;\r
+ x2 = y2 = -1;\r
+ for (y = 0; y < wMaxHeight; y++) {\r
+ for (x = 0; x < wMaxWidth; x++) {\r
+ if (lpImageData[i * wMaxWidth * wMaxHeight + y * wMaxWidth + x] >= 0) {\r
+ if (x < x1) x1 = x;\r
+ if (x > x2) x2 = x;\r
+ if (y < y1) y1 = y;\r
+ if (y > y2) y2 = y;\r
+ }\r
+ }\r
+ }\r
+ x2 = x2 - x1 + 1;\r
+ y2 = y2 - y1 + 1;\r
+ if ((WORD)x1 > 255) x1 = 255;\r
+ if ((WORD)y1 > 255) y1 = 255;\r
+ if ((WORD)x2 > 255) x2 = 255;\r
+ if ((WORD)y2 > 255) y2 = 255;\r
+ lpFrameHeaders[i].Left = x1;\r
+ lpFrameHeaders[i].Top = y1;\r
+ lpFrameHeaders[i].Width = x2;\r
+ lpFrameHeaders[i].Height = y2;\r
+\r
+ if (!bNoCompress) {\r
+ EncodeFrameData(lpImageData, i, &GrpHeader, &lpFrameHeaders[i], &lpFrameData[i]);\r
+\r
+ y = lpFrameHeaders[i].Height;\r
+ if (y > 0) {\r
+ y--;\r
+ nLastOffset = lpFrameHeaders[i].Offset + lpFrameData[i].lpRowOffsets[y] + lpFrameData[i].lpRowSizes[y];\r
+ }\r
+ else {\r
+ nLastOffset = lpFrameHeaders[i].Offset;\r
+ }\r
+ }\r
+ else {\r
+ nLastOffset = lpFrameHeaders[i].Offset + lpFrameHeaders[i].Width * lpFrameHeaders[i].Height;\r
+ }\r
}\r
- SetPixelV(hDC,X,Y,clrColor);\r
+\r
+ lpGrpData = (LPBYTE)malloc(nLastOffset);\r
+\r
+ // Write completed GRP to buffer\r
+ memcpy(lpGrpData, &GrpHeader, sizeof(GRPHEADER));\r
+ memcpy(lpGrpData + sizeof(GRPHEADER), lpFrameHeaders, nFrames * sizeof(FRAMEHEADER));\r
+\r
+ for (i = 0; i < nFrames; i++) {\r
+ if (lpFrameData[i].lpRowOffsets) {\r
+ if (!bNoCompress) {\r
+ memcpy(lpGrpData + lpFrameHeaders[i].Offset, lpFrameData[i].lpRowOffsets, lpFrameHeaders[i].Height * sizeof(WORD));\r
+\r
+ for (y = 0; y < lpFrameHeaders[i].Height; y++) {\r
+ if (lpFrameData[i].lpRowData[y]) {\r
+ memcpy(lpGrpData + lpFrameHeaders[i].Offset + lpFrameData[i].lpRowOffsets[y], lpFrameData[i].lpRowData[y], lpFrameData[i].lpRowSizes[y]);\r
+ free(lpFrameData[i].lpRowData[y]);\r
+ }\r
+ }\r
+\r
+ free(lpFrameData[i].lpRowOffsets);\r
+ free(lpFrameData[i].lpRowSizes);\r
+ free(lpFrameData[i].lpRowData);\r
+ }\r
+ else {\r
+ for (y = 0; y < lpFrameHeaders[i].Height; y++) {\r
+ for (x = 0; x < lpFrameHeaders[i].Width; x++) {\r
+ lpGrpData[lpFrameHeaders[i].Offset + y * lpFrameHeaders[i].Width + x] =\r
+ (BYTE)lpImageData[i * wMaxWidth * wMaxHeight + (lpFrameHeaders[i].Top + y) * wMaxWidth + lpFrameHeaders[i].Left + x];\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ free(lpFrameHeaders);\r
+ free(lpFrameData);\r
+\r
+ *nGrpSize = nLastOffset;\r
+ return (HANDLE)lpGrpData;\r
}\r
\r
+void EncodeFrameData(signed short *lpImageData, WORD nFrame, GRPHEADER *lpGrpHeader, FRAMEHEADER *lpFrameHeader, FRAMEDATA *lpFrameData)\r
+{\r
+ int x, y, i, nBufPos, nRepeat;\r
+ LPBYTE lpRowBuf;\r
+ WORD nLastOffset;\r
+\r
+ lpFrameData->lpRowOffsets = (WORD *)malloc(lpFrameHeader->Height * sizeof(WORD));\r
+ lpFrameData->lpRowSizes = (WORD *)malloc(lpFrameHeader->Height * sizeof(WORD));\r
+ lpFrameData->lpRowData = (LPBYTE *)malloc(lpFrameHeader->Height * sizeof(LPBYTE));\r
+ lpRowBuf = (LPBYTE)malloc(lpFrameHeader->Width * 2);\r
+ nLastOffset = lpFrameHeader->Height * sizeof(WORD);\r
+\r
+ for (y = 0; y < lpFrameHeader->Height; y++) {\r
+ i = nFrame * lpGrpHeader->wMaxWidth * lpGrpHeader->wMaxHeight + (lpFrameHeader->Top + y) * lpGrpHeader->wMaxWidth;\r
+\r
+ /* Fails verification when using this. Bug in encoder or decoder? Doesn't provide much benefit.\r
+ // Search for duplicate rows (experimental)\r
+ for (x = 0; x < y; x++) {\r
+ j = nFrame * lpGrpHeader->wMaxWidth * lpGrpHeader->wMaxHeight + (lpFrameHeader->Top + x) * lpGrpHeader->wMaxWidth;\r
+ if (memcmp(&lpImageData[i+lpFrameHeader->Left],\r
+ &lpImageData[j+lpFrameHeader->Left],\r
+ lpGrpHeader->wMaxWidth * sizeof(short)) == 0)\r
+ break;\r
+ }\r
+\r
+ if (x < y) {\r
+ lpFrameData->lpRowOffsets[y] = lpFrameData->lpRowOffsets[x];\r
+ lpFrameData->lpRowSizes[y] = 0;\r
+ lpFrameData->lpRowData[y] = 0;\r
+\r
+#ifdef _DEBUG\r
+ if (!VerifyRow(&lpImageData[i+lpFrameHeader->Left], lpFrameHeader->Width, lpFrameData->lpRowData[x], lpFrameData->lpRowSizes[x])) {\r
+ nBufPos = nBufPos;\r
+ }\r
+#endif\r
+\r
+ continue;\r
+ }\r
+ */\r
+\r
+ nBufPos = 0;\r
+ if (lpFrameHeader->Width > 0) {\r
+ for (x = lpFrameHeader->Left; x < lpFrameHeader->Left + lpFrameHeader->Width; x++) {\r
+ if (x < lpFrameHeader->Left + lpFrameHeader->Width - 1) {\r
+ if (lpImageData[i+x] < 0) {\r
+ lpRowBuf[nBufPos] = 0x80;\r
+ for (; lpImageData[i+x] < 0 && x < lpFrameHeader->Left + lpFrameHeader->Width && lpRowBuf[nBufPos] < 0xFF; x++) {\r
+ lpRowBuf[nBufPos]++;\r
+ }\r
+ x--;\r
+ if (nLastOffset + nBufPos + 1 <= 0xFFFF)\r
+ nBufPos++;\r
+ continue;\r
+ }\r
+\r
+ // Count repeating pixels, nRepeat = number of pixels - 1, ignore if there are less than 4 duplicates\r
+ for (nRepeat = 0; lpImageData[i+x+nRepeat] == lpImageData[i+x+nRepeat+1] && x+nRepeat < lpFrameHeader->Left + lpFrameHeader->Width - 1 && nRepeat < 0x3E; nRepeat++) {}\r
+\r
+ if (nRepeat > 2) {\r
+ lpRowBuf[nBufPos] = 0x41 + nRepeat;\r
+ lpRowBuf[nBufPos+1] = (BYTE)lpImageData[i+x];\r
+ x += nRepeat;\r
+ if (nLastOffset + nBufPos + 2 <= 0xFFFF)\r
+ nBufPos += 2;\r
+ }\r
+ else {\r
+ lpRowBuf[nBufPos] = 0;\r
+ for (; lpImageData[i+x] >= 0 && x < lpFrameHeader->Left + lpFrameHeader->Width && lpRowBuf[nBufPos] < 0x3F; x++) {\r
+ // Count repeating pixels, ignore if there are less than 4 duplicates\r
+ for (nRepeat = 0; lpImageData[i+x+nRepeat] == lpImageData[i+x+nRepeat+1] && x+nRepeat < lpFrameHeader->Left + lpFrameHeader->Width - 1 && nRepeat < 3; nRepeat++) {}\r
+ if (nRepeat > 2) break;\r
+\r
+ lpRowBuf[nBufPos]++;\r
+ lpRowBuf[nBufPos+lpRowBuf[nBufPos]] = (BYTE)lpImageData[i+x];\r
+ }\r
+ if (lpImageData[i+x] >= 0 && x == lpFrameHeader->Left + lpFrameHeader->Width - 1 && lpRowBuf[nBufPos] < 0x3F) {\r
+ lpRowBuf[nBufPos]++;\r
+ lpRowBuf[nBufPos+lpRowBuf[nBufPos]] = (BYTE)lpImageData[i+x];\r
+ }\r
+ x--;\r
+ if (nLastOffset + nBufPos + 1 + lpRowBuf[nBufPos] <= 0xFFFF)\r
+ nBufPos += 1 + lpRowBuf[nBufPos];\r
+ }\r
+ }\r
+ else {\r
+ if (lpImageData[i+x] < 0) {\r
+ lpRowBuf[nBufPos] = 0x81;\r
+ if (nLastOffset + nBufPos + 1 <= 0xFFFF)\r
+ nBufPos++;\r
+ }\r
+ else {\r
+ lpRowBuf[nBufPos] = 1;\r
+ lpRowBuf[nBufPos+1] = (BYTE)lpImageData[i+x];\r
+ if (nLastOffset + nBufPos + 2 <= 0xFFFF)\r
+ nBufPos += 2;\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+#ifdef _DEBUG\r
+ if (!VerifyRow(&lpImageData[i+lpFrameHeader->Left], lpFrameHeader->Width, lpRowBuf, nBufPos)) {\r
+ nBufPos = nBufPos;\r
+ }\r
+#endif\r
+\r
+ if (y == 0) {\r
+ lpFrameData->lpRowOffsets[y] = lpFrameHeader->Height * sizeof(WORD);\r
+ }\r
+ else {\r
+ lpFrameData->lpRowOffsets[y] = nLastOffset;\r
+ }\r
+\r
+ nLastOffset = lpFrameData->lpRowOffsets[y] + nBufPos;\r
+\r
+ lpFrameData->lpRowSizes[y] = nBufPos;\r
+ lpFrameData->lpRowData[y] = (LPBYTE)malloc(nBufPos);\r
+ memcpy(lpFrameData->lpRowData[y], lpRowBuf, nBufPos);\r
+ }\r
+\r
+ free(lpRowBuf);\r
+}\r
+\r
+#ifdef _DEBUG\r
+BOOL VerifyRow(signed short *lpRawRow, int nWidth, LPBYTE lpEncRow, int nSize)\r
+{\r
+ int i,x=0,ofs=0;\r
+ while (x < nWidth && ofs < nSize) {\r
+ if (!(lpEncRow[ofs] & 0x80)) {\r
+ if (!(lpEncRow[ofs] & 0x40)) {\r
+ for (i=1;i<=lpEncRow[ofs] && x<nWidth;i++) {\r
+ if (lpEncRow[ofs+i] != (BYTE)lpRawRow[x]) return FALSE;\r
+ x++;\r
+ }\r
+ ofs+=lpEncRow[ofs]+1;\r
+ }\r
+ else {\r
+ for (i=0;i<lpEncRow[ofs]-64 && x<nWidth;i++) {\r
+ if (lpEncRow[ofs+1] != (BYTE)lpRawRow[x]) return FALSE;\r
+ x++;\r
+ }\r
+ ofs+=2;\r
+ }\r
+ }\r
+ else {\r
+ for (i=0;i<lpEncRow[ofs]-128 && x<nWidth;i++) {\r
+ if (lpRawRow[x] >= 0) return FALSE;\r
+ }\r
+ x+=lpEncRow[ofs]-128;\r
+ ofs++;\r
+ }\r
+ }\r
+\r
+ if (x != nWidth || ofs != nSize) return FALSE;\r
+\r
+ return TRUE;\r
+}\r
+#endif\r