Main
Current News
Archived News
Search News
Forums
Discussion Forum


Old Forum
Programs
Install Programs
Downloads
More Downloads...
Troubleshooting
Other Sections
Source Code
Format Specs.
Misc. Information
Non-SF Stuff
Links



projects / grpapi.git / blame
? search:
summary | graphiclog | shortlog | log | commit | commitdiff | tree
blob | history | HEAD
Change duplicate frame detection
[grpapi.git] / grpapi / grpapi.cpp
CommitLineData
14362b19 1#include "grpapi.h"\r
ecca31ff 2#include "../LoadStorm/storm.h"\r
14362b19 3#include <malloc.h>\r
4\r
5#ifdef GRPAPI_STATIC\r
6#define DllMain GrpMain\r
7\r
8#include "grp_static.h"\r
9\r
10struct GRPLIBMODULE {\r
11 GRPLIBMODULE();\r
12 ~GRPLIBMODULE();\r
13} GrpLib;\r
14\r
15BOOL APIENTRY DllMain(HINSTANCE hInstDLL, DWORD ul_reason_for_call, LPVOID lpReserved);\r
16\r
17GRPLIBMODULE::GRPLIBMODULE()\r
18{\r
19 GrpMain(0,DLL_PROCESS_ATTACH,0);\r
20}\r
21\r
22GRPLIBMODULE::~GRPLIBMODULE()\r
23{\r
24 GrpMain(0,DLL_PROCESS_DETACH,0);\r
25}\r
26\r
27#endif\r
28\r
29typedef struct {\r
30 BYTE Left;\r
31 BYTE Top;\r
32 BYTE Width;\r
33 BYTE Height;\r
34 DWORD Offset;\r
35} FRAMEHEADER;\r
36\r
c483a082 37typedef struct {\r
38 WORD *lpRowOffsets;\r
39 WORD *lpRowSizes;\r
40 LPBYTE *lpRowData;\r
ca10c992 41 DWORD Size;\r
c483a082 42} FRAMEDATA;\r
43\r
ecca31ff 44GETPIXELPROC MyGetPixel = GetPixel;\r
45SETPIXELPROC MySetPixel = (SETPIXELPROC)SetPixelV;\r
46\r
ff024783 47void __inline SetPix(HDC hDC, int X, int Y, COLORREF clrColor, DWORD *dwPalette, DWORD dwFlags, DWORD dwAlpha);\r
ca10c992 48void EncodeFrameData(signed short *lpImageData, WORD nFrame, GRPHEADER *lpGrpHeader, FRAMEHEADER *lpFrameHeader, FRAMEDATA *lpFrameData, BOOL bNoCompress);\r
49BOOL VerifyRow(signed short *lpRawRow, int nWidth, LPBYTE lpEncRow, int nSize, BOOL bNoCompress);\r
14362b19 50\r
51extern HINSTANCE hStorm;\r
52\r
53BOOL APIENTRY DllMain( HINSTANCE hInstDLL, \r
54 DWORD ul_reason_for_call, \r
55 LPVOID lpReserved\r
56 )\r
57{\r
58 switch (ul_reason_for_call)\r
59 {\r
60 case DLL_PROCESS_ATTACH:\r
61 break;\r
62 case DLL_THREAD_ATTACH:\r
63 break;\r
64 case DLL_THREAD_DETACH:\r
65 break;\r
66 case DLL_PROCESS_DETACH:\r
67 break;\r
68 }\r
69\r
70 return TRUE;\r
71}\r
72\r
73BOOL GRPAPI WINAPI LoadGrpApi()\r
74{\r
ecca31ff 75 if (!hStorm) return FALSE;\r
14362b19 76 else return TRUE;\r
77}\r
78\r
79void GRPAPI WINAPI FreeGrpApi()\r
80{\r
81}\r
82\r
d8c90836 83/*\r
84HANDLE hProcessHeap = NULL;\r
85\r
86void * SFAlloc(size_t nSize)\r
87{\r
88 if (!hProcessHeap) hProcessHeap = GetProcessHeap();\r
89 if (hProcessHeap) return HeapAlloc(hProcessHeap, 0, nSize);\r
90 else return NULL;\r
91}\r
92\r
93void SFFree(void *lpMem)\r
94{\r
95 if (!hProcessHeap) hProcessHeap = GetProcessHeap();\r
96 if (hProcessHeap) HeapFree(hProcessHeap, 0, lpMem);\r
97}\r
98*/\r
99\r
ecca31ff 100BOOL GRPAPI WINAPI SetMpqDll(LPCSTR lpDllFileName)\r
101{\r
102 if (LoadStorm((char *)lpDllFileName)) return TRUE;\r
103 else return FALSE;\r
104}\r
105\r
14362b19 106BOOL GRPAPI WINAPI LoadPalette(LPCSTR lpFileName, DWORD *dwPaletteBuffer)\r
107{\r
ecca31ff 108 if (!lpFileName || !dwPaletteBuffer) return FALSE;\r
14362b19 109 HANDLE hFile;\r
ecca31ff 110 if (SFileOpenFileEx && SFileGetFileSize\r
111 && SFileSetFilePointer && SFileReadFile\r
112 && SFileCloseFile) {\r
113 if (!SFileOpenFileEx(0,lpFileName,1,&hFile)) return FALSE;\r
14362b19 114 DWORD fsz = SFileGetFileSize(hFile,0);\r
115 SFileSetFilePointer(hFile,0,0,FILE_BEGIN);\r
116 if (fsz>=1024) {\r
117 memset(dwPaletteBuffer,0,1024);\r
118 SFileReadFile(hFile,dwPaletteBuffer,1024,0,0);\r
119 }\r
120 else if (fsz==768) {\r
121 char *buffer = (char *)_alloca(768);\r
122 memset(buffer,0,768);\r
123 SFileReadFile(hFile,buffer,768,0,0);\r
124 for (DWORD i=0;i<256;i++) {\r
125 memcpy(&dwPaletteBuffer[i],buffer+i*3,3);\r
126 *(((char *)&dwPaletteBuffer[i])+3) = 0;\r
127 }\r
128 }\r
129 else {\r
130 memset(dwPaletteBuffer,0,1024);\r
131 SFileReadFile(hFile,dwPaletteBuffer,fsz,0,0);\r
132 }\r
133 SFileCloseFile(hFile);\r
134 }\r
135 else {\r
136 hFile = CreateFile(lpFileName,GENERIC_READ,FILE_SHARE_READ,0,OPEN_EXISTING,0,0);\r
137 if (hFile==INVALID_HANDLE_VALUE) return FALSE;\r
138 DWORD fsz = GetFileSize(hFile,0),tsz;\r
139 SetFilePointer(hFile,0,0,FILE_BEGIN);\r
140 if (fsz>=1024) {\r
141 memset(dwPaletteBuffer,0,1024);\r
142 ReadFile(hFile,dwPaletteBuffer,1024,&tsz,0);\r
143 }\r
144 else if (fsz==768) {\r
145 char *buffer = (char *)_alloca(768);\r
146 memset(buffer,0,768);\r
147 ReadFile(hFile,buffer,768,&tsz,0);\r
148 for (DWORD i=0;i<256;i++) {\r
149 memcpy(&dwPaletteBuffer[i],buffer+i*3,3);\r
150 *(((char *)&dwPaletteBuffer[i])+3) = 0;\r
151 }\r
152 }\r
153 else {\r
154 memset(dwPaletteBuffer,0,1024);\r
155 ReadFile(hFile,dwPaletteBuffer,fsz,&tsz,0);\r
156 }\r
157 CloseHandle(hFile);\r
158 }\r
159 return TRUE;\r
160}\r
161\r
162HANDLE GRPAPI WINAPI LoadGrp(LPCSTR lpFileName)\r
163{\r
ecca31ff 164 if (!lpFileName) return (HANDLE)-1;\r
14362b19 165 HANDLE hFile;\r
166 char *GrpFile;\r
ecca31ff 167 if (SFileOpenFileEx && SFileGetFileSize\r
168 && SFileSetFilePointer && SFileReadFile\r
169 && SFileCloseFile) {\r
170 if (!SFileOpenFileEx(0,lpFileName,1,&hFile)) return (HANDLE)-1;\r
14362b19 171 DWORD fsz = SFileGetFileSize(hFile,0);\r
172 if (fsz<6) {\r
173 SFileCloseFile(hFile);\r
174 return (HANDLE)-1;\r
175 }\r
afcd1861 176 GrpFile = (char *)malloc(fsz);\r
ecca31ff 177 if (GrpFile) {\r
14362b19 178 SFileSetFilePointer(hFile,0,0,FILE_BEGIN);\r
179 SFileReadFile(hFile,GrpFile,fsz,0,0);\r
180 }\r
181 else GrpFile=(char *)-1;\r
182 SFileCloseFile(hFile);\r
183 }\r
184 else {\r
185 hFile = CreateFile(lpFileName,GENERIC_READ,FILE_SHARE_READ,0,OPEN_EXISTING,0,0);\r
186 if (hFile==INVALID_HANDLE_VALUE) return (HANDLE)-1;\r
187 DWORD fsz = GetFileSize(hFile,0),tsz;\r
188 if (fsz<6) {\r
189 CloseHandle(hFile);\r
190 return (HANDLE)-1;\r
191 }\r
afcd1861 192 GrpFile = (char *)malloc(fsz);\r
ecca31ff 193 if (GrpFile) {\r
14362b19 194 SetFilePointer(hFile,0,0,FILE_BEGIN);\r
195 ReadFile(hFile,GrpFile,fsz,&tsz,0);\r
196 }\r
197 else GrpFile=(char *)-1;\r
198 CloseHandle(hFile);\r
199 }\r
200 return (HANDLE)GrpFile;\r
201}\r
202\r
203BOOL GRPAPI WINAPI DestroyGrp(HANDLE hGrp)\r
204{\r
ecca31ff 205 if (!hGrp || hGrp==INVALID_HANDLE_VALUE) return FALSE;\r
afcd1861 206 free(hGrp);\r
14362b19 207 return TRUE;\r
208}\r
209\r
210BOOL GRPAPI WINAPI DrawGrp(HANDLE hGrp, HDC hdcDest, int nXDest, int nYDest, WORD nFrame, DWORD *dwPalette, DWORD dwFlags, DWORD dwAlpha)\r
211{\r
c483a082 212 if (!hGrp || hGrp==INVALID_HANDLE_VALUE || hdcDest==0 || (!dwPalette && !(dwFlags&USE_INDEX))) return FALSE;\r
14362b19 213 GRPHEADER *GrpFile = (GRPHEADER *)hGrp;\r
214 nFrame %= GrpFile->nFrames;\r
215 FRAMEHEADER *GrpFrame = &((FRAMEHEADER *)(((char *)GrpFile)+6))[nFrame];\r
2975ca34 216 FRAMEHEADER *GrpFrames = &((FRAMEHEADER *)(((char *)GrpFile)+6))[0];\r
217 int FrameSize = 0xFFFFFF;\r
14362b19 218 DWORD Right,Bottom;\r
219 if (dwFlags&HORIZONTAL_FLIP) Right = nXDest+GrpFile->wMaxWidth-1-GrpFrame->Left;\r
220 if (dwFlags&VERTICAL_FLIP) Bottom = nYDest+GrpFile->wMaxHeight-1-GrpFrame->Top;\r
221 nXDest += GrpFrame->Left;\r
222 nYDest += GrpFrame->Top;\r
223 WORD *GrpOffsets = ((WORD *)(((char *)GrpFile)+GrpFrame->Offset));\r
2975ca34 224 BYTE *GrpRaw = (BYTE *)GrpOffsets;\r
ecca31ff 225 BYTE *RowData;\r
226 WORD x,ofs;\r
ff9de648 227 DWORD y, nMaxOffset = 0;\r
ecca31ff 228 WORD i;\r
ff9de648 229 int j, nFirstNonBlankFrame = 0;\r
230 for (i = 0; i < GrpFile->nFrames; i++) {\r
231 j = GrpFrames[i].Offset - GrpFrame->Offset;\r
232 if (j > 0 && j < FrameSize)\r
233 FrameSize = j;\r
234 if (GrpFrames[i].Offset > nMaxOffset)\r
235 nMaxOffset = GrpFrames[i].Offset;\r
2975ca34 236 }\r
a93929e5 237 if (FrameSize == 0xFFFFFF || FrameSize == GrpFrame->Width * GrpFrame->Height) {\r
238 FrameSize = 0xFFFFFF;\r
ff9de648 239 for (i = 0; i < GrpFile->nFrames; i++) {\r
240 if (GrpFrames[i].Width != 0 && GrpFrames[i].Height != 0 && GrpFrames[i].Offset != GrpFrame->Offset && GrpFrames[i].Offset != nMaxOffset) {\r
241 nFirstNonBlankFrame = i;\r
242 break;\r
243 }\r
244 }\r
245 if (i == GrpFile->nFrames)\r
246 nFirstNonBlankFrame = nFrame;\r
247\r
248 for (i = 0; i < GrpFile->nFrames; i++) {\r
249 j = GrpFrames[i].Offset - GrpFrames[nFirstNonBlankFrame].Offset;\r
2975ca34 250 if (j > 0 && j < FrameSize)\r
251 FrameSize = j;\r
252 }\r
ff9de648 253 if (FrameSize == GrpFrames[nFirstNonBlankFrame].Width * GrpFrames[nFirstNonBlankFrame].Height)\r
2975ca34 254 FrameSize = GrpFrame->Width * GrpFrame->Height;\r
255 }\r
ecca31ff 256 if (!(dwFlags&HORIZONTAL_FLIP) && !(dwFlags&VERTICAL_FLIP)) {\r
2975ca34 257 if (FrameSize != GrpFrame->Width * GrpFrame->Height) {\r
258 for (y=0;y<GrpFrame->Height;y++) {\r
259 RowData = ((BYTE *)(((char *)GrpOffsets)+GrpOffsets[y]));\r
260 x=0; ofs=0;\r
261 while (x<GrpFrame->Width) {\r
262 if (!(RowData[ofs] & 0x80)) {\r
263 if (!(RowData[ofs] & 0x40)) {\r
264 for (i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
ff024783 265 SetPix(hdcDest,nXDest+x,nYDest+y,RowData[ofs+i],dwPalette,dwFlags,dwAlpha);\r
2975ca34 266 x++;\r
267 }\r
268 ofs+=RowData[ofs]+1;\r
269 }\r
270 else {\r
271 for (i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
ff024783 272 SetPix(hdcDest,nXDest+x,nYDest+y,RowData[ofs+1],dwPalette,dwFlags,dwAlpha);\r
2975ca34 273 x++;\r
274 }\r
275 ofs+=2;\r
ecca31ff 276 }\r
14362b19 277 }\r
ecca31ff 278 else {\r
2975ca34 279 x+=RowData[ofs]-128;\r
280 ofs++;\r
14362b19 281 }\r
282 }\r
2975ca34 283 }\r
284 }\r
285 else {\r
286 for (y=0;y<GrpFrame->Height;y++) {\r
287 for (x=0;x<GrpFrame->Width;x++) {\r
ff024783 288 SetPix(hdcDest,nXDest+x,nYDest+y,GrpRaw[y * GrpFrame->Width + x],dwPalette,dwFlags,dwAlpha);\r
ecca31ff 289 }\r
290 }\r
291 }\r
292 }\r
293 else if (dwFlags&HORIZONTAL_FLIP && !(dwFlags&VERTICAL_FLIP)) {\r
2975ca34 294 if (FrameSize != GrpFrame->Width * GrpFrame->Height) {\r
295 for (y=0;y<GrpFrame->Height;y++) {\r
296 RowData = ((BYTE *)(((char *)GrpOffsets)+GrpOffsets[y]));\r
297 x=0; ofs=0;\r
298 while (x<GrpFrame->Width) {\r
299 if (!(RowData[ofs] & 0x80)) {\r
300 if (!(RowData[ofs] & 0x40)) {\r
301 for (i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
ff024783 302 SetPix(hdcDest,Right-x,nYDest+y,RowData[ofs+i],dwPalette,dwFlags,dwAlpha);\r
2975ca34 303 x++;\r
304 }\r
305 ofs+=RowData[ofs]+1;\r
306 }\r
307 else {\r
308 for (i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
ff024783 309 SetPix(hdcDest,Right-x,nYDest+y,RowData[ofs+1],dwPalette,dwFlags,dwAlpha);\r
2975ca34 310 x++;\r
311 }\r
312 ofs+=2;\r
ecca31ff 313 }\r
ecca31ff 314 }\r
315 else {\r
2975ca34 316 x+=RowData[ofs]-128;\r
317 ofs++;\r
14362b19 318 }\r
319 }\r
2975ca34 320 }\r
321 }\r
322 else {\r
323 for (y=0;y<GrpFrame->Height;y++) {\r
324 for (x=0;x<GrpFrame->Width;x++) {\r
ff024783 325 SetPix(hdcDest,Right-x,nYDest+y,GrpRaw[y * GrpFrame->Width + x],dwPalette,dwFlags,dwAlpha);\r
14362b19 326 }\r
14362b19 327 }\r
ecca31ff 328 }\r
329 }\r
330 else if (!(dwFlags&HORIZONTAL_FLIP) && dwFlags&VERTICAL_FLIP) {\r
2975ca34 331 if (FrameSize != GrpFrame->Width * GrpFrame->Height) {\r
332 for (y=0;y<GrpFrame->Height;y++) {\r
333 RowData = ((BYTE *)(((char *)GrpOffsets)+GrpOffsets[y]));\r
334 x=0; ofs=0;\r
335 while (x<GrpFrame->Width) {\r
336 if (!(RowData[ofs] & 0x80)) {\r
337 if (!(RowData[ofs] & 0x40)) {\r
338 for (i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
ff024783 339 SetPix(hdcDest,nXDest+x,Bottom-y,RowData[ofs+i],dwPalette,dwFlags,dwAlpha);\r
2975ca34 340 x++;\r
341 }\r
342 ofs+=RowData[ofs]+1;\r
343 }\r
344 else {\r
345 for (i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
ff024783 346 SetPix(hdcDest,nXDest+x,Bottom-y,RowData[ofs+1],dwPalette,dwFlags,dwAlpha);\r
2975ca34 347 x++;\r
348 }\r
349 ofs+=2;\r
ecca31ff 350 }\r
14362b19 351 }\r
ecca31ff 352 else {\r
2975ca34 353 x+=RowData[ofs]-128;\r
354 ofs++;\r
14362b19 355 }\r
356 }\r
2975ca34 357 }\r
358 }\r
359 else {\r
360 for (y=0;y<GrpFrame->Height;y++) {\r
361 for (x=0;x<GrpFrame->Width;x++) {\r
ff024783 362 SetPix(hdcDest,nXDest+x,Bottom-y,GrpRaw[y * GrpFrame->Width + x],dwPalette,dwFlags,dwAlpha);\r
ecca31ff 363 }\r
364 }\r
365 }\r
366 }\r
367 else {\r
2975ca34 368 if (FrameSize != GrpFrame->Width * GrpFrame->Height) {\r
369 for (y=0;y<GrpFrame->Height;y++) {\r
370 RowData = ((BYTE *)(((char *)GrpOffsets)+GrpOffsets[y]));\r
371 x=0; ofs=0;\r
372 while (x<GrpFrame->Width) {\r
373 if (!(RowData[ofs] & 0x80)) {\r
374 if (!(RowData[ofs] & 0x40)) {\r
375 for (i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
ff024783 376 SetPix(hdcDest,Right-x,Bottom-y,RowData[ofs+i],dwPalette,dwFlags,dwAlpha);\r
2975ca34 377 x++;\r
378 }\r
379 ofs+=RowData[ofs]+1;\r
380 }\r
381 else {\r
382 for (i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
ff024783 383 SetPix(hdcDest,Right-x,Bottom-y,RowData[ofs+1],dwPalette,dwFlags,dwAlpha);\r
2975ca34 384 x++;\r
385 }\r
386 ofs+=2;\r
ecca31ff 387 }\r
ecca31ff 388 }\r
389 else {\r
2975ca34 390 x+=RowData[ofs]-128;\r
391 ofs++;\r
14362b19 392 }\r
393 }\r
2975ca34 394 }\r
395 }\r
396 else {\r
397 for (y=0;y<GrpFrame->Height;y++) {\r
398 for (x=0;x<GrpFrame->Width;x++) {\r
ff024783 399 SetPix(hdcDest,Right-x,Bottom-y,GrpRaw[y * GrpFrame->Width + x],dwPalette,dwFlags,dwAlpha);\r
14362b19 400 }\r
14362b19 401 }\r
402 }\r
403 }\r
404 return TRUE;\r
405}\r
406\r
407BOOL GRPAPI WINAPI GetGrpInfo(HANDLE hGrp, GRPHEADER *GrpInfo)\r
408{\r
ecca31ff 409 if (!hGrp || hGrp==INVALID_HANDLE_VALUE || !GrpInfo) return FALSE;\r
14362b19 410 memcpy(GrpInfo,hGrp,6);\r
411 return TRUE;\r
412}\r
413\r
6ae30656 414BOOL GRPAPI WINAPI GetGrpFrameInfo(HANDLE hGrp, WORD nFrame, DWORD *nLeft, DWORD *nTop, DWORD *nWidth, DWORD *nHeight)\r
415{\r
416 if (!hGrp || hGrp==INVALID_HANDLE_VALUE) return FALSE;\r
417 FRAMEHEADER *GrpFrame = &((FRAMEHEADER *)(((char *)hGrp)+6))[nFrame];\r
418\r
419 if (nLeft) *nLeft = GrpFrame->Left;\r
420 if (nTop) *nTop = GrpFrame->Top;\r
421 if (nWidth) *nWidth = GrpFrame->Width;\r
422 if (nHeight) *nHeight = GrpFrame->Height;\r
423\r
424 return TRUE;\r
425}\r
426\r
ecca31ff 427void GRPAPI WINAPI SetFunctionGetPixel(GETPIXELPROC lpGetPixelProc)\r
428{\r
afcd1861 429 if (!lpGetPixelProc)\r
430 MyGetPixel = GetPixel;\r
431 else\r
432 MyGetPixel = lpGetPixelProc;\r
ecca31ff 433}\r
434\r
435void GRPAPI WINAPI SetFunctionSetPixel(SETPIXELPROC lpSetPixelProc)\r
436{\r
afcd1861 437 if (!lpSetPixelProc)\r
438 MySetPixel = (SETPIXELPROC)SetPixelV;\r
439 else\r
440 MySetPixel = lpSetPixelProc;\r
ecca31ff 441}\r
442\r
ff024783 443void __inline SetPix(HDC hDC, int X, int Y, COLORREF clrColor, DWORD *dwPalette, DWORD dwFlags, DWORD dwAlpha)\r
14362b19 444{\r
ff024783 445 if (!(dwFlags&USE_INDEX)) {\r
446 if (dwFlags&SHADOW_COLOR) {\r
447 clrColor = (dwFlags >> 8) & 0x00FFFFFF;\r
448 }\r
449 else {\r
450 clrColor = dwPalette[clrColor];\r
451 }\r
452 if (dwFlags&ALPHA_BLEND) {\r
453 DWORD dwColor = MyGetPixel(hDC,X,Y);\r
14362b19 454\r
ff024783 455 // Old alpha\r
456 /*((BYTE *)&dwColor)[0]*=1-((float)((BYTE *)&dwAlpha)[0]/256);\r
457 ((BYTE *)&dwColor)[1]*=1-((float)((BYTE *)&dwAlpha)[1]/256);\r
458 ((BYTE *)&dwColor)[2]*=1-((float)((BYTE *)&dwAlpha)[2]/256);\r
459 ((BYTE *)&clrColor)[0]*=(float)((BYTE *)&dwAlpha)[0]/256;\r
460 ((BYTE *)&clrColor)[1]*=(float)((BYTE *)&dwAlpha)[1]/256;\r
461 ((BYTE *)&clrColor)[2]*=(float)((BYTE *)&dwAlpha)[2]/256;\r
462 ((BYTE *)&clrColor)[0]+=((BYTE *)&dwColor)[0];\r
463 ((BYTE *)&clrColor)[1]+=((BYTE *)&dwColor)[1];\r
464 ((BYTE *)&clrColor)[2]+=((BYTE *)&dwColor)[2];*/\r
14362b19 465\r
ff024783 466 /* blendedcolor =\r
467 ( ( forecolor * ( 1 - alpha ) ) >> 8 )\r
468 + ( ( backcolor * ( 256 - alpha ) ) >> 8 ) */\r
469 ((BYTE *)&clrColor)[0] =\r
470 ( ( ((BYTE *)&clrColor)[0] * ( ((BYTE *)&dwAlpha)[0] + 1 ) ) >> 8 )\r
471 + ( ( ((BYTE *)&dwColor)[0] * ( 256 - ((BYTE *)&dwAlpha)[0] ) ) >> 8 );\r
472 ((BYTE *)&clrColor)[1] =\r
473 ( ( ((BYTE *)&clrColor)[1] * ( ((BYTE *)&dwAlpha)[1] + 1 ) ) >> 8 )\r
474 + ( ( ((BYTE *)&dwColor)[1] * ( 256 - ((BYTE *)&dwAlpha)[1] ) ) >> 8 );\r
475 ((BYTE *)&clrColor)[2] =\r
476 ( ( ((BYTE *)&clrColor)[2] * ( ((BYTE *)&dwAlpha)[2] + 1 ) ) >> 8 )\r
477 + ( ( ((BYTE *)&dwColor)[2] * ( 256 - ((BYTE *)&dwAlpha)[2] ) ) >> 8 );\r
478 }\r
14362b19 479 }\r
ecca31ff 480 MySetPixel(hDC,X,Y,clrColor);\r
14362b19 481}\r
c483a082 482\r
03269fee 483HANDLE GRPAPI WINAPI CreateGrp(signed short *lpImageData, WORD nFrames, WORD wMaxWidth, WORD wMaxHeight, BOOL bNoCompress, DWORD *nGrpSize)\r
c483a082 484{\r
485 GRPHEADER GrpHeader;\r
486 FRAMEHEADER *lpFrameHeaders;\r
487 FRAMEDATA *lpFrameData;\r
488 LPBYTE lpGrpData;\r
0df81049 489 int i, j, x, y, x1, x2, y1, y2;\r
490 DWORD nLastOffset;\r
c483a082 491\r
492 if (!lpImageData || !nGrpSize) return (HANDLE)-1;\r
493\r
494 GrpHeader.nFrames = nFrames;\r
495 GrpHeader.wMaxWidth = wMaxWidth;\r
496 GrpHeader.wMaxHeight = wMaxHeight;\r
0df81049 497 lpFrameHeaders = (FRAMEHEADER *)malloc(nFrames * sizeof(FRAMEHEADER));\r
c483a082 498 lpFrameData = (FRAMEDATA *)malloc(nFrames * sizeof(FRAMEDATA));\r
72348a2d 499 nLastOffset = sizeof(GRPHEADER) + nFrames * sizeof(FRAMEHEADER);\r
c483a082 500\r
0df81049 501 for (i = 0; i < nFrames; i++) {\r
ca10c992 502 lpFrameHeaders[i].Offset = nLastOffset;\r
c483a082 503\r
504 // Scan frame to find dimensions of used part\r
505 x1 = y1 = 0x10000;\r
506 x2 = y2 = -1;\r
507 for (y = 0; y < wMaxHeight; y++) {\r
508 for (x = 0; x < wMaxWidth; x++) {\r
509 if (lpImageData[i * wMaxWidth * wMaxHeight + y * wMaxWidth + x] >= 0) {\r
510 if (x < x1) x1 = x;\r
511 if (x > x2) x2 = x;\r
512 if (y < y1) y1 = y;\r
513 if (y > y2) y2 = y;\r
514 }\r
515 }\r
516 }\r
9492b9e6 517 x2 = x2 - x1 + 1;\r
518 y2 = y2 - y1 + 1;\r
519 if ((WORD)x1 > 255) x1 = 255;\r
520 if ((WORD)y1 > 255) y1 = 255;\r
521 if ((WORD)x2 > 255) x2 = 255;\r
522 if ((WORD)y2 > 255) y2 = 255;\r
c483a082 523 lpFrameHeaders[i].Left = x1;\r
524 lpFrameHeaders[i].Top = y1;\r
9492b9e6 525 lpFrameHeaders[i].Width = x2;\r
526 lpFrameHeaders[i].Height = y2;\r
c483a082 527\r
553c8149 528 // Search for duplicate frames\r
529 for (j = 0; j < i; j++) {\r
6ac16fc3 530 if (lpFrameData[j].lpRowOffsets && lpFrameHeaders[i].Width == lpFrameHeaders[j].Width && lpFrameHeaders[i].Height == lpFrameHeaders[j].Height) {\r
531 y1 = i * wMaxWidth * wMaxHeight + lpFrameHeaders[i].Top * wMaxWidth + lpFrameHeaders[i].Left;\r
532 y2 = j * wMaxWidth * wMaxHeight + lpFrameHeaders[j].Top * wMaxWidth + lpFrameHeaders[j].Left;\r
553c8149 533\r
6ac16fc3 534 for (y = 0; y < lpFrameHeaders[i].Height; y++) {\r
535 if (memcmp(&lpImageData[y1], &lpImageData[y2], lpFrameHeaders[i].Width * sizeof(short)) != 0)\r
553c8149 536 break;\r
537\r
6ac16fc3 538 y1 += wMaxWidth;\r
539 y2 += wMaxWidth;\r
553c8149 540 }\r
541\r
542 if (y == lpFrameHeaders[i].Height) {\r
543 break;\r
544 }\r
545 }\r
546 }\r
547\r
548 if (j < i) {\r
6ac16fc3 549 // Duplicate frame found, set offset and flag as duplicate\r
553c8149 550 lpFrameHeaders[i].Offset = lpFrameHeaders[j].Offset;\r
551 lpFrameData[i].lpRowOffsets = 0;\r
552 lpFrameData[i].lpRowSizes = 0;\r
553 lpFrameData[i].lpRowData = 0;\r
554 lpFrameData[i].Size = 0;\r
555 continue;\r
556 }\r
557\r
6ac16fc3 558 EncodeFrameData(lpImageData, i, &GrpHeader, &lpFrameHeaders[i], &lpFrameData[i], bNoCompress);\r
ca10c992 559 nLastOffset = lpFrameHeaders[i].Offset + lpFrameData[i].Size;\r
c483a082 560 }\r
561\r
0df81049 562 lpGrpData = (LPBYTE)malloc(nLastOffset);\r
c483a082 563\r
564 // Write completed GRP to buffer\r
565 memcpy(lpGrpData, &GrpHeader, sizeof(GRPHEADER));\r
566 memcpy(lpGrpData + sizeof(GRPHEADER), lpFrameHeaders, nFrames * sizeof(FRAMEHEADER));\r
567\r
568 for (i = 0; i < nFrames; i++) {\r
ec637542 569 if (lpFrameData[i].lpRowOffsets) {\r
ca10c992 570 if (!bNoCompress)\r
03269fee 571 memcpy(lpGrpData + lpFrameHeaders[i].Offset, lpFrameData[i].lpRowOffsets, lpFrameHeaders[i].Height * sizeof(WORD));\r
c483a082 572\r
ca10c992 573 for (y = 0; y < lpFrameHeaders[i].Height; y++) {\r
574 if (lpFrameData[i].lpRowData[y]) {\r
575 memcpy(lpGrpData + lpFrameHeaders[i].Offset + lpFrameData[i].lpRowOffsets[y], lpFrameData[i].lpRowData[y], lpFrameData[i].lpRowSizes[y]);\r
576 free(lpFrameData[i].lpRowData[y]);\r
03269fee 577 }\r
578 }\r
ca10c992 579\r
580 free(lpFrameData[i].lpRowOffsets);\r
581 free(lpFrameData[i].lpRowSizes);\r
582 free(lpFrameData[i].lpRowData);\r
0df81049 583 }\r
c483a082 584 }\r
585\r
c483a082 586 free(lpFrameHeaders);\r
587 free(lpFrameData);\r
588\r
0df81049 589 *nGrpSize = nLastOffset;\r
c483a082 590 return (HANDLE)lpGrpData;\r
591}\r
592\r
ca10c992 593void EncodeFrameData(signed short *lpImageData, WORD nFrame, GRPHEADER *lpGrpHeader, FRAMEHEADER *lpFrameHeader, FRAMEDATA *lpFrameData, BOOL bNoCompress)\r
c483a082 594{\r
ca10c992 595 int x, y, i, j, nBufPos, nRepeat;\r
c483a082 596 LPBYTE lpRowBuf;\r
ca10c992 597 WORD nLastOffset = 0;\r
c483a082 598\r
599 lpFrameData->lpRowOffsets = (WORD *)malloc(lpFrameHeader->Height * sizeof(WORD));\r
600 lpFrameData->lpRowSizes = (WORD *)malloc(lpFrameHeader->Height * sizeof(WORD));\r
601 lpFrameData->lpRowData = (LPBYTE *)malloc(lpFrameHeader->Height * sizeof(LPBYTE));\r
602 lpRowBuf = (LPBYTE)malloc(lpFrameHeader->Width * 2);\r
ca10c992 603\r
604 if (!bNoCompress)\r
605 nLastOffset = lpFrameHeader->Height * sizeof(WORD);\r
c483a082 606\r
607 for (y = 0; y < lpFrameHeader->Height; y++) {\r
608 i = nFrame * lpGrpHeader->wMaxWidth * lpGrpHeader->wMaxHeight + (lpFrameHeader->Top + y) * lpGrpHeader->wMaxWidth;\r
ec637542 609\r
ca10c992 610 if (!bNoCompress) {\r
611 // Search for duplicate rows\r
612 for (x = 0; x < y; x++) {\r
613 j = nFrame * lpGrpHeader->wMaxWidth * lpGrpHeader->wMaxHeight + (lpFrameHeader->Top + x) * lpGrpHeader->wMaxWidth;\r
614 if (memcmp(&lpImageData[i+lpFrameHeader->Left],\r
615 &lpImageData[j+lpFrameHeader->Left],\r
616 lpGrpHeader->wMaxWidth * sizeof(short)) == 0)\r
617 break;\r
618 }\r
ec637542 619\r
ca10c992 620 if (x < y) {\r
621 lpFrameData->lpRowOffsets[y] = lpFrameData->lpRowOffsets[x];\r
622 lpFrameData->lpRowSizes[y] = 0;\r
623 lpFrameData->lpRowData[y] = 0;\r
ec637542 624\r
625#ifdef _DEBUG\r
ca10c992 626 if (!VerifyRow(&lpImageData[i+lpFrameHeader->Left], lpFrameHeader->Width, lpFrameData->lpRowData[x], lpFrameData->lpRowSizes[x], bNoCompress)) {\r
627 nBufPos = nBufPos;\r
628 }\r
ec637542 629#endif\r
630\r
ca10c992 631 continue;\r
632 }\r
ec637542 633 }\r
ec637542 634\r
c483a082 635 nBufPos = 0;\r
0df81049 636 if (lpFrameHeader->Width > 0) {\r
637 for (x = lpFrameHeader->Left; x < lpFrameHeader->Left + lpFrameHeader->Width; x++) {\r
ca10c992 638 if (!bNoCompress) {\r
639 if (x < lpFrameHeader->Left + lpFrameHeader->Width - 1) {\r
640 if (lpImageData[i+x] < 0) {\r
641 lpRowBuf[nBufPos] = 0x80;\r
642 for (; lpImageData[i+x] < 0 && x < lpFrameHeader->Left + lpFrameHeader->Width && lpRowBuf[nBufPos] < 0xFF; x++) {\r
643 lpRowBuf[nBufPos]++;\r
644 }\r
645 x--;\r
646 if (nLastOffset + nBufPos + 1 <= 0xFFFF)\r
647 nBufPos++;\r
648 continue;\r
0df81049 649 }\r
0df81049 650\r
ca10c992 651 // Count repeating pixels, nRepeat = number of pixels - 1, ignore if there are less than 4 duplicates\r
652 for (nRepeat = 0; lpImageData[i+x+nRepeat] == lpImageData[i+x+nRepeat+1] && x+nRepeat < lpFrameHeader->Left + lpFrameHeader->Width - 1 && nRepeat < 0x3E; nRepeat++) {}\r
0df81049 653\r
ca10c992 654 if (nRepeat > 2) {\r
655 lpRowBuf[nBufPos] = 0x41 + nRepeat;\r
656 lpRowBuf[nBufPos+1] = (BYTE)(lpImageData[i+x]);\r
657 x += nRepeat;\r
658 if (nLastOffset + nBufPos + 2 <= 0xFFFF)\r
659 nBufPos += 2;\r
660 }\r
661 else {\r
662 lpRowBuf[nBufPos] = 0;\r
663 for (; lpImageData[i+x] >= 0 && x < lpFrameHeader->Left + lpFrameHeader->Width && lpRowBuf[nBufPos] < 0x3F; x++) {\r
664 // Count repeating pixels, ignore if there are less than 4 duplicates\r
665 for (nRepeat = 0; lpImageData[i+x+nRepeat] == lpImageData[i+x+nRepeat+1] && x+nRepeat < lpFrameHeader->Left + lpFrameHeader->Width - 1 && nRepeat < 3; nRepeat++) {}\r
666 if (nRepeat > 2) break;\r
667\r
668 lpRowBuf[nBufPos]++;\r
669 lpRowBuf[nBufPos+lpRowBuf[nBufPos]] = (BYTE)(lpImageData[i+x]);\r
670 }\r
671 if (lpImageData[i+x] >= 0 && x == lpFrameHeader->Left + lpFrameHeader->Width - 1 && lpRowBuf[nBufPos] < 0x3F) {\r
672 lpRowBuf[nBufPos]++;\r
673 lpRowBuf[nBufPos+lpRowBuf[nBufPos]] = (BYTE)(lpImageData[i+x]);\r
674 }\r
675 x--;\r
676 if (nLastOffset + nBufPos + 1 + lpRowBuf[nBufPos] <= 0xFFFF)\r
677 nBufPos += 1 + lpRowBuf[nBufPos];\r
678 }\r
0df81049 679 }\r
680 else {\r
ca10c992 681 if (lpImageData[i+x] < 0) {\r
682 lpRowBuf[nBufPos] = 0x81;\r
683 if (nLastOffset + nBufPos + 1 <= 0xFFFF)\r
684 nBufPos++;\r
0df81049 685 }\r
ca10c992 686 else {\r
687 lpRowBuf[nBufPos] = 1;\r
688 lpRowBuf[nBufPos+1] = (BYTE)(lpImageData[i+x]);\r
689 if (nLastOffset + nBufPos + 2 <= 0xFFFF)\r
690 nBufPos += 2;\r
0df81049 691 }\r
c483a082 692 }\r
c483a082 693 }\r
694 else {\r
ca10c992 695 lpRowBuf[nBufPos] = (BYTE)(lpImageData[i+x]);\r
696 if (nLastOffset + nBufPos + 1 <= 0xFFFF)\r
697 nBufPos++;\r
c483a082 698 }\r
699 }\r
700 }\r
0df81049 701\r
702#ifdef _DEBUG\r
ca10c992 703 if (!VerifyRow(&lpImageData[i+lpFrameHeader->Left], lpFrameHeader->Width, lpRowBuf, nBufPos, bNoCompress)) {\r
0df81049 704 nBufPos = nBufPos;\r
c483a082 705 }\r
0df81049 706#endif\r
c483a082 707\r
ca10c992 708 lpFrameData->lpRowOffsets[y] = nLastOffset;\r
ec637542 709 nLastOffset = lpFrameData->lpRowOffsets[y] + nBufPos;\r
710\r
c483a082 711 lpFrameData->lpRowSizes[y] = nBufPos;\r
712 lpFrameData->lpRowData[y] = (LPBYTE)malloc(nBufPos);\r
713 memcpy(lpFrameData->lpRowData[y], lpRowBuf, nBufPos);\r
714 }\r
715\r
ca10c992 716 lpFrameData->Size = nLastOffset;\r
717\r
c483a082 718 free(lpRowBuf);\r
719}\r
0df81049 720\r
721#ifdef _DEBUG\r
ca10c992 722BOOL VerifyRow(signed short *lpRawRow, int nWidth, LPBYTE lpEncRow, int nSize, BOOL bNoCompress)\r
0df81049 723{\r
724 int i,x=0,ofs=0;\r
725 while (x < nWidth && ofs < nSize) {\r
ca10c992 726 if (!bNoCompress) {\r
727 if (!(lpEncRow[ofs] & 0x80)) {\r
728 if (!(lpEncRow[ofs] & 0x40)) {\r
729 for (i=1;i<=lpEncRow[ofs] && x<nWidth;i++) {\r
730 if (lpEncRow[ofs+i] != (BYTE)lpRawRow[x]) return FALSE;\r
731 x++;\r
732 }\r
733 ofs+=lpEncRow[ofs]+1;\r
734 }\r
735 else {\r
736 for (i=0;i<lpEncRow[ofs]-64 && x<nWidth;i++) {\r
737 if (lpEncRow[ofs+1] != (BYTE)lpRawRow[x]) return FALSE;\r
738 x++;\r
739 }\r
740 ofs+=2;\r
0df81049 741 }\r
0df81049 742 }\r
743 else {\r
ca10c992 744 for (i=0;i<lpEncRow[ofs]-128 && x<nWidth;i++) {\r
745 if (lpRawRow[x] >= 0) return FALSE;\r
0df81049 746 }\r
ca10c992 747 x+=lpEncRow[ofs]-128;\r
748 ofs++;\r
0df81049 749 }\r
750 }\r
751 else {\r
ca10c992 752 if (lpEncRow[ofs] != (BYTE)lpRawRow[x]) return FALSE;\r
753 x++;\r
0df81049 754 ofs++;\r
755 }\r
756 }\r
757\r
758 if (x != nWidth || ofs != nSize) return FALSE;\r
759\r
760 return TRUE;\r
761}\r
762#endif\r
GRP encoding/decoding library