2d/ibitblt.c

   1 /* $Id: ibitblt.c,v 1.12 2005-07-30 09:17:06 chris Exp $ */
   2 /*
   3 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   4 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   5 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   6 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   7 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   8 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   9 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
  10 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  11 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  12 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  13 */
  14
  15 /*
  16  *
  17  * "PC" Version:
  18  * Rountines to copy a bitmap on top of another bitmap, but
  19  * only copying to pixels that are transparent.
  20  * "Mac" Version:
  21  * Routines to to inverse bitblitting -- well not really.
  22  * We don't inverse bitblt like in the PC, but this code
  23  * does set up a structure that blits around the cockpit
  24  *
  25  * d2x uses the "Mac" version for everything except __MSDOS__
  26  *
  27  */
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include <conf.h>
  31 #endif
  32
  33 #ifdef RCS
  34 static char rcsid[] = "$Id: ibitblt.c,v 1.12 2005-07-30 09:17:06 chris Exp $";
  35 #endif
  36
  37 #ifdef __MSDOS__ //ndef MACINTOSH
  38
  39 #include <conio.h>
  40 #include <dos.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44
  45 #include "types.h"
  46 #include "gr.h"
  47 #include "mem.h"
  48 #include "error.h"
  49 #include "ibitblt.h"
  50 #include "grdef.h"
  51
  52 #define MODE_NONE           0
  53 #define MODE_SKIP           1
  54 #define MODE_DRAW           2
  55
  56 #define OPCODE_ADD          0x81
  57 #define OPCODE_ESI          0xC6        // Followed by a dword  (add esi, ????)
  58 #define OPCODE_EDI          0xC7        // Followed by a dword  (add edi, ????)
  59 #define OPCODE_MOV_ECX      0xB9        // Followed by a dword  (mov ecx,????)
  60 #define OPCODE_MOVSB        0xA4        // movsb
  61 #define OPCODE_16BIT        0x66        // movsw
  62 #define OPCODE_MOVSD        0xA5        // movsd
  63 #define OPCODE_REP          0xF3        // rep
  64 #define OPCODE_RET          0xC3        // ret
  65 #define OPCODE_MOV_EAX      0xB8        // mov eax, im dword
  66 #define OPCODE_MOV_EBX      0xBB        // mov ebx, im dword
  67 #define OPCODE_CALL_EBX1    0xFF        // call
  68 #define OPCODE_CALL_EBX2    0xD3        //      ebx
  69 #define OPCODE_MOV_EDI      0xBF        // mov edi, im dword
  70
  71
  72 ubyte *Code_pointer = NULL;
  73 int Code_counter = 0;
  74 int ibitblt_svga_page = 0;
  75 int is_svga = 0;
  76 uint linear_address;
  77
  78
  79
  80 void count_block( int ecx )
  81 {
  82         int blocks;
  83
  84         while ( ecx > 0 ) {
  85                 switch(ecx) {
  86                 case 1: Code_counter++; ecx = 0; break;     // MOVSB
  87                 case 2: Code_counter+=2; ecx = 0; break;    // MOVSW
  88                 case 3: Code_counter+=3; ecx = 0; break;    // MOVSW, MOVSB
  89                 case 4: Code_counter++; ecx = 0; break;     // MOVSD
  90                 default:
  91                         blocks = ecx / 4;
  92                         if ( blocks == 1 )
  93                                 Code_counter++; // MOVSD
  94                         else
  95                                 Code_counter+=7;
  96                         ecx -= blocks*4;
  97                 }
  98         }
  99 }
 100
 101
 102 void move_and_count( int dsource, int ddest, int ecx )
 103 {
 104         if ( ecx <= 0 )
 105                 return;
 106
 107         if ( dsource > 0 ) {
 108                 // ADD ESI, dsource
 109                 Code_counter += 6;
 110         }
 111         if ( !is_svga ) {
 112                 if ( ddest > 0 ) {
 113                         // ADD EDI, ddest
 114                         Code_counter += 6;
 115                 }
 116                 count_block( ecx );
 117         } else {
 118                 int p1, p2, o1;
 119
 120                 linear_address += ddest;        // Skip to next block
 121
 122                 p1 = linear_address >> 16; o1 = linear_address & 0xFFFF;
 123                 p2 = (linear_address+ecx) >> 16;
 124                 if ( p1 != ibitblt_svga_page ) {
 125                         // Set page
 126                         // MOV EAX, ?, CALL EBX
 127                         Code_counter += 7;
 128                         ibitblt_svga_page = p1;
 129                 }
 130
 131                 Code_counter += 5;  // mov edi, ????
 132
 133                 if ( p1 == p2 ) {
 134                         count_block( ecx );
 135                 } else {
 136                         int nbytes;
 137                         nbytes = 0xFFFF-o1+1;
 138                         count_block( nbytes );
 139                         // set page
 140                         // MOV EAX, 0
 141                         Code_counter += 7;  // mov eax,???? call ebx
 142
 143                         ibitblt_svga_page = p2;
 144
 145                         Code_counter += 5;  // mov edi, ????
 146
 147                         nbytes = ecx - nbytes;
 148                         if (nbytes > 0 )
 149                                 count_block( nbytes );
 150                 }
 151                 linear_address += ecx;
 152         }
 153 }
 154
 155
 156
 157 void draw_block( int ecx )
 158 {
 159         int blocks;
 160         int * iptr;
 161
 162         while ( ecx > 0 )   {
 163                 switch( ecx )   {
 164                 case 1:
 165                         // MOVSB
 166                         *Code_pointer++ = OPCODE_MOVSB;
 167                         ecx = 0;
 168                         break;
 169                 case 2:
 170                         // MOVSW
 171                         *Code_pointer++ = OPCODE_16BIT;
 172                         *Code_pointer++ = OPCODE_MOVSD;
 173                         ecx = 0;
 174                         break;
 175                 case 3:
 176                         // MOVSW, MOVSB
 177                         *Code_pointer++ = OPCODE_16BIT;
 178                         *Code_pointer++ = OPCODE_MOVSD;
 179                         *Code_pointer++ = OPCODE_MOVSB;
 180                         ecx = 0;
 181                         break;
 182                 case 4:
 183                         // MOVSD
 184                         *Code_pointer++ = OPCODE_MOVSD;
 185                         ecx = 0;
 186                         break;
 187                 default:
 188                         blocks = ecx / 4;
 189
 190                         if ( blocks == 1 ) {
 191                                 // MOVSD
 192                                 *Code_pointer++ = OPCODE_MOVSD;
 193                         } else {
 194                                 // MOV ECX, blocks
 195                                 *Code_pointer++ = OPCODE_MOV_ECX;
 196                                 iptr = (int *)Code_pointer;
 197                                 *iptr++ = blocks;
 198                                 Code_pointer = (ubyte *)iptr;
 199                                 // REP MOVSD
 200                                 *Code_pointer++ = OPCODE_REP;
 201                                 *Code_pointer++ = OPCODE_MOVSD;
 202                         }
 203                         ecx -= blocks*4;
 204                 }
 205         }
 206 }
 207
 208
 209 void move_and_draw( int dsource, int ddest, int ecx )
 210 {
 211         int * iptr;
 212
 213         if ( ecx <= 0 )
 214                 return;
 215
 216         if ( dsource > 0 ) {
 217                 // ADD ESI, dsource
 218                 *Code_pointer++ = OPCODE_ADD;
 219                 *Code_pointer++ = OPCODE_ESI;
 220                 iptr = (int *)Code_pointer;
 221                 *iptr++ = dsource;
 222                 Code_pointer = (ubyte *)iptr;
 223         }
 224         if ( !is_svga ) {
 225                 if ( ddest > 0 ) {
 226                         // ADD EDI, ddest
 227                         *Code_pointer++ = OPCODE_ADD;
 228                         *Code_pointer++ = OPCODE_EDI;
 229                         iptr = (int *)Code_pointer;
 230                         *iptr++ = ddest;
 231                         Code_pointer = (ubyte *)iptr;
 232                 }
 233                 draw_block( ecx );
 234         } else {
 235                 unsigned int temp;
 236                 int temp_offset;
 237                 int p1, p2, o1;
 238
 239                 linear_address += ddest;        // Skip to next block
 240
 241                 p1 = linear_address >> 16; o1 = linear_address & 0xFFFF;
 242                 p2 = (linear_address+ecx) >> 16;
 243                 if ( p1 != ibitblt_svga_page ) {
 244                         // Set page
 245                         // MOV EAX, 0
 246                         *Code_pointer++ = OPCODE_MOV_EAX;
 247                         temp = p1;
 248                         memcpy( Code_pointer, &temp, sizeof(int) );
 249                         Code_pointer += sizeof(int);
 250                         // CALL EBX
 251                         *Code_pointer++ = OPCODE_CALL_EBX1;
 252                         *Code_pointer++ = OPCODE_CALL_EBX2;
 253                         ibitblt_svga_page = p1;
 254                 }
 255
 256                 temp_offset = 0xA0000 + o1;
 257                 *Code_pointer++ = OPCODE_MOV_EDI;
 258                 iptr = (int *)Code_pointer;
 259                 *iptr++ = temp_offset;
 260                 Code_pointer = (ubyte *)iptr;
 261
 262                 if ( p1 == p2 ) {
 263                         draw_block( ecx );
 264                 } else {
 265                         int nbytes;
 266                         nbytes = 0xFFFF-o1+1;
 267                         draw_block( nbytes );
 268                         // set page
 269                         // MOV EAX, 0
 270                         *Code_pointer++ = OPCODE_MOV_EAX;
 271                         temp = p2;
 272                         memcpy( Code_pointer, &temp, sizeof(int) );
 273                         Code_pointer += sizeof(int);
 274                         // CALL EBX
 275                         *Code_pointer++ = OPCODE_CALL_EBX1;
 276                         *Code_pointer++ = OPCODE_CALL_EBX2;
 277                         ibitblt_svga_page = p2;
 278
 279                         temp_offset = 0xA0000;
 280                         *Code_pointer++ = OPCODE_MOV_EDI;
 281                         iptr = (int *)Code_pointer;
 282                         *iptr++ = temp_offset;
 283                         Code_pointer = (ubyte *)iptr;
 284
 285                         nbytes = ecx - nbytes;
 286                         if (nbytes > 0 )
 287                                 draw_block( nbytes );
 288                 }
 289                 linear_address += ecx;
 290         }
 291
 292 }
 293
 294 //-----------------------------------------------------------------------------------------
 295 // Given bitmap, bmp, finds the size of the code
 296
 297 int gr_ibitblt_find_code_size_sub( grs_bitmap * mask_bmp, int sx, int sy, int sw, int sh, int srowsize, int dest_type )
 298 {
 299         int x,y;
 300         ubyte pixel;
 301         int draw_mode = MODE_NONE;
 302         int source_offset = 0;
 303         int dest_offset = 0;
 304         int num_to_draw, draw_start_source, draw_start_dest;
 305         int esi, edi;
 306
 307         Assert( (!(mask_bmp->bm_flags&BM_FLAG_RLE)) );
 308
 309         Code_counter = 0;
 310
 311         if ( dest_type == BM_SVGA ) {
 312                 Code_counter += 1+4;    // move ebx, gr_vesa_set_page
 313                 Code_counter += 1+4;    // move eax, 0
 314                 Code_counter += 2;      // call ebx
 315                 ibitblt_svga_page = 0;
 316                 linear_address = 0;
 317                 is_svga = 1;
 318         } else {
 319                 is_svga = 0;
 320         }
 321
 322         esi = source_offset = 0;
 323         edi = dest_offset = 0;
 324         draw_start_source = draw_start_dest = 0;
 325
 326         for ( y=sy; y<sy+sh; y++ ) {
 327                 for ( x=sx; x<sx+sw; x++ ) {
 328                         dest_offset = y*mask_bmp->bm_rowsize+x;
 329                         pixel = mask_bmp->bm_data[dest_offset];
 330                         if ( pixel!=255 ) {
 331                                 switch ( draw_mode) {
 332                                 case MODE_DRAW:
 333                                         move_and_count( draw_start_source-esi, draw_start_dest-edi, num_to_draw );
 334                                         esi = draw_start_source + num_to_draw;
 335                                         edi = draw_start_dest + num_to_draw;
 336                                         // fall through!!!
 337                                 case MODE_NONE:
 338                                 case MODE_SKIP:
 339                                         break;
 340                                 }
 341                                 draw_mode = MODE_SKIP;
 342                         } else {
 343                                 switch ( draw_mode) {
 344                                 case MODE_SKIP:
 345                                 case MODE_NONE:
 346                                         draw_start_source = source_offset;
 347                                         draw_start_dest = dest_offset;
 348                                         num_to_draw = 0;
 349                                         // fall through
 350                                 case MODE_DRAW:
 351                                         num_to_draw++;
 352                                         break;
 353                                 }
 354                                 draw_mode = MODE_DRAW;
 355                         }
 356                         source_offset++;
 357                 }
 358                 if ( draw_mode == MODE_DRAW ) {
 359                         move_and_count( draw_start_source-esi, draw_start_dest-edi, num_to_draw );
 360                         esi = draw_start_source + num_to_draw;
 361                         edi = draw_start_dest + num_to_draw;
 362                 }
 363                 draw_mode = MODE_NONE;
 364                 source_offset += (srowsize - sw);
 365         }
 366         Code_counter++;     // for return
 367
 368         //printf( "Code will be %d bytes\n", Code_counter );
 369
 370         Code_counter += 16; // for safety was 16
 371
 372         return Code_counter;
 373 }
 374
 375 int gr_ibitblt_find_code_size( grs_bitmap * mask_bmp, int sx, int sy, int sw, int sh, int srowsize )
 376 {
 377         return gr_ibitblt_find_code_size_sub( mask_bmp, sx, sy, sw, sh, srowsize, BM_LINEAR );
 378 }
 379
 380 int gr_ibitblt_find_code_size_svga( grs_bitmap * mask_bmp, int sx, int sy, int sw, int sh, int srowsize )
 381 {
 382         return gr_ibitblt_find_code_size_sub( mask_bmp, sx, sy, sw, sh, srowsize, BM_SVGA );
 383 }
 384
 385 //-----------------------------------------------------------------------------------------
 386 // Given bitmap, bmp, create code that transfers a bitmap of size sw*sh to position
 387 // (sx,sy) on top of bmp, only overwritting transparent pixels of the bitmap.
 388
 389 ubyte   *gr_ibitblt_create_mask_sub( grs_bitmap * mask_bmp, int sx, int sy, int sw, int sh, int srowsize, int dest_type )
 390 {
 391         int x,y;
 392         ubyte pixel;
 393         int draw_mode = MODE_NONE;
 394         int source_offset = 0;
 395         int dest_offset = 0;
 396         int num_to_draw, draw_start_source, draw_start_dest;
 397         int esi, edi;
 398         int code_size;
 399         ubyte *code;
 400         uint temp;
 401
 402         Assert( (!(mask_bmp->bm_flags&BM_FLAG_RLE)) );
 403
 404         if ( dest_type == BM_SVGA )
 405                 code_size = gr_ibitblt_find_code_size_svga( mask_bmp, sx, sy, sw, sh, srowsize );
 406         else
 407                 code_size = gr_ibitblt_find_code_size( mask_bmp, sx, sy, sw, sh, srowsize );
 408
 409         code = malloc( code_size );
 410         if ( code == NULL )
 411                 return NULL;
 412
 413         Code_pointer = code;
 414
 415         if ( dest_type == BM_SVGA ) {
 416                 // MOV EBX, gr_vesa_setpage
 417                 *Code_pointer++ = OPCODE_MOV_EBX;
 418                 temp = (uint)gr_vesa_setpage;
 419                 memcpy( Code_pointer, &temp, sizeof(int) );
 420                 Code_pointer += sizeof(int);
 421                 // MOV EAX, 0
 422                 *Code_pointer++ = OPCODE_MOV_EAX;
 423                 temp = 0;
 424                 memcpy( Code_pointer, &temp, sizeof(int) );
 425                 Code_pointer += sizeof(int);
 426                 // CALL EBX
 427                 *Code_pointer++ = OPCODE_CALL_EBX1;
 428                 *Code_pointer++ = OPCODE_CALL_EBX2;
 429
 430                 ibitblt_svga_page = 0;
 431                 is_svga = 1;
 432                 linear_address = 0;
 433         } else {
 434                 is_svga = 0;
 435         }
 436         esi = source_offset = 0;
 437         edi = dest_offset = 0;
 438         draw_start_source = draw_start_dest = 0;
 439
 440         for ( y=sy; y<sy+sh; y++ ) {
 441                 for ( x=sx; x<sx+sw; x++ ) {
 442                         dest_offset = y*mask_bmp->bm_rowsize+x;
 443                         pixel = mask_bmp->bm_data[dest_offset];
 444                         if ( pixel!=255 ) {
 445                                 switch ( draw_mode) {
 446                                 case MODE_DRAW:
 447                                         move_and_draw( draw_start_source-esi, draw_start_dest-edi, num_to_draw );
 448                                         esi = draw_start_source + num_to_draw;
 449                                         edi = draw_start_dest + num_to_draw;
 450                                         // fall through!!!
 451                                 case MODE_NONE:
 452                                 case MODE_SKIP:
 453                                         break;
 454                                 }
 455                                 draw_mode = MODE_SKIP;
 456                         } else {
 457                                 switch ( draw_mode) {
 458                                 case MODE_SKIP:
 459                                 case MODE_NONE:
 460                                         draw_start_source = source_offset;
 461                                         draw_start_dest = dest_offset;
 462                                         num_to_draw = 0;
 463                                         // fall through
 464                                 case MODE_DRAW:
 465                                         num_to_draw++;
 466                                         break;
 467                                 }
 468                                 draw_mode = MODE_DRAW;
 469                         }
 470                         source_offset++;
 471                 }
 472                 if ( draw_mode == MODE_DRAW ) {
 473                         move_and_draw( draw_start_source-esi, draw_start_dest-edi, num_to_draw );
 474                         esi = draw_start_source + num_to_draw;
 475                         edi = draw_start_dest + num_to_draw;
 476                 }
 477                 draw_mode = MODE_NONE;
 478                 source_offset += (srowsize - sw);
 479         }
 480         *Code_pointer++ = OPCODE_RET;
 481
 482         if ( Code_pointer >= &code[code_size-1] )
 483                 Error( "ibitblt overwrote allocated code block\n" );
 484
 485         //printf( "Code is %d bytes\n", Code_pointer - code );
 486
 487         return code;
 488 }
 489
 490 ubyte   *gr_ibitblt_create_mask( grs_bitmap * mask_bmp, int sx, int sy, int sw, int sh, int srowsize )
 491 {
 492         return gr_ibitblt_create_mask_sub( mask_bmp, sx, sy, sw, sh, srowsize, BM_LINEAR );
 493 }
 494
 495 ubyte   *gr_ibitblt_create_mask_svga( grs_bitmap * mask_bmp, int sx, int sy, int sw, int sh, int srowsize )
 496 {
 497         return gr_ibitblt_create_mask_sub( mask_bmp, sx, sy, sw, sh, srowsize, BM_SVGA );
 498 }
 499
 500
 501 void gr_ibitblt_do_asm(char *start_si, char *start_di, ubyte * code);
 502 #pragma aux gr_ibitblt_do_asm parm [esi] [edi] [eax] modify [ecx edi esi eax] = \
 503     "pusha"         \
 504     "cld"           \
 505     "call   eax"    \
 506     "popa"
 507
 508
 509 void gr_ibitblt(grs_bitmap * source_bmp, grs_bitmap * dest_bmp, ubyte * mask )
 510 {
 511         if (mask != NULL )
 512                 gr_ibitblt_do_asm( source_bmp->bm_data, dest_bmp->bm_data, mask );
 513 }
 514
 515
 516 void    gr_ibitblt_find_hole_size( grs_bitmap * mask_bmp, int *minx, int *miny, int *maxx, int *maxy )
 517 {
 518         int x, y, count=0;
 519         ubyte c;
 520
 521         Assert( (!(mask_bmp->bm_flags&BM_FLAG_RLE)) );
 522
 523         *minx = mask_bmp->bm_w-1;
 524         *maxx = 0;
 525         *miny = mask_bmp->bm_h-1;
 526         *maxy = 0;
 527
 528         for ( y=0; y<mask_bmp->bm_h; y++ )
 529                 for ( x=0; x<mask_bmp->bm_w; x++ ) {
 530                         c = mask_bmp->bm_data[mask_bmp->bm_rowsize*y+x];
 531                         if (c == 255 ) {
 532                                 if ( x < *minx ) *minx = x;
 533                                 if ( y < *miny ) *miny = y;
 534                                 if ( x > *maxx ) *maxx = x;
 535                                 if ( y > *maxy ) *maxy = y;
 536                                 count++;
 537                         }
 538                 }
 539
 540         if ( count == 0 ) {
 541                 Error( "Bitmap for ibitblt doesn't have transparency!\n" );
 542         }
 543 }
 544
 545 #else /* __MSDOS__ */ // was: /* !MACINTOSH */
 546
 547 #include "pstypes.h"
 548 #include "gr.h"
 549 #include "ibitblt.h"
 550 #include "error.h"
 551 #include "u_mem.h"
 552 #include "grdef.h"
 553
 554 #define FIND_START      1
 555 #define FIND_STOP       2
 556
 557 #define MAX_WIDTH       640
 558 #define MAX_SCANLINES   480
 559 #define MAX_HOLES       5
 560
 561 static short start_points[MAX_SCANLINES][MAX_HOLES];
 562 static short hole_length[MAX_SCANLINES][MAX_HOLES];
 563 static double *scanline = NULL;
 564
 565 void gr_ibitblt(grs_bitmap *src_bmp, grs_bitmap *dest_bmp)
 566 {
 567         int x, y, sw, sh, srowsize, drowsize, dstart, sy;
 568         ubyte *src, *dest;
 569
 570 // variable setup
 571
 572         sw = src_bmp->bm_w;
 573         sh = src_bmp->bm_h;
 574         srowsize = src_bmp->bm_rowsize;
 575         drowsize = dest_bmp->bm_rowsize;
 576         src = src_bmp->bm_data;
 577         dest = dest_bmp->bm_data;
 578
 579         sy = 0;
 580         while (start_points[sy][0] == -1) {
 581                 sy++;
 582                 dest += drowsize;
 583         }
 584
 585         Assert(sw <= MAX_WIDTH);
 586         Assert(sh <= MAX_SCANLINES);
 587         for (y = sy; y < sy + sh; y++) {
 588                 for (x = 0; x < MAX_HOLES; x++) {
 589                         if (start_points[y][x] == -1)
 590                                 break;
 591                         dstart = start_points[y][x];
 592                         gr_linear_movsd(&(src[dstart]), &(dest[dstart]), hole_length[y][x]);
 593                 }
 594                 dest += drowsize;
 595                 src += srowsize;
 596         }
 597 }
 598
 599 void gr_ibitblt_create_mask(grs_bitmap *mask_bmp, int sx, int sy, int sw, int sh, int srowsize)
 600 {
 601         int x, y;
 602         ubyte mode;
 603         int count = 0;
 604
 605         Assert( (!(mask_bmp->bm_flags&BM_FLAG_RLE)) );
 606
 607         for (y = 0; y < MAX_SCANLINES; y++) {
 608                 for (x = 0; x < MAX_HOLES; x++) {
 609                         start_points[y][x] = -1;
 610                         hole_length[y][x] = -1;
 611                 }
 612         }
 613
 614         for (y = sy; y < sy+sh; y++) {
 615                 count = 0;
 616                 mode = FIND_START;
 617                 for (x = sx; x < sx + sw; x++) {
 618                         if ((mode == FIND_START) && (mask_bmp->bm_data[mask_bmp->bm_rowsize*y+x] == TRANSPARENCY_COLOR)) {
 619                                 start_points[y][count] = x;
 620                                 mode = FIND_STOP;
 621                         } else if ((mode == FIND_STOP) && (mask_bmp->bm_data[mask_bmp->bm_rowsize*y+x] != TRANSPARENCY_COLOR)) {
 622                                 hole_length[y][count] = x - start_points[y][count];
 623                                 count++;
 624                                 mode = FIND_START;
 625                         }
 626                 }
 627                 if (mode == FIND_STOP) {
 628                         hole_length[y][count] = x - start_points[y][count];
 629                         count++;
 630                 }
 631                 Assert(count <= MAX_HOLES);
 632         }
 633 }
 634
 635 void gr_ibitblt_find_hole_size(grs_bitmap *mask_bmp, int *minx, int *miny, int *maxx, int *maxy)
 636 {
 637         ubyte c;
 638         int x, y, count = 0;
 639
 640         Assert( (!(mask_bmp->bm_flags&BM_FLAG_RLE)) );
 641         Assert( mask_bmp->bm_flags&BM_FLAG_TRANSPARENT );
 642
 643         *minx = mask_bmp->bm_w - 1;
 644         *maxx = 0;
 645         *miny = mask_bmp->bm_h - 1;
 646         *maxy = 0;
 647
 648         if (scanline == NULL)
 649                 scanline = (double *)malloc(sizeof(double) * (MAX_WIDTH / sizeof(double)));
 650
 651         for (y = 0; y < mask_bmp->bm_h; y++) {
 652                 for (x = 0; x < mask_bmp->bm_w; x++) {
 653                         c = mask_bmp->bm_data[mask_bmp->bm_rowsize*y+x];
 654                         if (c == TRANSPARENCY_COLOR) { // don't look for transparancy color here.
 655                                 count++;
 656                                 if (x < *minx) *minx = x;
 657                                 if (y < *miny) *miny = y;
 658                                 if (x > *maxx) *maxx = x;
 659                                 if (y > *maxy) *maxy = y;
 660                         }
 661                 }
 662         }
 663         Assert (count);
 664 }
 665
 666 #endif /* __MSDOS__ */ // was: /* !MACINTOSH */