grpapi/grpapi.cpp

   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         DWORD Size;\r
  42 } FRAMEDATA;\r
  43 \r
  44 GETPIXELPROC MyGetPixel = GetPixel;\r
  45 SETPIXELPROC MySetPixel = (SETPIXELPROC)SetPixelV;\r
  46 \r
  47 void __inline SetPix(HDC hDC, int X, int Y, COLORREF clrColor, DWORD *dwPalette, DWORD dwFlags, DWORD dwAlpha);\r
  48 void EncodeFrameData(signed short *lpImageData, WORD nFrame, GRPHEADER *lpGrpHeader, FRAMEHEADER *lpFrameHeader, FRAMEDATA *lpFrameData, BOOL bNoCompress);\r
  49 BOOL VerifyRow(signed short *lpRawRow, int nWidth, LPBYTE lpEncRow, int nSize, BOOL bNoCompress);\r
  50 \r
  51 extern HINSTANCE hStorm;\r
  52 \r
  53 BOOL 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
  73 BOOL GRPAPI WINAPI LoadGrpApi()\r
  74 {\r
  75         if (!hStorm) return FALSE;\r
  76         else return TRUE;\r
  77 }\r
  78 \r
  79 void GRPAPI WINAPI FreeGrpApi()\r
  80 {\r
  81 }\r
  82 \r
  83 /*\r
  84 HANDLE hProcessHeap = NULL;\r
  85 \r
  86 void * 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
  93 void 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
 100 BOOL 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
 106 BOOL GRPAPI WINAPI LoadPalette(LPCSTR lpFileName, DWORD *dwPaletteBuffer)\r
 107 {\r
 108         if (!lpFileName || !dwPaletteBuffer) return FALSE;\r
 109         HANDLE hFile;\r
 110         if (SFileOpenFileEx && SFileGetFileSize\r
 111          && SFileSetFilePointer && SFileReadFile\r
 112          && SFileCloseFile) {\r
 113                 if (!SFileOpenFileEx(0,lpFileName,1,&hFile)) return FALSE;\r
 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
 162 HANDLE GRPAPI WINAPI LoadGrp(LPCSTR lpFileName)\r
 163 {\r
 164         if (!lpFileName) return (HANDLE)-1;\r
 165         HANDLE hFile;\r
 166         char *GrpFile;\r
 167         if (SFileOpenFileEx && SFileGetFileSize\r
 168          && SFileSetFilePointer && SFileReadFile\r
 169          && SFileCloseFile) {\r
 170                 if (!SFileOpenFileEx(0,lpFileName,1,&hFile)) return (HANDLE)-1;\r
 171                 DWORD fsz = SFileGetFileSize(hFile,0);\r
 172                 if (fsz<6) {\r
 173                         SFileCloseFile(hFile);\r
 174                         return (HANDLE)-1;\r
 175                 }\r
 176                 GrpFile = (char *)malloc(fsz);\r
 177                 if (GrpFile) {\r
 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
 192                 GrpFile = (char *)malloc(fsz);\r
 193                 if (GrpFile) {\r
 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
 203 BOOL GRPAPI WINAPI DestroyGrp(HANDLE hGrp)\r
 204 {\r
 205         if (!hGrp || hGrp==INVALID_HANDLE_VALUE) return FALSE;\r
 206         free(hGrp);\r
 207         return TRUE;\r
 208 }\r
 209 \r
 210 BOOL GRPAPI WINAPI DrawGrp(HANDLE hGrp, HDC hdcDest, int nXDest, int nYDest, WORD nFrame, DWORD *dwPalette, DWORD dwFlags, DWORD dwAlpha)\r
 211 {\r
 212         if (!hGrp || hGrp==INVALID_HANDLE_VALUE || hdcDest==0 || (!dwPalette && !(dwFlags&USE_INDEX))) return FALSE;\r
 213         GRPHEADER *GrpFile = (GRPHEADER *)hGrp;\r
 214         nFrame %= GrpFile->nFrames;\r
 215         FRAMEHEADER *GrpFrame = &((FRAMEHEADER *)(((char *)GrpFile)+6))[nFrame];\r
 216         FRAMEHEADER *GrpFrames = &((FRAMEHEADER *)(((char *)GrpFile)+6))[0];\r
 217         int FrameSize = 0xFFFFFF;\r
 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
 224         BYTE *GrpRaw = (BYTE *)GrpOffsets;\r
 225         BYTE *RowData;\r
 226         WORD x,ofs;\r
 227         DWORD y, nMaxOffset = 0;\r
 228         WORD i;\r
 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
 236         }\r
 237         if (FrameSize == 0xFFFFFF || FrameSize == GrpFrame->Width * GrpFrame->Height) {\r
 238                 FrameSize = 0xFFFFFF;\r
 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
 250                         if (j > 0 && j < FrameSize)\r
 251                                 FrameSize = j;\r
 252                 }\r
 253                 if (FrameSize == GrpFrames[nFirstNonBlankFrame].Width * GrpFrames[nFirstNonBlankFrame].Height)\r
 254                         FrameSize = GrpFrame->Width * GrpFrame->Height;\r
 255         }\r
 256         if (!(dwFlags&HORIZONTAL_FLIP) && !(dwFlags&VERTICAL_FLIP)) {\r
 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
 265                                                                 SetPix(hdcDest,nXDest+x,nYDest+y,RowData[ofs+i],dwPalette,dwFlags,dwAlpha);\r
 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
 272                                                                 SetPix(hdcDest,nXDest+x,nYDest+y,RowData[ofs+1],dwPalette,dwFlags,dwAlpha);\r
 273                                                                 x++;\r
 274                                                         }\r
 275                                                         ofs+=2;\r
 276                                                 }\r
 277                                         }\r
 278                                         else {\r
 279                                                 x+=RowData[ofs]-128;\r
 280                                                 ofs++;\r
 281                                         }\r
 282                                 }\r
 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
 288                                         SetPix(hdcDest,nXDest+x,nYDest+y,GrpRaw[y * GrpFrame->Width + x],dwPalette,dwFlags,dwAlpha);\r
 289                                 }\r
 290                         }\r
 291                 }\r
 292         }\r
 293         else if (dwFlags&HORIZONTAL_FLIP && !(dwFlags&VERTICAL_FLIP)) {\r
 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
 302                                                                 SetPix(hdcDest,Right-x,nYDest+y,RowData[ofs+i],dwPalette,dwFlags,dwAlpha);\r
 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
 309                                                                 SetPix(hdcDest,Right-x,nYDest+y,RowData[ofs+1],dwPalette,dwFlags,dwAlpha);\r
 310                                                                 x++;\r
 311                                                         }\r
 312                                                         ofs+=2;\r
 313                                                 }\r
 314                                         }\r
 315                                         else {\r
 316                                                 x+=RowData[ofs]-128;\r
 317                                                 ofs++;\r
 318                                         }\r
 319                                 }\r
 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
 325                                         SetPix(hdcDest,Right-x,nYDest+y,GrpRaw[y * GrpFrame->Width + x],dwPalette,dwFlags,dwAlpha);\r
 326                                 }\r
 327                         }\r
 328                 }\r
 329         }\r
 330         else if (!(dwFlags&HORIZONTAL_FLIP) && dwFlags&VERTICAL_FLIP) {\r
 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
 339                                                                 SetPix(hdcDest,nXDest+x,Bottom-y,RowData[ofs+i],dwPalette,dwFlags,dwAlpha);\r
 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
 346                                                                 SetPix(hdcDest,nXDest+x,Bottom-y,RowData[ofs+1],dwPalette,dwFlags,dwAlpha);\r
 347                                                                 x++;\r
 348                                                         }\r
 349                                                         ofs+=2;\r
 350                                                 }\r
 351                                         }\r
 352                                         else {\r
 353                                                 x+=RowData[ofs]-128;\r
 354                                                 ofs++;\r
 355                                         }\r
 356                                 }\r
 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
 362                                         SetPix(hdcDest,nXDest+x,Bottom-y,GrpRaw[y * GrpFrame->Width + x],dwPalette,dwFlags,dwAlpha);\r
 363                                 }\r
 364                         }\r
 365                 }\r
 366         }\r
 367         else {\r
 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
 376                                                                 SetPix(hdcDest,Right-x,Bottom-y,RowData[ofs+i],dwPalette,dwFlags,dwAlpha);\r
 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
 383                                                                 SetPix(hdcDest,Right-x,Bottom-y,RowData[ofs+1],dwPalette,dwFlags,dwAlpha);\r
 384                                                                 x++;\r
 385                                                         }\r
 386                                                         ofs+=2;\r
 387                                                 }\r
 388                                         }\r
 389                                         else {\r
 390                                                 x+=RowData[ofs]-128;\r
 391                                                 ofs++;\r
 392                                         }\r
 393                                 }\r
 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
 399                                         SetPix(hdcDest,Right-x,Bottom-y,GrpRaw[y * GrpFrame->Width + x],dwPalette,dwFlags,dwAlpha);\r
 400                                 }\r
 401                         }\r
 402                 }\r
 403         }\r
 404         return TRUE;\r
 405 }\r
 406 \r
 407 BOOL GRPAPI WINAPI GetGrpInfo(HANDLE hGrp, GRPHEADER *GrpInfo)\r
 408 {\r
 409         if (!hGrp || hGrp==INVALID_HANDLE_VALUE || !GrpInfo) return FALSE;\r
 410         memcpy(GrpInfo,hGrp,6);\r
 411         return TRUE;\r
 412 }\r
 413 \r
 414 BOOL 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
 427 void GRPAPI WINAPI SetFunctionGetPixel(GETPIXELPROC lpGetPixelProc)\r
 428 {\r
 429         if (!lpGetPixelProc)\r
 430                 MyGetPixel = GetPixel;\r
 431         else\r
 432                 MyGetPixel = lpGetPixelProc;\r
 433 }\r
 434 \r
 435 void GRPAPI WINAPI SetFunctionSetPixel(SETPIXELPROC lpSetPixelProc)\r
 436 {\r
 437         if (!lpSetPixelProc)\r
 438                 MySetPixel = (SETPIXELPROC)SetPixelV;\r
 439         else\r
 440                 MySetPixel = lpSetPixelProc;\r
 441 }\r
 442 \r
 443 void __inline SetPix(HDC hDC, int X, int Y, COLORREF clrColor, DWORD *dwPalette, DWORD dwFlags, DWORD dwAlpha)\r
 444 {\r
 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
 454 \r
 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
 465 \r
 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
 479         }\r
 480         MySetPixel(hDC,X,Y,clrColor);\r
 481 }\r
 482 \r
 483 HANDLE GRPAPI WINAPI CreateGrp(signed short *lpImageData, WORD nFrames, WORD wMaxWidth, WORD wMaxHeight, BOOL bNoCompress, DWORD *nGrpSize)\r
 484 {\r
 485         GRPHEADER GrpHeader;\r
 486         FRAMEHEADER *lpFrameHeaders;\r
 487         FRAMEDATA *lpFrameData;\r
 488         LPBYTE lpGrpData;\r
 489         int i, j, x, y, x1, x2, y1, y2;\r
 490         DWORD nLastOffset;\r
 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
 497         lpFrameHeaders = (FRAMEHEADER *)malloc(nFrames * sizeof(FRAMEHEADER));\r
 498         lpFrameData = (FRAMEDATA *)malloc(nFrames * sizeof(FRAMEDATA));\r
 499         nLastOffset = sizeof(GRPHEADER) + nFrames * sizeof(FRAMEHEADER);\r
 500 \r
 501         for (i = 0; i < nFrames; i++) {\r
 502                 lpFrameHeaders[i].Offset = nLastOffset;\r
 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
 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
 523                 lpFrameHeaders[i].Left = x1;\r
 524                 lpFrameHeaders[i].Top = y1;\r
 525                 lpFrameHeaders[i].Width = x2;\r
 526                 lpFrameHeaders[i].Height = y2;\r
 527 \r
 528                 EncodeFrameData(lpImageData, i, &GrpHeader, &lpFrameHeaders[i], &lpFrameData[i], bNoCompress);\r
 529 \r
 530                 // Search for duplicate frames\r
 531                 for (j = 0; j < i; j++) {\r
 532                         if (lpFrameData[j].lpRowOffsets && lpFrameHeaders[i].Width == lpFrameHeaders[j].Width && lpFrameHeaders[i].Height == lpFrameHeaders[j].Height && lpFrameData[i].Size == lpFrameData[j].Size) {\r
 533                                 for (y = 0; y < lpFrameHeaders[i].Height; y++) {\r
 534                                         if (!lpFrameData[i].lpRowData[y] && !lpFrameData[j].lpRowData[y])\r
 535                                                 continue;\r
 536 \r
 537                                         if ((!lpFrameData[i].lpRowData[y] && lpFrameData[j].lpRowData[y]) || (lpFrameData[i].lpRowData[y] && !lpFrameData[j].lpRowData[y]) || lpFrameData[i].lpRowSizes[y] != lpFrameData[j].lpRowSizes[y])\r
 538                                                 break;\r
 539 \r
 540                                         if (memcmp(lpFrameData[i].lpRowData[y], lpFrameData[j].lpRowData[y], lpFrameData[i].lpRowSizes[y]) != 0)\r
 541                                                 break;\r
 542                                 }\r
 543 \r
 544                                 if (y == lpFrameHeaders[i].Height) {\r
 545                                         break;\r
 546                                 }\r
 547                         }\r
 548                 }\r
 549 \r
 550                 if (j < i) {\r
 551                         // Duplicate frame found, free stored frame data and change offset\r
 552                         for (y = 0; y < lpFrameHeaders[i].Height; y++) {\r
 553                                 if (lpFrameData[i].lpRowData[y]) {\r
 554                                         free(lpFrameData[i].lpRowData[y]);\r
 555                                 }\r
 556                         }\r
 557 \r
 558                         free(lpFrameData[i].lpRowOffsets);\r
 559                         free(lpFrameData[i].lpRowSizes);\r
 560                         free(lpFrameData[i].lpRowData);\r
 561 \r
 562                         lpFrameHeaders[i].Offset = lpFrameHeaders[j].Offset;\r
 563                         lpFrameData[i].lpRowOffsets = 0;\r
 564                         lpFrameData[i].lpRowSizes = 0;\r
 565                         lpFrameData[i].lpRowData = 0;\r
 566                         lpFrameData[i].Size = 0;\r
 567                         continue;\r
 568                 }\r
 569 \r
 570                 nLastOffset = lpFrameHeaders[i].Offset + lpFrameData[i].Size;\r
 571         }\r
 572 \r
 573         lpGrpData = (LPBYTE)malloc(nLastOffset);\r
 574 \r
 575         // Write completed GRP to buffer\r
 576         memcpy(lpGrpData, &GrpHeader, sizeof(GRPHEADER));\r
 577         memcpy(lpGrpData + sizeof(GRPHEADER), lpFrameHeaders, nFrames * sizeof(FRAMEHEADER));\r
 578 \r
 579         for (i = 0; i < nFrames; i++) {\r
 580                 if (lpFrameData[i].lpRowOffsets) {\r
 581                         if (!bNoCompress)\r
 582                                 memcpy(lpGrpData + lpFrameHeaders[i].Offset, lpFrameData[i].lpRowOffsets, lpFrameHeaders[i].Height * sizeof(WORD));\r
 583 \r
 584                         for (y = 0; y < lpFrameHeaders[i].Height; y++) {\r
 585                                 if (lpFrameData[i].lpRowData[y]) {\r
 586                                         memcpy(lpGrpData + lpFrameHeaders[i].Offset + lpFrameData[i].lpRowOffsets[y], lpFrameData[i].lpRowData[y], lpFrameData[i].lpRowSizes[y]);\r
 587                                         free(lpFrameData[i].lpRowData[y]);\r
 588                                 }\r
 589                         }\r
 590 \r
 591                         free(lpFrameData[i].lpRowOffsets);\r
 592                         free(lpFrameData[i].lpRowSizes);\r
 593                         free(lpFrameData[i].lpRowData);\r
 594                 }\r
 595         }\r
 596 \r
 597         free(lpFrameHeaders);\r
 598         free(lpFrameData);\r
 599 \r
 600         *nGrpSize = nLastOffset;\r
 601         return (HANDLE)lpGrpData;\r
 602 }\r
 603 \r
 604 void EncodeFrameData(signed short *lpImageData, WORD nFrame, GRPHEADER *lpGrpHeader, FRAMEHEADER *lpFrameHeader, FRAMEDATA *lpFrameData, BOOL bNoCompress)\r
 605 {\r
 606         int x, y, i, j, nBufPos, nRepeat;\r
 607         LPBYTE lpRowBuf;\r
 608         WORD nLastOffset = 0;\r
 609 \r
 610         lpFrameData->lpRowOffsets = (WORD *)malloc(lpFrameHeader->Height * sizeof(WORD));\r
 611         lpFrameData->lpRowSizes = (WORD *)malloc(lpFrameHeader->Height * sizeof(WORD));\r
 612         lpFrameData->lpRowData = (LPBYTE *)malloc(lpFrameHeader->Height * sizeof(LPBYTE));\r
 613         lpRowBuf = (LPBYTE)malloc(lpFrameHeader->Width * 2);\r
 614 \r
 615         if (!bNoCompress)\r
 616                 nLastOffset = lpFrameHeader->Height * sizeof(WORD);\r
 617 \r
 618         for (y = 0; y < lpFrameHeader->Height; y++) {\r
 619                 i = nFrame * lpGrpHeader->wMaxWidth * lpGrpHeader->wMaxHeight + (lpFrameHeader->Top + y) * lpGrpHeader->wMaxWidth;\r
 620 \r
 621                 if (!bNoCompress) {\r
 622                         // Search for duplicate rows\r
 623                         for (x = 0; x < y; x++) {\r
 624                                 j = nFrame * lpGrpHeader->wMaxWidth * lpGrpHeader->wMaxHeight + (lpFrameHeader->Top + x) * lpGrpHeader->wMaxWidth;\r
 625                                 if (memcmp(&lpImageData[i+lpFrameHeader->Left],\r
 626                                                    &lpImageData[j+lpFrameHeader->Left],\r
 627                                                    lpGrpHeader->wMaxWidth * sizeof(short)) == 0)\r
 628                                         break;\r
 629                         }\r
 630 \r
 631                         if (x < y) {\r
 632                                 lpFrameData->lpRowOffsets[y] = lpFrameData->lpRowOffsets[x];\r
 633                                 lpFrameData->lpRowSizes[y] = 0;\r
 634                                 lpFrameData->lpRowData[y] = 0;\r
 635 \r
 636 #ifdef _DEBUG\r
 637                                 if (!VerifyRow(&lpImageData[i+lpFrameHeader->Left], lpFrameHeader->Width, lpFrameData->lpRowData[x], lpFrameData->lpRowSizes[x], bNoCompress)) {\r
 638                                         nBufPos = nBufPos;\r
 639                                 }\r
 640 #endif\r
 641 \r
 642                                 continue;\r
 643                         }\r
 644                 }\r
 645 \r
 646                 nBufPos = 0;\r
 647                 if (lpFrameHeader->Width > 0) {\r
 648                         for (x = lpFrameHeader->Left; x < lpFrameHeader->Left + lpFrameHeader->Width; x++) {\r
 649                                 if (!bNoCompress) {\r
 650                                         if (x < lpFrameHeader->Left + lpFrameHeader->Width - 1) {\r
 651                                                 if (lpImageData[i+x] < 0) {\r
 652                                                         lpRowBuf[nBufPos] = 0x80;\r
 653                                                         for (; lpImageData[i+x] < 0 && x < lpFrameHeader->Left + lpFrameHeader->Width && lpRowBuf[nBufPos] < 0xFF; x++) {\r
 654                                                                 lpRowBuf[nBufPos]++;\r
 655                                                         }\r
 656                                                         x--;\r
 657                                                         if (nLastOffset + nBufPos + 1 <= 0xFFFF)\r
 658                                                                 nBufPos++;\r
 659                                                         continue;\r
 660                                                 }\r
 661 \r
 662                                                 // Count repeating pixels, nRepeat = number of pixels - 1, ignore if there are less than 4 duplicates\r
 663                                                 for (nRepeat = 0; lpImageData[i+x+nRepeat] == lpImageData[i+x+nRepeat+1] && x+nRepeat < lpFrameHeader->Left + lpFrameHeader->Width - 1 && nRepeat < 0x3E; nRepeat++) {}\r
 664 \r
 665                                                 if (nRepeat > 2) {\r
 666                                                         lpRowBuf[nBufPos] = 0x41 + nRepeat;\r
 667                                                         lpRowBuf[nBufPos+1] = (BYTE)(lpImageData[i+x]);\r
 668                                                         x += nRepeat;\r
 669                                                         if (nLastOffset + nBufPos + 2 <= 0xFFFF)\r
 670                                                                 nBufPos += 2;\r
 671                                                 }\r
 672                                                 else {\r
 673                                                         lpRowBuf[nBufPos] = 0;\r
 674                                                         for (; lpImageData[i+x] >= 0 && x < lpFrameHeader->Left + lpFrameHeader->Width && lpRowBuf[nBufPos] < 0x3F; x++) {\r
 675                                                                 // Count repeating pixels, ignore if there are less than 4 duplicates\r
 676                                                                 for (nRepeat = 0; lpImageData[i+x+nRepeat] == lpImageData[i+x+nRepeat+1] && x+nRepeat < lpFrameHeader->Left + lpFrameHeader->Width - 1 && nRepeat < 3; nRepeat++) {}\r
 677                                                                 if (nRepeat > 2) break;\r
 678 \r
 679                                                                 lpRowBuf[nBufPos]++;\r
 680                                                                 lpRowBuf[nBufPos+lpRowBuf[nBufPos]] = (BYTE)(lpImageData[i+x]);\r
 681                                                         }\r
 682                                                         if (lpImageData[i+x] >= 0 && x == lpFrameHeader->Left + lpFrameHeader->Width - 1 && lpRowBuf[nBufPos] < 0x3F) {\r
 683                                                                 lpRowBuf[nBufPos]++;\r
 684                                                                 lpRowBuf[nBufPos+lpRowBuf[nBufPos]] = (BYTE)(lpImageData[i+x]);\r
 685                                                         }\r
 686                                                         x--;\r
 687                                                         if (nLastOffset + nBufPos + 1 + lpRowBuf[nBufPos] <= 0xFFFF)\r
 688                                                                 nBufPos += 1 + lpRowBuf[nBufPos];\r
 689                                                 }\r
 690                                         }\r
 691                                         else {\r
 692                                                 if (lpImageData[i+x] < 0) {\r
 693                                                         lpRowBuf[nBufPos] = 0x81;\r
 694                                                         if (nLastOffset + nBufPos + 1 <= 0xFFFF)\r
 695                                                                 nBufPos++;\r
 696                                                 }\r
 697                                                 else {\r
 698                                                         lpRowBuf[nBufPos] = 1;\r
 699                                                         lpRowBuf[nBufPos+1] = (BYTE)(lpImageData[i+x]);\r
 700                                                         if (nLastOffset + nBufPos + 2 <= 0xFFFF)\r
 701                                                                 nBufPos += 2;\r
 702                                                 }\r
 703                                         }\r
 704                                 }\r
 705                                 else {\r
 706                                         lpRowBuf[nBufPos] = (BYTE)(lpImageData[i+x]);\r
 707                                         if (nLastOffset + nBufPos + 1 <= 0xFFFF)\r
 708                                                 nBufPos++;\r
 709                                 }\r
 710                         }\r
 711                 }\r
 712 \r
 713 #ifdef _DEBUG\r
 714                 if (!VerifyRow(&lpImageData[i+lpFrameHeader->Left], lpFrameHeader->Width, lpRowBuf, nBufPos, bNoCompress)) {\r
 715                         nBufPos = nBufPos;\r
 716                 }\r
 717 #endif\r
 718 \r
 719                 lpFrameData->lpRowOffsets[y] = nLastOffset;\r
 720                 nLastOffset = lpFrameData->lpRowOffsets[y] + nBufPos;\r
 721 \r
 722                 lpFrameData->lpRowSizes[y] = nBufPos;\r
 723                 lpFrameData->lpRowData[y] = (LPBYTE)malloc(nBufPos);\r
 724                 memcpy(lpFrameData->lpRowData[y], lpRowBuf, nBufPos);\r
 725         }\r
 726 \r
 727         lpFrameData->Size = nLastOffset;\r
 728 \r
 729         free(lpRowBuf);\r
 730 }\r
 731 \r
 732 #ifdef _DEBUG\r
 733 BOOL VerifyRow(signed short *lpRawRow, int nWidth, LPBYTE lpEncRow, int nSize, BOOL bNoCompress)\r
 734 {\r
 735         int i,x=0,ofs=0;\r
 736         while (x < nWidth && ofs < nSize) {\r
 737                 if (!bNoCompress) {\r
 738                         if (!(lpEncRow[ofs] & 0x80)) {\r
 739                                 if (!(lpEncRow[ofs] & 0x40)) {\r
 740                                         for (i=1;i<=lpEncRow[ofs] && x<nWidth;i++) {\r
 741                                                 if (lpEncRow[ofs+i] != (BYTE)lpRawRow[x]) return FALSE;\r
 742                                                 x++;\r
 743                                         }\r
 744                                         ofs+=lpEncRow[ofs]+1;\r
 745                                 }\r
 746                                 else {\r
 747                                         for (i=0;i<lpEncRow[ofs]-64 && x<nWidth;i++) {\r
 748                                                 if (lpEncRow[ofs+1] != (BYTE)lpRawRow[x]) return FALSE;\r
 749                                                 x++;\r
 750                                         }\r
 751                                         ofs+=2;\r
 752                                 }\r
 753                         }\r
 754                         else {\r
 755                                 for (i=0;i<lpEncRow[ofs]-128 && x<nWidth;i++) {\r
 756                                         if (lpRawRow[x] >= 0) return FALSE;\r
 757                                 }\r
 758                                 x+=lpEncRow[ofs]-128;\r
 759                                 ofs++;\r
 760                         }\r
 761                 }\r
 762                 else {\r
 763                         if (lpEncRow[ofs] != (BYTE)lpRawRow[x]) return FALSE;\r
 764                         x++;\r
 765                         ofs++;\r
 766                 }\r
 767         }\r
 768 \r
 769         if (x != nWidth || ofs != nSize) return FALSE;\r
 770 \r
 771         return TRUE;\r
 772 }\r
 773 #endif\r