grpapi/grpapi.cpp

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