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