2d/ibitblt.c

   1 /* $Id: ibitblt.c,v 1.7 2003-10-25 01:44:23 btb 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  * Old Log: ibitblt.c
  28  * Revision 1.3  1995/09/13  11:43:22  allender
  29  * start on optimizing cockpit copy code
  30  *
  31  * Revision 1.2  1995/09/07  10:16:57  allender
  32  * fixed up cockpit and rearview hole blitting
  33  *
  34  * Revision 1.1  1995/08/18  15:50:48  allender
  35  * Initial revision
  36  *
  37  * PC version:
  38  * Routines to copy a bitmap on top of another bitmap, but
  39  * only copying to pixels that are transparent.
  40  *
  41  * Old Log:
  42  * Revision 1.6  1994/11/28  17:07:29  john
  43  * Took out some unused functions in linear.asm, moved
  44  * gr_linear_movsd from linear.asm to bitblt.c, made sure that
  45  * the code in ibiblt.c sets the direction flags before rep movsing.
  46  *
  47  * Revision 1.5  1994/11/18  22:50:22  john
  48  * Changed shorts to ints in parameters.
  49  *
  50  * Revision 1.4  1994/11/09  16:35:16  john
  51  * First version with working RLE bitmaps.
  52  *
  53  * Revision 1.3  1994/10/03  17:18:05  john
  54  * Fixed bug with edi not getting intialized to zero
  55  * in create_mask.
  56  *
  57  * Revision 1.2  1994/05/31  11:10:55  john
  58  * *** empty log message ***
  59  *
  60  * Revision 1.1  1994/05/30  16:08:27  john
  61  * Initial revision
  62  *
  63  */
  64
  65 #ifdef HAVE_CONFIG_H
  66 #include <conf.h>
  67 #endif
  68
  69 #ifdef RCS
  70 static char rcsid[] = "$Id: ibitblt.c,v 1.7 2003-10-25 01:44:23 btb Exp $";
  71 #endif
  72
  73 #ifdef __MSDOS__ //ndef MACINTOSH
  74
  75 #include <conio.h>
  76 #include <dos.h>
  77 #include <stdio.h>
  78 #include <stdlib.h>
  79 #include <string.h>
  80
  81 #include "pa_enabl.h"                   //$$POLY_ACC
  82 #include "types.h"
  83 #include "gr.h"
  84 #include "mem.h"
  85 #include "error.h"
  86 #include "ibitblt.h"
  87 #include "grdef.h"
  88
  89 #if defined(POLY_ACC)
  90 #include "poly_acc.h"
  91 #endif
  92
  93 #define MODE_NONE           0
  94 #define MODE_SKIP           1
  95 #define MODE_DRAW           2
  96
  97 #define OPCODE_ADD          0x81
  98 #define OPCODE_ESI          0xC6        // Followed by a dword  (add esi, ????)
  99 #define OPCODE_EDI          0xC7        // Followed by a dword  (add edi, ????)
 100 #define OPCODE_MOV_ECX      0xB9        // Followed by a dword  (mov ecx,????)
 101 #define OPCODE_MOVSB        0xA4        // movsb
 102 #define OPCODE_16BIT        0x66        // movsw
 103 #define OPCODE_MOVSD        0xA5        // movsd
 104 #define OPCODE_REP          0xF3        // rep
 105 #define OPCODE_RET          0xC3        // ret
 106 #define OPCODE_MOV_EAX      0xB8        // mov eax, im dword
 107 #define OPCODE_MOV_EBX      0xBB        // mov ebx, im dword
 108 #define OPCODE_CALL_EBX1    0xFF        // call
 109 #define OPCODE_CALL_EBX2    0xD3        //      ebx
 110 #define OPCODE_MOV_EDI      0xBF        // mov edi, im dword
 111
 112
 113 ubyte *Code_pointer = NULL;
 114 int Code_counter = 0;
 115 int ibitblt_svga_page = 0;
 116 int is_svga = 0;
 117 uint linear_address;
 118
 119
 120
 121 void count_block( int ecx )
 122 {
 123         int blocks;
 124
 125         while ( ecx > 0 ) {
 126                 switch(ecx) {
 127                 case 1: Code_counter++; ecx = 0; break;     // MOVSB
 128                 case 2: Code_counter+=2; ecx = 0; break;    // MOVSW
 129                 case 3: Code_counter+=3; ecx = 0; break;    // MOVSW, MOVSB
 130                 case 4: Code_counter++; ecx = 0; break;     // MOVSD
 131                 default:
 132                         blocks = ecx / 4;
 133                         if ( blocks == 1 )
 134                                 Code_counter++; // MOVSD
 135                         else
 136                                 Code_counter+=7;
 137                         ecx -= blocks*4;
 138                 }
 139         }
 140 }
 141
 142
 143 void move_and_count( int dsource, int ddest, int ecx )
 144 {
 145         if ( ecx <= 0 )
 146                 return;
 147
 148         if ( dsource > 0 ) {
 149                 // ADD ESI, dsource
 150                 Code_counter += 6;
 151         }
 152         if ( !is_svga ) {
 153                 if ( ddest > 0 ) {
 154                         // ADD EDI, ddest
 155                         Code_counter += 6;
 156                 }
 157                 count_block( ecx );
 158         } else {
 159                 int p1, p2, o1;
 160
 161                 linear_address += ddest;        // Skip to next block
 162
 163                 p1 = linear_address >> 16; o1 = linear_address & 0xFFFF;
 164                 p2 = (linear_address+ecx) >> 16;
 165                 if ( p1 != ibitblt_svga_page ) {
 166                         // Set page
 167                         // MOV EAX, ?, CALL EBX
 168                         Code_counter += 7;
 169                         ibitblt_svga_page = p1;
 170                 }
 171
 172                 Code_counter += 5;  // mov edi, ????
 173
 174                 if ( p1 == p2 ) {
 175                         count_block( ecx );
 176                 } else {
 177                         int nbytes;
 178                         nbytes = 0xFFFF-o1+1;
 179                         count_block( nbytes );
 180                         // set page
 181                         // MOV EAX, 0
 182                         Code_counter += 7;  // mov eax,???? call ebx
 183
 184                         ibitblt_svga_page = p2;
 185
 186                         Code_counter += 5;  // mov edi, ????
 187
 188                         nbytes = ecx - nbytes;
 189                         if (nbytes > 0 )
 190                                 count_block( nbytes );
 191                 }
 192                 linear_address += ecx;
 193         }
 194 }
 195
 196
 197
 198 void draw_block( int ecx )
 199 {
 200         int blocks;
 201         int * iptr;
 202
 203         while ( ecx > 0 )   {
 204                 switch( ecx )   {
 205                 case 1:
 206                         // MOVSB
 207                         *Code_pointer++ = OPCODE_MOVSB;
 208                         ecx = 0;
 209                         break;
 210                 case 2:
 211                         // MOVSW
 212                         *Code_pointer++ = OPCODE_16BIT;
 213                         *Code_pointer++ = OPCODE_MOVSD;
 214                         ecx = 0;
 215                         break;
 216                 case 3:
 217                         // MOVSW, MOVSB
 218                         *Code_pointer++ = OPCODE_16BIT;
 219                         *Code_pointer++ = OPCODE_MOVSD;
 220                         *Code_pointer++ = OPCODE_MOVSB;
 221                         ecx = 0;
 222                         break;
 223                 case 4:
 224                         // MOVSD
 225                         *Code_pointer++ = OPCODE_MOVSD;
 226                         ecx = 0;
 227                         break;
 228                 default:
 229                         blocks = ecx / 4;
 230
 231                         if ( blocks == 1 ) {
 232                                 // MOVSD
 233                                 *Code_pointer++ = OPCODE_MOVSD;
 234                         } else {
 235                                 // MOV ECX, blocks
 236                                 *Code_pointer++ = OPCODE_MOV_ECX;
 237                                 iptr = (int *)Code_pointer;
 238                                 *iptr++ = blocks;
 239                                 Code_pointer = (ubyte *)iptr;
 240                                 // REP MOVSD
 241                                 *Code_pointer++ = OPCODE_REP;
 242                                 *Code_pointer++ = OPCODE_MOVSD;
 243                         }
 244                         ecx -= blocks*4;
 245                 }
 246         }
 247 }
 248
 249
 250 void move_and_draw( int dsource, int ddest, int ecx )
 251 {
 252         int * iptr;
 253
 254         if ( ecx <= 0 )
 255                 return;
 256
 257         if ( dsource > 0 ) {
 258                 // ADD ESI, dsource
 259                 *Code_pointer++ = OPCODE_ADD;
 260                 *Code_pointer++ = OPCODE_ESI;
 261                 iptr = (int *)Code_pointer;
 262                 *iptr++ = dsource;
 263                 Code_pointer = (ubyte *)iptr;
 264         }
 265         if ( !is_svga ) {
 266                 if ( ddest > 0 ) {
 267                         // ADD EDI, ddest
 268                         *Code_pointer++ = OPCODE_ADD;
 269                         *Code_pointer++ = OPCODE_EDI;
 270                         iptr = (int *)Code_pointer;
 271                         *iptr++ = ddest;
 272                         Code_pointer = (ubyte *)iptr;
 273                 }
 274                 draw_block( ecx );
 275         } else {
 276                 unsigned int temp;
 277                 int temp_offset;
 278                 int p1, p2, o1;
 279
 280                 linear_address += ddest;        // Skip to next block
 281
 282                 p1 = linear_address >> 16; o1 = linear_address & 0xFFFF;
 283                 p2 = (linear_address+ecx) >> 16;
 284                 if ( p1 != ibitblt_svga_page ) {
 285                         // Set page
 286                         // MOV EAX, 0
 287                         *Code_pointer++ = OPCODE_MOV_EAX;
 288                         temp = p1;
 289                         memcpy( Code_pointer, &temp, sizeof(int) );
 290                         Code_pointer += sizeof(int);
 291                         // CALL EBX
 292                         *Code_pointer++ = OPCODE_CALL_EBX1;
 293                         *Code_pointer++ = OPCODE_CALL_EBX2;
 294                         ibitblt_svga_page = p1;
 295                 }
 296
 297                 temp_offset = 0xA0000 + o1;
 298                 *Code_pointer++ = OPCODE_MOV_EDI;
 299                 iptr = (int *)Code_pointer;
 300                 *iptr++ = temp_offset;
 301                 Code_pointer = (ubyte *)iptr;
 302
 303                 if ( p1 == p2 ) {
 304                         draw_block( ecx );
 305                 } else {
 306                         int nbytes;
 307                         nbytes = 0xFFFF-o1+1;
 308                         draw_block( nbytes );
 309                         // set page
 310                         // MOV EAX, 0
 311                         *Code_pointer++ = OPCODE_MOV_EAX;
 312                         temp = p2;
 313                         memcpy( Code_pointer, &temp, sizeof(int) );
 314                         Code_pointer += sizeof(int);
 315                         // CALL EBX
 316                         *Code_pointer++ = OPCODE_CALL_EBX1;
 317                         *Code_pointer++ = OPCODE_CALL_EBX2;
 318                         ibitblt_svga_page = p2;
 319
 320                         temp_offset = 0xA0000;
 321                         *Code_pointer++ = OPCODE_MOV_EDI;
 322                         iptr = (int *)Code_pointer;
 323                         *iptr++ = temp_offset;
 324                         Code_pointer = (ubyte *)iptr;
 325
 326                         nbytes = ecx - nbytes;
 327                         if (nbytes > 0 )
 328                                 draw_block( nbytes );
 329                 }
 330                 linear_address += ecx;
 331         }
 332
 333 }
 334
 335 //-----------------------------------------------------------------------------------------
 336 // Given bitmap, bmp, finds the size of the code
 337
 338 int gr_ibitblt_find_code_size_sub( grs_bitmap * mask_bmp, int sx, int sy, int sw, int sh, int srowsize, int dest_type )
 339 {
 340         int x,y;
 341         ubyte pixel;
 342         int draw_mode = MODE_NONE;
 343         int source_offset = 0;
 344         int dest_offset = 0;
 345         int num_to_draw, draw_start_source, draw_start_dest;
 346         int esi, edi;
 347
 348         Assert( (!(mask_bmp->bm_flags&BM_FLAG_RLE)) );
 349
 350         Code_counter = 0;
 351
 352         if ( dest_type == BM_SVGA ) {
 353                 Code_counter += 1+4;    // move ebx, gr_vesa_set_page
 354                 Code_counter += 1+4;    // move eax, 0
 355                 Code_counter += 2;      // call ebx
 356                 ibitblt_svga_page = 0;
 357                 linear_address = 0;
 358                 is_svga = 1;
 359         } else {
 360                 is_svga = 0;
 361         }
 362
 363         esi = source_offset = 0;
 364         edi = dest_offset = 0;
 365         draw_start_source = draw_start_dest = 0;
 366
 367         for ( y=sy; y<sy+sh; y++ ) {
 368                 for ( x=sx; x<sx+sw; x++ ) {
 369                         dest_offset = y*mask_bmp->bm_rowsize+x;
 370                         pixel = mask_bmp->bm_data[dest_offset];
 371                         if ( pixel!=255 ) {
 372                                 switch ( draw_mode) {
 373                                 case MODE_DRAW:
 374                                         move_and_count( draw_start_source-esi, draw_start_dest-edi, num_to_draw );
 375                                         esi = draw_start_source + num_to_draw;
 376                                         edi = draw_start_dest + num_to_draw;
 377                                         // fall through!!!
 378                                 case MODE_NONE:
 379                                 case MODE_SKIP:
 380                                         break;
 381                                 }
 382                                 draw_mode = MODE_SKIP;
 383                         } else {
 384                                 switch ( draw_mode) {
 385                                 case MODE_SKIP:
 386                                 case MODE_NONE:
 387                                         draw_start_source = source_offset;
 388                                         draw_start_dest = dest_offset;
 389                                         num_to_draw = 0;
 390                                         // fall through
 391                                 case MODE_DRAW:
 392                                         num_to_draw++;
 393                                         break;
 394                                 }
 395                                 draw_mode = MODE_DRAW;
 396                         }
 397                         source_offset++;
 398                 }
 399                 if ( draw_mode == MODE_DRAW ) {
 400                         move_and_count( draw_start_source-esi, draw_start_dest-edi, num_to_draw );
 401                         esi = draw_start_source + num_to_draw;
 402                         edi = draw_start_dest + num_to_draw;
 403                 }
 404                 draw_mode = MODE_NONE;
 405                 source_offset += (srowsize - sw);
 406         }
 407         Code_counter++;     // for return
 408
 409         //printf( "Code will be %d bytes\n", Code_counter );
 410
 411         Code_counter += 16; // for safety was 16
 412
 413         return Code_counter;
 414 }
 415
 416 int gr_ibitblt_find_code_size( grs_bitmap * mask_bmp, int sx, int sy, int sw, int sh, int srowsize )
 417 {
 418         return gr_ibitblt_find_code_size_sub( mask_bmp, sx, sy, sw, sh, srowsize, BM_LINEAR );
 419 }
 420
 421 int gr_ibitblt_find_code_size_svga( grs_bitmap * mask_bmp, int sx, int sy, int sw, int sh, int srowsize )
 422 {
 423         return gr_ibitblt_find_code_size_sub( mask_bmp, sx, sy, sw, sh, srowsize, BM_SVGA );
 424 }
 425
 426 //-----------------------------------------------------------------------------------------
 427 // Given bitmap, bmp, create code that transfers a bitmap of size sw*sh to position
 428 // (sx,sy) on top of bmp, only overwritting transparent pixels of the bitmap.
 429
 430 ubyte   *gr_ibitblt_create_mask_sub( grs_bitmap * mask_bmp, int sx, int sy, int sw, int sh, int srowsize, int dest_type )
 431 {
 432         int x,y;
 433         ubyte pixel;
 434         int draw_mode = MODE_NONE;
 435         int source_offset = 0;
 436         int dest_offset = 0;
 437         int num_to_draw, draw_start_source, draw_start_dest;
 438         int esi, edi;
 439         int code_size;
 440         ubyte *code;
 441         uint temp;
 442
 443         Assert( (!(mask_bmp->bm_flags&BM_FLAG_RLE)) );
 444
 445         if ( dest_type == BM_SVGA )
 446                 code_size = gr_ibitblt_find_code_size_svga( mask_bmp, sx, sy, sw, sh, srowsize );
 447         else
 448                 code_size = gr_ibitblt_find_code_size( mask_bmp, sx, sy, sw, sh, srowsize );
 449
 450         code = malloc( code_size );
 451         if ( code == NULL )
 452                 return NULL;
 453
 454         Code_pointer = code;
 455
 456         if ( dest_type == BM_SVGA ) {
 457                 // MOV EBX, gr_vesa_setpage
 458                 *Code_pointer++ = OPCODE_MOV_EBX;
 459                 temp = (uint)gr_vesa_setpage;
 460                 memcpy( Code_pointer, &temp, sizeof(int) );
 461                 Code_pointer += sizeof(int);
 462                 // MOV EAX, 0
 463                 *Code_pointer++ = OPCODE_MOV_EAX;
 464                 temp = 0;
 465                 memcpy( Code_pointer, &temp, sizeof(int) );
 466                 Code_pointer += sizeof(int);
 467                 // CALL EBX
 468                 *Code_pointer++ = OPCODE_CALL_EBX1;
 469                 *Code_pointer++ = OPCODE_CALL_EBX2;
 470
 471                 ibitblt_svga_page = 0;
 472                 is_svga = 1;
 473                 linear_address = 0;
 474         } else {
 475                 is_svga = 0;
 476         }
 477         esi = source_offset = 0;
 478         edi = dest_offset = 0;
 479         draw_start_source = draw_start_dest = 0;
 480
 481         for ( y=sy; y<sy+sh; y++ ) {
 482                 for ( x=sx; x<sx+sw; x++ ) {
 483                         dest_offset = y*mask_bmp->bm_rowsize+x;
 484                         pixel = mask_bmp->bm_data[dest_offset];
 485                         if ( pixel!=255 ) {
 486                                 switch ( draw_mode) {
 487                                 case MODE_DRAW:
 488                                         move_and_draw( draw_start_source-esi, draw_start_dest-edi, num_to_draw );
 489                                         esi = draw_start_source + num_to_draw;
 490                                         edi = draw_start_dest + num_to_draw;
 491                                         // fall through!!!
 492                                 case MODE_NONE:
 493                                 case MODE_SKIP:
 494                                         break;
 495                                 }
 496                                 draw_mode = MODE_SKIP;
 497                         } else {
 498                                 switch ( draw_mode) {
 499                                 case MODE_SKIP:
 500                                 case MODE_NONE:
 501                                         draw_start_source = source_offset;
 502                                         draw_start_dest = dest_offset;
 503                                         num_to_draw = 0;
 504                                         // fall through
 505                                 case MODE_DRAW:
 506                                         num_to_draw++;
 507                                         break;
 508                                 }
 509                                 draw_mode = MODE_DRAW;
 510                         }
 511                         source_offset++;
 512                 }
 513                 if ( draw_mode == MODE_DRAW ) {
 514                         move_and_draw( draw_start_source-esi, draw_start_dest-edi, num_to_draw );
 515                         esi = draw_start_source + num_to_draw;
 516                         edi = draw_start_dest + num_to_draw;
 517                 }
 518                 draw_mode = MODE_NONE;
 519                 source_offset += (srowsize - sw);
 520         }
 521         *Code_pointer++ = OPCODE_RET;
 522
 523         if ( Code_pointer >= &code[code_size-1] )
 524                 Error( "ibitblt overwrote allocated code block\n" );
 525
 526         //printf( "Code is %d bytes\n", Code_pointer - code );
 527
 528         return code;
 529 }
 530
 531 ubyte   *gr_ibitblt_create_mask( grs_bitmap * mask_bmp, int sx, int sy, int sw, int sh, int srowsize )
 532 {
 533         return gr_ibitblt_create_mask_sub( mask_bmp, sx, sy, sw, sh, srowsize, BM_LINEAR );
 534 }
 535
 536 #if defined(POLY_ACC)
 537 ulong *pa_emit_blit(int gencode, ulong *buf, int w, int h, int sx, int sy, int dx, int dy)
 538 {
 539         if(w == 0 || h == 0)
 540                 return buf;
 541
 542         if(gencode)
 543         {
 544                 buf[0] = (w << 16)  | h;
 545                 buf[1] = (sx << 16) | sy;
 546                 buf[2] = (dx << 16) | dy;
 547         }
 548         return buf + 3;
 549 }
 550
 551 ubyte   *gr_ibitblt_create_mask_pa( grs_bitmap * mask_bmp, int sx, int sy, int sw, int sh, int srowsize )
 552 {
 553         ulong *ret, *code = 0;
 554         int pass, x, y, n;
 555         ushort *s;
 556
 557         Assert(mask_bmp->bm_type == BM_LINEAR15);
 558
 559         srowsize /= PA_BPP;
 560
 561         pa_flush();
 562
 563         // make two passes, first pass gets size of output block, second actually creates data.
 564         for(pass = 0; pass != 2; ++pass)
 565         {
 566                 for (y = sy; y < sy + sh; y++ )
 567                 {
 568                         // first byte of interest in mask
 569                         s = (ushort *)(mask_bmp->bm_data + y * mask_bmp->bm_rowsize + sx * PA_BPP);
 570                         for ( x=0; x < sw; )
 571                         {
 572                                 for(; x != sw && (s[x] & 0x8000); ++x)              // while opaque...
 573                                         ;
 574                                 for(n = 0; x != sw && !(s[x] & 0x8000); ++n, ++x)   // while transparent...
 575                                         ;
 576                                 code = pa_emit_blit(pass, code, n, 1, x - n, y - sy, x + sx - n, y);
 577                         }
 578                 }
 579                 if(pass == 0)
 580                 {
 581                         ret = malloc((int)code + sizeof(ulong));
 582                         ret[0] = (int)code / sizeof(ulong);        // store num ulongs in list.
 583                         code = ret + 1;
 584                 }
 585         }
 586         return (ubyte *)ret;
 587 }
 588
 589 #else
 590 ubyte   *gr_ibitblt_create_mask_svga( grs_bitmap * mask_bmp, int sx, int sy, int sw, int sh, int srowsize )
 591 {
 592         return gr_ibitblt_create_mask_sub( mask_bmp, sx, sy, sw, sh, srowsize, BM_SVGA );
 593 }
 594 #endif
 595
 596
 597 void gr_ibitblt_do_asm(char *start_si, char *start_di, ubyte * code);
 598 #pragma aux gr_ibitblt_do_asm parm [esi] [edi] [eax] modify [ecx edi esi eax] = \
 599     "pusha"         \
 600     "cld"           \
 601     "call   eax"    \
 602     "popa"
 603
 604
 605 void gr_ibitblt(grs_bitmap * source_bmp, grs_bitmap * dest_bmp, ubyte * mask )
 606 {
 607 #if defined(POLY_ACC)
 608     Assert(source_bmp->bm_type == BM_LINEAR15);
 609     pa_ibitblt(source_bmp->bm_data, dest_bmp->bm_data, mask);
 610 #else
 611         if (mask != NULL )
 612                 gr_ibitblt_do_asm( source_bmp->bm_data, dest_bmp->bm_data, mask );
 613 #endif
 614 }
 615
 616
 617 void    gr_ibitblt_find_hole_size( grs_bitmap * mask_bmp, int *minx, int *miny, int *maxx, int *maxy )
 618 {
 619         int x, y, count=0;
 620 #if defined(POLY_ACC)
 621         short c;
 622 #else
 623         ubyte c;
 624 #endif
 625
 626         Assert( (!(mask_bmp->bm_flags&BM_FLAG_RLE)) );
 627
 628 #if defined(POLY_ACC)
 629         Assert(mask_bmp->bm_type == BM_LINEAR15);
 630         pa_flush();
 631 #endif
 632
 633         *minx = mask_bmp->bm_w-1;
 634         *maxx = 0;
 635         *miny = mask_bmp->bm_h-1;
 636         *maxy = 0;
 637
 638         for ( y=0; y<mask_bmp->bm_h; y++ )
 639                 for ( x=0; x<mask_bmp->bm_w; x++ ) {
 640 #if defined(POLY_ACC)
 641                         c = *(short *)(mask_bmp->bm_data + mask_bmp->bm_rowsize * y + x * PA_BPP);
 642                         if (c >= 0)  {      // hi true means opaque.
 643 #else
 644                         c = mask_bmp->bm_data[mask_bmp->bm_rowsize*y+x];
 645                         if (c == 255 ) {
 646 #endif
 647                                 if ( x < *minx ) *minx = x;
 648                                 if ( y < *miny ) *miny = y;
 649                                 if ( x > *maxx ) *maxx = x;
 650                                 if ( y > *maxy ) *maxy = y;
 651                                 count++;
 652                         }
 653                 }
 654
 655         if ( count == 0 ) {
 656                 Error( "Bitmap for ibitblt doesn't have transparency!\n" );
 657         }
 658 }
 659
 660 #else /* __MSDOS__ */ // was: /* !MACINTOSH */
 661
 662 #include "pa_enabl.h"
 663 #include "pstypes.h"
 664 #include "gr.h"
 665 #include "ibitblt.h"
 666 #include "error.h"
 667 #include "u_mem.h"
 668 #include "grdef.h"
 669
 670 #if defined(POLY_ACC)
 671 #include "poly_acc.h"
 672 #endif
 673
 674 #define FIND_START      1
 675 #define FIND_STOP       2
 676
 677 #define MAX_WIDTH       640
 678 #define MAX_SCANLINES   480
 679 #define MAX_HOLES       5
 680
 681 static short start_points[MAX_SCANLINES][MAX_HOLES];
 682 static short hole_length[MAX_SCANLINES][MAX_HOLES];
 683 static double *scanline = NULL;
 684
 685 void gr_ibitblt(grs_bitmap *src_bmp, grs_bitmap *dest_bmp, ubyte pixel_double)
 686 {
 687         int x, y, sw, sh, srowsize, drowsize, dstart, sy, dy;
 688         ubyte *src, *dest;
 689         short *current_hole, *current_hole_length;
 690
 691 // variable setup
 692
 693 #if defined(POLY_ACC)
 694         if ( PAEnabled )
 695                 return;
 696 #endif
 697
 698         sw = src_bmp->bm_w;
 699         sh = src_bmp->bm_h;
 700         srowsize = src_bmp->bm_rowsize;
 701         drowsize = dest_bmp->bm_rowsize;
 702         src = src_bmp->bm_data;
 703         dest = dest_bmp->bm_data;
 704
 705         sy = 0;
 706         while (start_points[sy][0] == -1) {
 707                 sy++;
 708                 dest += drowsize;
 709         }
 710
 711         if (pixel_double) {
 712                 ubyte *scan = (ubyte *)scanline;    // set up for byte processing of scanline
 713
 714                 dy = sy;
 715                 for (y = sy; y < sy + sh; y++) {
 716                         gr_linear_rep_movsd_2x(src, scan, sw); // was: gr_linear_movsd_double(src, scan, sw*2);
 717                         current_hole = start_points[dy];
 718                         current_hole_length = hole_length[dy];
 719                         for (x = 0; x < MAX_HOLES; x++) {
 720                                 if (*current_hole == -1)
 721                                         break;
 722                                 dstart = *current_hole;
 723                                 gr_linear_movsd(&(scan[dstart]), &(dest[dstart]), *current_hole_length);
 724                                 current_hole++;
 725                                 current_hole_length++;
 726                         }
 727                         dy++;
 728                         dest += drowsize;
 729                         current_hole = start_points[dy];
 730                         current_hole_length = hole_length[dy];
 731                         for (x = 0;x < MAX_HOLES; x++) {
 732                                 if (*current_hole == -1)
 733                                         break;
 734                                 dstart = *current_hole;
 735                                 gr_linear_movsd(&(scan[dstart]), &(dest[dstart]), *current_hole_length);
 736                                 current_hole++;
 737                                 current_hole_length++;
 738                         }
 739                         dy++;
 740                         dest += drowsize;
 741                         src += srowsize;
 742                 }
 743         } else {
 744                 Assert(sw <= MAX_WIDTH);
 745                 Assert(sh <= MAX_SCANLINES);
 746                 for (y = sy; y < sy + sh; y++) {
 747                         for (x = 0; x < MAX_HOLES; x++) {
 748                                 if (start_points[y][x] == -1)
 749                                         break;
 750                                 dstart = start_points[y][x];
 751                                 gr_linear_movsd(&(src[dstart]), &(dest[dstart]), hole_length[y][x]);
 752                         }
 753                         dest += drowsize;
 754                         src += srowsize;
 755                 }
 756         }
 757 }
 758
 759 #if defined(POLY_ACC)
 760
 761 ulong *pa_emit_blit(int gencode, ulong *buf, int w, int h, int sx, int sy, int dx, int dy)
 762 {
 763         if(w == 0 || h == 0)
 764                 return buf;
 765
 766         if(gencode)
 767         {
 768                 buf[0] = (w << 16)  | h;
 769                 buf[1] = (sx << 16) | sy;
 770                 buf[2] = (dx << 16) | dy;
 771         }
 772         return buf + 3;
 773 }
 774
 775 void gr_ibitblt_create_mask_pa( grs_bitmap * mask_bmp, int sx, int sy, int sw, int sh, int srowsize )
 776 {
 777         ulong *ret, *code = 0;
 778         int pass, x, y, n;
 779         ushort *s;
 780
 781         Assert(mask_bmp->bm_type == BM_LINEAR15);
 782
 783         srowsize /= PA_BPP;
 784
 785         pa_flush();
 786
 787         // make two passes, first pass gets size of output block, second actually creates data.
 788         for(pass = 0; pass != 2; ++pass)
 789         {
 790                 for (y = sy; y < sy + sh; y++ )
 791                 {
 792                         // first byte of interest in mask
 793                         s = (ushort *)(mask_bmp->bm_data + y * mask_bmp->bm_rowsize + sx * PA_BPP);
 794                         for ( x=0; x < sw; )
 795                         {
 796                                 for(; x != sw && (s[x] & 0x8000); ++x)              // while opaque...
 797                                         ;
 798                                 for(n = 0; x != sw && !(s[x] & 0x8000); ++n, ++x)   // while transparent...
 799                                         ;
 800                                 code = pa_emit_blit(pass, code, n, 1, x - n, y - sy, x + sx - n, y);
 801                         }
 802                 }
 803
 804                 if(pass == 0) {
 805                         ret = malloc((int)code + sizeof(ulong));
 806                         ret[0] = (int)code / sizeof(ulong);        // store num ulongs in list.
 807                         code = ret + 1;
 808                 }
 809         }
 810 //      return (ubyte *)ret;
 811 }
 812 #endif
 813
 814 void gr_ibitblt_create_mask(grs_bitmap *mask_bmp, int sx, int sy, int sw, int sh, int srowsize)
 815 {
 816         int x, y;
 817         ubyte mode;
 818         int count = 0;
 819
 820         Assert( (!(mask_bmp->bm_flags&BM_FLAG_RLE)) );
 821
 822         for (y = 0; y < MAX_SCANLINES; y++) {
 823                 for (x = 0; x < MAX_HOLES; x++) {
 824                         start_points[y][x] = -1;
 825                         hole_length[y][x] = -1;
 826                 }
 827         }
 828
 829         for (y = sy; y < sy+sh; y++) {
 830                 count = 0;
 831                 mode = FIND_START;
 832                 for (x = sx; x < sx + sw; x++) {
 833                         if ((mode == FIND_START) && (mask_bmp->bm_data[mask_bmp->bm_rowsize*y+x] == TRANSPARENCY_COLOR)) {
 834                                 start_points[y][count] = x;
 835                                 mode = FIND_STOP;
 836                         } else if ((mode == FIND_STOP) && (mask_bmp->bm_data[mask_bmp->bm_rowsize*y+x] != TRANSPARENCY_COLOR)) {
 837                                 hole_length[y][count] = x - start_points[y][count];
 838                                 count++;
 839                                 mode = FIND_START;
 840                         }
 841                 }
 842                 if (mode == FIND_STOP) {
 843                         hole_length[y][count] = x - start_points[y][count];
 844                         count++;
 845                 }
 846                 Assert(count <= MAX_HOLES);
 847         }
 848 }
 849
 850 #if defined(POLY_ACC)
 851
 852 void gr_ibitblt_find_hole_size_pa( grs_bitmap * mask_bmp, int *minx, int *miny, int *maxx, int *maxy )
 853 {
 854         int x, y, count=0;
 855         short c;
 856
 857         Assert( (!(mask_bmp->bm_flags&BM_FLAG_RLE)) );
 858
 859         Assert(mask_bmp->bm_type == BM_LINEAR15);
 860         while(!pa_idle());
 861
 862         *minx = mask_bmp->bm_w-1;
 863         *maxx = 0;
 864         *miny = mask_bmp->bm_h-1;
 865         *maxy = 0;
 866
 867         for ( y=0; y<mask_bmp->bm_h; y++ )
 868                 for ( x=0; x<mask_bmp->bm_w; x++ ) {
 869                         c = *(short *)(mask_bmp->bm_data + mask_bmp->bm_rowsize * y + x * PA_BPP);
 870                         if (c >= 0)  {  // hi true means opaque.
 871                                 if ( x < *minx ) *minx = x;
 872                                 if ( y < *miny ) *miny = y;
 873                                 if ( x > *maxx ) *maxx = x;
 874                                 if ( y > *maxy ) *maxy = y;
 875                                 count++;
 876                         }
 877                 }
 878
 879         if ( count == 0 ) {
 880                 Error( "Bitmap for ibitblt doesn't have transparency!\n" );
 881         }
 882 }
 883 #endif
 884
 885 void gr_ibitblt_find_hole_size(grs_bitmap *mask_bmp, int *minx, int *miny, int *maxx, int *maxy)
 886 {
 887         ubyte c;
 888         int x, y, count = 0;
 889
 890 #if defined(POLY_ACC)
 891         if ( PAEnabled ) {
 892                 gr_ibitblt_find_hole_size_pa( mask_bmp, minx, miny, maxx, maxy );
 893                 return;
 894         }
 895 #endif
 896
 897         Assert( (!(mask_bmp->bm_flags&BM_FLAG_RLE)) );
 898         Assert( mask_bmp->bm_flags&BM_FLAG_TRANSPARENT );
 899
 900         *minx = mask_bmp->bm_w - 1;
 901         *maxx = 0;
 902         *miny = mask_bmp->bm_h - 1;
 903         *maxy = 0;
 904
 905         if (scanline == NULL)
 906                 scanline = (double *)malloc(sizeof(double) * (MAX_WIDTH / sizeof(double)));
 907
 908         for (y = 0; y < mask_bmp->bm_h; y++) {
 909                 for (x = 0; x < mask_bmp->bm_w; x++) {
 910                         c = mask_bmp->bm_data[mask_bmp->bm_rowsize*y+x];
 911                         if (c == TRANSPARENCY_COLOR) { // don't look for transparancy color here.
 912                                 count++;
 913                                 if (x < *minx) *minx = x;
 914                                 if (y < *miny) *miny = y;
 915                                 if (x > *maxx) *maxx = x;
 916                                 if (y > *maxy) *maxy = y;
 917                         }
 918                 }
 919         }
 920         Assert (count);
 921 }
 922
 923 #endif /* __MSDOS__ */ // was: /* !MACINTOSH */