2d/bitblt.c

   1 /* $Id: bitblt.c,v 1.7 2002-09-04 22:01:07 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  * Routines for bitblt's.
  18  *
  19  * Old Log:
  20  * Revision 1.29  1995/03/14  12:14:28  john
  21  * Added code to double horz/vert bitblts.
  22  *
  23  * Revision 1.28  1995/03/13  09:01:48  john
  24  * Fixed bug with VFX1 screen not tall enough.
  25  *
  26  * Revision 1.27  1995/03/01  15:38:10  john
  27  * Better ModeX support.
  28  *
  29  * Revision 1.26  1994/12/15  12:19:00  john
  30  * Added gr_bm_bitblt (clipped!) function.
  31  *
  32  * Revision 1.25  1994/12/09  18:58:42  matt
  33  * Took out include of 3d.h
  34  *
  35  * Revision 1.24  1994/11/28  17:08:32  john
  36  * Took out some unused functions in linear.asm, moved
  37  * gr_linear_movsd from linear.asm to bitblt.c, made sure that
  38  * the code in ibiblt.c sets the direction flags before rep movsing.
  39  *
  40  * Revision 1.22  1994/11/23  16:04:00  john
  41  * Fixed generic rle'ing to use new bit method.
  42  *
  43  * Revision 1.21  1994/11/18  22:51:03  john
  44  * Changed a bunch of shorts to ints in calls.
  45  *
  46  * Revision 1.20  1994/11/10  15:59:48  john
  47  * Fixed bugs with canvas's being created with bogus bm_flags.
  48  *
  49  * Revision 1.19  1994/11/09  21:03:35  john
  50  * Added RLE for svga gr_ubitmap.
  51  *
  52  * Revision 1.18  1994/11/09  17:41:29  john
  53  * Made a slow version of rle bitblt to svga, modex.
  54  *
  55  * Revision 1.17  1994/11/09  16:35:15  john
  56  * First version with working RLE bitmaps.
  57  *
  58  * Revision 1.16  1994/11/04  10:06:58  john
  59  * Added fade table for fading fonts. Made font that partially clips
  60  * not print a warning message.
  61  *
  62  * Revision 1.15  1994/09/22  16:08:38  john
  63  * Fixed some palette stuff.
  64  *
  65  * Revision 1.14  1994/09/19  11:44:27  john
  66  * Changed call to allocate selector to the dpmi module.
  67  *
  68  * Revision 1.13  1994/08/08  13:03:00  john
  69  * Fixed bug in gr_bitmap in modex
  70  *
  71  * Revision 1.12  1994/07/13  19:47:23  john
  72  * Fixed bug with modex bitblt to page 2 not working.
  73  *
  74  * Revision 1.11  1994/05/31  11:10:52  john
  75  * *** empty log message ***
  76  *
  77  * Revision 1.10  1994/03/18  15:24:34  matt
  78  * Removed interlace stuff
  79  *
  80  * Revision 1.9  1994/02/18  15:32:20  john
  81  * *** empty log message ***
  82  *
  83  * Revision 1.8  1994/02/01  13:22:54  john
  84  * *** empty log message ***
  85  *
  86  * Revision 1.7  1994/01/13  08:28:25  mike
  87  * Modify rect copy to copy alternate scanlines when in interlaced mode.
  88  *
  89  * Revision 1.6  1993/12/28  12:09:46  john
  90  * added lbitblt.asm
  91  *
  92  * Revision 1.5  1993/10/26  13:18:09  john
  93  * *** empty log message ***
  94  *
  95  * Revision 1.4  1993/10/15  16:23:30  john
  96  * y
  97  *
  98  * Revision 1.3  1993/09/13  17:52:58  john
  99  * Fixed bug in BitBlt linear to SVGA
 100  *
 101  * Revision 1.2  1993/09/08  14:47:00  john
 102  * Made bitmap00 add rowsize instead of bitmap width.
 103  * Other routines might have this problem too.
 104  *
 105  * Revision 1.1  1993/09/08  11:43:01  john
 106  * Initial revision
 107  *
 108  */
 109
 110 #ifdef HAVE_CONFIG_H
 111 #include <conf.h>
 112 #endif
 113
 114 #include "pa_enabl.h"                   //$$POLY_ACC
 115 #include "u_mem.h"
 116 #include "gr.h"
 117 #include "grdef.h"
 118 #include "rle.h"
 119 #include "mono.h"
 120 #include "byteswap.h"       // because of rle code that has short for row offsets
 121 #include "error.h"
 122
 123 #ifdef OGL
 124 #include "ogl_init.h"
 125 #endif
 126
 127 #if defined(POLY_ACC)
 128 #include "poly_acc.h"
 129 #endif
 130
 131 int gr_bitblt_dest_step_shift = 0;
 132 int gr_bitblt_double = 0;
 133 ubyte *gr_bitblt_fade_table=NULL;
 134
 135 extern void gr_vesa_bitmap( grs_bitmap * source, grs_bitmap * dest, int x, int y );
 136
 137 #ifdef NO_ASM
 138
 139 #define THRESHOLD   8
 140
 141 #ifdef RELEASE
 142 #define test_byteblit   0
 143 #else
 144 ubyte test_byteblit = 0;
 145 #endif
 146
 147 void gr_linear_movsd(ubyte * src, ubyte * dest, unsigned int num_pixels )
 148 {
 149         int i;
 150         uint n, r;
 151         double *d, *s;
 152         ubyte *d1, *s1;
 153
 154 // check to see if we are starting on an even byte boundry
 155 // if not, move appropriate number of bytes to even
 156 // 8 byte boundry
 157
 158         if ( (num_pixels < THRESHOLD) || (((int)src & 0x7) != ((int)dest & 0x7)) || test_byteblit ) {
 159                 for (i = 0; i < num_pixels; i++)
 160                         *dest++ = *src++;
 161                 return;
 162         }
 163
 164         i = 0;
 165         if ((r = (int)src & 0x7)) {
 166                 for (i = 0; i < 8 - r; i++)
 167                         *dest++ = *src++;
 168         }
 169         num_pixels -= i;
 170
 171         n = num_pixels / 8;
 172         r = num_pixels % 8;
 173         s = (double *)src;
 174         d = (double *)dest;
 175         for (i = 0; i < n; i++)
 176                 *d++ = *s++;
 177         s1 = (ubyte *)s;
 178         d1 = (ubyte *)d;
 179         for (i = 0; i < r; i++)
 180                 *d1++ = *s1++;
 181 }
 182
 183 #endif  //#ifdef NO_ASM
 184
 185
 186 static void gr_linear_rep_movsdm(ubyte * src, ubyte * dest, unsigned int num_pixels );
 187
 188 #if !defined(NO_ASM) && defined(__WATCOMC__)
 189
 190 #pragma aux gr_linear_rep_movsdm parm [esi] [edi] [ecx] modify exact [ecx esi edi eax] = \
 191 "nextpixel:"                \
 192     "mov    al,[esi]"       \
 193     "inc    esi"            \
 194     "cmp    al, 255"        \
 195     "je skip_it"            \
 196     "mov    [edi], al"      \
 197 "skip_it:"                  \
 198     "inc    edi"            \
 199     "dec    ecx"            \
 200     "jne    nextpixel";
 201
 202 #elif !defined(NO_ASM) && defined(__GNUC__)
 203
 204 static inline void gr_linear_rep_movsdm(ubyte * src, ubyte * dest, unsigned int num_pixels ) {
 205         int dummy[3];
 206  __asm__ __volatile__ (
 207 "0: ;"
 208 " movb  (%%esi), %%al;"
 209 " incl  %%esi;"
 210 " cmpb  $255, %%al;"
 211 " je    1f;"
 212 " movb  %%al,(%%edi);"
 213 "1: ;"
 214 " incl  %%edi;"
 215 " decl  %%ecx;"
 216 " jne   0b"
 217  : "=S" (dummy[0]), "=D" (dummy[1]), "=c" (dummy[2])
 218  : "0" (src), "1" (dest), "2" (num_pixels)
 219  : "%eax");
 220 }
 221
 222 #elif !defined(NO_ASM) && defined(_MSC_VER)
 223
 224 __inline void gr_linear_rep_movsdm(ubyte * src, ubyte * dest, unsigned int num_pixels )
 225 {
 226  __asm {
 227   nextpixel:
 228   mov esi, [src]
 229   mov edi, [dest]
 230   mov ecx, [num_pixels]
 231   mov al,  [esi]
 232   inc esi
 233   cmp al,  255
 234   je skip_it
 235   mov [edi], al
 236   skip_it:
 237   inc edi
 238   dec ecx
 239   jne nextpixel
 240  }
 241 }
 242
 243 #else
 244
 245 static void gr_linear_rep_movsdm(ubyte * src, ubyte * dest, unsigned int num_pixels )
 246 {
 247         int i;
 248         for (i=0; i<num_pixels; i++ ) {
 249                 if (*src != TRANSPARENCY_COLOR )
 250                         *dest = *src;
 251                 dest++;
 252                 src++;
 253         }
 254 }
 255
 256 #endif
 257
 258 static void gr_linear_rep_movsdm_faded(ubyte * src, ubyte * dest, unsigned int num_pixels, ubyte fade_value );
 259
 260 #if !defined(NO_ASM) && defined(__WATCOMC__)
 261
 262 #pragma aux gr_linear_rep_movsdm_faded parm [esi] [edi] [ecx] [ebx] modify exact [ecx esi edi eax ebx] = \
 263 "  xor eax, eax"                    \
 264 "  mov ah, bl"                      \
 265 "nextpixel:"                        \
 266     "mov    al,[esi]"               \
 267     "inc    esi"                    \
 268     "cmp    al, 255"                \
 269     "je skip_it"                    \
 270     "mov  al, gr_fade_table[eax]"   \
 271     "mov    [edi], al"              \
 272 "skip_it:"                          \
 273     "inc    edi"                    \
 274     "dec    ecx"                    \
 275     "jne    nextpixel";
 276
 277 #elif !defined(NO_ASM) && defined(__GNUC__)
 278
 279 /* #pragma aux gr_linear_rep_movsdm_faded parm [esi] [edi] [ecx] [ebx] modify exact [ecx esi edi eax ebx] */
 280 static inline void gr_linear_rep_movsdm_faded(ubyte * src, ubyte * dest, unsigned int num_pixels, ubyte fade_value ) {
 281         int dummy[4];
 282  __asm__ __volatile__ (
 283 "  xorl   %%eax, %%eax;"
 284 "  movb   %%bl, %%ah;"
 285 "0:;"
 286 "  movb   (%%esi), %%al;"
 287 "  incl   %%esi;"
 288 "  cmpb   $255, %%al;"
 289 "  je 1f;"
 290 #ifdef __linux__
 291 "  movb   gr_fade_table(%%eax), %%al;"
 292 #else
 293 "  movb   _gr_fade_table(%%eax), %%al;"
 294 #endif
 295 "  movb   %%al, (%%edi);"
 296 "1:"
 297 "  incl   %%edi;"
 298 "  decl   %%ecx;"
 299 "  jne    0b"
 300  : "=S" (dummy[0]), "=D" (dummy[1]), "=c" (dummy[2]), "=b" (dummy[3])
 301  : "0" (src), "1" (dest), "2" (num_pixels), "3" (fade_value)
 302  : "%eax");
 303 }
 304
 305 #elif !defined(NO_ASM) && defined(_MSC_VER)
 306
 307 __inline void gr_linear_rep_movsdm_faded(void * src, void * dest, unsigned int num_pixels, ubyte fade_value )
 308 {
 309  __asm {
 310   mov esi, [src]
 311   mov edi, [dest]
 312   mov ecx, [num_pixels]
 313   movzx ebx, byte ptr [fade_value]
 314   xor eax, eax
 315   mov ah, bl
 316   nextpixel:
 317   mov al, [esi]
 318   inc esi
 319   cmp al, 255
 320   je skip_it
 321   mov al, gr_fade_table[eax]
 322   mov [edi], al
 323   skip_it:
 324   inc edi
 325   dec ecx
 326   jne nextpixel
 327  }
 328 }
 329
 330 #else
 331
 332 static void gr_linear_rep_movsdm_faded(ubyte * src, ubyte * dest, unsigned int num_pixels, ubyte fade_value )
 333 {
 334         int i;
 335         ubyte source;
 336         ubyte *fade_base;
 337
 338         fade_base = gr_fade_table + (fade_value * 256);
 339
 340         for (i=num_pixels; i != 0; i-- )
 341         {
 342                 source = *src;
 343                 if (source != (ubyte)TRANSPARENCY_COLOR )
 344                         *dest = *(fade_base + source);
 345                 dest++;
 346                 src++;
 347         }
 348 }
 349
 350 #endif
 351
 352
 353 static void gr_linear_rep_movsd_2x(ubyte * src, ubyte * dest, unsigned int num_dest_pixels );
 354
 355 #if !defined(NO_ASM) && defined(__WATCOMC__)
 356
 357 #pragma aux gr_linear_rep_movsd_2x parm [esi] [edi] [ecx] modify exact [ecx esi edi eax ebx] = \
 358     "shr    ecx, 1"             \
 359     "jnc    nextpixel"          \
 360     "mov    al, [esi]"          \
 361     "mov    [edi], al"          \
 362     "inc    esi"                \
 363     "inc    edi"                \
 364     "cmp    ecx, 0"             \
 365     "je done"                   \
 366 "nextpixel:"                    \
 367     "mov    al,[esi]"           \
 368     "mov    ah, al"             \
 369     "mov    [edi], ax"          \
 370     "inc    esi"                \
 371     "inc    edi"                \
 372     "inc    edi"                \
 373     "dec    ecx"                \
 374     "jne    nextpixel"          \
 375 "done:"
 376
 377 #elif !defined(NO_ASM) && defined (__GNUC__)
 378
 379 static inline void gr_linear_rep_movsd_2x(ubyte * src, ubyte * dest, unsigned int num_dest_pixels ) {
 380 /* #pragma aux gr_linear_rep_movsd_2x parm [esi] [edi] [ecx] modify exact [ecx esi edi eax ebx] */
 381         int dummy[3];
 382  __asm__ __volatile__ (
 383     "shrl   $1, %%ecx;"
 384     "jnc    0f;"
 385     "movb   (%%esi), %%al;"
 386     "movb   %%al, (%%edi);"
 387     "incl   %%esi;"
 388     "incl   %%edi;"
 389     "cmpl   $0, %%ecx;"
 390     "je 1f;"
 391 "0: ;"
 392     "movb   (%%esi), %%al;"
 393     "movb   %%al, %%ah;"
 394     "movw   %%ax, (%%edi);"
 395     "incl   %%esi;"
 396     "incl   %%edi;"
 397     "incl   %%edi;"
 398     "decl   %%ecx;"
 399     "jne    0b;"
 400 "1:"
 401  : "=S" (dummy[0]), "=D" (dummy[1]), "=c" (dummy[2])
 402  : "0" (src), "1" (dest), "2" (num_dest_pixels)
 403  :      "%eax");
 404 }
 405
 406 #elif !defined(NO_ASM) && defined(_MSC_VER)
 407
 408 __inline void gr_linear_rep_movsd_2x(ubyte * src, ubyte * dest, unsigned int num_dest_pixels )
 409 {
 410  __asm {
 411   mov esi, [src]
 412   mov edi, [dest]
 413   mov ecx, [num_dest_pixels]
 414   shr ecx, 1
 415   jnc nextpixel
 416   mov al, [esi]
 417   mov [edi], al
 418   inc esi
 419   inc edi
 420   cmp ecx, 0
 421   je done
 422 nextpixel:
 423   mov al, [esi]
 424   mov ah, al
 425   mov [edi], ax
 426   inc esi
 427   inc edi
 428   inc edi
 429   dec ecx
 430   jne nextpixel
 431 done:
 432  }
 433 }
 434
 435 #else
 436
 437 static void gr_linear_rep_movsd_2x(ubyte *src, ubyte *dest, int num_pixels)
 438 {
 439         double  *d = (double *)dest;
 440         uint    *s = (uint *)src;
 441         uint    doubletemp[2];
 442         uint    temp, work;
 443         int     i;
 444
 445         if (num_pixels & 0x3) {
 446                 // not a multiple of 4?  do single pixel at a time
 447                 for (i=0; i<num_pixels; i++) {
 448                         *dest++ = *src;
 449                         *dest++ = *src++;
 450                 }
 451                 return;
 452         }
 453
 454         for (i = 0; i < num_pixels / 4; i++) {
 455                 temp = work = *s++;
 456
 457                 temp = ((temp >> 8) & 0x00FFFF00) | (temp & 0xFF0000FF); // 0xABCDEFGH -> 0xABABCDEF
 458                 temp = ((temp >> 8) & 0x000000FF) | (temp & 0xFFFFFF00); // 0xABABCDEF -> 0xABABCDCD
 459                 doubletemp[0] = temp;
 460
 461                 work = ((work << 8) & 0x00FFFF00) | (work & 0xFF0000FF); // 0xABCDEFGH -> 0xABEFGHGH
 462                 work = ((work << 8) & 0xFF000000) | (work & 0x00FFFFFF); // 0xABEFGHGH -> 0xEFEFGHGH
 463                 doubletemp[1] = work;
 464
 465                 *d = *(double *) &(doubletemp[0]);
 466                 d++;
 467         }
 468 }
 469
 470 #endif
 471
 472 static void modex_copy_column(ubyte * src, ubyte * dest, int num_pixels, int src_rowsize, int dest_rowsize );
 473
 474 #if !defined(NO_ASM) && defined(__WATCOMC__)
 475
 476 #pragma aux modex_copy_column parm [esi] [edi] [ecx] [ebx] [edx] modify exact [ecx esi edi] = \
 477 "nextpixel:"            \
 478     "mov    al,[esi]"   \
 479     "add    esi, ebx"   \
 480     "mov    [edi], al"  \
 481     "add    edi, edx"   \
 482     "dec    ecx"        \
 483     "jne    nextpixel"
 484
 485 #elif !defined(NO_ASM) && defined(__GNUC__)
 486
 487 static inline void modex_copy_column(ubyte * src, ubyte * dest, int num_pixels, int src_rowsize, int dest_rowsize ) {
 488 /*#pragma aux modex_copy_column parm [esi] [edi] [ecx] [ebx] [edx] modify exact [ecx esi edi] = */
 489  __asm__ __volatile__ (
 490 "0: ;"
 491     "movb   (%%esi), %%al;"
 492     "addl   %%ebx, %%esi;"
 493     "movb   %%al, (%%edi);"
 494     "addl   %%edx, %%edi;"
 495     "decl   %%ecx;"
 496     "jne    0b"
 497  : : "S" (src), "D" (dest), "c" (num_pixels), "b" (src_rowsize), "d" (dest_rowsize)
 498  : "%eax", "%ecx", "%esi", "%edi");
 499 }
 500
 501 #else
 502
 503 static void modex_copy_column(ubyte * src, ubyte * dest, int num_pixels, int src_rowsize, int dest_rowsize )
 504 {
 505         src = src;
 506         dest = dest;
 507         num_pixels = num_pixels;
 508         src_rowsize = src_rowsize;
 509         dest_rowsize = dest_rowsize;
 510         Int3();
 511 }
 512
 513 #endif
 514
 515 static void modex_copy_column_m(ubyte * src, ubyte * dest, int num_pixels, int src_rowsize, int dest_rowsize );
 516
 517 #if !defined(NO_ASM) && defined(__WATCOMC__)
 518
 519 #pragma aux modex_copy_column_m parm [esi] [edi] [ecx] [ebx] [edx] modify exact [ecx esi edi] = \
 520 "nextpixel:"            \
 521     "mov    al,[esi]"   \
 522     "add    esi, ebx"   \
 523     "cmp    al, 255"    \
 524     "je skip_itx"       \
 525     "mov    [edi], al"  \
 526 "skip_itx:"             \
 527     "add    edi, edx"   \
 528     "dec    ecx"        \
 529     "jne    nextpixel"
 530
 531 #elif !defined(NO_ASM) && defined(__GNUC__)
 532
 533 static inline void modex_copy_column_m(ubyte * src, ubyte * dest, int num_pixels, int src_rowsize, int dest_rowsize ) {
 534 /* #pragma aux modex_copy_column_m parm [esi] [edi] [ecx] [ebx] [edx] modify exact [ecx esi edi] = */
 535  int dummy[3];
 536  __asm__ __volatile__ (
 537 "0: ;"
 538     "movb    (%%esi), %%al;"
 539     "addl    %%ebx, %%esi;"
 540     "cmpb    $255, %%al;"
 541     "je 1f;"
 542     "movb   %%al, (%%edi);"
 543 "1: ;"
 544     "addl   %%edx, %%edi;"
 545     "decl   %%ecx;"
 546     "jne    0b"
 547  : "=c" (dummy[0]), "=S" (dummy[1]), "=D" (dummy[2])
 548  : "1" (src), "2" (dest), "0" (num_pixels), "b" (src_rowsize), "d" (dest_rowsize)
 549  :      "%eax" );
 550 }
 551
 552 #else
 553
 554 static void modex_copy_column_m(ubyte * src, ubyte * dest, int num_pixels, int src_rowsize, int dest_rowsize )
 555 {
 556         src = src;
 557         dest = dest;
 558         num_pixels = num_pixels;
 559         src_rowsize = src_rowsize;
 560         dest_rowsize = dest_rowsize;
 561         Int3();
 562 }
 563
 564 #endif
 565
 566 void gr_ubitmap00( int x, int y, grs_bitmap *bm )
 567 {
 568         register int y1;
 569         int dest_rowsize;
 570
 571         unsigned char * dest;
 572         unsigned char * src;
 573
 574         dest_rowsize=grd_curcanv->cv_bitmap.bm_rowsize << gr_bitblt_dest_step_shift;
 575         dest = &(grd_curcanv->cv_bitmap.bm_data[ dest_rowsize*y+x ]);
 576
 577         src = bm->bm_data;
 578
 579         for (y1=0; y1 < bm->bm_h; y1++ )    {
 580                 if (gr_bitblt_double)
 581                         gr_linear_rep_movsd_2x( src, dest, bm->bm_w );
 582                 else
 583                         gr_linear_movsd( src, dest, bm->bm_w );
 584                 src += bm->bm_rowsize;
 585                 dest+= (int)(dest_rowsize);
 586         }
 587 }
 588
 589 void gr_ubitmap00m( int x, int y, grs_bitmap *bm )
 590 {
 591         register int y1;
 592         int dest_rowsize;
 593
 594         unsigned char * dest;
 595         unsigned char * src;
 596
 597         dest_rowsize=grd_curcanv->cv_bitmap.bm_rowsize << gr_bitblt_dest_step_shift;
 598         dest = &(grd_curcanv->cv_bitmap.bm_data[ dest_rowsize*y+x ]);
 599
 600         src = bm->bm_data;
 601
 602         if (gr_bitblt_fade_table==NULL) {
 603                 for (y1=0; y1 < bm->bm_h; y1++ )    {
 604                         gr_linear_rep_movsdm( src, dest, bm->bm_w );
 605                         src += bm->bm_rowsize;
 606                         dest+= (int)(dest_rowsize);
 607                 }
 608         } else {
 609                 for (y1=0; y1 < bm->bm_h; y1++ )    {
 610                         gr_linear_rep_movsdm_faded( src, dest, bm->bm_w, gr_bitblt_fade_table[y1+y] );
 611                         src += bm->bm_rowsize;
 612                         dest+= (int)(dest_rowsize);
 613                 }
 614         }
 615 }
 616
 617 #if 0
 618 "       jmp     aligned4        "   \
 619 "       mov eax, edi            "   \
 620 "       and eax, 11b            "   \
 621 "       jz      aligned4        "   \
 622 "       mov ebx, 4              "   \
 623 "       sub ebx, eax            "   \
 624 "       sub ecx, ebx            "   \
 625 "alignstart:                    "   \
 626 "       mov al, [esi]           "   \
 627 "       add esi, 4              "   \
 628 "       mov [edi], al           "   \
 629 "       inc edi                 "   \
 630 "       dec ebx                 "   \
 631 "       jne alignstart          "   \
 632 "aligned4:                      "
 633 #endif
 634
 635 static void modex_copy_scanline( ubyte * src, ubyte * dest, int npixels );
 636
 637 #if !defined(NO_ASM) && defined(__WATCOMC__)
 638
 639 #pragma aux modex_copy_scanline parm [esi] [edi] [ecx] modify exact [ecx esi edi eax ebx edx] = \
 640 "       mov ebx, ecx            "   \
 641 "       and ebx, 11b            "   \
 642 "       shr ecx, 2              "   \
 643 "       cmp ecx, 0              "   \
 644 "       je      no2group        "   \
 645 "next4pixels:                   "   \
 646 "       mov al, [esi+8]         "   \
 647 "       mov ah, [esi+12]        "   \
 648 "       shl eax, 16             "   \
 649 "       mov al, [esi]           "   \
 650 "       mov ah, [esi+4]         "   \
 651 "       mov [edi], eax          "   \
 652 "       add esi, 16             "   \
 653 "       add edi, 4              "   \
 654 "       dec ecx                 "   \
 655 "       jne next4pixels         "   \
 656 "no2group:                      "   \
 657 "       cmp ebx, 0              "   \
 658 "       je      done2           "   \
 659 "finishend:                     "   \
 660 "       mov al, [esi]           "   \
 661 "       add esi, 4              "   \
 662 "       mov [edi], al           "   \
 663 "       inc edi                 "   \
 664 "       dec ebx                 "   \
 665 "       jne finishend           "   \
 666 "done2:                         ";
 667
 668 #elif !defined (NO_ASM) && defined(__GNUC__)
 669
 670 static inline void modex_copy_scanline( ubyte * src, ubyte * dest, int npixels ) {
 671 /* #pragma aux modex_copy_scanline parm [esi] [edi] [ecx] modify exact [ecx esi edi eax ebx edx] */
 672 int dummy[3];
 673  __asm__ __volatile__ (
 674 "       movl %%ecx, %%ebx;"
 675 "       andl $3, %%ebx;"
 676 "       shrl $2, %%ecx;"
 677 "       cmpl $0, %%ecx;"
 678 "       je   1f;"
 679 "0: ;"
 680 "       movb 8(%%esi), %%al;"
 681 "       movb 12(%%esi), %%ah;"
 682 "       shll $16, %%eax;"
 683 "       movb (%%esi), %%al;"
 684 "       movb 4(%%esi), %%ah;"
 685 "       movl %%eax, (%%edi);"
 686 "       addl $16, %%esi;"
 687 "       addl $4, %%edi;"
 688 "       decl %%ecx;"
 689 "       jne 0b;"
 690 "1: ;"
 691 "       cmpl $0, %%ebx;"
 692 "       je      3f;"
 693 "2: ;"
 694 "       movb (%%esi), %%al;"
 695 "       addl $4, %%esi;"
 696 "       movb %%al, (%%edi);"
 697 "       incl %%edi;"
 698 "       decl %%ebx;"
 699 "       jne 2b;"
 700 "3:"
 701  : "=c" (dummy[0]), "=S" (dummy[1]), "=D" (dummy[2])
 702  : "1" (src), "2" (dest), "0" (npixels)
 703  :      "%eax", "%ebx", "%edx" );
 704 }
 705
 706 #else
 707
 708 static void modex_copy_scanline( ubyte * src, ubyte * dest, int npixels )
 709 {
 710         src = src;
 711         dest = dest;
 712         npixels = npixels;
 713         Int3();
 714 }
 715
 716 #endif
 717
 718 static void modex_copy_scanline_2x( ubyte * src, ubyte * dest, int npixels );
 719
 720 #if !defined(NO_ASM) && defined(__WATCOMC__)
 721
 722 #pragma aux modex_copy_scanline_2x parm [esi] [edi] [ecx] modify exact [ecx esi edi eax ebx edx] = \
 723 "       mov ebx, ecx            "   \
 724 "       and ebx, 11b            "   \
 725 "       shr ecx, 2              "   \
 726 "       cmp ecx, 0              "   \
 727 "       je      no2group        "   \
 728 "next4pixels:                   "   \
 729 "       mov al, [esi+4]         "   \
 730 "       mov ah, [esi+6]         "   \
 731 "       shl eax, 16             "   \
 732 "       mov al, [esi]           "   \
 733 "       mov ah, [esi+2]         "   \
 734 "       mov [edi], eax          "   \
 735 "       add esi, 8              "   \
 736 "       add edi, 4              "   \
 737 "       dec ecx                 "   \
 738 "       jne next4pixels         "   \
 739 "no2group:                      "   \
 740 "       cmp ebx, 0              "   \
 741 "       je      done2           "   \
 742 "finishend:                     "   \
 743 "       mov al, [esi]           "   \
 744 "       add esi, 2              "   \
 745 "       mov [edi], al           "   \
 746 "       inc edi                 "   \
 747 "       dec ebx                 "   \
 748 "       jne finishend           "   \
 749 "done2:                         ";
 750
 751 #elif !defined(NO_ASM) && defined(__GNUC__)
 752
 753 static inline void modex_copy_scanline_2x( ubyte * src, ubyte * dest, int npixels ) {
 754 /* #pragma aux modex_copy_scanline_2x parm [esi] [edi] [ecx] modify exact [ecx esi edi eax ebx edx] = */
 755 int dummy[3];
 756  __asm__ __volatile__ (
 757 "       movl %%ecx, %%ebx;"
 758 "       andl $3, %%ebx;"
 759 "       shrl $2, %%ecx;"
 760 "       cmpl $0, %%ecx;"
 761 "       je 1f;"
 762 "0: ;"
 763 "       movb 4(%%esi), %%al;"
 764 "       movb 6(%%esi), %%ah;"
 765 "       shll $16, %%eax;"
 766 "       movb (%%esi), %%al;"
 767 "       movb 2(%%esi), %%ah;"
 768 "       movl %%eax, (%%edi);"
 769 "       addl $8, %%esi;"
 770 "       addl $4, %%edi;"
 771 "       decl %%ecx;"
 772 "       jne 0b;"
 773 "1: ;"
 774 "       cmp $0, %%ebx;"
 775 "       je  3f;"
 776 "2:"
 777 "       movb (%%esi),%%al;"
 778 "       addl $2, %%esi;"
 779 "       movb %%al, (%%edi);"
 780 "       incl %%edi;"
 781 "       decl %%ebx;"
 782 "       jne 2b;"
 783 "3:"
 784  : "=c" (dummy[0]), "=S" (dummy[1]), "=D" (dummy[2])
 785  : "1" (src), "2" (dest), "0" (npixels)
 786  :      "%eax", "%ebx", "%edx" );
 787 }
 788
 789 #else
 790
 791 static void modex_copy_scanline_2x( ubyte * src, ubyte * dest, int npixels )
 792 {
 793         src = src;
 794         dest = dest;
 795         npixels = npixels;
 796         Int3();
 797 }
 798
 799 #endif
 800
 801
 802 #ifdef __MSDOS__
 803
 804 // From Linear to ModeX
 805 void gr_bm_ubitblt01(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
 806 {
 807         ubyte * dbits;
 808         ubyte * sbits;
 809         int sstep,dstep;
 810         int y,plane;
 811         int w1;
 812
 813         if ( w < 4 ) return;
 814
 815         sstep = src->bm_rowsize;
 816         dstep = dest->bm_rowsize << gr_bitblt_dest_step_shift;
 817
 818         if (!gr_bitblt_double) {
 819                 for (plane=0; plane<4; plane++ ) {
 820                         gr_modex_setplane( (plane+dx)&3 );
 821                         sbits = src->bm_data + (src->bm_rowsize * sy) + sx + plane;
 822                         dbits = &gr_video_memory[(dest->bm_rowsize * dy) + ((plane+dx)/4) ];
 823                         w1 = w >> 2;
 824                         if ( (w&3) > plane ) w1++;
 825                         for (y=dy; y < dy+h; y++ ) {
 826                                 modex_copy_scanline( sbits, dbits, w1 );
 827                                 dbits += dstep;
 828                                 sbits += sstep;
 829                         }
 830                 }
 831         } else {
 832                 for (plane=0; plane<4; plane++ ) {
 833                         gr_modex_setplane( (plane+dx)&3 );
 834                         sbits = src->bm_data + (src->bm_rowsize * sy) + sx + plane/2;
 835                         dbits = &gr_video_memory[(dest->bm_rowsize * dy) + ((plane+dx)/4) ];
 836                         w1 = w >> 2;
 837                         if ( (w&3) > plane ) w1++;
 838                         for (y=dy; y < dy+h; y++ ) {
 839                                 modex_copy_scanline_2x( sbits, dbits, w1 );
 840                                 dbits += dstep;
 841                                 sbits += sstep;
 842                         }
 843                 }
 844         }
 845 }
 846
 847
 848 // From Linear to ModeX masked
 849 void gr_bm_ubitblt01m(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
 850 {
 851         //ubyte * dbits1;
 852         //ubyte * sbits1;
 853
 854         ubyte * dbits;
 855         ubyte * sbits;
 856
 857         int x;
 858         //int y;
 859
 860         sbits =   src->bm_data  + (src->bm_rowsize * sy) + sx;
 861         dbits =   &gr_video_memory[(dest->bm_rowsize * dy) + dx/4];
 862
 863         for (x=dx; x < dx+w; x++ ) {
 864                 gr_modex_setplane( x&3 );
 865
 866                 //sbits1 = sbits;
 867                 //dbits1 = dbits;
 868                 //for (y=0; y < h; y++ )    {
 869                 //      *dbits1 = *sbits1;
 870                 //      sbits1 += src_bm_rowsize;
 871                 //      dbits1 += dest_bm_rowsize;
 872                 //}
 873                 modex_copy_column_m(sbits, dbits, h, src->bm_rowsize, dest->bm_rowsize << gr_bitblt_dest_step_shift );
 874
 875                 sbits++;
 876                 if ( (x&3)==3 )
 877                         dbits++;
 878         }
 879 }
 880
 881 #endif
 882
 883
 884 void gr_ubitmap012( int x, int y, grs_bitmap *bm )
 885 {
 886         register int x1, y1;
 887         unsigned char * src;
 888
 889         src = bm->bm_data;
 890
 891         for (y1=y; y1 < (y+bm->bm_h); y1++ )    {
 892                 for (x1=x; x1 < (x+bm->bm_w); x1++ )    {
 893                         gr_setcolor( *src++ );
 894                         gr_upixel( x1, y1 );
 895                 }
 896         }
 897 }
 898
 899 void gr_ubitmap012m( int x, int y, grs_bitmap *bm )
 900 {
 901         register int x1, y1;
 902         unsigned char * src;
 903
 904         src = bm->bm_data;
 905
 906         for (y1=y; y1 < (y+bm->bm_h); y1++ ) {
 907                 for (x1=x; x1 < (x+bm->bm_w); x1++ ) {
 908                         if ( *src != TRANSPARENCY_COLOR ) {
 909                                 gr_setcolor( *src );
 910                                 gr_upixel( x1, y1 );
 911                         }
 912                         src++;
 913                 }
 914         }
 915 }
 916
 917 #if defined(POLY_ACC)
 918 void gr_ubitmap05( int x, int y, grs_bitmap *bm )
 919 {
 920         register int x1, y1;
 921         unsigned char *src;
 922         short *dst;
 923         int mod;
 924
 925         pa_flush();
 926         src = bm->bm_data;
 927         dst = (short *)(DATA + y * ROWSIZE + x * PA_BPP);
 928         mod = ROWSIZE / 2 - bm->bm_w;
 929
 930         for (y1=y; y1 < (y+bm->bm_h); y1++ )    {
 931                 for (x1=x; x1 < (x+bm->bm_w); x1++ )    {
 932                         *dst++ = pa_clut[*src++];
 933                 }
 934                 dst += mod;
 935         }
 936 }
 937
 938 void gr_ubitmap05m( int x, int y, grs_bitmap *bm )
 939 {
 940         register int x1, y1;
 941         unsigned char *src;
 942         short *dst;
 943         int mod;
 944
 945         pa_flush();
 946         src = bm->bm_data;
 947         dst = (short *)(DATA + y * ROWSIZE + x * PA_BPP);
 948         mod = ROWSIZE / 2 - bm->bm_w;
 949
 950         for (y1=y; y1 < (y+bm->bm_h); y1++ )    {
 951                 for (x1=x; x1 < (x+bm->bm_w); x1++ )    {
 952                         if ( *src != TRANSPARENCY_COLOR )   {
 953                                 *dst = pa_clut[*src];
 954                         }
 955                         src++;
 956                         ++dst;
 957                 }
 958                 dst += mod;
 959         }
 960 }
 961
 962 void gr_bm_ubitblt05_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
 963 {
 964         unsigned short * dbits;
 965         unsigned char * sbits, scanline[640];
 966         int i, data_offset, j, nextrow;
 967
 968         pa_flush();
 969         nextrow=dest->bm_rowsize/PA_BPP;
 970
 971         data_offset = 1;
 972         if (src->bm_flags & BM_FLAG_RLE_BIG)
 973                 data_offset = 2;
 974
 975         sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
 976         for (i=0; i<sy; i++ )
 977                 sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
 978
 979         dbits = (unsigned short *)(dest->bm_data + (dest->bm_rowsize * dy) + dx*PA_BPP);
 980
 981         // No interlacing, copy the whole buffer.
 982         for (i=0; i < h; i++ )    {
 983                 gr_rle_expand_scanline( scanline, sbits, sx, sx+w-1 );
 984                 for(j = 0; j != w; ++j)
 985                         dbits[j] = pa_clut[scanline[j]];
 986                 if ( src->bm_flags & BM_FLAG_RLE_BIG )
 987                         sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((i+sy)*data_offset)])));
 988                 else
 989                         sbits += (int)(src->bm_data[4+i+sy]);
 990                 dbits += nextrow;
 991         }
 992 }
 993
 994 void gr_bm_ubitblt05m_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
 995 {
 996         unsigned short * dbits;
 997         unsigned char * sbits, scanline[640];
 998         int i, data_offset, j, nextrow;
 999
1000         pa_flush();
1001         nextrow=dest->bm_rowsize/PA_BPP;
1002         data_offset = 1;
1003         if (src->bm_flags & BM_FLAG_RLE_BIG)
1004                 data_offset = 2;
1005
1006         sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
1007         for (i=0; i<sy; i++ )
1008                 sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
1009
1010         dbits = (unsigned short *)(dest->bm_data + (dest->bm_rowsize * dy) + dx*PA_BPP);
1011
1012         // No interlacing, copy the whole buffer.
1013         for (i=0; i < h; i++ )    {
1014                 gr_rle_expand_scanline( scanline, sbits, sx, sx+w-1 );
1015                 for(j = 0; j != w; ++j)
1016                         if(scanline[j] != TRANSPARENCY_COLOR)
1017                                 dbits[j] = pa_clut[scanline[j]];
1018                 if ( src->bm_flags & BM_FLAG_RLE_BIG )
1019                         sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((i+sy)*data_offset)])));
1020                 else
1021                         sbits += (int)(src->bm_data[4+i+sy]);
1022                 dbits += nextrow;
1023         }
1024 }
1025 #endif
1026
1027 void gr_ubitmapGENERIC(int x, int y, grs_bitmap * bm)
1028 {
1029         register int x1, y1;
1030
1031         for (y1=0; y1 < bm->bm_h; y1++ )    {
1032                 for (x1=0; x1 < bm->bm_w; x1++ )    {
1033                         gr_setcolor( gr_gpixel(bm,x1,y1) );
1034                         gr_upixel( x+x1, y+y1 );
1035                 }
1036         }
1037 }
1038
1039 void gr_ubitmapGENERICm(int x, int y, grs_bitmap * bm)
1040 {
1041         register int x1, y1;
1042         ubyte c;
1043
1044         for (y1=0; y1 < bm->bm_h; y1++ ) {
1045                 for (x1=0; x1 < bm->bm_w; x1++ ) {
1046                         c = gr_gpixel(bm,x1,y1);
1047                         if ( c != TRANSPARENCY_COLOR ) {
1048                                 gr_setcolor( c );
1049                                 gr_upixel( x+x1, y+y1 );
1050                         }
1051                 }
1052         }
1053 }
1054
1055
1056 #ifdef __MSDOS__
1057 // From linear to SVGA
1058 void gr_bm_ubitblt02(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1059 {
1060         unsigned char * sbits;
1061
1062         unsigned int offset, EndingOffset, VideoLocation;
1063
1064         int sbpr, dbpr, y1, page, BytesToMove;
1065
1066         sbpr = src->bm_rowsize;
1067
1068         dbpr = dest->bm_rowsize << gr_bitblt_dest_step_shift;
1069
1070         VideoLocation = (unsigned int)dest->bm_data + (dest->bm_rowsize * dy) + dx;
1071
1072         sbits = src->bm_data + ( sbpr*sy ) + sx;
1073
1074         for (y1=0; y1 < h; y1++ )    {
1075
1076                 page    = VideoLocation >> 16;
1077                 offset  = VideoLocation & 0xFFFF;
1078
1079                 gr_vesa_setpage( page );
1080
1081                 EndingOffset = offset+w-1;
1082
1083                 if ( EndingOffset <= 0xFFFF )
1084                 {
1085                         if ( gr_bitblt_double )
1086                                 gr_linear_rep_movsd_2x( (void *)sbits, (void *)(offset+0xA0000), w );
1087                         else
1088                                 gr_linear_movsd( (void *)sbits, (void *)(offset+0xA0000), w );
1089
1090                         VideoLocation += dbpr;
1091                         sbits += sbpr;
1092                 }
1093                 else
1094                 {
1095                         BytesToMove = 0xFFFF-offset+1;
1096
1097                         if ( gr_bitblt_double )
1098                                 gr_linear_rep_movsd_2x( (void *)sbits, (void *)(offset+0xA0000), BytesToMove );
1099                         else
1100                                 gr_linear_movsd( (void *)sbits, (void *)(offset+0xA0000), BytesToMove );
1101
1102                         page++;
1103                         gr_vesa_setpage(page);
1104
1105                         if ( gr_bitblt_double )
1106                                 gr_linear_rep_movsd_2x( (void *)(sbits+BytesToMove/2), (void *)0xA0000, EndingOffset - 0xFFFF );
1107                         else
1108                                 gr_linear_movsd( (void *)(sbits+BytesToMove), (void *)0xA0000, EndingOffset - 0xFFFF );
1109
1110                         VideoLocation += dbpr;
1111                         sbits += sbpr;
1112                 }
1113         }
1114 }
1115 #endif
1116
1117 #ifdef __MSDOS__
1118
1119 void gr_bm_ubitblt02m(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1120 {
1121         unsigned char * sbits;
1122
1123         unsigned int offset, EndingOffset, VideoLocation;
1124
1125         int sbpr, dbpr, y1, page, BytesToMove;
1126
1127         sbpr = src->bm_rowsize;
1128
1129         dbpr = dest->bm_rowsize << gr_bitblt_dest_step_shift;
1130
1131         VideoLocation = (unsigned int)dest->bm_data + (dest->bm_rowsize * dy) + dx;
1132
1133         sbits = src->bm_data + ( sbpr*sy ) + sx;
1134
1135         for (y1=0; y1 < h; y1++ )    {
1136
1137                 page    = VideoLocation >> 16;
1138                 offset  = VideoLocation & 0xFFFF;
1139
1140                 gr_vesa_setpage( page );
1141
1142                 EndingOffset = offset+w-1;
1143
1144                 if ( EndingOffset <= 0xFFFF )
1145                 {
1146                         gr_linear_rep_movsdm( (void *)sbits, (void *)(offset+0xA0000), w );
1147
1148                         VideoLocation += dbpr;
1149                         sbits += sbpr;
1150                 }
1151                 else
1152                 {
1153                         BytesToMove = 0xFFFF-offset+1;
1154
1155                         gr_linear_rep_movsdm( (void *)sbits, (void *)(offset+0xA0000), BytesToMove );
1156
1157                         page++;
1158                         gr_vesa_setpage(page);
1159
1160                         gr_linear_rep_movsdm( (void *)(sbits+BytesToMove), (void *)0xA0000, EndingOffset - 0xFFFF );
1161
1162                         VideoLocation += dbpr;
1163                         sbits += sbpr;
1164                 }
1165         }
1166 }
1167
1168
1169 // From SVGA to linear
1170 void gr_bm_ubitblt20(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1171 {
1172         unsigned char * dbits;
1173
1174         unsigned int offset, offset1, offset2;
1175
1176         int sbpr, dbpr, y1, page;
1177
1178         dbpr = dest->bm_rowsize;
1179
1180         sbpr = src->bm_rowsize;
1181
1182         for (y1=0; y1 < h; y1++ )    {
1183
1184                 offset2 =   (unsigned int)src->bm_data  + (sbpr * (y1+sy)) + sx;
1185                 dbits   =   dest->bm_data + (dbpr * (y1+dy)) + dx;
1186
1187                 page = offset2 >> 16;
1188                 offset = offset2 & 0xFFFF;
1189                 offset1 = offset+w-1;
1190                 gr_vesa_setpage( page );
1191
1192                 if ( offset1 > 0xFFFF )  {
1193                         // Overlaps two pages
1194                         while( offset <= 0xFFFF )
1195                                 *dbits++ = gr_video_memory[offset++];
1196                         offset1 -= (0xFFFF+1);
1197                         offset = 0;
1198                         page++;
1199                         gr_vesa_setpage(page);
1200                 }
1201                 while( offset <= offset1 )
1202                         *dbits++ = gr_video_memory[offset++];
1203
1204         }
1205 }
1206
1207 #endif
1208
1209 //@extern int Interlacing_on;
1210
1211 // From Linear to Linear
1212 void gr_bm_ubitblt00(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1213 {
1214         unsigned char * dbits;
1215         unsigned char * sbits;
1216         //int src_bm_rowsize_2, dest_bm_rowsize_2;
1217         int dstep;
1218
1219         int i;
1220
1221         sbits =   src->bm_data  + (src->bm_rowsize * sy) + sx;
1222         dbits =   dest->bm_data + (dest->bm_rowsize * dy) + dx;
1223
1224         dstep = dest->bm_rowsize << gr_bitblt_dest_step_shift;
1225
1226         // No interlacing, copy the whole buffer.
1227         for (i=0; i < h; i++ )    {
1228                 if (gr_bitblt_double)
1229                         gr_linear_rep_movsd_2x( sbits, dbits, w );
1230                 else
1231                         gr_linear_movsd( sbits, dbits, w );
1232                 sbits += src->bm_rowsize;
1233                 dbits += dstep;
1234         }
1235 }
1236 // From Linear to Linear Masked
1237 void gr_bm_ubitblt00m(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1238 {
1239         unsigned char * dbits;
1240         unsigned char * sbits;
1241         //int src_bm_rowsize_2, dest_bm_rowsize_2;
1242
1243         int i;
1244
1245         sbits =   src->bm_data  + (src->bm_rowsize * sy) + sx;
1246         dbits =   dest->bm_data + (dest->bm_rowsize * dy) + dx;
1247
1248         // No interlacing, copy the whole buffer.
1249
1250         if (gr_bitblt_fade_table==NULL) {
1251                 for (i=0; i < h; i++ )    {
1252                         gr_linear_rep_movsdm( sbits, dbits, w );
1253                         sbits += src->bm_rowsize;
1254                         dbits += dest->bm_rowsize;
1255                 }
1256         } else {
1257                 for (i=0; i < h; i++ )    {
1258                         gr_linear_rep_movsdm_faded( sbits, dbits, w, gr_bitblt_fade_table[dy+i] );
1259                         sbits += src->bm_rowsize;
1260                         dbits += dest->bm_rowsize;
1261                 }
1262         }
1263 }
1264
1265
1266 extern void gr_lbitblt( grs_bitmap * source, grs_bitmap * dest, int height, int width );
1267
1268 #if 1 //def MACINTOSH
1269
1270 // width == number of destination pixels
1271
1272 void gr_linear_movsd_double(ubyte *src, ubyte *dest, int width)
1273 {
1274         double  *d = (double *)dest;
1275         uint    *s = (uint *)src;
1276         uint    doubletemp[2];
1277         uint    temp, work;
1278         int     i, num_pixels;
1279
1280         num_pixels = width / 2;
1281         if ( (num_pixels & 0x3) || (((int)src & 0x7) != ((int)dest & 0x7)) ) {
1282                 // not a multiple of 4?  do single pixel at a time
1283                 for (i=0; i<num_pixels; i++) {
1284                         *dest++ = *src;
1285                         *dest++ = *src++;
1286                 }
1287                 return;
1288         }
1289
1290         for (i = 0; i < num_pixels / 4; i++) {
1291                 temp = work = *s++;
1292
1293                 temp = ((temp >> 8) & 0x00FFFF00) | (temp & 0xFF0000FF); // 0xABCDEFGH -> 0xABABCDEF
1294                 temp = ((temp >> 8) & 0x000000FF) | (temp & 0xFFFFFF00); // 0xABABCDEF -> 0xABABCDCD
1295                 doubletemp[0] = temp;
1296
1297                 work = ((work << 8) & 0x00FFFF00) | (work & 0xFF0000FF); // 0xABCDEFGH -> 0xABEFGHGH
1298                 work = ((work << 8) & 0xFF000000) | (work & 0x00FFFFFF); // 0xABEFGHGH -> 0xEFEFGHGH
1299                 doubletemp[1] = work;
1300
1301                 *d = *(double *) &(doubletemp[0]);
1302                 d++;
1303         }
1304 }
1305
1306 //extern void BlitLargeAlign(ubyte *draw_buffer, int dstRowBytes, ubyte *dstPtr, int w, int h, int modulus);
1307
1308 #ifdef MACINTOSH
1309 asm void BlitLargeAlign(ubyte *rSrcPtr, int rDblDStrd, ubyte *rDst1Ptr, int rWidth, int rHeight, int rModulus)
1310 {
1311     stw     r31,-4(SP)          // store non-volatile reg in red zone
1312     addi    r5,r5,-8            // subtract 8 from dst
1313     stw     r30,-8(SP)          // store non-volatile reg in red zone
1314
1315     la      r30,-16(SP)         // calculate copy of local 8-byte variable
1316     sub     r9,r8,r6
1317                                 // rSStrd = modulus - w
1318     add     r31,r5,r4           // dst2 = dstRowBytes + dst1
1319     sub     r4,r4,r6            // r4 = dstRowBytes - w
1320     addi    r7,r7,-1            // subtract 1 from height count
1321     srawi   r6,r6,2             // rWidth = w >> 2
1322     addi    r3,r3,-4            // subtract 4 from src
1323     addi    r6,r6,-1            // subtract 1 from width count
1324     add     r4,r4,r4            // rDblDStrd = 2 * r4
1325
1326 BlitLargeAlignY:                // y count is in r7
1327     lwzu     r10,4(r3)          // load a long into r10
1328     mr       r0,r10             // put a copy in r0
1329     mr       r11,r10
1330 // these are simplified -- can't use 'em    inslwi   r0,r10,16,8
1331 // these are simplified -- can't use 'em    insrwi   r11,r10,16,8
1332     rlwimi   r0,r10,24,8,31
1333     rlwimi   r11,r10,8,8,23
1334     rlwimi   r0,r10,16,24,31
1335     stw      r0,0(r30)
1336     rlwimi   r11,r10,16,0,7
1337     stw      r11,4(r30)
1338     mtctr       r6              // copy x count into the counter
1339     lfd      fp0,0(r30)
1340
1341 BlitLargeAlignX:
1342     lwzu     r10,4(r3)          // load a long into r10
1343     stfdu    fp0,8(r5)
1344     mr       r0,r10             // put a copy in r0
1345     mr       r11,r10
1346 // simplefied   inslwi   r0,r10,16,8
1347 // simplefied   insrwi   r11,r10,16,8
1348     rlwimi   r0,r10,24,8,31
1349     rlwimi   r11,r10,8,8,23
1350     rlwimi   r0,r10,16,24,31
1351     stw      r0,0(r30)
1352     rlwimi   r11,r10,16,0,7
1353     stw      r11,4(r30)
1354     stfdu    fp0,8(r31)
1355     lfd      fp0,0(r30)
1356     bdnz     BlitLargeAlignX    // loop over all x
1357
1358     stfdu    fp0,8(r5)
1359     addic.   r7,r7,-1           // decrement the counter
1360     add      r3,r3,r9
1361                                 // src += sstride
1362     add      r5,r5,r4
1363                                 // dst1 += dstride
1364     stfdu    fp0,8(r31)
1365     add      r31,r31,r4
1366                                 // dst2 += dstride
1367     bne      BlitLargeAlignY    // loop for all y
1368
1369     lwz     r30,-8(SP)          // restore non-volatile regs
1370     lwz     r31,-4(SP)          // restore non-volatile regs
1371     blr                         // return to caller
1372 }
1373
1374 void gr_bm_ubitblt_double(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap *src, grs_bitmap *dest)
1375 {
1376         ubyte * dbits;
1377         ubyte * sbits;
1378         int dstep, i;
1379
1380         sbits = src->bm_data  + (src->bm_rowsize * sy) + sx;
1381         dbits = dest->bm_data + (dest->bm_rowsize * dy) + dx;
1382         dstep = dest->bm_rowsize << gr_bitblt_dest_step_shift;
1383         Assert( !((int)dbits & 0x7) );  // assert to check double word alignment
1384         BlitLargeAlign(sbits, dstep, dbits, src->bm_w, src->bm_h, src->bm_rowsize);
1385 }
1386 #endif
1387
1388 // w and h are the doubled width and height
1389
1390 void gr_bm_ubitblt_double_slow(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap *src, grs_bitmap *dest)
1391 {
1392         ubyte * dbits;
1393         ubyte * sbits;
1394         int dstep, i;
1395
1396         sbits = src->bm_data  + (src->bm_rowsize * sy) + sx;
1397         dbits = dest->bm_data + (dest->bm_rowsize * dy) + dx;
1398         dstep = dest->bm_rowsize << gr_bitblt_dest_step_shift;
1399
1400         for (i=0; i < h; i++ )    {
1401
1402                 gr_linear_movsd_double(sbits, dbits, w);
1403                 dbits += dstep;
1404                 if (i & 1)
1405                         sbits += src->bm_rowsize;
1406         }
1407 }
1408
1409 #endif
1410
1411
1412 // Clipped bitmap ...
1413
1414 void gr_bitmap( int x, int y, grs_bitmap *bm )
1415 {
1416         int dx1=x, dx2=x+bm->bm_w-1;
1417         int dy1=y, dy2=y+bm->bm_h-1;
1418         int sx=0, sy=0;
1419
1420         if ((dx1 >= grd_curcanv->cv_bitmap.bm_w ) || (dx2 < 0)) return;
1421         if ((dy1 >= grd_curcanv->cv_bitmap.bm_h) || (dy2 < 0)) return;
1422         if ( dx1 < 0 ) { sx = -dx1; dx1 = 0; }
1423         if ( dy1 < 0 ) { sy = -dy1; dy1 = 0; }
1424         if ( dx2 >= grd_curcanv->cv_bitmap.bm_w ) { dx2 = grd_curcanv->cv_bitmap.bm_w-1; }
1425         if ( dy2 >= grd_curcanv->cv_bitmap.bm_h ) { dy2 = grd_curcanv->cv_bitmap.bm_h-1; }
1426
1427         // Draw bitmap bm[x,y] into (dx1,dy1)-(dx2,dy2)
1428
1429         gr_bm_ubitblt(dx2-dx1+1,dy2-dy1+1, dx1, dy1, sx, sy, bm, &grd_curcanv->cv_bitmap );
1430
1431 }
1432
1433 //-NOT-used // From linear to SVGA
1434 //-NOT-used void gr_bm_ubitblt02_2x(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1435 //-NOT-used {
1436 //-NOT-used     unsigned char * sbits;
1437 //-NOT-used
1438 //-NOT-used     unsigned int offset, EndingOffset, VideoLocation;
1439 //-NOT-used
1440 //-NOT-used     int sbpr, dbpr, y1, page, BytesToMove;
1441 //-NOT-used
1442 //-NOT-used     sbpr = src->bm_rowsize;
1443 //-NOT-used
1444 //-NOT-used     dbpr = dest->bm_rowsize << gr_bitblt_dest_step_shift;
1445 //-NOT-used
1446 //-NOT-used     VideoLocation = (unsigned int)dest->bm_data + (dest->bm_rowsize * dy) + dx;
1447 //-NOT-used
1448 //-NOT-used     sbits = src->bm_data + ( sbpr*sy ) + sx;
1449 //-NOT-used
1450 //-NOT-used     for (y1=0; y1 < h; y1++ )    {
1451 //-NOT-used
1452 //-NOT-used             page    = VideoLocation >> 16;
1453 //-NOT-used             offset  = VideoLocation & 0xFFFF;
1454 //-NOT-used
1455 //-NOT-used             gr_vesa_setpage( page );
1456 //-NOT-used
1457 //-NOT-used             EndingOffset = offset+w-1;
1458 //-NOT-used
1459 //-NOT-used             if ( EndingOffset <= 0xFFFF )
1460 //-NOT-used             {
1461 //-NOT-used                     gr_linear_rep_movsd_2x( (void *)sbits, (void *)(offset+0xA0000), w );
1462 //-NOT-used
1463 //-NOT-used                     VideoLocation += dbpr;
1464 //-NOT-used                     sbits += sbpr;
1465 //-NOT-used             }
1466 //-NOT-used             else
1467 //-NOT-used             {
1468 //-NOT-used                     BytesToMove = 0xFFFF-offset+1;
1469 //-NOT-used
1470 //-NOT-used                     gr_linear_rep_movsd_2x( (void *)sbits, (void *)(offset+0xA0000), BytesToMove );
1471 //-NOT-used
1472 //-NOT-used                     page++;
1473 //-NOT-used                     gr_vesa_setpage(page);
1474 //-NOT-used
1475 //-NOT-used                     gr_linear_rep_movsd_2x( (void *)(sbits+BytesToMove/2), (void *)0xA0000, EndingOffset - 0xFFFF );
1476 //-NOT-used
1477 //-NOT-used                     VideoLocation += dbpr;
1478 //-NOT-used                     sbits += sbpr;
1479 //-NOT-used             }
1480 //-NOT-used
1481 //-NOT-used
1482 //-NOT-used     }
1483 //-NOT-used }
1484
1485
1486 //-NOT-used // From Linear to Linear
1487 //-NOT-used void gr_bm_ubitblt00_2x(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1488 //-NOT-used {
1489 //-NOT-used     unsigned char * dbits;
1490 //-NOT-used     unsigned char * sbits;
1491 //-NOT-used     //int src_bm_rowsize_2, dest_bm_rowsize_2;
1492 //-NOT-used
1493 //-NOT-used     int i;
1494 //-NOT-used
1495 //-NOT-used     sbits =   src->bm_data  + (src->bm_rowsize * sy) + sx;
1496 //-NOT-used     dbits =   dest->bm_data + (dest->bm_rowsize * dy) + dx;
1497 //-NOT-used
1498 //-NOT-used     // No interlacing, copy the whole buffer.
1499 //-NOT-used     for (i=0; i < h; i++ )    {
1500 //-NOT-used             gr_linear_rep_movsd_2x( sbits, dbits, w );
1501 //-NOT-used
1502 //-NOT-used             sbits += src->bm_rowsize;
1503 //-NOT-used             dbits += dest->bm_rowsize << gr_bitblt_dest_step_shift;
1504 //-NOT-used     }
1505 //-NOT-used }
1506
1507 void gr_bm_ubitblt00_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1508 {
1509         unsigned char * dbits;
1510         unsigned char * sbits;
1511         int i, data_offset;
1512
1513         data_offset = 1;
1514         if (src->bm_flags & BM_FLAG_RLE_BIG)
1515                 data_offset = 2;
1516
1517         sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
1518
1519         for (i=0; i<sy; i++ )
1520                 sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
1521
1522         dbits = dest->bm_data + (dest->bm_rowsize * dy) + dx;
1523
1524         // No interlacing, copy the whole buffer.
1525         for (i=0; i < h; i++ )    {
1526                 gr_rle_expand_scanline( dbits, sbits, sx, sx+w-1 );
1527                 if ( src->bm_flags & BM_FLAG_RLE_BIG )
1528                         sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((i+sy)*data_offset)])));
1529                 else
1530                         sbits += (int)(src->bm_data[4+i+sy]);
1531                 dbits += dest->bm_rowsize << gr_bitblt_dest_step_shift;
1532         }
1533 }
1534
1535 void gr_bm_ubitblt00m_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1536 {
1537         unsigned char * dbits;
1538         unsigned char * sbits;
1539         int i, data_offset;
1540
1541         data_offset = 1;
1542         if (src->bm_flags & BM_FLAG_RLE_BIG)
1543                 data_offset = 2;
1544
1545         sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
1546         for (i=0; i<sy; i++ )
1547                 sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
1548
1549         dbits = dest->bm_data + (dest->bm_rowsize * dy) + dx;
1550
1551         // No interlacing, copy the whole buffer.
1552         for (i=0; i < h; i++ )    {
1553                 gr_rle_expand_scanline_masked( dbits, sbits, sx, sx+w-1 );
1554                 if ( src->bm_flags & BM_FLAG_RLE_BIG )
1555                         sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((i+sy)*data_offset)])));
1556                 else
1557                         sbits += (int)(src->bm_data[4+i+sy]);
1558                 dbits += dest->bm_rowsize << gr_bitblt_dest_step_shift;
1559         }
1560 }
1561
1562 // in rle.c
1563
1564 extern void gr_rle_expand_scanline_generic( grs_bitmap * dest, int dx, int dy, ubyte *src, int x1, int x2  );
1565 extern void gr_rle_expand_scanline_generic_masked( grs_bitmap * dest, int dx, int dy, ubyte *src, int x1, int x2  );
1566 extern void gr_rle_expand_scanline_svga_masked( grs_bitmap * dest, int dx, int dy, ubyte *src, int x1, int x2  );
1567
1568 void gr_bm_ubitblt0x_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1569 {
1570         int i, data_offset;
1571         register int y1;
1572         unsigned char * sbits;
1573
1574         //mprintf( 0, "SVGA RLE!\n" );
1575
1576         data_offset = 1;
1577         if (src->bm_flags & BM_FLAG_RLE_BIG)
1578                 data_offset = 2;
1579
1580         sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
1581         for (i=0; i<sy; i++ )
1582                 sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
1583
1584         for (y1=0; y1 < h; y1++ )    {
1585                 gr_rle_expand_scanline_generic( dest, dx, dy+y1,  sbits, sx, sx+w-1  );
1586                 if ( src->bm_flags & BM_FLAG_RLE_BIG )
1587                         sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((y1+sy)*data_offset)])));
1588                 else
1589                         sbits += (int)src->bm_data[4+y1+sy];
1590         }
1591
1592 }
1593
1594 void gr_bm_ubitblt0xm_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1595 {
1596         int i, data_offset;
1597         register int y1;
1598         unsigned char * sbits;
1599
1600         //mprintf( 0, "SVGA RLE!\n" );
1601
1602         data_offset = 1;
1603         if (src->bm_flags & BM_FLAG_RLE_BIG)
1604                 data_offset = 2;
1605
1606         sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
1607         for (i=0; i<sy; i++ )
1608                 sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
1609
1610         for (y1=0; y1 < h; y1++ )    {
1611                 gr_rle_expand_scanline_generic_masked( dest, dx, dy+y1,  sbits, sx, sx+w-1  );
1612                 if ( src->bm_flags & BM_FLAG_RLE_BIG )
1613                         sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((y1+sy)*data_offset)])));
1614                 else
1615                         sbits += (int)src->bm_data[4+y1+sy];
1616         }
1617
1618 }
1619
1620 #ifdef __MSDOS__
1621 void gr_bm_ubitblt02m_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1622 {
1623         int i, data_offset;
1624         register int y1;
1625         unsigned char * sbits;
1626
1627         //mprintf( 0, "SVGA RLE!\n" );
1628
1629         data_offset = 1;
1630         if (src->bm_flags & BM_FLAG_RLE_BIG)
1631                 data_offset = 2;
1632
1633         sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
1634         for (i=0; i<sy; i++ )
1635                 sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
1636
1637         for (y1=0; y1 < h; y1++ )    {
1638                 gr_rle_expand_scanline_svga_masked( dest, dx, dy+y1,  sbits, sx, sx+w-1  );
1639                 if ( src->bm_flags & BM_FLAG_RLE_BIG )
1640                         sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((y1+sy)*data_offset)])));
1641                 else
1642                         sbits += (int)src->bm_data[4+y1+sy];
1643         }
1644 }
1645 #endif
1646
1647 void gr_bm_ubitblt(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1648 {
1649         register int x1, y1;
1650
1651         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_LINEAR ))
1652         {
1653                 if ( src->bm_flags & BM_FLAG_RLE )
1654                         gr_bm_ubitblt00_rle( w, h, dx, dy, sx, sy, src, dest );
1655                 else
1656                         gr_bm_ubitblt00( w, h, dx, dy, sx, sy, src, dest );
1657                 return;
1658         }
1659
1660 #ifdef OGL
1661         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_OGL ))
1662         {
1663                 ogl_ubitblt(w, h, dx, dy, sx, sy, src, dest);
1664                 return;
1665         }
1666         if ( (src->bm_type == BM_OGL) && (dest->bm_type == BM_LINEAR ))
1667         {
1668                 ogl_ubitblt_tolinear(w, h, dx, dy, sx, sy, src, dest);
1669                 return;
1670         }
1671         if ( (src->bm_type == BM_OGL) && (dest->bm_type == BM_OGL ))
1672         {
1673                 ogl_ubitblt_copy(w, h, dx, dy, sx, sy, src, dest);
1674                 return;
1675         }
1676 #endif
1677
1678 #ifdef D1XD3D
1679         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_DIRECTX ))
1680         {
1681                 Assert ((int)dest->bm_data == BM_D3D_RENDER || (int)dest->bm_data == BM_D3D_DISPLAY);
1682                 Win32_BlitLinearToDirectX_bm (src, sx, sy, w, h, dx, dy, 0);
1683                 return;
1684         }
1685         if ( (src->bm_type == BM_DIRECTX) && (dest->bm_type == BM_LINEAR ))
1686         {
1687                 return;
1688         }
1689         if ( (src->bm_type == BM_DIRECTX) && (dest->bm_type == BM_DIRECTX ))
1690         {
1691                 return;
1692         }
1693 #endif
1694
1695         if ( (src->bm_flags & BM_FLAG_RLE ) && (src->bm_type == BM_LINEAR) ) {
1696                 gr_bm_ubitblt0x_rle(w, h, dx, dy, sx, sy, src, dest );
1697                 return;
1698         }
1699
1700 #ifdef __MSDOS__
1701         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_SVGA ))
1702         {
1703                 gr_bm_ubitblt02( w, h, dx, dy, sx, sy, src, dest );
1704                 return;
1705         }
1706
1707         if ( (src->bm_type == BM_SVGA) && (dest->bm_type == BM_LINEAR ))
1708         {
1709                 gr_bm_ubitblt20( w, h, dx, dy, sx, sy, src, dest );
1710                 return;
1711         }
1712
1713         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_MODEX ))
1714         {
1715                 gr_bm_ubitblt01( w, h, dx+XOFFSET, dy+YOFFSET, sx, sy, src, dest );
1716                 return;
1717         }
1718 #endif
1719
1720 #if defined(POLY_ACC)
1721         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_LINEAR15 ))
1722         {
1723                 ubyte *s = src->bm_data + sy * src->bm_rowsize + sx;
1724                 ushort *t = (ushort *)(dest->bm_data + dy * dest->bm_rowsize + dx * PA_BPP);
1725                 int x;
1726                 pa_flush();
1727                 for(;h--;)
1728                 {
1729                         for(x = 0; x < w; x++)
1730                                 t[x] = pa_clut[s[x]];
1731                         s += src->bm_rowsize;
1732                         t += dest->bm_rowsize / PA_BPP;
1733                 }
1734                 return;
1735         }
1736
1737         if ( (src->bm_type == BM_LINEAR15) && (dest->bm_type == BM_LINEAR15 ))
1738         {
1739                 pa_blit(dest, dx, dy, src, sx, sy, w, h);
1740                 return;
1741         }
1742 #endif
1743
1744         for (y1=0; y1 < h; y1++ )    {
1745                 for (x1=0; x1 < w; x1++ )    {
1746                         gr_bm_pixel( dest, dx+x1, dy+y1, gr_gpixel(src,sx+x1,sy+y1) );
1747                 }
1748         }
1749 }
1750
1751 void gr_bm_bitblt(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1752 {
1753         int dx1=dx, dx2=dx+dest->bm_w-1;
1754         int dy1=dy, dy2=dy+dest->bm_h-1;
1755
1756         int sx1=sx, sx2=sx+src->bm_w-1;
1757         int sy1=sy, sy2=sy+src->bm_h-1;
1758
1759         if ((dx1 >= dest->bm_w ) || (dx2 < 0)) return;
1760         if ((dy1 >= dest->bm_h ) || (dy2 < 0)) return;
1761         if ( dx1 < 0 ) { sx1 += -dx1; dx1 = 0; }
1762         if ( dy1 < 0 ) { sy1 += -dy1; dy1 = 0; }
1763         if ( dx2 >= dest->bm_w ) { dx2 = dest->bm_w-1; }
1764         if ( dy2 >= dest->bm_h ) { dy2 = dest->bm_h-1; }
1765
1766         if ((sx1 >= src->bm_w ) || (sx2 < 0)) return;
1767         if ((sy1 >= src->bm_h ) || (sy2 < 0)) return;
1768         if ( sx1 < 0 ) { dx1 += -sx1; sx1 = 0; }
1769         if ( sy1 < 0 ) { dy1 += -sy1; sy1 = 0; }
1770         if ( sx2 >= src->bm_w ) { sx2 = src->bm_w-1; }
1771         if ( sy2 >= src->bm_h ) { sy2 = src->bm_h-1; }
1772
1773         // Draw bitmap bm[x,y] into (dx1,dy1)-(dx2,dy2)
1774         if ( dx2-dx1+1 < w )
1775                 w = dx2-dx1+1;
1776         if ( dy2-dy1+1 < h )
1777                 h = dy2-dy1+1;
1778         if ( sx2-sx1+1 < w )
1779                 w = sx2-sx1+1;
1780         if ( sy2-sy1+1 < h )
1781                 h = sy2-sy1+1;
1782
1783         gr_bm_ubitblt(w,h, dx1, dy1, sx1, sy1, src, dest );
1784 }
1785
1786 void gr_ubitmap( int x, int y, grs_bitmap *bm )
1787 {
1788         int source, dest;
1789
1790         source = bm->bm_type;
1791         dest = TYPE;
1792
1793         if (source==BM_LINEAR) {
1794                 switch( dest )
1795                 {
1796                 case BM_LINEAR:
1797                         if ( bm->bm_flags & BM_FLAG_RLE )
1798                                 gr_bm_ubitblt00_rle(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap );
1799                         else
1800                                 gr_ubitmap00( x, y, bm );
1801                         return;
1802 #ifdef OGL
1803                 case BM_OGL:
1804                         ogl_ubitmapm(x,y,bm);
1805                         return;
1806 #endif
1807 #ifdef D1XD3D
1808                 case BM_DIRECTX:
1809                         Assert ((int)grd_curcanv->cv_bitmap.bm_data == BM_D3D_RENDER || (int)grd_curcanv->cv_bitmap.bm_data == BM_D3D_DISPLAY);
1810                         Win32_BlitLinearToDirectX_bm(bm, 0, 0, bm->bm_w, bm->bm_h, x, y, 0);
1811                         return;
1812 #endif
1813 #ifdef __MSDOS__
1814                 case BM_SVGA:
1815                         if ( bm->bm_flags & BM_FLAG_RLE )
1816                                 gr_bm_ubitblt0x_rle(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap );
1817                         else
1818                                 gr_vesa_bitmap( bm, &grd_curcanv->cv_bitmap, x, y );
1819                         return;
1820                 case BM_MODEX:
1821                         gr_bm_ubitblt01(bm->bm_w, bm->bm_h, x+XOFFSET, y+YOFFSET, 0, 0, bm, &grd_curcanv->cv_bitmap);
1822                         return;
1823 #endif
1824 #if defined(POLY_ACC)
1825                 case BM_LINEAR15:
1826                         if ( bm->bm_flags & BM_FLAG_RLE )
1827                                 gr_bm_ubitblt05_rle(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap );
1828                         else
1829                                 gr_ubitmap05( x, y, bm);
1830                         return;
1831
1832 #endif
1833                 default:
1834                         gr_ubitmap012( x, y, bm );
1835                         return;
1836                 }
1837         } else  {
1838                 gr_ubitmapGENERIC(x, y, bm);
1839         }
1840 }
1841
1842
1843 void gr_ubitmapm( int x, int y, grs_bitmap *bm )
1844 {
1845         int source, dest;
1846
1847         source = bm->bm_type;
1848         dest = TYPE;
1849
1850         Assert(x+bm->bm_w <= grd_curcanv->cv_w);
1851         Assert(y+bm->bm_h <= grd_curcanv->cv_h);
1852
1853 #ifdef _3DFX
1854         _3dfx_Blit( x, y, bm );
1855         if ( _3dfx_skip_ddraw )
1856                 return;
1857 #endif
1858
1859         if (source==BM_LINEAR) {
1860                 switch( dest )
1861                 {
1862                 case BM_LINEAR:
1863                         if ( bm->bm_flags & BM_FLAG_RLE )
1864                                 gr_bm_ubitblt00m_rle(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap );
1865                         else
1866                                 gr_ubitmap00m( x, y, bm );
1867                         return;
1868 #ifdef __MSDOS__
1869                 case BM_SVGA:
1870                         if (bm->bm_flags & BM_FLAG_RLE)
1871                                 gr_bm_ubitblt02m_rle(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap);
1872                         //gr_bm_ubitblt0xm_rle(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap);
1873                         else
1874                                 gr_bm_ubitblt02m(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap);
1875                         //gr_ubitmapGENERICm(x, y, bm);
1876                         return;
1877                 case BM_MODEX:
1878                         gr_bm_ubitblt01m(bm->bm_w, bm->bm_h, x+XOFFSET, y+YOFFSET, 0, 0, bm, &grd_curcanv->cv_bitmap);
1879                         return;
1880 #endif
1881 #if defined(POLY_ACC)
1882                 case BM_LINEAR15:
1883                         if ( bm->bm_flags & BM_FLAG_RLE )
1884                                 gr_bm_ubitblt05m_rle(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap );
1885                         else
1886                                 gr_ubitmap05m( x, y, bm );
1887                         return;
1888 #endif
1889
1890                 default:
1891                         gr_ubitmap012m( x, y, bm );
1892                         return;
1893                 }
1894         } else {
1895                 gr_ubitmapGENERICm(x, y, bm);
1896         }
1897 }
1898
1899
1900 void gr_bitmapm( int x, int y, grs_bitmap *bm )
1901 {
1902         int dx1=x, dx2=x+bm->bm_w-1;
1903         int dy1=y, dy2=y+bm->bm_h-1;
1904         int sx=0, sy=0;
1905
1906         if ((dx1 >= grd_curcanv->cv_bitmap.bm_w ) || (dx2 < 0)) return;
1907         if ((dy1 >= grd_curcanv->cv_bitmap.bm_h) || (dy2 < 0)) return;
1908         if ( dx1 < 0 ) { sx = -dx1; dx1 = 0; }
1909         if ( dy1 < 0 ) { sy = -dy1; dy1 = 0; }
1910         if ( dx2 >= grd_curcanv->cv_bitmap.bm_w ) { dx2 = grd_curcanv->cv_bitmap.bm_w-1; }
1911         if ( dy2 >= grd_curcanv->cv_bitmap.bm_h ) { dy2 = grd_curcanv->cv_bitmap.bm_h-1; }
1912
1913         // Draw bitmap bm[x,y] into (dx1,dy1)-(dx2,dy2)
1914
1915         if ( (bm->bm_type == BM_LINEAR) && (grd_curcanv->cv_bitmap.bm_type == BM_LINEAR ))
1916         {
1917                 if ( bm->bm_flags & BM_FLAG_RLE )
1918                         gr_bm_ubitblt00m_rle(dx2-dx1+1,dy2-dy1+1, dx1, dy1, sx, sy, bm, &grd_curcanv->cv_bitmap );
1919                 else
1920                         gr_bm_ubitblt00m(dx2-dx1+1,dy2-dy1+1, dx1, dy1, sx, sy, bm, &grd_curcanv->cv_bitmap );
1921                 return;
1922         }
1923 #ifdef __MSDOS__
1924         else if ( (bm->bm_type == BM_LINEAR) && (grd_curcanv->cv_bitmap.bm_type == BM_SVGA ))
1925         {
1926                 gr_bm_ubitblt02m(dx2-dx1+1,dy2-dy1+1, dx1, dy1, sx, sy, bm, &grd_curcanv->cv_bitmap );
1927                 return;
1928         }
1929 #endif
1930
1931         gr_bm_ubitbltm(dx2-dx1+1,dy2-dy1+1, dx1, dy1, sx, sy, bm, &grd_curcanv->cv_bitmap );
1932
1933 }
1934
1935 void gr_bm_ubitbltm(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1936 {
1937         register int x1, y1;
1938         ubyte c;
1939
1940 #ifdef OGL
1941         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_OGL ))
1942         {
1943                 ogl_ubitblt(w, h, dx, dy, sx, sy, src, dest);
1944                 return;
1945         }
1946         if ( (src->bm_type == BM_OGL) && (dest->bm_type == BM_LINEAR ))
1947         {
1948                 ogl_ubitblt_tolinear(w, h, dx, dy, sx, sy, src, dest);
1949                 return;
1950         }
1951         if ( (src->bm_type == BM_OGL) && (dest->bm_type == BM_OGL ))
1952         {
1953                 ogl_ubitblt_copy(w, h, dx, dy, sx, sy, src, dest);
1954                 return;
1955         }
1956 #endif
1957 #ifdef D1XD3D
1958         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_DIRECTX ))
1959         {
1960                 Assert ((int)dest->bm_data == BM_D3D_RENDER || (int)dest->bm_data == BM_D3D_DISPLAY);
1961                 Win32_BlitLinearToDirectX_bm (src, sx, sy, w, h, dx, dy, 1);
1962                 return;
1963         }
1964         if ( (src->bm_type == BM_DIRECTX) && (dest->bm_type == BM_DIRECTX ))
1965         {
1966                 Assert ((int)src->bm_data == BM_D3D_RENDER || (int)src->bm_data == BM_D3D_DISPLAY);
1967                 //Win32_BlitDirectXToDirectX (w, h, dx, dy, sx, sy, src->bm_data, dest->bm_data, 0);
1968                 return;
1969         }
1970 #endif
1971 #if defined(POLY_ACC)
1972         if(src->bm_type == BM_LINEAR && dest->bm_type == BM_LINEAR15)
1973         {
1974                 ubyte *s;
1975                 ushort *d;
1976                 ushort u;
1977                 int smod, dmod;
1978
1979                 pa_flush();
1980                 s = (ubyte *)(src->bm_data + src->bm_rowsize * sy + sx);
1981                 smod = src->bm_rowsize - w;
1982                 d = (ushort *)(dest->bm_data + dest->bm_rowsize * dy + dx * PA_BPP);
1983                 dmod = dest->bm_rowsize / PA_BPP - w;
1984                 for (; h--;) {
1985                         for (x1=w; x1--; ) {
1986                                 if ((u = *s) != TRANSPARENCY_COLOR)
1987                                         *d = pa_clut[u];
1988                                 ++s;
1989                                 ++d;
1990                         }
1991                         s += smod;
1992                         d += dmod;
1993                 }
1994         }
1995
1996         if(src->bm_type == BM_LINEAR15)
1997         {
1998                 Assert(src->bm_type == dest->bm_type);         // I don't support 15 to 8 yet.
1999                 pa_blit_transparent(dest, dx, dy, src, sx, sy, w, h);
2000                 return;
2001         }
2002 #endif
2003
2004         for (y1=0; y1 < h; y1++ )    {
2005                 for (x1=0; x1 < w; x1++ )    {
2006                         if ((c=gr_gpixel(src,sx+x1,sy+y1))!=TRANSPARENCY_COLOR)
2007                                 gr_bm_pixel( dest, dx+x1, dy+y1,c  );
2008                 }
2009         }
2010 }
2011
2012
2013 // rescalling bitmaps, 10/14/99 Jan Bobrowski jb@wizard.ae.krakow.pl
2014
2015 inline void scale_line(byte *in, byte *out, int ilen, int olen)
2016 {
2017         int a = olen/ilen, b = olen%ilen;
2018         int c = 0, i;
2019         byte *end = out + olen;
2020         while(out<end) {
2021                 i = a;
2022                 c += b;
2023                 if(c >= ilen) {
2024                         c -= ilen;
2025                         goto inside;
2026                 }
2027                 while(--i>=0) {
2028                 inside:
2029                         *out++ = *in;
2030                 }
2031                 in++;
2032         }
2033 }
2034
2035 void gr_bitmap_scale_to(grs_bitmap *src, grs_bitmap *dst)
2036 {
2037         byte *s = src->bm_data;
2038         byte *d = dst->bm_data;
2039         int h = src->bm_h;
2040         int a = dst->bm_h/h, b = dst->bm_h%h;
2041         int c = 0, i, y;
2042
2043         for(y=0; y<h; y++) {
2044                 i = a;
2045                 c += b;
2046                 if(c >= h) {
2047                         c -= h;
2048                         goto inside;
2049                 }
2050                 while(--i>=0) {
2051                 inside:
2052                         scale_line(s, d, src->bm_w, dst->bm_w);
2053                         d += dst->bm_rowsize;
2054                 }
2055                 s += src->bm_rowsize;
2056         }
2057 }
2058
2059 void show_fullscr(grs_bitmap *bm)
2060 {
2061         grs_bitmap * const scr = &grd_curcanv->cv_bitmap;
2062
2063 #ifdef OGL
2064         if(bm->bm_type == BM_LINEAR && scr->bm_type == BM_OGL) {
2065                 ogl_ubitblt_i(scr->bm_w,scr->bm_h,0,0,bm->bm_w,bm->bm_h,0,0,bm,scr);//use opengl to scale, faster and saves ram. -MPM
2066                 return;
2067         }
2068 #endif
2069         if(scr->bm_type != BM_LINEAR) {
2070                 grs_bitmap *tmp = gr_create_bitmap(scr->bm_w, scr->bm_h);
2071                 gr_bitmap_scale_to(bm, tmp);
2072                 gr_bitmap(0, 0, tmp);
2073                 gr_free_bitmap(tmp);
2074                 return;
2075         }
2076         gr_bitmap_scale_to(bm, scr);
2077 }