Current News 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: |
1 #include "grpapi.h"\r
2 #include "../LoadStorm/storm.h"\r
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
10 struct GRPLIBMODULE {\r
11 GRPLIBMODULE();\r
12 ~GRPLIBMODULE();\r
13 } GrpLib;\r
14 \r
15 BOOL APIENTRY DllMain(HINSTANCE hInstDLL, DWORD ul_reason_for_call, LPVOID lpReserved);\r
16 \r
17 GRPLIBMODULE::GRPLIBMODULE()\r
18 {\r
19 GrpMain(0,DLL_PROCESS_ATTACH,0);\r
20 }\r
21 \r
22 GRPLIBMODULE::~GRPLIBMODULE()\r
23 {\r
24 GrpMain(0,DLL_PROCESS_DETACH,0);\r
25 }\r
26 \r
27 #endif\r
28 \r
29 typedef 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
37 typedef struct {\r
38 WORD *lpRowOffsets;\r
39 WORD *lpRowSizes;\r
40 LPBYTE *lpRowData;\r
41 } FRAMEDATA;\r
42 \r
43 GETPIXELPROC MyGetPixel = GetPixel;\r
44 SETPIXELPROC MySetPixel = (SETPIXELPROC)SetPixelV;\r
45 \r
46 void __inline SetPix(HDC hDC, int X, int Y, COLORREF clrColor, DWORD *dwPalette, DWORD dwFlags, DWORD dwAlpha);\r
47 void EncodeFrameData(signed short *lpImageData, WORD nFrame, GRPHEADER *lpGrpHeader, FRAMEHEADER *lpFrameHeader, FRAMEDATA *lpFrameData);\r
48 BOOL VerifyRow(signed short *lpRawRow, int nWidth, LPBYTE lpEncRow, int nSize);\r
49 \r
50 extern HINSTANCE hStorm;\r
51 \r
52 BOOL 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
72 BOOL GRPAPI WINAPI LoadGrpApi()\r
73 {\r
74 if (!hStorm) return FALSE;\r
75 else return TRUE;\r
76 }\r
77 \r
78 void GRPAPI WINAPI FreeGrpApi()\r
79 {\r
80 }\r
81 \r
82 /*\r
83 HANDLE hProcessHeap = NULL;\r
84 \r
85 void * 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
92 void 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
99 BOOL 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
105 BOOL GRPAPI WINAPI LoadPalette(LPCSTR lpFileName, DWORD *dwPaletteBuffer)\r
106 {\r
107 if (!lpFileName || !dwPaletteBuffer) return FALSE;\r
108 HANDLE hFile;\r
109 if (SFileOpenFileEx && SFileGetFileSize\r
110 && SFileSetFilePointer && SFileReadFile\r
111 && SFileCloseFile) {\r
112 if (!SFileOpenFileEx(0,lpFileName,1,&hFile)) return FALSE;\r
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
161 HANDLE GRPAPI WINAPI LoadGrp(LPCSTR lpFileName)\r
162 {\r
163 if (!lpFileName) return (HANDLE)-1;\r
164 HANDLE hFile;\r
165 char *GrpFile;\r
166 if (SFileOpenFileEx && SFileGetFileSize\r
167 && SFileSetFilePointer && SFileReadFile\r
168 && SFileCloseFile) {\r
169 if (!SFileOpenFileEx(0,lpFileName,1,&hFile)) return (HANDLE)-1;\r
170 DWORD fsz = SFileGetFileSize(hFile,0);\r
171 if (fsz<6) {\r
172 SFileCloseFile(hFile);\r
173 return (HANDLE)-1;\r
174 }\r
175 GrpFile = (char *)malloc(fsz);\r
176 if (GrpFile) {\r
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
191 GrpFile = (char *)malloc(fsz);\r
192 if (GrpFile) {\r
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
202 BOOL GRPAPI WINAPI DestroyGrp(HANDLE hGrp)\r
203 {\r
204 if (!hGrp || hGrp==INVALID_HANDLE_VALUE) return FALSE;\r
205 free(hGrp);\r
206 return TRUE;\r
207 }\r
208 \r
209 BOOL GRPAPI WINAPI DrawGrp(HANDLE hGrp, HDC hdcDest, int nXDest, int nYDest, WORD nFrame, DWORD *dwPalette, DWORD dwFlags, DWORD dwAlpha)\r
210 {\r
211 if (!hGrp || hGrp==INVALID_HANDLE_VALUE || hdcDest==0 || (!dwPalette && !(dwFlags&USE_INDEX))) return FALSE;\r
212 GRPHEADER *GrpFile = (GRPHEADER *)hGrp;\r
213 nFrame %= GrpFile->nFrames;\r
214 FRAMEHEADER *GrpFrame = &((FRAMEHEADER *)(((char *)GrpFile)+6))[nFrame];\r
215 FRAMEHEADER *GrpFrames = &((FRAMEHEADER *)(((char *)GrpFile)+6))[0];\r
216 int FrameSize = 0xFFFFFF;\r
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
223 BYTE *GrpRaw = (BYTE *)GrpOffsets;\r
224 BYTE *RowData;\r
225 WORD x,ofs;\r
226 DWORD y;\r
227 WORD i;\r
228 int j;\r
229 if (nFrame + 1 < GrpFile->nFrames) {\r
230 for (i = 0; i + 1 < GrpFile->nFrames; i++) {\r
231 j = GrpFrames[i].Offset - GrpFrame->Offset;\r
232 if (j > 0 && j < FrameSize)\r
233 FrameSize = j;\r
234 }\r
235 }\r
236 if (FrameSize == 0xFFFFFF || FrameSize == GrpFrame->Width * GrpFrame->Height) {\r
237 FrameSize = 0xFFFFFF;\r
238 for (i = 0; i + 1 < GrpFile->nFrames; i++) {\r
239 j = GrpFrames[i].Offset - GrpFrames[0].Offset;\r
240 if (j > 0 && j < FrameSize)\r
241 FrameSize = j;\r
242 }\r
243 if (FrameSize == GrpFrames[0].Width * GrpFrames[0].Height)\r
244 FrameSize = GrpFrame->Width * GrpFrame->Height;\r
245 }\r
246 if (!(dwFlags&HORIZONTAL_FLIP) && !(dwFlags&VERTICAL_FLIP)) {\r
247 if (FrameSize != GrpFrame->Width * GrpFrame->Height) {\r
248 for (y=0;y<GrpFrame->Height;y++) {\r
249 RowData = ((BYTE *)(((char *)GrpOffsets)+GrpOffsets[y]));\r
250 x=0; ofs=0;\r
251 while (x<GrpFrame->Width) {\r
252 if (!(RowData[ofs] & 0x80)) {\r
253 if (!(RowData[ofs] & 0x40)) {\r
254 for (i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
255 SetPix(hdcDest,nXDest+x,nYDest+y,RowData[ofs+i],dwPalette,dwFlags,dwAlpha);\r
256 x++;\r
257 }\r
258 ofs+=RowData[ofs]+1;\r
259 }\r
260 else {\r
261 for (i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
262 SetPix(hdcDest,nXDest+x,nYDest+y,RowData[ofs+1],dwPalette,dwFlags,dwAlpha);\r
263 x++;\r
264 }\r
265 ofs+=2;\r
266 }\r
267 }\r
268 else {\r
269 x+=RowData[ofs]-128;\r
270 ofs++;\r
271 }\r
272 }\r
273 }\r
274 }\r
275 else {\r
276 for (y=0;y<GrpFrame->Height;y++) {\r
277 for (x=0;x<GrpFrame->Width;x++) {\r
278 SetPix(hdcDest,nXDest+x,nYDest+y,GrpRaw[y * GrpFrame->Width + x],dwPalette,dwFlags,dwAlpha);\r
279 }\r
280 }\r
281 }\r
282 }\r
283 else if (dwFlags&HORIZONTAL_FLIP && !(dwFlags&VERTICAL_FLIP)) {\r
284 if (FrameSize != GrpFrame->Width * GrpFrame->Height) {\r
285 for (y=0;y<GrpFrame->Height;y++) {\r
286 RowData = ((BYTE *)(((char *)GrpOffsets)+GrpOffsets[y]));\r
287 x=0; ofs=0;\r
288 while (x<GrpFrame->Width) {\r
289 if (!(RowData[ofs] & 0x80)) {\r
290 if (!(RowData[ofs] & 0x40)) {\r
291 for (i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
292 SetPix(hdcDest,Right-x,nYDest+y,RowData[ofs+i],dwPalette,dwFlags,dwAlpha);\r
293 x++;\r
294 }\r
295 ofs+=RowData[ofs]+1;\r
296 }\r
297 else {\r
298 for (i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
299 SetPix(hdcDest,Right-x,nYDest+y,RowData[ofs+1],dwPalette,dwFlags,dwAlpha);\r
300 x++;\r
301 }\r
302 ofs+=2;\r
303 }\r
304 }\r
305 else {\r
306 x+=RowData[ofs]-128;\r
307 ofs++;\r
308 }\r
309 }\r
310 }\r
311 }\r
312 else {\r
313 for (y=0;y<GrpFrame->Height;y++) {\r
314 for (x=0;x<GrpFrame->Width;x++) {\r
315 SetPix(hdcDest,Right-x,nYDest+y,GrpRaw[y * GrpFrame->Width + x],dwPalette,dwFlags,dwAlpha);\r
316 }\r
317 }\r
318 }\r
319 }\r
320 else if (!(dwFlags&HORIZONTAL_FLIP) && dwFlags&VERTICAL_FLIP) {\r
321 if (FrameSize != GrpFrame->Width * GrpFrame->Height) {\r
322 for (y=0;y<GrpFrame->Height;y++) {\r
323 RowData = ((BYTE *)(((char *)GrpOffsets)+GrpOffsets[y]));\r
324 x=0; ofs=0;\r
325 while (x<GrpFrame->Width) {\r
326 if (!(RowData[ofs] & 0x80)) {\r
327 if (!(RowData[ofs] & 0x40)) {\r
328 for (i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
329 SetPix(hdcDest,nXDest+x,Bottom-y,RowData[ofs+i],dwPalette,dwFlags,dwAlpha);\r
330 x++;\r
331 }\r
332 ofs+=RowData[ofs]+1;\r
333 }\r
334 else {\r
335 for (i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
336 SetPix(hdcDest,nXDest+x,Bottom-y,RowData[ofs+1],dwPalette,dwFlags,dwAlpha);\r
337 x++;\r
338 }\r
339 ofs+=2;\r
340 }\r
341 }\r
342 else {\r
343 x+=RowData[ofs]-128;\r
344 ofs++;\r
345 }\r
346 }\r
347 }\r
348 }\r
349 else {\r
350 for (y=0;y<GrpFrame->Height;y++) {\r
351 for (x=0;x<GrpFrame->Width;x++) {\r
352 SetPix(hdcDest,nXDest+x,Bottom-y,GrpRaw[y * GrpFrame->Width + x],dwPalette,dwFlags,dwAlpha);\r
353 }\r
354 }\r
355 }\r
356 }\r
357 else {\r
358 if (FrameSize != GrpFrame->Width * GrpFrame->Height) {\r
359 for (y=0;y<GrpFrame->Height;y++) {\r
360 RowData = ((BYTE *)(((char *)GrpOffsets)+GrpOffsets[y]));\r
361 x=0; ofs=0;\r
362 while (x<GrpFrame->Width) {\r
363 if (!(RowData[ofs] & 0x80)) {\r
364 if (!(RowData[ofs] & 0x40)) {\r
365 for (i=1;i<=RowData[ofs] && x<GrpFrame->Width;i++) {\r
366 SetPix(hdcDest,Right-x,Bottom-y,RowData[ofs+i],dwPalette,dwFlags,dwAlpha);\r
367 x++;\r
368 }\r
369 ofs+=RowData[ofs]+1;\r
370 }\r
371 else {\r
372 for (i=0;i<RowData[ofs]-64 && x<GrpFrame->Width;i++) {\r
373 SetPix(hdcDest,Right-x,Bottom-y,RowData[ofs+1],dwPalette,dwFlags,dwAlpha);\r
374 x++;\r
375 }\r
376 ofs+=2;\r
377 }\r
378 }\r
379 else {\r
380 x+=RowData[ofs]-128;\r
381 ofs++;\r
382 }\r
383 }\r
384 }\r
385 }\r
386 else {\r
387 for (y=0;y<GrpFrame->Height;y++) {\r
388 for (x=0;x<GrpFrame->Width;x++) {\r
389 SetPix(hdcDest,Right-x,Bottom-y,GrpRaw[y * GrpFrame->Width + x],dwPalette,dwFlags,dwAlpha);\r
390 }\r
391 }\r
392 }\r
393 }\r
394 return TRUE;\r
395 }\r
396 \r
397 BOOL GRPAPI WINAPI GetGrpInfo(HANDLE hGrp, GRPHEADER *GrpInfo)\r
398 {\r
399 if (!hGrp || hGrp==INVALID_HANDLE_VALUE || !GrpInfo) return FALSE;\r
400 memcpy(GrpInfo,hGrp,6);\r
401 return TRUE;\r
402 }\r
403 \r
404 void GRPAPI WINAPI SetFunctionGetPixel(GETPIXELPROC lpGetPixelProc)\r
405 {\r
406 if (!lpGetPixelProc)\r
407 MyGetPixel = GetPixel;\r
408 else\r
409 MyGetPixel = lpGetPixelProc;\r
410 }\r
411 \r
412 void GRPAPI WINAPI SetFunctionSetPixel(SETPIXELPROC lpSetPixelProc)\r
413 {\r
414 if (!lpSetPixelProc)\r
415 MySetPixel = (SETPIXELPROC)SetPixelV;\r
416 else\r
417 MySetPixel = lpSetPixelProc;\r
418 }\r
419 \r
420 void __inline SetPix(HDC hDC, int X, int Y, COLORREF clrColor, DWORD *dwPalette, DWORD dwFlags, DWORD dwAlpha)\r
421 {\r
422 if (!(dwFlags&USE_INDEX)) {\r
423 if (dwFlags&SHADOW_COLOR) {\r
424 clrColor = (dwFlags >> 8) & 0x00FFFFFF;\r
425 }\r
426 else {\r
427 clrColor = dwPalette[clrColor];\r
428 }\r
429 if (dwFlags&ALPHA_BLEND) {\r
430 DWORD dwColor = MyGetPixel(hDC,X,Y);\r
431 \r
432 // Old alpha\r
433 /*((BYTE *)&dwColor)[0]*=1-((float)((BYTE *)&dwAlpha)[0]/256);\r
434 ((BYTE *)&dwColor)[1]*=1-((float)((BYTE *)&dwAlpha)[1]/256);\r
435 ((BYTE *)&dwColor)[2]*=1-((float)((BYTE *)&dwAlpha)[2]/256);\r
436 ((BYTE *)&clrColor)[0]*=(float)((BYTE *)&dwAlpha)[0]/256;\r
437 ((BYTE *)&clrColor)[1]*=(float)((BYTE *)&dwAlpha)[1]/256;\r
438 ((BYTE *)&clrColor)[2]*=(float)((BYTE *)&dwAlpha)[2]/256;\r
439 ((BYTE *)&clrColor)[0]+=((BYTE *)&dwColor)[0];\r
440 ((BYTE *)&clrColor)[1]+=((BYTE *)&dwColor)[1];\r
441 ((BYTE *)&clrColor)[2]+=((BYTE *)&dwColor)[2];*/\r
442 \r
443 /* blendedcolor =\r
444 ( ( forecolor * ( 1 - alpha ) ) >> 8 )\r
445 + ( ( backcolor * ( 256 - alpha ) ) >> 8 ) */\r
446 ((BYTE *)&clrColor)[0] =\r
447 ( ( ((BYTE *)&clrColor)[0] * ( ((BYTE *)&dwAlpha)[0] + 1 ) ) >> 8 )\r
448 + ( ( ((BYTE *)&dwColor)[0] * ( 256 - ((BYTE *)&dwAlpha)[0] ) ) >> 8 );\r
449 ((BYTE *)&clrColor)[1] =\r
450 ( ( ((BYTE *)&clrColor)[1] * ( ((BYTE *)&dwAlpha)[1] + 1 ) ) >> 8 )\r
451 + ( ( ((BYTE *)&dwColor)[1] * ( 256 - ((BYTE *)&dwAlpha)[1] ) ) >> 8 );\r
452 ((BYTE *)&clrColor)[2] =\r
453 ( ( ((BYTE *)&clrColor)[2] * ( ((BYTE *)&dwAlpha)[2] + 1 ) ) >> 8 )\r
454 + ( ( ((BYTE *)&dwColor)[2] * ( 256 - ((BYTE *)&dwAlpha)[2] ) ) >> 8 );\r
455 }\r
456 }\r
457 MySetPixel(hDC,X,Y,clrColor);\r
458 }\r
459 \r
460 HANDLE GRPAPI WINAPI CreateGrp(signed short *lpImageData, WORD nFrames, WORD wMaxWidth, WORD wMaxHeight, BOOL bNoCompress, DWORD *nGrpSize)\r
461 {\r
462 GRPHEADER GrpHeader;\r
463 FRAMEHEADER *lpFrameHeaders;\r
464 FRAMEDATA *lpFrameData;\r
465 LPBYTE lpGrpData;\r
466 int i, j, x, y, x1, x2, y1, y2;\r
467 DWORD nLastOffset;\r
468 \r
469 if (!lpImageData || !nGrpSize) return (HANDLE)-1;\r
470 \r
471 GrpHeader.nFrames = nFrames;\r
472 GrpHeader.wMaxWidth = wMaxWidth;\r
473 GrpHeader.wMaxHeight = wMaxHeight;\r
474 lpFrameHeaders = (FRAMEHEADER *)malloc(nFrames * sizeof(FRAMEHEADER));\r
475 lpFrameData = (FRAMEDATA *)malloc(nFrames * sizeof(FRAMEDATA));\r
476 nLastOffset = sizeof(GRPHEADER) + nFrames * sizeof(FRAMEHEADER);\r
477 \r
478 for (i = 0; i < nFrames; i++) {\r
479 // Search for duplicate frames\r
480 for (j = 0; j < i; j++) {\r
481 if (memcmp(&lpImageData[i * wMaxWidth * wMaxHeight],\r
482 &lpImageData[j * wMaxWidth * wMaxHeight],\r
483 wMaxWidth * wMaxHeight * sizeof(short)) == 0)\r
484 break;\r
485 }\r
486 \r
487 if (j < i) {\r
488 memcpy(&lpFrameHeaders[i], &lpFrameHeaders[j], sizeof(FRAMEHEADER));\r
489 lpFrameData[i].lpRowOffsets = 0;\r
490 continue;\r
491 }\r
492 \r
493 if (i == 0) {\r
494 lpFrameHeaders[i].Offset = sizeof(GRPHEADER) + nFrames * sizeof(FRAMEHEADER);\r
495 }\r
496 else {\r
497 lpFrameHeaders[i].Offset = nLastOffset;\r
498 }\r
499 \r
500 // Scan frame to find dimensions of used part\r
501 x1 = y1 = 0x10000;\r
502 x2 = y2 = -1;\r
503 for (y = 0; y < wMaxHeight; y++) {\r
504 for (x = 0; x < wMaxWidth; x++) {\r
505 if (lpImageData[i * wMaxWidth * wMaxHeight + y * wMaxWidth + x] >= 0) {\r
506 if (x < x1) x1 = x;\r
507 if (x > x2) x2 = x;\r
508 if (y < y1) y1 = y;\r
509 if (y > y2) y2 = y;\r
510 }\r
511 }\r
512 }\r
513 x2 = x2 - x1 + 1;\r
514 y2 = y2 - y1 + 1;\r
515 if ((WORD)x1 > 255) x1 = 255;\r
516 if ((WORD)y1 > 255) y1 = 255;\r
517 if ((WORD)x2 > 255) x2 = 255;\r
518 if ((WORD)y2 > 255) y2 = 255;\r
519 lpFrameHeaders[i].Left = x1;\r
520 lpFrameHeaders[i].Top = y1;\r
521 lpFrameHeaders[i].Width = x2;\r
522 lpFrameHeaders[i].Height = y2;\r
523 \r
524 if (!bNoCompress) {\r
525 EncodeFrameData(lpImageData, i, &GrpHeader, &lpFrameHeaders[i], &lpFrameData[i]);\r
526 \r
527 y = lpFrameHeaders[i].Height;\r
528 if (y > 0) {\r
529 y--;\r
530 nLastOffset = lpFrameHeaders[i].Offset + lpFrameData[i].lpRowOffsets[y] + lpFrameData[i].lpRowSizes[y];\r
531 }\r
532 else {\r
533 nLastOffset = lpFrameHeaders[i].Offset;\r
534 }\r
535 }\r
536 else {\r
537 nLastOffset = lpFrameHeaders[i].Offset + lpFrameHeaders[i].Width * lpFrameHeaders[i].Height;\r
538 }\r
539 }\r
540 \r
541 lpGrpData = (LPBYTE)malloc(nLastOffset);\r
542 \r
543 // Write completed GRP to buffer\r
544 memcpy(lpGrpData, &GrpHeader, sizeof(GRPHEADER));\r
545 memcpy(lpGrpData + sizeof(GRPHEADER), lpFrameHeaders, nFrames * sizeof(FRAMEHEADER));\r
546 \r
547 for (i = 0; i < nFrames; i++) {\r
548 if (lpFrameData[i].lpRowOffsets) {\r
549 if (!bNoCompress) {\r
550 memcpy(lpGrpData + lpFrameHeaders[i].Offset, lpFrameData[i].lpRowOffsets, lpFrameHeaders[i].Height * sizeof(WORD));\r
551 \r
552 for (y = 0; y < lpFrameHeaders[i].Height; y++) {\r
553 if (lpFrameData[i].lpRowData[y]) {\r
554 memcpy(lpGrpData + lpFrameHeaders[i].Offset + lpFrameData[i].lpRowOffsets[y], lpFrameData[i].lpRowData[y], lpFrameData[i].lpRowSizes[y]);\r
555 free(lpFrameData[i].lpRowData[y]);\r
556 }\r
557 }\r
558 \r
559 free(lpFrameData[i].lpRowOffsets);\r
560 free(lpFrameData[i].lpRowSizes);\r
561 free(lpFrameData[i].lpRowData);\r
562 }\r
563 else {\r
564 for (y = 0; y < lpFrameHeaders[i].Height; y++) {\r
565 for (x = 0; x < lpFrameHeaders[i].Width; x++) {\r
566 lpGrpData[lpFrameHeaders[i].Offset + y * lpFrameHeaders[i].Width + x] =\r
567 (BYTE)lpImageData[i * wMaxWidth * wMaxHeight + (lpFrameHeaders[i].Top + y) * wMaxWidth + lpFrameHeaders[i].Left + x];\r
568 }\r
569 }\r
570 }\r
571 }\r
572 }\r
573 \r
574 free(lpFrameHeaders);\r
575 free(lpFrameData);\r
576 \r
577 *nGrpSize = nLastOffset;\r
578 return (HANDLE)lpGrpData;\r
579 }\r
580 \r
581 void EncodeFrameData(signed short *lpImageData, WORD nFrame, GRPHEADER *lpGrpHeader, FRAMEHEADER *lpFrameHeader, FRAMEDATA *lpFrameData)\r
582 {\r
583 int x, y, i, nBufPos, nRepeat;\r
584 LPBYTE lpRowBuf;\r
585 WORD nLastOffset;\r
586 \r
587 lpFrameData->lpRowOffsets = (WORD *)malloc(lpFrameHeader->Height * sizeof(WORD));\r
588 lpFrameData->lpRowSizes = (WORD *)malloc(lpFrameHeader->Height * sizeof(WORD));\r
589 lpFrameData->lpRowData = (LPBYTE *)malloc(lpFrameHeader->Height * sizeof(LPBYTE));\r
590 lpRowBuf = (LPBYTE)malloc(lpFrameHeader->Width * 2);\r
591 nLastOffset = lpFrameHeader->Height * sizeof(WORD);\r
592 \r
593 for (y = 0; y < lpFrameHeader->Height; y++) {\r
594 i = nFrame * lpGrpHeader->wMaxWidth * lpGrpHeader->wMaxHeight + (lpFrameHeader->Top + y) * lpGrpHeader->wMaxWidth;\r
595 \r
596 /* Fails verification when using this. Bug in encoder or decoder? Doesn't provide much benefit.\r
597 // Search for duplicate rows (experimental)\r
598 for (x = 0; x < y; x++) {\r
599 j = nFrame * lpGrpHeader->wMaxWidth * lpGrpHeader->wMaxHeight + (lpFrameHeader->Top + x) * lpGrpHeader->wMaxWidth;\r
600 if (memcmp(&lpImageData[i+lpFrameHeader->Left],\r
601 &lpImageData[j+lpFrameHeader->Left],\r
602 lpGrpHeader->wMaxWidth * sizeof(short)) == 0)\r
603 break;\r
604 }\r
605 \r
606 if (x < y) {\r
607 lpFrameData->lpRowOffsets[y] = lpFrameData->lpRowOffsets[x];\r
608 lpFrameData->lpRowSizes[y] = 0;\r
609 lpFrameData->lpRowData[y] = 0;\r
610 \r
611 #ifdef _DEBUG\r
612 if (!VerifyRow(&lpImageData[i+lpFrameHeader->Left], lpFrameHeader->Width, lpFrameData->lpRowData[x], lpFrameData->lpRowSizes[x])) {\r
613 nBufPos = nBufPos;\r
614 }\r
615 #endif\r
616 \r
617 continue;\r
618 }\r
619 */\r
620 \r
621 nBufPos = 0;\r
622 if (lpFrameHeader->Width > 0) {\r
623 for (x = lpFrameHeader->Left; x < lpFrameHeader->Left + lpFrameHeader->Width; x++) {\r
624 if (x < lpFrameHeader->Left + lpFrameHeader->Width - 1) {\r
625 if (lpImageData[i+x] < 0) {\r
626 lpRowBuf[nBufPos] = 0x80;\r
627 for (; lpImageData[i+x] < 0 && x < lpFrameHeader->Left + lpFrameHeader->Width && lpRowBuf[nBufPos] < 0xFF; x++) {\r
628 lpRowBuf[nBufPos]++;\r
629 }\r
630 x--;\r
631 if (nLastOffset + nBufPos + 1 <= 0xFFFF)\r
632 nBufPos++;\r
633 continue;\r
634 }\r
635 \r
636 // Count repeating pixels, nRepeat = number of pixels - 1, ignore if there are less than 4 duplicates\r
637 for (nRepeat = 0; lpImageData[i+x+nRepeat] == lpImageData[i+x+nRepeat+1] && x+nRepeat < lpFrameHeader->Left + lpFrameHeader->Width - 1 && nRepeat < 0x3E; nRepeat++) {}\r
638 \r
639 if (nRepeat > 2) {\r
640 lpRowBuf[nBufPos] = 0x41 + nRepeat;\r
641 lpRowBuf[nBufPos+1] = (BYTE)lpImageData[i+x];\r
642 x += nRepeat;\r
643 if (nLastOffset + nBufPos + 2 <= 0xFFFF)\r
644 nBufPos += 2;\r
645 }\r
646 else {\r
647 lpRowBuf[nBufPos] = 0;\r
648 for (; lpImageData[i+x] >= 0 && x < lpFrameHeader->Left + lpFrameHeader->Width && lpRowBuf[nBufPos] < 0x3F; x++) {\r
649 // Count repeating pixels, ignore if there are less than 4 duplicates\r
650 for (nRepeat = 0; lpImageData[i+x+nRepeat] == lpImageData[i+x+nRepeat+1] && x+nRepeat < lpFrameHeader->Left + lpFrameHeader->Width - 1 && nRepeat < 3; nRepeat++) {}\r
651 if (nRepeat > 2) break;\r
652 \r
653 lpRowBuf[nBufPos]++;\r
654 lpRowBuf[nBufPos+lpRowBuf[nBufPos]] = (BYTE)lpImageData[i+x];\r
655 }\r
656 if (lpImageData[i+x] >= 0 && x == lpFrameHeader->Left + lpFrameHeader->Width - 1 && lpRowBuf[nBufPos] < 0x3F) {\r
657 lpRowBuf[nBufPos]++;\r
658 lpRowBuf[nBufPos+lpRowBuf[nBufPos]] = (BYTE)lpImageData[i+x];\r
659 }\r
660 x--;\r
661 if (nLastOffset + nBufPos + 1 + lpRowBuf[nBufPos] <= 0xFFFF)\r
662 nBufPos += 1 + lpRowBuf[nBufPos];\r
663 }\r
664 }\r
665 else {\r
666 if (lpImageData[i+x] < 0) {\r
667 lpRowBuf[nBufPos] = 0x81;\r
668 if (nLastOffset + nBufPos + 1 <= 0xFFFF)\r
669 nBufPos++;\r
670 }\r
671 else {\r
672 lpRowBuf[nBufPos] = 1;\r
673 lpRowBuf[nBufPos+1] = (BYTE)lpImageData[i+x];\r
674 if (nLastOffset + nBufPos + 2 <= 0xFFFF)\r
675 nBufPos += 2;\r
676 }\r
677 }\r
678 }\r
679 }\r
680 \r
681 #ifdef _DEBUG\r
682 if (!VerifyRow(&lpImageData[i+lpFrameHeader->Left], lpFrameHeader->Width, lpRowBuf, nBufPos)) {\r
683 nBufPos = nBufPos;\r
684 }\r
685 #endif\r
686 \r
687 if (y == 0) {\r
688 lpFrameData->lpRowOffsets[y] = lpFrameHeader->Height * sizeof(WORD);\r
689 }\r
690 else {\r
691 lpFrameData->lpRowOffsets[y] = nLastOffset;\r
692 }\r
693 \r
694 nLastOffset = lpFrameData->lpRowOffsets[y] + nBufPos;\r
695 \r
696 lpFrameData->lpRowSizes[y] = nBufPos;\r
697 lpFrameData->lpRowData[y] = (LPBYTE)malloc(nBufPos);\r
698 memcpy(lpFrameData->lpRowData[y], lpRowBuf, nBufPos);\r
699 }\r
700 \r
701 free(lpRowBuf);\r
702 }\r
703 \r
704 #ifdef _DEBUG\r
705 BOOL VerifyRow(signed short *lpRawRow, int nWidth, LPBYTE lpEncRow, int nSize)\r
706 {\r
707 int i,x=0,ofs=0;\r
708 while (x < nWidth && ofs < nSize) {\r
709 if (!(lpEncRow[ofs] & 0x80)) {\r
710 if (!(lpEncRow[ofs] & 0x40)) {\r
711 for (i=1;i<=lpEncRow[ofs] && x<nWidth;i++) {\r
712 if (lpEncRow[ofs+i] != (BYTE)lpRawRow[x]) return FALSE;\r
713 x++;\r
714 }\r
715 ofs+=lpEncRow[ofs]+1;\r
716 }\r
717 else {\r
718 for (i=0;i<lpEncRow[ofs]-64 && x<nWidth;i++) {\r
719 if (lpEncRow[ofs+1] != (BYTE)lpRawRow[x]) return FALSE;\r
720 x++;\r
721 }\r
722 ofs+=2;\r
723 }\r
724 }\r
725 else {\r
726 for (i=0;i<lpEncRow[ofs]-128 && x<nWidth;i++) {\r
727 if (lpRawRow[x] >= 0) return FALSE;\r
728 }\r
729 x+=lpEncRow[ofs]-128;\r
730 ofs++;\r
731 }\r
732 }\r
733 \r
734 if (x != nWidth || ofs != nSize) return FALSE;\r
735 \r
736 return TRUE;\r
737 }\r
738 #endif\r
|