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