2d/bitblt.c

   1 /* $Id: bitblt.c,v 1.8 2002-09-04 23:29:53 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, unsigned 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
 473 #ifdef __MSDOS__
 474
 475 static void modex_copy_column(ubyte * src, ubyte * dest, int num_pixels, int src_rowsize, int dest_rowsize );
 476
 477 #if !defined(NO_ASM) && defined(__WATCOMC__)
 478
 479 #pragma aux modex_copy_column parm [esi] [edi] [ecx] [ebx] [edx] modify exact [ecx esi edi] = \
 480 "nextpixel:"            \
 481     "mov    al,[esi]"   \
 482     "add    esi, ebx"   \
 483     "mov    [edi], al"  \
 484     "add    edi, edx"   \
 485     "dec    ecx"        \
 486     "jne    nextpixel"
 487
 488 #elif !defined(NO_ASM) && defined(__GNUC__)
 489
 490 static inline void modex_copy_column(ubyte * src, ubyte * dest, int num_pixels, int src_rowsize, int dest_rowsize ) {
 491 /*#pragma aux modex_copy_column parm [esi] [edi] [ecx] [ebx] [edx] modify exact [ecx esi edi] = */
 492  __asm__ __volatile__ (
 493 "0: ;"
 494     "movb   (%%esi), %%al;"
 495     "addl   %%ebx, %%esi;"
 496     "movb   %%al, (%%edi);"
 497     "addl   %%edx, %%edi;"
 498     "decl   %%ecx;"
 499     "jne    0b"
 500  : : "S" (src), "D" (dest), "c" (num_pixels), "b" (src_rowsize), "d" (dest_rowsize)
 501  : "%eax", "%ecx", "%esi", "%edi");
 502 }
 503
 504 #else
 505
 506 static void modex_copy_column(ubyte * src, ubyte * dest, int num_pixels, int src_rowsize, int dest_rowsize )
 507 {
 508         src = src;
 509         dest = dest;
 510         num_pixels = num_pixels;
 511         src_rowsize = src_rowsize;
 512         dest_rowsize = dest_rowsize;
 513         Int3();
 514 }
 515
 516 #endif
 517
 518
 519 static void modex_copy_column_m(ubyte * src, ubyte * dest, int num_pixels, int src_rowsize, int dest_rowsize );
 520
 521 #if !defined(NO_ASM) && defined(__WATCOMC__)
 522
 523 #pragma aux modex_copy_column_m parm [esi] [edi] [ecx] [ebx] [edx] modify exact [ecx esi edi] = \
 524 "nextpixel:"            \
 525     "mov    al,[esi]"   \
 526     "add    esi, ebx"   \
 527     "cmp    al, 255"    \
 528     "je skip_itx"       \
 529     "mov    [edi], al"  \
 530 "skip_itx:"             \
 531     "add    edi, edx"   \
 532     "dec    ecx"        \
 533     "jne    nextpixel"
 534
 535 #elif !defined(NO_ASM) && defined(__GNUC__)
 536
 537 static inline void modex_copy_column_m(ubyte * src, ubyte * dest, int num_pixels, int src_rowsize, int dest_rowsize ) {
 538 /* #pragma aux modex_copy_column_m parm [esi] [edi] [ecx] [ebx] [edx] modify exact [ecx esi edi] = */
 539  int dummy[3];
 540  __asm__ __volatile__ (
 541 "0: ;"
 542     "movb    (%%esi), %%al;"
 543     "addl    %%ebx, %%esi;"
 544     "cmpb    $255, %%al;"
 545     "je 1f;"
 546     "movb   %%al, (%%edi);"
 547 "1: ;"
 548     "addl   %%edx, %%edi;"
 549     "decl   %%ecx;"
 550     "jne    0b"
 551  : "=c" (dummy[0]), "=S" (dummy[1]), "=D" (dummy[2])
 552  : "1" (src), "2" (dest), "0" (num_pixels), "b" (src_rowsize), "d" (dest_rowsize)
 553  :      "%eax" );
 554 }
 555
 556 #else
 557
 558 static void modex_copy_column_m(ubyte * src, ubyte * dest, int num_pixels, int src_rowsize, int dest_rowsize )
 559 {
 560         src = src;
 561         dest = dest;
 562         num_pixels = num_pixels;
 563         src_rowsize = src_rowsize;
 564         dest_rowsize = dest_rowsize;
 565         Int3();
 566 }
 567
 568 #endif
 569
 570 #endif /* __MSDOS__ */
 571
 572 void gr_ubitmap00( int x, int y, grs_bitmap *bm )
 573 {
 574         register int y1;
 575         int dest_rowsize;
 576
 577         unsigned char * dest;
 578         unsigned char * src;
 579
 580         dest_rowsize=grd_curcanv->cv_bitmap.bm_rowsize << gr_bitblt_dest_step_shift;
 581         dest = &(grd_curcanv->cv_bitmap.bm_data[ dest_rowsize*y+x ]);
 582
 583         src = bm->bm_data;
 584
 585         for (y1=0; y1 < bm->bm_h; y1++ )    {
 586                 if (gr_bitblt_double)
 587                         gr_linear_rep_movsd_2x( src, dest, bm->bm_w );
 588                 else
 589                         gr_linear_movsd( src, dest, bm->bm_w );
 590                 src += bm->bm_rowsize;
 591                 dest+= (int)(dest_rowsize);
 592         }
 593 }
 594
 595 void gr_ubitmap00m( int x, int y, grs_bitmap *bm )
 596 {
 597         register int y1;
 598         int dest_rowsize;
 599
 600         unsigned char * dest;
 601         unsigned char * src;
 602
 603         dest_rowsize=grd_curcanv->cv_bitmap.bm_rowsize << gr_bitblt_dest_step_shift;
 604         dest = &(grd_curcanv->cv_bitmap.bm_data[ dest_rowsize*y+x ]);
 605
 606         src = bm->bm_data;
 607
 608         if (gr_bitblt_fade_table==NULL) {
 609                 for (y1=0; y1 < bm->bm_h; y1++ )    {
 610                         gr_linear_rep_movsdm( src, dest, bm->bm_w );
 611                         src += bm->bm_rowsize;
 612                         dest+= (int)(dest_rowsize);
 613                 }
 614         } else {
 615                 for (y1=0; y1 < bm->bm_h; y1++ )    {
 616                         gr_linear_rep_movsdm_faded( src, dest, bm->bm_w, gr_bitblt_fade_table[y1+y] );
 617                         src += bm->bm_rowsize;
 618                         dest+= (int)(dest_rowsize);
 619                 }
 620         }
 621 }
 622
 623 #if 0
 624 "       jmp     aligned4        "   \
 625 "       mov eax, edi            "   \
 626 "       and eax, 11b            "   \
 627 "       jz      aligned4        "   \
 628 "       mov ebx, 4              "   \
 629 "       sub ebx, eax            "   \
 630 "       sub ecx, ebx            "   \
 631 "alignstart:                    "   \
 632 "       mov al, [esi]           "   \
 633 "       add esi, 4              "   \
 634 "       mov [edi], al           "   \
 635 "       inc edi                 "   \
 636 "       dec ebx                 "   \
 637 "       jne alignstart          "   \
 638 "aligned4:                      "
 639 #endif
 640
 641 #ifdef __MSDOS__
 642
 643 static void modex_copy_scanline( ubyte * src, ubyte * dest, int npixels );
 644
 645 #if !defined(NO_ASM) && defined(__WATCOMC__)
 646
 647 #pragma aux modex_copy_scanline parm [esi] [edi] [ecx] modify exact [ecx esi edi eax ebx edx] = \
 648 "       mov ebx, ecx            "   \
 649 "       and ebx, 11b            "   \
 650 "       shr ecx, 2              "   \
 651 "       cmp ecx, 0              "   \
 652 "       je      no2group        "   \
 653 "next4pixels:                   "   \
 654 "       mov al, [esi+8]         "   \
 655 "       mov ah, [esi+12]        "   \
 656 "       shl eax, 16             "   \
 657 "       mov al, [esi]           "   \
 658 "       mov ah, [esi+4]         "   \
 659 "       mov [edi], eax          "   \
 660 "       add esi, 16             "   \
 661 "       add edi, 4              "   \
 662 "       dec ecx                 "   \
 663 "       jne next4pixels         "   \
 664 "no2group:                      "   \
 665 "       cmp ebx, 0              "   \
 666 "       je      done2           "   \
 667 "finishend:                     "   \
 668 "       mov al, [esi]           "   \
 669 "       add esi, 4              "   \
 670 "       mov [edi], al           "   \
 671 "       inc edi                 "   \
 672 "       dec ebx                 "   \
 673 "       jne finishend           "   \
 674 "done2:                         ";
 675
 676 #elif !defined (NO_ASM) && defined(__GNUC__)
 677
 678 static inline void modex_copy_scanline( ubyte * src, ubyte * dest, int npixels ) {
 679 /* #pragma aux modex_copy_scanline parm [esi] [edi] [ecx] modify exact [ecx esi edi eax ebx edx] */
 680 int dummy[3];
 681  __asm__ __volatile__ (
 682 "       movl %%ecx, %%ebx;"
 683 "       andl $3, %%ebx;"
 684 "       shrl $2, %%ecx;"
 685 "       cmpl $0, %%ecx;"
 686 "       je   1f;"
 687 "0: ;"
 688 "       movb 8(%%esi), %%al;"
 689 "       movb 12(%%esi), %%ah;"
 690 "       shll $16, %%eax;"
 691 "       movb (%%esi), %%al;"
 692 "       movb 4(%%esi), %%ah;"
 693 "       movl %%eax, (%%edi);"
 694 "       addl $16, %%esi;"
 695 "       addl $4, %%edi;"
 696 "       decl %%ecx;"
 697 "       jne 0b;"
 698 "1: ;"
 699 "       cmpl $0, %%ebx;"
 700 "       je      3f;"
 701 "2: ;"
 702 "       movb (%%esi), %%al;"
 703 "       addl $4, %%esi;"
 704 "       movb %%al, (%%edi);"
 705 "       incl %%edi;"
 706 "       decl %%ebx;"
 707 "       jne 2b;"
 708 "3:"
 709  : "=c" (dummy[0]), "=S" (dummy[1]), "=D" (dummy[2])
 710  : "1" (src), "2" (dest), "0" (npixels)
 711  :      "%eax", "%ebx", "%edx" );
 712 }
 713
 714 #else
 715
 716 static void modex_copy_scanline( ubyte * src, ubyte * dest, int npixels )
 717 {
 718         src = src;
 719         dest = dest;
 720         npixels = npixels;
 721         Int3();
 722 }
 723
 724 #endif
 725
 726 static void modex_copy_scanline_2x( ubyte * src, ubyte * dest, int npixels );
 727
 728 #if !defined(NO_ASM) && defined(__WATCOMC__)
 729
 730 #pragma aux modex_copy_scanline_2x parm [esi] [edi] [ecx] modify exact [ecx esi edi eax ebx edx] = \
 731 "       mov ebx, ecx            "   \
 732 "       and ebx, 11b            "   \
 733 "       shr ecx, 2              "   \
 734 "       cmp ecx, 0              "   \
 735 "       je      no2group        "   \
 736 "next4pixels:                   "   \
 737 "       mov al, [esi+4]         "   \
 738 "       mov ah, [esi+6]         "   \
 739 "       shl eax, 16             "   \
 740 "       mov al, [esi]           "   \
 741 "       mov ah, [esi+2]         "   \
 742 "       mov [edi], eax          "   \
 743 "       add esi, 8              "   \
 744 "       add edi, 4              "   \
 745 "       dec ecx                 "   \
 746 "       jne next4pixels         "   \
 747 "no2group:                      "   \
 748 "       cmp ebx, 0              "   \
 749 "       je      done2           "   \
 750 "finishend:                     "   \
 751 "       mov al, [esi]           "   \
 752 "       add esi, 2              "   \
 753 "       mov [edi], al           "   \
 754 "       inc edi                 "   \
 755 "       dec ebx                 "   \
 756 "       jne finishend           "   \
 757 "done2:                         ";
 758
 759 #elif !defined(NO_ASM) && defined(__GNUC__)
 760
 761 static inline void modex_copy_scanline_2x( ubyte * src, ubyte * dest, int npixels ) {
 762 /* #pragma aux modex_copy_scanline_2x parm [esi] [edi] [ecx] modify exact [ecx esi edi eax ebx edx] = */
 763 int dummy[3];
 764  __asm__ __volatile__ (
 765 "       movl %%ecx, %%ebx;"
 766 "       andl $3, %%ebx;"
 767 "       shrl $2, %%ecx;"
 768 "       cmpl $0, %%ecx;"
 769 "       je 1f;"
 770 "0: ;"
 771 "       movb 4(%%esi), %%al;"
 772 "       movb 6(%%esi), %%ah;"
 773 "       shll $16, %%eax;"
 774 "       movb (%%esi), %%al;"
 775 "       movb 2(%%esi), %%ah;"
 776 "       movl %%eax, (%%edi);"
 777 "       addl $8, %%esi;"
 778 "       addl $4, %%edi;"
 779 "       decl %%ecx;"
 780 "       jne 0b;"
 781 "1: ;"
 782 "       cmp $0, %%ebx;"
 783 "       je  3f;"
 784 "2:"
 785 "       movb (%%esi),%%al;"
 786 "       addl $2, %%esi;"
 787 "       movb %%al, (%%edi);"
 788 "       incl %%edi;"
 789 "       decl %%ebx;"
 790 "       jne 2b;"
 791 "3:"
 792  : "=c" (dummy[0]), "=S" (dummy[1]), "=D" (dummy[2])
 793  : "1" (src), "2" (dest), "0" (npixels)
 794  :      "%eax", "%ebx", "%edx" );
 795 }
 796
 797 #else
 798
 799 static void modex_copy_scanline_2x( ubyte * src, ubyte * dest, int npixels )
 800 {
 801         src = src;
 802         dest = dest;
 803         npixels = npixels;
 804         Int3();
 805 }
 806
 807 #endif
 808
 809
 810 // From Linear to ModeX
 811 void gr_bm_ubitblt01(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
 812 {
 813         ubyte * dbits;
 814         ubyte * sbits;
 815         int sstep,dstep;
 816         int y,plane;
 817         int w1;
 818
 819         if ( w < 4 ) return;
 820
 821         sstep = src->bm_rowsize;
 822         dstep = dest->bm_rowsize << gr_bitblt_dest_step_shift;
 823
 824         if (!gr_bitblt_double) {
 825                 for (plane=0; plane<4; plane++ ) {
 826                         gr_modex_setplane( (plane+dx)&3 );
 827                         sbits = src->bm_data + (src->bm_rowsize * sy) + sx + plane;
 828                         dbits = &gr_video_memory[(dest->bm_rowsize * dy) + ((plane+dx)/4) ];
 829                         w1 = w >> 2;
 830                         if ( (w&3) > plane ) w1++;
 831                         for (y=dy; y < dy+h; y++ ) {
 832                                 modex_copy_scanline( sbits, dbits, w1 );
 833                                 dbits += dstep;
 834                                 sbits += sstep;
 835                         }
 836                 }
 837         } else {
 838                 for (plane=0; plane<4; plane++ ) {
 839                         gr_modex_setplane( (plane+dx)&3 );
 840                         sbits = src->bm_data + (src->bm_rowsize * sy) + sx + plane/2;
 841                         dbits = &gr_video_memory[(dest->bm_rowsize * dy) + ((plane+dx)/4) ];
 842                         w1 = w >> 2;
 843                         if ( (w&3) > plane ) w1++;
 844                         for (y=dy; y < dy+h; y++ ) {
 845                                 modex_copy_scanline_2x( sbits, dbits, w1 );
 846                                 dbits += dstep;
 847                                 sbits += sstep;
 848                         }
 849                 }
 850         }
 851 }
 852
 853
 854 // From Linear to ModeX masked
 855 void gr_bm_ubitblt01m(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
 856 {
 857         //ubyte * dbits1;
 858         //ubyte * sbits1;
 859
 860         ubyte * dbits;
 861         ubyte * sbits;
 862
 863         int x;
 864         //int y;
 865
 866         sbits =   src->bm_data  + (src->bm_rowsize * sy) + sx;
 867         dbits =   &gr_video_memory[(dest->bm_rowsize * dy) + dx/4];
 868
 869         for (x=dx; x < dx+w; x++ ) {
 870                 gr_modex_setplane( x&3 );
 871
 872                 //sbits1 = sbits;
 873                 //dbits1 = dbits;
 874                 //for (y=0; y < h; y++ )    {
 875                 //      *dbits1 = *sbits1;
 876                 //      sbits1 += src_bm_rowsize;
 877                 //      dbits1 += dest_bm_rowsize;
 878                 //}
 879                 modex_copy_column_m(sbits, dbits, h, src->bm_rowsize, dest->bm_rowsize << gr_bitblt_dest_step_shift );
 880
 881                 sbits++;
 882                 if ( (x&3)==3 )
 883                         dbits++;
 884         }
 885 }
 886
 887 #endif /* __MSDOS__ */
 888
 889
 890 void gr_ubitmap012( int x, int y, grs_bitmap *bm )
 891 {
 892         register int x1, y1;
 893         unsigned char * src;
 894
 895         src = bm->bm_data;
 896
 897         for (y1=y; y1 < (y+bm->bm_h); y1++ )    {
 898                 for (x1=x; x1 < (x+bm->bm_w); x1++ )    {
 899                         gr_setcolor( *src++ );
 900                         gr_upixel( x1, y1 );
 901                 }
 902         }
 903 }
 904
 905 void gr_ubitmap012m( int x, int y, grs_bitmap *bm )
 906 {
 907         register int x1, y1;
 908         unsigned char * src;
 909
 910         src = bm->bm_data;
 911
 912         for (y1=y; y1 < (y+bm->bm_h); y1++ ) {
 913                 for (x1=x; x1 < (x+bm->bm_w); x1++ ) {
 914                         if ( *src != TRANSPARENCY_COLOR ) {
 915                                 gr_setcolor( *src );
 916                                 gr_upixel( x1, y1 );
 917                         }
 918                         src++;
 919                 }
 920         }
 921 }
 922
 923 #if defined(POLY_ACC)
 924 void gr_ubitmap05( int x, int y, grs_bitmap *bm )
 925 {
 926         register int x1, y1;
 927         unsigned char *src;
 928         short *dst;
 929         int mod;
 930
 931         pa_flush();
 932         src = bm->bm_data;
 933         dst = (short *)(DATA + y * ROWSIZE + x * PA_BPP);
 934         mod = ROWSIZE / 2 - bm->bm_w;
 935
 936         for (y1=y; y1 < (y+bm->bm_h); y1++ )    {
 937                 for (x1=x; x1 < (x+bm->bm_w); x1++ )    {
 938                         *dst++ = pa_clut[*src++];
 939                 }
 940                 dst += mod;
 941         }
 942 }
 943
 944 void gr_ubitmap05m( int x, int y, grs_bitmap *bm )
 945 {
 946         register int x1, y1;
 947         unsigned char *src;
 948         short *dst;
 949         int mod;
 950
 951         pa_flush();
 952         src = bm->bm_data;
 953         dst = (short *)(DATA + y * ROWSIZE + x * PA_BPP);
 954         mod = ROWSIZE / 2 - bm->bm_w;
 955
 956         for (y1=y; y1 < (y+bm->bm_h); y1++ )    {
 957                 for (x1=x; x1 < (x+bm->bm_w); x1++ )    {
 958                         if ( *src != TRANSPARENCY_COLOR )   {
 959                                 *dst = pa_clut[*src];
 960                         }
 961                         src++;
 962                         ++dst;
 963                 }
 964                 dst += mod;
 965         }
 966 }
 967
 968 void gr_bm_ubitblt05_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
 969 {
 970         unsigned short * dbits;
 971         unsigned char * sbits, scanline[640];
 972         int i, data_offset, j, nextrow;
 973
 974         pa_flush();
 975         nextrow=dest->bm_rowsize/PA_BPP;
 976
 977         data_offset = 1;
 978         if (src->bm_flags & BM_FLAG_RLE_BIG)
 979                 data_offset = 2;
 980
 981         sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
 982         for (i=0; i<sy; i++ )
 983                 sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
 984
 985         dbits = (unsigned short *)(dest->bm_data + (dest->bm_rowsize * dy) + dx*PA_BPP);
 986
 987         // No interlacing, copy the whole buffer.
 988         for (i=0; i < h; i++ )    {
 989                 gr_rle_expand_scanline( scanline, sbits, sx, sx+w-1 );
 990                 for(j = 0; j != w; ++j)
 991                         dbits[j] = pa_clut[scanline[j]];
 992                 if ( src->bm_flags & BM_FLAG_RLE_BIG )
 993                         sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((i+sy)*data_offset)])));
 994                 else
 995                         sbits += (int)(src->bm_data[4+i+sy]);
 996                 dbits += nextrow;
 997         }
 998 }
 999
1000 void gr_bm_ubitblt05m_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1001 {
1002         unsigned short * dbits;
1003         unsigned char * sbits, scanline[640];
1004         int i, data_offset, j, nextrow;
1005
1006         pa_flush();
1007         nextrow=dest->bm_rowsize/PA_BPP;
1008         data_offset = 1;
1009         if (src->bm_flags & BM_FLAG_RLE_BIG)
1010                 data_offset = 2;
1011
1012         sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
1013         for (i=0; i<sy; i++ )
1014                 sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
1015
1016         dbits = (unsigned short *)(dest->bm_data + (dest->bm_rowsize * dy) + dx*PA_BPP);
1017
1018         // No interlacing, copy the whole buffer.
1019         for (i=0; i < h; i++ )    {
1020                 gr_rle_expand_scanline( scanline, sbits, sx, sx+w-1 );
1021                 for(j = 0; j != w; ++j)
1022                         if(scanline[j] != TRANSPARENCY_COLOR)
1023                                 dbits[j] = pa_clut[scanline[j]];
1024                 if ( src->bm_flags & BM_FLAG_RLE_BIG )
1025                         sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((i+sy)*data_offset)])));
1026                 else
1027                         sbits += (int)(src->bm_data[4+i+sy]);
1028                 dbits += nextrow;
1029         }
1030 }
1031 #endif
1032
1033 void gr_ubitmapGENERIC(int x, int y, grs_bitmap * bm)
1034 {
1035         register int x1, y1;
1036
1037         for (y1=0; y1 < bm->bm_h; y1++ )    {
1038                 for (x1=0; x1 < bm->bm_w; x1++ )    {
1039                         gr_setcolor( gr_gpixel(bm,x1,y1) );
1040                         gr_upixel( x+x1, y+y1 );
1041                 }
1042         }
1043 }
1044
1045 void gr_ubitmapGENERICm(int x, int y, grs_bitmap * bm)
1046 {
1047         register int x1, y1;
1048         ubyte c;
1049
1050         for (y1=0; y1 < bm->bm_h; y1++ ) {
1051                 for (x1=0; x1 < bm->bm_w; x1++ ) {
1052                         c = gr_gpixel(bm,x1,y1);
1053                         if ( c != TRANSPARENCY_COLOR ) {
1054                                 gr_setcolor( c );
1055                                 gr_upixel( x+x1, y+y1 );
1056                         }
1057                 }
1058         }
1059 }
1060
1061
1062 #ifdef __MSDOS__
1063 // From linear to SVGA
1064 void gr_bm_ubitblt02(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1065 {
1066         unsigned char * sbits;
1067
1068         unsigned int offset, EndingOffset, VideoLocation;
1069
1070         int sbpr, dbpr, y1, page, BytesToMove;
1071
1072         sbpr = src->bm_rowsize;
1073
1074         dbpr = dest->bm_rowsize << gr_bitblt_dest_step_shift;
1075
1076         VideoLocation = (unsigned int)dest->bm_data + (dest->bm_rowsize * dy) + dx;
1077
1078         sbits = src->bm_data + ( sbpr*sy ) + sx;
1079
1080         for (y1=0; y1 < h; y1++ )    {
1081
1082                 page    = VideoLocation >> 16;
1083                 offset  = VideoLocation & 0xFFFF;
1084
1085                 gr_vesa_setpage( page );
1086
1087                 EndingOffset = offset+w-1;
1088
1089                 if ( EndingOffset <= 0xFFFF )
1090                 {
1091                         if ( gr_bitblt_double )
1092                                 gr_linear_rep_movsd_2x( (void *)sbits, (void *)(offset+0xA0000), w );
1093                         else
1094                                 gr_linear_movsd( (void *)sbits, (void *)(offset+0xA0000), w );
1095
1096                         VideoLocation += dbpr;
1097                         sbits += sbpr;
1098                 }
1099                 else
1100                 {
1101                         BytesToMove = 0xFFFF-offset+1;
1102
1103                         if ( gr_bitblt_double )
1104                                 gr_linear_rep_movsd_2x( (void *)sbits, (void *)(offset+0xA0000), BytesToMove );
1105                         else
1106                                 gr_linear_movsd( (void *)sbits, (void *)(offset+0xA0000), BytesToMove );
1107
1108                         page++;
1109                         gr_vesa_setpage(page);
1110
1111                         if ( gr_bitblt_double )
1112                                 gr_linear_rep_movsd_2x( (void *)(sbits+BytesToMove/2), (void *)0xA0000, EndingOffset - 0xFFFF );
1113                         else
1114                                 gr_linear_movsd( (void *)(sbits+BytesToMove), (void *)0xA0000, EndingOffset - 0xFFFF );
1115
1116                         VideoLocation += dbpr;
1117                         sbits += sbpr;
1118                 }
1119         }
1120 }
1121 #endif
1122
1123 #ifdef __MSDOS__
1124
1125 void gr_bm_ubitblt02m(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1126 {
1127         unsigned char * sbits;
1128
1129         unsigned int offset, EndingOffset, VideoLocation;
1130
1131         int sbpr, dbpr, y1, page, BytesToMove;
1132
1133         sbpr = src->bm_rowsize;
1134
1135         dbpr = dest->bm_rowsize << gr_bitblt_dest_step_shift;
1136
1137         VideoLocation = (unsigned int)dest->bm_data + (dest->bm_rowsize * dy) + dx;
1138
1139         sbits = src->bm_data + ( sbpr*sy ) + sx;
1140
1141         for (y1=0; y1 < h; y1++ )    {
1142
1143                 page    = VideoLocation >> 16;
1144                 offset  = VideoLocation & 0xFFFF;
1145
1146                 gr_vesa_setpage( page );
1147
1148                 EndingOffset = offset+w-1;
1149
1150                 if ( EndingOffset <= 0xFFFF )
1151                 {
1152                         gr_linear_rep_movsdm( (void *)sbits, (void *)(offset+0xA0000), w );
1153
1154                         VideoLocation += dbpr;
1155                         sbits += sbpr;
1156                 }
1157                 else
1158                 {
1159                         BytesToMove = 0xFFFF-offset+1;
1160
1161                         gr_linear_rep_movsdm( (void *)sbits, (void *)(offset+0xA0000), BytesToMove );
1162
1163                         page++;
1164                         gr_vesa_setpage(page);
1165
1166                         gr_linear_rep_movsdm( (void *)(sbits+BytesToMove), (void *)0xA0000, EndingOffset - 0xFFFF );
1167
1168                         VideoLocation += dbpr;
1169                         sbits += sbpr;
1170                 }
1171         }
1172 }
1173
1174
1175 // From SVGA to linear
1176 void gr_bm_ubitblt20(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1177 {
1178         unsigned char * dbits;
1179
1180         unsigned int offset, offset1, offset2;
1181
1182         int sbpr, dbpr, y1, page;
1183
1184         dbpr = dest->bm_rowsize;
1185
1186         sbpr = src->bm_rowsize;
1187
1188         for (y1=0; y1 < h; y1++ )    {
1189
1190                 offset2 =   (unsigned int)src->bm_data  + (sbpr * (y1+sy)) + sx;
1191                 dbits   =   dest->bm_data + (dbpr * (y1+dy)) + dx;
1192
1193                 page = offset2 >> 16;
1194                 offset = offset2 & 0xFFFF;
1195                 offset1 = offset+w-1;
1196                 gr_vesa_setpage( page );
1197
1198                 if ( offset1 > 0xFFFF )  {
1199                         // Overlaps two pages
1200                         while( offset <= 0xFFFF )
1201                                 *dbits++ = gr_video_memory[offset++];
1202                         offset1 -= (0xFFFF+1);
1203                         offset = 0;
1204                         page++;
1205                         gr_vesa_setpage(page);
1206                 }
1207                 while( offset <= offset1 )
1208                         *dbits++ = gr_video_memory[offset++];
1209
1210         }
1211 }
1212
1213 #endif
1214
1215 //@extern int Interlacing_on;
1216
1217 // From Linear to Linear
1218 void gr_bm_ubitblt00(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1219 {
1220         unsigned char * dbits;
1221         unsigned char * sbits;
1222         //int src_bm_rowsize_2, dest_bm_rowsize_2;
1223         int dstep;
1224
1225         int i;
1226
1227         sbits =   src->bm_data  + (src->bm_rowsize * sy) + sx;
1228         dbits =   dest->bm_data + (dest->bm_rowsize * dy) + dx;
1229
1230         dstep = dest->bm_rowsize << gr_bitblt_dest_step_shift;
1231
1232         // No interlacing, copy the whole buffer.
1233         for (i=0; i < h; i++ )    {
1234                 if (gr_bitblt_double)
1235                         gr_linear_rep_movsd_2x( sbits, dbits, w );
1236                 else
1237                         gr_linear_movsd( sbits, dbits, w );
1238                 sbits += src->bm_rowsize;
1239                 dbits += dstep;
1240         }
1241 }
1242 // From Linear to Linear Masked
1243 void gr_bm_ubitblt00m(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1244 {
1245         unsigned char * dbits;
1246         unsigned char * sbits;
1247         //int src_bm_rowsize_2, dest_bm_rowsize_2;
1248
1249         int i;
1250
1251         sbits =   src->bm_data  + (src->bm_rowsize * sy) + sx;
1252         dbits =   dest->bm_data + (dest->bm_rowsize * dy) + dx;
1253
1254         // No interlacing, copy the whole buffer.
1255
1256         if (gr_bitblt_fade_table==NULL) {
1257                 for (i=0; i < h; i++ )    {
1258                         gr_linear_rep_movsdm( sbits, dbits, w );
1259                         sbits += src->bm_rowsize;
1260                         dbits += dest->bm_rowsize;
1261                 }
1262         } else {
1263                 for (i=0; i < h; i++ )    {
1264                         gr_linear_rep_movsdm_faded( sbits, dbits, w, gr_bitblt_fade_table[dy+i] );
1265                         sbits += src->bm_rowsize;
1266                         dbits += dest->bm_rowsize;
1267                 }
1268         }
1269 }
1270
1271
1272 extern void gr_lbitblt( grs_bitmap * source, grs_bitmap * dest, int height, int width );
1273
1274 #if 1 //def MACINTOSH
1275
1276 // width == number of destination pixels
1277
1278 void gr_linear_movsd_double(ubyte *src, ubyte *dest, int width)
1279 {
1280         double  *d = (double *)dest;
1281         uint    *s = (uint *)src;
1282         uint    doubletemp[2];
1283         uint    temp, work;
1284         int     i, num_pixels;
1285
1286         num_pixels = width / 2;
1287         if ( (num_pixels & 0x3) || (((int)src & 0x7) != ((int)dest & 0x7)) ) {
1288                 // not a multiple of 4?  do single pixel at a time
1289                 for (i=0; i<num_pixels; i++) {
1290                         *dest++ = *src;
1291                         *dest++ = *src++;
1292                 }
1293                 return;
1294         }
1295
1296         for (i = 0; i < num_pixels / 4; i++) {
1297                 temp = work = *s++;
1298
1299                 temp = ((temp >> 8) & 0x00FFFF00) | (temp & 0xFF0000FF); // 0xABCDEFGH -> 0xABABCDEF
1300                 temp = ((temp >> 8) & 0x000000FF) | (temp & 0xFFFFFF00); // 0xABABCDEF -> 0xABABCDCD
1301                 doubletemp[0] = temp;
1302
1303                 work = ((work << 8) & 0x00FFFF00) | (work & 0xFF0000FF); // 0xABCDEFGH -> 0xABEFGHGH
1304                 work = ((work << 8) & 0xFF000000) | (work & 0x00FFFFFF); // 0xABEFGHGH -> 0xEFEFGHGH
1305                 doubletemp[1] = work;
1306
1307                 *d = *(double *) &(doubletemp[0]);
1308                 d++;
1309         }
1310 }
1311
1312 //extern void BlitLargeAlign(ubyte *draw_buffer, int dstRowBytes, ubyte *dstPtr, int w, int h, int modulus);
1313
1314 #ifdef MACINTOSH
1315 asm void BlitLargeAlign(ubyte *rSrcPtr, int rDblDStrd, ubyte *rDst1Ptr, int rWidth, int rHeight, int rModulus)
1316 {
1317     stw     r31,-4(SP)          // store non-volatile reg in red zone
1318     addi    r5,r5,-8            // subtract 8 from dst
1319     stw     r30,-8(SP)          // store non-volatile reg in red zone
1320
1321     la      r30,-16(SP)         // calculate copy of local 8-byte variable
1322     sub     r9,r8,r6
1323                                 // rSStrd = modulus - w
1324     add     r31,r5,r4           // dst2 = dstRowBytes + dst1
1325     sub     r4,r4,r6            // r4 = dstRowBytes - w
1326     addi    r7,r7,-1            // subtract 1 from height count
1327     srawi   r6,r6,2             // rWidth = w >> 2
1328     addi    r3,r3,-4            // subtract 4 from src
1329     addi    r6,r6,-1            // subtract 1 from width count
1330     add     r4,r4,r4            // rDblDStrd = 2 * r4
1331
1332 BlitLargeAlignY:                // y count is in r7
1333     lwzu     r10,4(r3)          // load a long into r10
1334     mr       r0,r10             // put a copy in r0
1335     mr       r11,r10
1336 // these are simplified -- can't use 'em    inslwi   r0,r10,16,8
1337 // these are simplified -- can't use 'em    insrwi   r11,r10,16,8
1338     rlwimi   r0,r10,24,8,31
1339     rlwimi   r11,r10,8,8,23
1340     rlwimi   r0,r10,16,24,31
1341     stw      r0,0(r30)
1342     rlwimi   r11,r10,16,0,7
1343     stw      r11,4(r30)
1344     mtctr       r6              // copy x count into the counter
1345     lfd      fp0,0(r30)
1346
1347 BlitLargeAlignX:
1348     lwzu     r10,4(r3)          // load a long into r10
1349     stfdu    fp0,8(r5)
1350     mr       r0,r10             // put a copy in r0
1351     mr       r11,r10
1352 // simplefied   inslwi   r0,r10,16,8
1353 // simplefied   insrwi   r11,r10,16,8
1354     rlwimi   r0,r10,24,8,31
1355     rlwimi   r11,r10,8,8,23
1356     rlwimi   r0,r10,16,24,31
1357     stw      r0,0(r30)
1358     rlwimi   r11,r10,16,0,7
1359     stw      r11,4(r30)
1360     stfdu    fp0,8(r31)
1361     lfd      fp0,0(r30)
1362     bdnz     BlitLargeAlignX    // loop over all x
1363
1364     stfdu    fp0,8(r5)
1365     addic.   r7,r7,-1           // decrement the counter
1366     add      r3,r3,r9
1367                                 // src += sstride
1368     add      r5,r5,r4
1369                                 // dst1 += dstride
1370     stfdu    fp0,8(r31)
1371     add      r31,r31,r4
1372                                 // dst2 += dstride
1373     bne      BlitLargeAlignY    // loop for all y
1374
1375     lwz     r30,-8(SP)          // restore non-volatile regs
1376     lwz     r31,-4(SP)          // restore non-volatile regs
1377     blr                         // return to caller
1378 }
1379
1380 void gr_bm_ubitblt_double(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap *src, grs_bitmap *dest)
1381 {
1382         ubyte * dbits;
1383         ubyte * sbits;
1384         int dstep, i;
1385
1386         sbits = src->bm_data  + (src->bm_rowsize * sy) + sx;
1387         dbits = dest->bm_data + (dest->bm_rowsize * dy) + dx;
1388         dstep = dest->bm_rowsize << gr_bitblt_dest_step_shift;
1389         Assert( !((int)dbits & 0x7) );  // assert to check double word alignment
1390         BlitLargeAlign(sbits, dstep, dbits, src->bm_w, src->bm_h, src->bm_rowsize);
1391 }
1392 #endif
1393
1394 // w and h are the doubled width and height
1395
1396 void gr_bm_ubitblt_double_slow(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap *src, grs_bitmap *dest)
1397 {
1398         ubyte * dbits;
1399         ubyte * sbits;
1400         int dstep, i;
1401
1402         sbits = src->bm_data  + (src->bm_rowsize * sy) + sx;
1403         dbits = dest->bm_data + (dest->bm_rowsize * dy) + dx;
1404         dstep = dest->bm_rowsize << gr_bitblt_dest_step_shift;
1405
1406         for (i=0; i < h; i++ )    {
1407
1408                 gr_linear_movsd_double(sbits, dbits, w);
1409                 dbits += dstep;
1410                 if (i & 1)
1411                         sbits += src->bm_rowsize;
1412         }
1413 }
1414
1415 #endif
1416
1417
1418 // Clipped bitmap ...
1419
1420 void gr_bitmap( int x, int y, grs_bitmap *bm )
1421 {
1422         int dx1=x, dx2=x+bm->bm_w-1;
1423         int dy1=y, dy2=y+bm->bm_h-1;
1424         int sx=0, sy=0;
1425
1426         if ((dx1 >= grd_curcanv->cv_bitmap.bm_w ) || (dx2 < 0)) return;
1427         if ((dy1 >= grd_curcanv->cv_bitmap.bm_h) || (dy2 < 0)) return;
1428         if ( dx1 < 0 ) { sx = -dx1; dx1 = 0; }
1429         if ( dy1 < 0 ) { sy = -dy1; dy1 = 0; }
1430         if ( dx2 >= grd_curcanv->cv_bitmap.bm_w ) { dx2 = grd_curcanv->cv_bitmap.bm_w-1; }
1431         if ( dy2 >= grd_curcanv->cv_bitmap.bm_h ) { dy2 = grd_curcanv->cv_bitmap.bm_h-1; }
1432
1433         // Draw bitmap bm[x,y] into (dx1,dy1)-(dx2,dy2)
1434
1435         gr_bm_ubitblt(dx2-dx1+1,dy2-dy1+1, dx1, dy1, sx, sy, bm, &grd_curcanv->cv_bitmap );
1436
1437 }
1438
1439 //-NOT-used // From linear to SVGA
1440 //-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)
1441 //-NOT-used {
1442 //-NOT-used     unsigned char * sbits;
1443 //-NOT-used
1444 //-NOT-used     unsigned int offset, EndingOffset, VideoLocation;
1445 //-NOT-used
1446 //-NOT-used     int sbpr, dbpr, y1, page, BytesToMove;
1447 //-NOT-used
1448 //-NOT-used     sbpr = src->bm_rowsize;
1449 //-NOT-used
1450 //-NOT-used     dbpr = dest->bm_rowsize << gr_bitblt_dest_step_shift;
1451 //-NOT-used
1452 //-NOT-used     VideoLocation = (unsigned int)dest->bm_data + (dest->bm_rowsize * dy) + dx;
1453 //-NOT-used
1454 //-NOT-used     sbits = src->bm_data + ( sbpr*sy ) + sx;
1455 //-NOT-used
1456 //-NOT-used     for (y1=0; y1 < h; y1++ )    {
1457 //-NOT-used
1458 //-NOT-used             page    = VideoLocation >> 16;
1459 //-NOT-used             offset  = VideoLocation & 0xFFFF;
1460 //-NOT-used
1461 //-NOT-used             gr_vesa_setpage( page );
1462 //-NOT-used
1463 //-NOT-used             EndingOffset = offset+w-1;
1464 //-NOT-used
1465 //-NOT-used             if ( EndingOffset <= 0xFFFF )
1466 //-NOT-used             {
1467 //-NOT-used                     gr_linear_rep_movsd_2x( (void *)sbits, (void *)(offset+0xA0000), w );
1468 //-NOT-used
1469 //-NOT-used                     VideoLocation += dbpr;
1470 //-NOT-used                     sbits += sbpr;
1471 //-NOT-used             }
1472 //-NOT-used             else
1473 //-NOT-used             {
1474 //-NOT-used                     BytesToMove = 0xFFFF-offset+1;
1475 //-NOT-used
1476 //-NOT-used                     gr_linear_rep_movsd_2x( (void *)sbits, (void *)(offset+0xA0000), BytesToMove );
1477 //-NOT-used
1478 //-NOT-used                     page++;
1479 //-NOT-used                     gr_vesa_setpage(page);
1480 //-NOT-used
1481 //-NOT-used                     gr_linear_rep_movsd_2x( (void *)(sbits+BytesToMove/2), (void *)0xA0000, EndingOffset - 0xFFFF );
1482 //-NOT-used
1483 //-NOT-used                     VideoLocation += dbpr;
1484 //-NOT-used                     sbits += sbpr;
1485 //-NOT-used             }
1486 //-NOT-used
1487 //-NOT-used
1488 //-NOT-used     }
1489 //-NOT-used }
1490
1491
1492 //-NOT-used // From Linear to Linear
1493 //-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)
1494 //-NOT-used {
1495 //-NOT-used     unsigned char * dbits;
1496 //-NOT-used     unsigned char * sbits;
1497 //-NOT-used     //int src_bm_rowsize_2, dest_bm_rowsize_2;
1498 //-NOT-used
1499 //-NOT-used     int i;
1500 //-NOT-used
1501 //-NOT-used     sbits =   src->bm_data  + (src->bm_rowsize * sy) + sx;
1502 //-NOT-used     dbits =   dest->bm_data + (dest->bm_rowsize * dy) + dx;
1503 //-NOT-used
1504 //-NOT-used     // No interlacing, copy the whole buffer.
1505 //-NOT-used     for (i=0; i < h; i++ )    {
1506 //-NOT-used             gr_linear_rep_movsd_2x( sbits, dbits, w );
1507 //-NOT-used
1508 //-NOT-used             sbits += src->bm_rowsize;
1509 //-NOT-used             dbits += dest->bm_rowsize << gr_bitblt_dest_step_shift;
1510 //-NOT-used     }
1511 //-NOT-used }
1512
1513 void gr_bm_ubitblt00_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1514 {
1515         unsigned char * dbits;
1516         unsigned char * sbits;
1517         int i, data_offset;
1518
1519         data_offset = 1;
1520         if (src->bm_flags & BM_FLAG_RLE_BIG)
1521                 data_offset = 2;
1522
1523         sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
1524
1525         for (i=0; i<sy; i++ )
1526                 sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
1527
1528         dbits = dest->bm_data + (dest->bm_rowsize * dy) + dx;
1529
1530         // No interlacing, copy the whole buffer.
1531         for (i=0; i < h; i++ )    {
1532                 gr_rle_expand_scanline( dbits, sbits, sx, sx+w-1 );
1533                 if ( src->bm_flags & BM_FLAG_RLE_BIG )
1534                         sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((i+sy)*data_offset)])));
1535                 else
1536                         sbits += (int)(src->bm_data[4+i+sy]);
1537                 dbits += dest->bm_rowsize << gr_bitblt_dest_step_shift;
1538         }
1539 }
1540
1541 void gr_bm_ubitblt00m_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1542 {
1543         unsigned char * dbits;
1544         unsigned char * sbits;
1545         int i, data_offset;
1546
1547         data_offset = 1;
1548         if (src->bm_flags & BM_FLAG_RLE_BIG)
1549                 data_offset = 2;
1550
1551         sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
1552         for (i=0; i<sy; i++ )
1553                 sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
1554
1555         dbits = dest->bm_data + (dest->bm_rowsize * dy) + dx;
1556
1557         // No interlacing, copy the whole buffer.
1558         for (i=0; i < h; i++ )    {
1559                 gr_rle_expand_scanline_masked( dbits, sbits, sx, sx+w-1 );
1560                 if ( src->bm_flags & BM_FLAG_RLE_BIG )
1561                         sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((i+sy)*data_offset)])));
1562                 else
1563                         sbits += (int)(src->bm_data[4+i+sy]);
1564                 dbits += dest->bm_rowsize << gr_bitblt_dest_step_shift;
1565         }
1566 }
1567
1568 // in rle.c
1569
1570 extern void gr_rle_expand_scanline_generic( grs_bitmap * dest, int dx, int dy, ubyte *src, int x1, int x2  );
1571 extern void gr_rle_expand_scanline_generic_masked( grs_bitmap * dest, int dx, int dy, ubyte *src, int x1, int x2  );
1572 extern void gr_rle_expand_scanline_svga_masked( grs_bitmap * dest, int dx, int dy, ubyte *src, int x1, int x2  );
1573
1574 void gr_bm_ubitblt0x_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1575 {
1576         int i, data_offset;
1577         register int y1;
1578         unsigned char * sbits;
1579
1580         //mprintf( 0, "SVGA RLE!\n" );
1581
1582         data_offset = 1;
1583         if (src->bm_flags & BM_FLAG_RLE_BIG)
1584                 data_offset = 2;
1585
1586         sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
1587         for (i=0; i<sy; i++ )
1588                 sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
1589
1590         for (y1=0; y1 < h; y1++ )    {
1591                 gr_rle_expand_scanline_generic( dest, dx, dy+y1,  sbits, sx, sx+w-1  );
1592                 if ( src->bm_flags & BM_FLAG_RLE_BIG )
1593                         sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((y1+sy)*data_offset)])));
1594                 else
1595                         sbits += (int)src->bm_data[4+y1+sy];
1596         }
1597
1598 }
1599
1600 void gr_bm_ubitblt0xm_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1601 {
1602         int i, data_offset;
1603         register int y1;
1604         unsigned char * sbits;
1605
1606         //mprintf( 0, "SVGA RLE!\n" );
1607
1608         data_offset = 1;
1609         if (src->bm_flags & BM_FLAG_RLE_BIG)
1610                 data_offset = 2;
1611
1612         sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
1613         for (i=0; i<sy; i++ )
1614                 sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
1615
1616         for (y1=0; y1 < h; y1++ )    {
1617                 gr_rle_expand_scanline_generic_masked( dest, dx, dy+y1,  sbits, sx, sx+w-1  );
1618                 if ( src->bm_flags & BM_FLAG_RLE_BIG )
1619                         sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((y1+sy)*data_offset)])));
1620                 else
1621                         sbits += (int)src->bm_data[4+y1+sy];
1622         }
1623
1624 }
1625
1626 #ifdef __MSDOS__
1627 void gr_bm_ubitblt02m_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1628 {
1629         int i, data_offset;
1630         register int y1;
1631         unsigned char * sbits;
1632
1633         //mprintf( 0, "SVGA RLE!\n" );
1634
1635         data_offset = 1;
1636         if (src->bm_flags & BM_FLAG_RLE_BIG)
1637                 data_offset = 2;
1638
1639         sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
1640         for (i=0; i<sy; i++ )
1641                 sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
1642
1643         for (y1=0; y1 < h; y1++ )    {
1644                 gr_rle_expand_scanline_svga_masked( dest, dx, dy+y1,  sbits, sx, sx+w-1  );
1645                 if ( src->bm_flags & BM_FLAG_RLE_BIG )
1646                         sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((y1+sy)*data_offset)])));
1647                 else
1648                         sbits += (int)src->bm_data[4+y1+sy];
1649         }
1650 }
1651 #endif
1652
1653 void gr_bm_ubitblt(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1654 {
1655         register int x1, y1;
1656
1657         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_LINEAR ))
1658         {
1659                 if ( src->bm_flags & BM_FLAG_RLE )
1660                         gr_bm_ubitblt00_rle( w, h, dx, dy, sx, sy, src, dest );
1661                 else
1662                         gr_bm_ubitblt00( w, h, dx, dy, sx, sy, src, dest );
1663                 return;
1664         }
1665
1666 #ifdef OGL
1667         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_OGL ))
1668         {
1669                 ogl_ubitblt(w, h, dx, dy, sx, sy, src, dest);
1670                 return;
1671         }
1672         if ( (src->bm_type == BM_OGL) && (dest->bm_type == BM_LINEAR ))
1673         {
1674                 ogl_ubitblt_tolinear(w, h, dx, dy, sx, sy, src, dest);
1675                 return;
1676         }
1677         if ( (src->bm_type == BM_OGL) && (dest->bm_type == BM_OGL ))
1678         {
1679                 ogl_ubitblt_copy(w, h, dx, dy, sx, sy, src, dest);
1680                 return;
1681         }
1682 #endif
1683
1684 #ifdef D1XD3D
1685         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_DIRECTX ))
1686         {
1687                 Assert ((int)dest->bm_data == BM_D3D_RENDER || (int)dest->bm_data == BM_D3D_DISPLAY);
1688                 Win32_BlitLinearToDirectX_bm (src, sx, sy, w, h, dx, dy, 0);
1689                 return;
1690         }
1691         if ( (src->bm_type == BM_DIRECTX) && (dest->bm_type == BM_LINEAR ))
1692         {
1693                 return;
1694         }
1695         if ( (src->bm_type == BM_DIRECTX) && (dest->bm_type == BM_DIRECTX ))
1696         {
1697                 return;
1698         }
1699 #endif
1700
1701         if ( (src->bm_flags & BM_FLAG_RLE ) && (src->bm_type == BM_LINEAR) ) {
1702                 gr_bm_ubitblt0x_rle(w, h, dx, dy, sx, sy, src, dest );
1703                 return;
1704         }
1705
1706 #ifdef __MSDOS__
1707         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_SVGA ))
1708         {
1709                 gr_bm_ubitblt02( w, h, dx, dy, sx, sy, src, dest );
1710                 return;
1711         }
1712
1713         if ( (src->bm_type == BM_SVGA) && (dest->bm_type == BM_LINEAR ))
1714         {
1715                 gr_bm_ubitblt20( w, h, dx, dy, sx, sy, src, dest );
1716                 return;
1717         }
1718
1719         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_MODEX ))
1720         {
1721                 gr_bm_ubitblt01( w, h, dx+XOFFSET, dy+YOFFSET, sx, sy, src, dest );
1722                 return;
1723         }
1724 #endif
1725
1726 #if defined(POLY_ACC)
1727         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_LINEAR15 ))
1728         {
1729                 ubyte *s = src->bm_data + sy * src->bm_rowsize + sx;
1730                 ushort *t = (ushort *)(dest->bm_data + dy * dest->bm_rowsize + dx * PA_BPP);
1731                 int x;
1732                 pa_flush();
1733                 for(;h--;)
1734                 {
1735                         for(x = 0; x < w; x++)
1736                                 t[x] = pa_clut[s[x]];
1737                         s += src->bm_rowsize;
1738                         t += dest->bm_rowsize / PA_BPP;
1739                 }
1740                 return;
1741         }
1742
1743         if ( (src->bm_type == BM_LINEAR15) && (dest->bm_type == BM_LINEAR15 ))
1744         {
1745                 pa_blit(dest, dx, dy, src, sx, sy, w, h);
1746                 return;
1747         }
1748 #endif
1749
1750         for (y1=0; y1 < h; y1++ )    {
1751                 for (x1=0; x1 < w; x1++ )    {
1752                         gr_bm_pixel( dest, dx+x1, dy+y1, gr_gpixel(src,sx+x1,sy+y1) );
1753                 }
1754         }
1755 }
1756
1757 void gr_bm_bitblt(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1758 {
1759         int dx1=dx, dx2=dx+dest->bm_w-1;
1760         int dy1=dy, dy2=dy+dest->bm_h-1;
1761
1762         int sx1=sx, sx2=sx+src->bm_w-1;
1763         int sy1=sy, sy2=sy+src->bm_h-1;
1764
1765         if ((dx1 >= dest->bm_w ) || (dx2 < 0)) return;
1766         if ((dy1 >= dest->bm_h ) || (dy2 < 0)) return;
1767         if ( dx1 < 0 ) { sx1 += -dx1; dx1 = 0; }
1768         if ( dy1 < 0 ) { sy1 += -dy1; dy1 = 0; }
1769         if ( dx2 >= dest->bm_w ) { dx2 = dest->bm_w-1; }
1770         if ( dy2 >= dest->bm_h ) { dy2 = dest->bm_h-1; }
1771
1772         if ((sx1 >= src->bm_w ) || (sx2 < 0)) return;
1773         if ((sy1 >= src->bm_h ) || (sy2 < 0)) return;
1774         if ( sx1 < 0 ) { dx1 += -sx1; sx1 = 0; }
1775         if ( sy1 < 0 ) { dy1 += -sy1; sy1 = 0; }
1776         if ( sx2 >= src->bm_w ) { sx2 = src->bm_w-1; }
1777         if ( sy2 >= src->bm_h ) { sy2 = src->bm_h-1; }
1778
1779         // Draw bitmap bm[x,y] into (dx1,dy1)-(dx2,dy2)
1780         if ( dx2-dx1+1 < w )
1781                 w = dx2-dx1+1;
1782         if ( dy2-dy1+1 < h )
1783                 h = dy2-dy1+1;
1784         if ( sx2-sx1+1 < w )
1785                 w = sx2-sx1+1;
1786         if ( sy2-sy1+1 < h )
1787                 h = sy2-sy1+1;
1788
1789         gr_bm_ubitblt(w,h, dx1, dy1, sx1, sy1, src, dest );
1790 }
1791
1792 void gr_ubitmap( int x, int y, grs_bitmap *bm )
1793 {
1794         int source, dest;
1795
1796         source = bm->bm_type;
1797         dest = TYPE;
1798
1799         if (source==BM_LINEAR) {
1800                 switch( dest )
1801                 {
1802                 case BM_LINEAR:
1803                         if ( bm->bm_flags & BM_FLAG_RLE )
1804                                 gr_bm_ubitblt00_rle(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap );
1805                         else
1806                                 gr_ubitmap00( x, y, bm );
1807                         return;
1808 #ifdef OGL
1809                 case BM_OGL:
1810                         ogl_ubitmapm(x,y,bm);
1811                         return;
1812 #endif
1813 #ifdef D1XD3D
1814                 case BM_DIRECTX:
1815                         Assert ((int)grd_curcanv->cv_bitmap.bm_data == BM_D3D_RENDER || (int)grd_curcanv->cv_bitmap.bm_data == BM_D3D_DISPLAY);
1816                         Win32_BlitLinearToDirectX_bm(bm, 0, 0, bm->bm_w, bm->bm_h, x, y, 0);
1817                         return;
1818 #endif
1819 #ifdef __MSDOS__
1820                 case BM_SVGA:
1821                         if ( bm->bm_flags & BM_FLAG_RLE )
1822                                 gr_bm_ubitblt0x_rle(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap );
1823                         else
1824                                 gr_vesa_bitmap( bm, &grd_curcanv->cv_bitmap, x, y );
1825                         return;
1826                 case BM_MODEX:
1827                         gr_bm_ubitblt01(bm->bm_w, bm->bm_h, x+XOFFSET, y+YOFFSET, 0, 0, bm, &grd_curcanv->cv_bitmap);
1828                         return;
1829 #endif
1830 #if defined(POLY_ACC)
1831                 case BM_LINEAR15:
1832                         if ( bm->bm_flags & BM_FLAG_RLE )
1833                                 gr_bm_ubitblt05_rle(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap );
1834                         else
1835                                 gr_ubitmap05( x, y, bm);
1836                         return;
1837
1838 #endif
1839                 default:
1840                         gr_ubitmap012( x, y, bm );
1841                         return;
1842                 }
1843         } else  {
1844                 gr_ubitmapGENERIC(x, y, bm);
1845         }
1846 }
1847
1848
1849 void gr_ubitmapm( int x, int y, grs_bitmap *bm )
1850 {
1851         int source, dest;
1852
1853         source = bm->bm_type;
1854         dest = TYPE;
1855
1856         Assert(x+bm->bm_w <= grd_curcanv->cv_w);
1857         Assert(y+bm->bm_h <= grd_curcanv->cv_h);
1858
1859 #ifdef _3DFX
1860         _3dfx_Blit( x, y, bm );
1861         if ( _3dfx_skip_ddraw )
1862                 return;
1863 #endif
1864
1865         if (source==BM_LINEAR) {
1866                 switch( dest )
1867                 {
1868                 case BM_LINEAR:
1869                         if ( bm->bm_flags & BM_FLAG_RLE )
1870                                 gr_bm_ubitblt00m_rle(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap );
1871                         else
1872                                 gr_ubitmap00m( x, y, bm );
1873                         return;
1874 #ifdef __MSDOS__
1875                 case BM_SVGA:
1876                         if (bm->bm_flags & BM_FLAG_RLE)
1877                                 gr_bm_ubitblt02m_rle(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap);
1878                         //gr_bm_ubitblt0xm_rle(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap);
1879                         else
1880                                 gr_bm_ubitblt02m(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap);
1881                         //gr_ubitmapGENERICm(x, y, bm);
1882                         return;
1883                 case BM_MODEX:
1884                         gr_bm_ubitblt01m(bm->bm_w, bm->bm_h, x+XOFFSET, y+YOFFSET, 0, 0, bm, &grd_curcanv->cv_bitmap);
1885                         return;
1886 #endif
1887 #if defined(POLY_ACC)
1888                 case BM_LINEAR15:
1889                         if ( bm->bm_flags & BM_FLAG_RLE )
1890                                 gr_bm_ubitblt05m_rle(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap );
1891                         else
1892                                 gr_ubitmap05m( x, y, bm );
1893                         return;
1894 #endif
1895
1896                 default:
1897                         gr_ubitmap012m( x, y, bm );
1898                         return;
1899                 }
1900         } else {
1901                 gr_ubitmapGENERICm(x, y, bm);
1902         }
1903 }
1904
1905
1906 void gr_bitmapm( int x, int y, grs_bitmap *bm )
1907 {
1908         int dx1=x, dx2=x+bm->bm_w-1;
1909         int dy1=y, dy2=y+bm->bm_h-1;
1910         int sx=0, sy=0;
1911
1912         if ((dx1 >= grd_curcanv->cv_bitmap.bm_w ) || (dx2 < 0)) return;
1913         if ((dy1 >= grd_curcanv->cv_bitmap.bm_h) || (dy2 < 0)) return;
1914         if ( dx1 < 0 ) { sx = -dx1; dx1 = 0; }
1915         if ( dy1 < 0 ) { sy = -dy1; dy1 = 0; }
1916         if ( dx2 >= grd_curcanv->cv_bitmap.bm_w ) { dx2 = grd_curcanv->cv_bitmap.bm_w-1; }
1917         if ( dy2 >= grd_curcanv->cv_bitmap.bm_h ) { dy2 = grd_curcanv->cv_bitmap.bm_h-1; }
1918
1919         // Draw bitmap bm[x,y] into (dx1,dy1)-(dx2,dy2)
1920
1921         if ( (bm->bm_type == BM_LINEAR) && (grd_curcanv->cv_bitmap.bm_type == BM_LINEAR ))
1922         {
1923                 if ( bm->bm_flags & BM_FLAG_RLE )
1924                         gr_bm_ubitblt00m_rle(dx2-dx1+1,dy2-dy1+1, dx1, dy1, sx, sy, bm, &grd_curcanv->cv_bitmap );
1925                 else
1926                         gr_bm_ubitblt00m(dx2-dx1+1,dy2-dy1+1, dx1, dy1, sx, sy, bm, &grd_curcanv->cv_bitmap );
1927                 return;
1928         }
1929 #ifdef __MSDOS__
1930         else if ( (bm->bm_type == BM_LINEAR) && (grd_curcanv->cv_bitmap.bm_type == BM_SVGA ))
1931         {
1932                 gr_bm_ubitblt02m(dx2-dx1+1,dy2-dy1+1, dx1, dy1, sx, sy, bm, &grd_curcanv->cv_bitmap );
1933                 return;
1934         }
1935 #endif
1936
1937         gr_bm_ubitbltm(dx2-dx1+1,dy2-dy1+1, dx1, dy1, sx, sy, bm, &grd_curcanv->cv_bitmap );
1938
1939 }
1940
1941 void gr_bm_ubitbltm(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1942 {
1943         register int x1, y1;
1944         ubyte c;
1945
1946 #ifdef OGL
1947         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_OGL ))
1948         {
1949                 ogl_ubitblt(w, h, dx, dy, sx, sy, src, dest);
1950                 return;
1951         }
1952         if ( (src->bm_type == BM_OGL) && (dest->bm_type == BM_LINEAR ))
1953         {
1954                 ogl_ubitblt_tolinear(w, h, dx, dy, sx, sy, src, dest);
1955                 return;
1956         }
1957         if ( (src->bm_type == BM_OGL) && (dest->bm_type == BM_OGL ))
1958         {
1959                 ogl_ubitblt_copy(w, h, dx, dy, sx, sy, src, dest);
1960                 return;
1961         }
1962 #endif
1963 #ifdef D1XD3D
1964         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_DIRECTX ))
1965         {
1966                 Assert ((int)dest->bm_data == BM_D3D_RENDER || (int)dest->bm_data == BM_D3D_DISPLAY);
1967                 Win32_BlitLinearToDirectX_bm (src, sx, sy, w, h, dx, dy, 1);
1968                 return;
1969         }
1970         if ( (src->bm_type == BM_DIRECTX) && (dest->bm_type == BM_DIRECTX ))
1971         {
1972                 Assert ((int)src->bm_data == BM_D3D_RENDER || (int)src->bm_data == BM_D3D_DISPLAY);
1973                 //Win32_BlitDirectXToDirectX (w, h, dx, dy, sx, sy, src->bm_data, dest->bm_data, 0);
1974                 return;
1975         }
1976 #endif
1977 #if defined(POLY_ACC)
1978         if(src->bm_type == BM_LINEAR && dest->bm_type == BM_LINEAR15)
1979         {
1980                 ubyte *s;
1981                 ushort *d;
1982                 ushort u;
1983                 int smod, dmod;
1984
1985                 pa_flush();
1986                 s = (ubyte *)(src->bm_data + src->bm_rowsize * sy + sx);
1987                 smod = src->bm_rowsize - w;
1988                 d = (ushort *)(dest->bm_data + dest->bm_rowsize * dy + dx * PA_BPP);
1989                 dmod = dest->bm_rowsize / PA_BPP - w;
1990                 for (; h--;) {
1991                         for (x1=w; x1--; ) {
1992                                 if ((u = *s) != TRANSPARENCY_COLOR)
1993                                         *d = pa_clut[u];
1994                                 ++s;
1995                                 ++d;
1996                         }
1997                         s += smod;
1998                         d += dmod;
1999                 }
2000         }
2001
2002         if(src->bm_type == BM_LINEAR15)
2003         {
2004                 Assert(src->bm_type == dest->bm_type);         // I don't support 15 to 8 yet.
2005                 pa_blit_transparent(dest, dx, dy, src, sx, sy, w, h);
2006                 return;
2007         }
2008 #endif
2009
2010         for (y1=0; y1 < h; y1++ )    {
2011                 for (x1=0; x1 < w; x1++ )    {
2012                         if ((c=gr_gpixel(src,sx+x1,sy+y1))!=TRANSPARENCY_COLOR)
2013                                 gr_bm_pixel( dest, dx+x1, dy+y1,c  );
2014                 }
2015         }
2016 }
2017
2018
2019 // rescalling bitmaps, 10/14/99 Jan Bobrowski jb@wizard.ae.krakow.pl
2020
2021 inline void scale_line(byte *in, byte *out, int ilen, int olen)
2022 {
2023         int a = olen/ilen, b = olen%ilen;
2024         int c = 0, i;
2025         byte *end = out + olen;
2026         while(out<end) {
2027                 i = a;
2028                 c += b;
2029                 if(c >= ilen) {
2030                         c -= ilen;
2031                         goto inside;
2032                 }
2033                 while(--i>=0) {
2034                 inside:
2035                         *out++ = *in;
2036                 }
2037                 in++;
2038         }
2039 }
2040
2041 void gr_bitmap_scale_to(grs_bitmap *src, grs_bitmap *dst)
2042 {
2043         byte *s = src->bm_data;
2044         byte *d = dst->bm_data;
2045         int h = src->bm_h;
2046         int a = dst->bm_h/h, b = dst->bm_h%h;
2047         int c = 0, i, y;
2048
2049         for(y=0; y<h; y++) {
2050                 i = a;
2051                 c += b;
2052                 if(c >= h) {
2053                         c -= h;
2054                         goto inside;
2055                 }
2056                 while(--i>=0) {
2057                 inside:
2058                         scale_line(s, d, src->bm_w, dst->bm_w);
2059                         d += dst->bm_rowsize;
2060                 }
2061                 s += src->bm_rowsize;
2062         }
2063 }
2064
2065 void show_fullscr(grs_bitmap *bm)
2066 {
2067         grs_bitmap * const scr = &grd_curcanv->cv_bitmap;
2068
2069 #ifdef OGL
2070         if(bm->bm_type == BM_LINEAR && scr->bm_type == BM_OGL) {
2071                 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
2072                 return;
2073         }
2074 #endif
2075         if(scr->bm_type != BM_LINEAR) {
2076                 grs_bitmap *tmp = gr_create_bitmap(scr->bm_w, scr->bm_h);
2077                 gr_bitmap_scale_to(bm, tmp);
2078                 gr_bitmap(0, 0, tmp);
2079                 gr_free_bitmap(tmp);
2080                 return;
2081         }
2082         gr_bitmap_scale_to(bm, scr);
2083 }