2d/bitblt.c

   1 /*
   2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
   9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  11 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12 */
  13
  14 /*
  15  *
  16  * Routines for bitblt's.
  17  *
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <conf.h>
  22 #endif
  23
  24 #include "u_mem.h"
  25 #include "gr.h"
  26 #include "mono.h"
  27 #include "byteswap.h"       // because of rle code that has short for row offsets
  28 #include "dxxerror.h"
  29
  30 #ifdef OGL
  31 #include "ogl_init.h"
  32 #endif
  33
  34
  35 int gr_bitblt_dest_step_shift = 0;
  36 int gr_bitblt_double = 0;
  37 ubyte *gr_bitblt_fade_table=NULL;
  38
  39 extern void gr_vesa_bitmap( grs_bitmap * source, grs_bitmap * dest, int x, int y );
  40
  41 void gr_linear_movsd( ubyte * source, ubyte * dest, unsigned int nbytes);
  42 // This code aligns edi so that the destination is aligned to a dword boundry before rep movsd
  43
  44 #if !defined(NO_ASM) && defined(__WATCOMC__)
  45
  46 #pragma aux gr_linear_movsd parm [esi] [edi] [ecx] modify exact [ecx esi edi eax ebx] = \
  47 " cld "                                 \
  48 " mov           ebx, ecx        "       \
  49 " mov           eax, edi"       \
  50 " and           eax, 011b"      \
  51 " jz            d_aligned"      \
  52 " mov           ecx, 4"         \
  53 " sub           ecx, eax"       \
  54 " sub           ebx, ecx"       \
  55 " rep           movsb"          \
  56 " d_aligned: "                  \
  57 " mov           ecx, ebx"       \
  58 " shr           ecx, 2"         \
  59 " rep   movsd"          \
  60 " mov           ecx, ebx"       \
  61 " and   ecx, 11b"       \
  62 " rep   movsb";
  63
  64 #elif !defined(NO_ASM) && defined(__GNUC__)
  65
  66 inline void gr_linear_movsd(ubyte *src, ubyte *dest, unsigned int num_pixels) {
  67         int dummy[3];
  68  __asm__ __volatile__ (
  69 " cld;"
  70 " movl      %%ecx, %%ebx;"
  71 " movl      %%edi, %%eax;"
  72 " andl      $3, %%eax;"
  73 " jz        0f;"
  74 " movl      $4, %%ecx;"
  75 " subl      %%eax,%%ecx;"
  76 " subl      %%ecx,%%ebx;"
  77 " rep;      movsb;"
  78 "0: ;"
  79 " movl      %%ebx, %%ecx;"
  80 " shrl      $2, %%ecx;"
  81 " rep;      movsl;"
  82 " movl      %%ebx, %%ecx;"
  83 " andl      $3, %%ecx;"
  84 " rep;      movsb"
  85  : "=S" (dummy[0]), "=D" (dummy[1]), "=c" (dummy[2])
  86  : "0" (src), "1" (dest), "2" (num_pixels)
  87  :      "%eax", "%ebx");
  88 }
  89
  90 #elif !defined(NO_ASM) && defined(_MSC_VER)
  91
  92 __inline void gr_linear_movsd(ubyte *src, ubyte *dest, unsigned int num_pixels)
  93 {
  94  __asm {
  95    mov esi, [src]
  96    mov edi, [dest]
  97    mov ecx, [num_pixels]
  98    cld
  99    mov ebx, ecx
 100    mov eax, edi
 101    and eax, 011b
 102    jz d_aligned
 103    mov ecx, 4
 104    sub ecx, eax
 105    sub ebx, ecx
 106    rep movsb
 107 d_aligned:
 108    mov ecx, ebx
 109    shr ecx, 2
 110    rep movsd
 111    mov ecx, ebx
 112    and ecx, 11b
 113    rep movsb
 114  }
 115 }
 116
 117 #else // NO_ASM or unknown compiler
 118
 119 #define THRESHOLD   8
 120
 121 #ifdef RELEASE
 122 #define test_byteblit   0
 123 #else
 124 ubyte test_byteblit = 0;
 125 #endif
 126
 127 void gr_linear_movsd(ubyte * src, ubyte * dest, unsigned int num_pixels )
 128 {
 129         int i;
 130         uint n, r;
 131         double *d, *s;
 132         ubyte *d1, *s1;
 133
 134 // check to see if we are starting on an even byte boundry
 135 // if not, move appropriate number of bytes to even
 136 // 8 byte boundry
 137
 138         if ( (num_pixels < THRESHOLD) || (((int)src & 0x7) != ((int)dest & 0x7)) || test_byteblit ) {
 139                 for (i = 0; i < num_pixels; i++)
 140                         *dest++ = *src++;
 141                 return;
 142         }
 143
 144         i = 0;
 145         if ((r = (int)src & 0x7)) {
 146                 for (i = 0; i < 8 - r; i++)
 147                         *dest++ = *src++;
 148         }
 149         num_pixels -= i;
 150
 151         n = num_pixels / 8;
 152         r = num_pixels % 8;
 153         s = (double *)src;
 154         d = (double *)dest;
 155         for (i = 0; i < n; i++)
 156                 *d++ = *s++;
 157         s1 = (ubyte *)s;
 158         d1 = (ubyte *)d;
 159         for (i = 0; i < r; i++)
 160                 *d1++ = *s1++;
 161 }
 162
 163 #endif  //#ifdef NO_ASM
 164
 165
 166 static void gr_linear_rep_movsdm(ubyte * src, ubyte * dest, unsigned int num_pixels );
 167
 168 #if !defined(NO_ASM) && defined(__WATCOMC__)
 169
 170 #pragma aux gr_linear_rep_movsdm parm [esi] [edi] [ecx] modify exact [ecx esi edi eax] = \
 171 "nextpixel:"                \
 172     "mov    al,[esi]"       \
 173     "inc    esi"            \
 174     "cmp    al, " TRANSPARENCY_COLOR_STR   \
 175     "je skip_it"            \
 176     "mov    [edi], al"      \
 177 "skip_it:"                  \
 178     "inc    edi"            \
 179     "dec    ecx"            \
 180     "jne    nextpixel";
 181
 182 #elif !defined(NO_ASM) && defined(__GNUC__)
 183
 184 static inline void gr_linear_rep_movsdm(ubyte * src, ubyte * dest, unsigned int num_pixels ) {
 185         int dummy[3];
 186  __asm__ __volatile__ (
 187 "0: ;"
 188 " movb  (%%esi), %%al;"
 189 " incl  %%esi;"
 190 " cmpb  $" TRANSPARENCY_COLOR_STR ", %%al;"
 191 " je    1f;"
 192 " movb  %%al,(%%edi);"
 193 "1: ;"
 194 " incl  %%edi;"
 195 " decl  %%ecx;"
 196 " jne   0b"
 197  : "=S" (dummy[0]), "=D" (dummy[1]), "=c" (dummy[2])
 198  : "0" (src), "1" (dest), "2" (num_pixels)
 199  : "%eax");
 200 }
 201
 202 #elif !defined(NO_ASM) && defined(_MSC_VER)
 203
 204 __inline void gr_linear_rep_movsdm(ubyte * src, ubyte * dest, unsigned int num_pixels )
 205 {
 206  __asm {
 207   nextpixel:
 208   mov esi, [src]
 209   mov edi, [dest]
 210   mov ecx, [num_pixels]
 211   mov al,  [esi]
 212   inc esi
 213   cmp al,  TRANSPARENCY_COLOR
 214   je skip_it
 215   mov [edi], al
 216   skip_it:
 217   inc edi
 218   dec ecx
 219   jne nextpixel
 220  }
 221 }
 222
 223 #else
 224
 225 static void gr_linear_rep_movsdm(ubyte * src, ubyte * dest, unsigned int num_pixels )
 226 {
 227         int i;
 228         for (i=0; i<num_pixels; i++ ) {
 229                 if (*src != TRANSPARENCY_COLOR )
 230                         *dest = *src;
 231                 dest++;
 232                 src++;
 233         }
 234 }
 235
 236 #endif
 237
 238 static void gr_linear_rep_movsdm_faded(ubyte * src, ubyte * dest, unsigned int num_pixels, ubyte fade_value );
 239
 240 #if !defined(NO_ASM) && defined(__WATCOMC__)
 241
 242 #pragma aux gr_linear_rep_movsdm_faded parm [esi] [edi] [ecx] [ebx] modify exact [ecx esi edi eax ebx] = \
 243 "  xor eax, eax"                    \
 244 "  mov ah, bl"                      \
 245 "nextpixel:"                        \
 246     "mov    al,[esi]"               \
 247     "inc    esi"                    \
 248     "cmp    al, " TRANSPARENCY_COLOR_STR     \
 249     "je skip_it"                    \
 250     "mov  al, gr_fade_table[eax]"   \
 251     "mov    [edi], al"              \
 252 "skip_it:"                          \
 253     "inc    edi"                    \
 254     "dec    ecx"                    \
 255     "jne    nextpixel";
 256
 257 #elif !defined(NO_ASM) && defined(__GNUC__)
 258
 259 /* #pragma aux gr_linear_rep_movsdm_faded parm [esi] [edi] [ecx] [ebx] modify exact [ecx esi edi eax ebx] */
 260 static inline void gr_linear_rep_movsdm_faded(ubyte * src, ubyte * dest, unsigned int num_pixels, ubyte fade_value ) {
 261         int dummy[4];
 262  __asm__ __volatile__ (
 263 "  xorl   %%eax, %%eax;"
 264 "  movb   %%bl, %%ah;"
 265 "0:;"
 266 "  movb   (%%esi), %%al;"
 267 "  incl   %%esi;"
 268 "  cmpb   $" TRANSPARENCY_COLOR_STR ", %%al;"
 269 "  je 1f;"
 270 #ifdef __ELF__
 271 "  movb   gr_fade_table(%%eax), %%al;"
 272 #else
 273 "  movb   _gr_fade_table(%%eax), %%al;"
 274 #endif
 275 "  movb   %%al, (%%edi);"
 276 "1:"
 277 "  incl   %%edi;"
 278 "  decl   %%ecx;"
 279 "  jne    0b"
 280  : "=S" (dummy[0]), "=D" (dummy[1]), "=c" (dummy[2]), "=b" (dummy[3])
 281  : "0" (src), "1" (dest), "2" (num_pixels), "3" (fade_value)
 282  : "%eax");
 283 }
 284
 285 #elif !defined(NO_ASM) && defined(_MSC_VER)
 286
 287 __inline void gr_linear_rep_movsdm_faded(void * src, void * dest, unsigned int num_pixels, ubyte fade_value )
 288 {
 289  __asm {
 290   mov esi, [src]
 291   mov edi, [dest]
 292   mov ecx, [num_pixels]
 293   movzx ebx, byte ptr [fade_value]
 294   xor eax, eax
 295   mov ah, bl
 296   nextpixel:
 297   mov al, [esi]
 298   inc esi
 299   cmp al, TRANSPARENCY_COLOR
 300   je skip_it
 301   mov al, gr_fade_table[eax]
 302   mov [edi], al
 303   skip_it:
 304   inc edi
 305   dec ecx
 306   jne nextpixel
 307  }
 308 }
 309
 310 #else
 311
 312 static void gr_linear_rep_movsdm_faded(ubyte * src, ubyte * dest, unsigned int num_pixels, ubyte fade_value )
 313 {
 314         int i;
 315         ubyte source;
 316         ubyte *fade_base;
 317
 318         fade_base = gr_fade_table + (fade_value * 256);
 319
 320         for (i=num_pixels; i != 0; i-- )
 321         {
 322                 source = *src;
 323                 if (source != (ubyte)TRANSPARENCY_COLOR )
 324                         *dest = *(fade_base + source);
 325                 dest++;
 326                 src++;
 327         }
 328 }
 329
 330 #endif
 331
 332
 333 void gr_linear_rep_movsd_2x(ubyte *src, ubyte *dest, unsigned int num_dest_pixels);
 334
 335 #if !defined(NO_ASM) && defined(__WATCOMC__)
 336
 337 #pragma aux gr_linear_rep_movsd_2x parm [esi] [edi] [ecx] modify exact [ecx esi edi eax ebx] = \
 338     "shr    ecx, 1"             \
 339     "jnc    nextpixel"          \
 340     "mov    al, [esi]"          \
 341     "mov    [edi], al"          \
 342     "inc    esi"                \
 343     "inc    edi"                \
 344     "cmp    ecx, 0"             \
 345     "je done"                   \
 346 "nextpixel:"                    \
 347     "mov    al,[esi]"           \
 348     "mov    ah, al"             \
 349     "mov    [edi], ax"          \
 350     "inc    esi"                \
 351     "inc    edi"                \
 352     "inc    edi"                \
 353     "dec    ecx"                \
 354     "jne    nextpixel"          \
 355 "done:"
 356
 357 #elif !defined(NO_ASM) && defined (__GNUC__)
 358
 359 inline void gr_linear_rep_movsd_2x(ubyte *src, ubyte *dest, unsigned int num_dest_pixels)
 360 {
 361 /* #pragma aux gr_linear_rep_movsd_2x parm [esi] [edi] [ecx] modify exact [ecx esi edi eax ebx] */
 362         int dummy[3];
 363  __asm__ __volatile__ (
 364     "shrl   $1, %%ecx;"
 365     "jnc    0f;"
 366     "movb   (%%esi), %%al;"
 367     "movb   %%al, (%%edi);"
 368     "incl   %%esi;"
 369     "incl   %%edi;"
 370     "cmpl   $0, %%ecx;"
 371     "je 1f;"
 372 "0: ;"
 373     "movb   (%%esi), %%al;"
 374     "movb   %%al, %%ah;"
 375     "movw   %%ax, (%%edi);"
 376     "incl   %%esi;"
 377     "incl   %%edi;"
 378     "incl   %%edi;"
 379     "decl   %%ecx;"
 380     "jne    0b;"
 381 "1:"
 382  : "=S" (dummy[0]), "=D" (dummy[1]), "=c" (dummy[2])
 383  : "0" (src), "1" (dest), "2" (num_dest_pixels)
 384  :      "%eax");
 385 }
 386
 387 #elif !defined(NO_ASM) && defined(_MSC_VER)
 388
 389 __inline void gr_linear_rep_movsd_2x(ubyte *src, ubyte *dest, unsigned int num_dest_pixels)
 390 {
 391  __asm {
 392   mov esi, [src]
 393   mov edi, [dest]
 394   mov ecx, [num_dest_pixels]
 395   shr ecx, 1
 396   jnc nextpixel
 397   mov al, [esi]
 398   mov [edi], al
 399   inc esi
 400   inc edi
 401   cmp ecx, 0
 402   je done
 403 nextpixel:
 404   mov al, [esi]
 405   mov ah, al
 406   mov [edi], ax
 407   inc esi
 408   inc edi
 409   inc edi
 410   dec ecx
 411   jne nextpixel
 412 done:
 413  }
 414 }
 415
 416 #else
 417
 418 void gr_linear_rep_movsd_2x(ubyte *src, ubyte *dest, unsigned int num_pixels)
 419 {
 420         register ubyte c;
 421         while (num_pixels--) {
 422                 if (num_pixels&1)
 423                         *dest++=*src++;
 424                 else {
 425                         unsigned short *sp=(unsigned short *)dest;
 426                         c=*src++;
 427                         *sp=((short)c<<8)|(short)c;
 428                         dest+=2;
 429                 }
 430         }
 431 }
 432
 433 #endif
 434
 435
 436 #ifdef __MSDOS__
 437
 438 static void modex_copy_column(ubyte * src, ubyte * dest, int num_pixels, int src_rowsize, int dest_rowsize );
 439
 440 #if !defined(NO_ASM) && defined(__WATCOMC__)
 441
 442 #pragma aux modex_copy_column parm [esi] [edi] [ecx] [ebx] [edx] modify exact [ecx esi edi] = \
 443 "nextpixel:"            \
 444     "mov    al,[esi]"   \
 445     "add    esi, ebx"   \
 446     "mov    [edi], al"  \
 447     "add    edi, edx"   \
 448     "dec    ecx"        \
 449     "jne    nextpixel"
 450
 451 #elif !defined(NO_ASM) && defined(__GNUC__)
 452
 453 static inline void modex_copy_column(ubyte * src, ubyte * dest, int num_pixels, int src_rowsize, int dest_rowsize ) {
 454 /*#pragma aux modex_copy_column parm [esi] [edi] [ecx] [ebx] [edx] modify exact [ecx esi edi] = */
 455  __asm__ __volatile__ (
 456 "0: ;"
 457     "movb   (%%esi), %%al;"
 458     "addl   %%ebx, %%esi;"
 459     "movb   %%al, (%%edi);"
 460     "addl   %%edx, %%edi;"
 461     "decl   %%ecx;"
 462     "jne    0b"
 463  : : "S" (src), "D" (dest), "c" (num_pixels), "b" (src_rowsize), "d" (dest_rowsize)
 464  : "%eax", "%ecx", "%esi", "%edi");
 465 }
 466
 467 #else
 468
 469 static void modex_copy_column(ubyte * src, ubyte * dest, int num_pixels, int src_rowsize, int dest_rowsize )
 470 {
 471         src = src;
 472         dest = dest;
 473         num_pixels = num_pixels;
 474         src_rowsize = src_rowsize;
 475         dest_rowsize = dest_rowsize;
 476         Int3();
 477 }
 478
 479 #endif
 480
 481
 482 static void modex_copy_column_m(ubyte * src, ubyte * dest, int num_pixels, int src_rowsize, int dest_rowsize );
 483
 484 #if !defined(NO_ASM) && defined(__WATCOMC__)
 485
 486 #pragma aux modex_copy_column_m parm [esi] [edi] [ecx] [ebx] [edx] modify exact [ecx esi edi] = \
 487 "nextpixel:"            \
 488     "mov    al,[esi]"   \
 489     "add    esi, ebx"   \
 490     "cmp    al, " TRANSPARENCY_COLOR_STR   \
 491     "je skip_itx"       \
 492     "mov    [edi], al"  \
 493 "skip_itx:"             \
 494     "add    edi, edx"   \
 495     "dec    ecx"        \
 496     "jne    nextpixel"
 497
 498 #elif !defined(NO_ASM) && defined(__GNUC__)
 499
 500 static inline void modex_copy_column_m(ubyte * src, ubyte * dest, int num_pixels, int src_rowsize, int dest_rowsize ) {
 501 /* #pragma aux modex_copy_column_m parm [esi] [edi] [ecx] [ebx] [edx] modify exact [ecx esi edi] = */
 502  int dummy[3];
 503  __asm__ __volatile__ (
 504 "0: ;"
 505     "movb    (%%esi), %%al;"
 506     "addl    %%ebx, %%esi;"
 507     "cmpb    $" TRANSPARENCY_COLOR_STR ", %%al;"
 508     "je 1f;"
 509     "movb   %%al, (%%edi);"
 510 "1: ;"
 511     "addl   %%edx, %%edi;"
 512     "decl   %%ecx;"
 513     "jne    0b"
 514  : "=c" (dummy[0]), "=S" (dummy[1]), "=D" (dummy[2])
 515  : "1" (src), "2" (dest), "0" (num_pixels), "b" (src_rowsize), "d" (dest_rowsize)
 516  :      "%eax" );
 517 }
 518
 519 #else
 520
 521 static void modex_copy_column_m(ubyte * src, ubyte * dest, int num_pixels, int src_rowsize, int dest_rowsize )
 522 {
 523         src = src;
 524         dest = dest;
 525         num_pixels = num_pixels;
 526         src_rowsize = src_rowsize;
 527         dest_rowsize = dest_rowsize;
 528         Int3();
 529 }
 530
 531 #endif
 532
 533 #endif /* __MSDOS__ */
 534
 535 void gr_ubitmap00( int x, int y, grs_bitmap *bm )
 536 {
 537         register int y1;
 538         int dest_rowsize;
 539
 540         unsigned char * dest;
 541         unsigned char * src;
 542
 543         dest_rowsize=grd_curcanv->cv_bitmap.bm_rowsize << gr_bitblt_dest_step_shift;
 544         dest = &(grd_curcanv->cv_bitmap.bm_data[ dest_rowsize*y+x ]);
 545
 546         src = bm->bm_data;
 547
 548         for (y1=0; y1 < bm->bm_h; y1++ )    {
 549                 if (gr_bitblt_double)
 550                         gr_linear_rep_movsd_2x( src, dest, bm->bm_w );
 551                 else
 552                         gr_linear_movsd( src, dest, bm->bm_w );
 553                 src += bm->bm_rowsize;
 554                 dest+= (int)(dest_rowsize);
 555         }
 556 }
 557
 558 void gr_ubitmap00m( int x, int y, grs_bitmap *bm )
 559 {
 560         register int y1;
 561         int dest_rowsize;
 562
 563         unsigned char * dest;
 564         unsigned char * src;
 565
 566         dest_rowsize=grd_curcanv->cv_bitmap.bm_rowsize << gr_bitblt_dest_step_shift;
 567         dest = &(grd_curcanv->cv_bitmap.bm_data[ dest_rowsize*y+x ]);
 568
 569         src = bm->bm_data;
 570
 571         if (gr_bitblt_fade_table==NULL) {
 572                 for (y1=0; y1 < bm->bm_h; y1++ )    {
 573                         gr_linear_rep_movsdm( src, dest, bm->bm_w );
 574                         src += bm->bm_rowsize;
 575                         dest+= (int)(dest_rowsize);
 576                 }
 577         } else {
 578                 for (y1=0; y1 < bm->bm_h; y1++ )    {
 579                         gr_linear_rep_movsdm_faded( src, dest, bm->bm_w, gr_bitblt_fade_table[y1+y] );
 580                         src += bm->bm_rowsize;
 581                         dest+= (int)(dest_rowsize);
 582                 }
 583         }
 584 }
 585
 586 #if 0
 587 "       jmp     aligned4        "   \
 588 "       mov eax, edi            "   \
 589 "       and eax, 11b            "   \
 590 "       jz      aligned4        "   \
 591 "       mov ebx, 4              "   \
 592 "       sub ebx, eax            "   \
 593 "       sub ecx, ebx            "   \
 594 "alignstart:                    "   \
 595 "       mov al, [esi]           "   \
 596 "       add esi, 4              "   \
 597 "       mov [edi], al           "   \
 598 "       inc edi                 "   \
 599 "       dec ebx                 "   \
 600 "       jne alignstart          "   \
 601 "aligned4:                      "
 602 #endif
 603
 604 #ifdef __MSDOS__
 605
 606 static void modex_copy_scanline( ubyte * src, ubyte * dest, int npixels );
 607
 608 #if !defined(NO_ASM) && defined(__WATCOMC__)
 609
 610 #pragma aux modex_copy_scanline parm [esi] [edi] [ecx] modify exact [ecx esi edi eax ebx edx] = \
 611 "       mov ebx, ecx            "   \
 612 "       and ebx, 11b            "   \
 613 "       shr ecx, 2              "   \
 614 "       cmp ecx, 0              "   \
 615 "       je      no2group        "   \
 616 "next4pixels:                   "   \
 617 "       mov al, [esi+8]         "   \
 618 "       mov ah, [esi+12]        "   \
 619 "       shl eax, 16             "   \
 620 "       mov al, [esi]           "   \
 621 "       mov ah, [esi+4]         "   \
 622 "       mov [edi], eax          "   \
 623 "       add esi, 16             "   \
 624 "       add edi, 4              "   \
 625 "       dec ecx                 "   \
 626 "       jne next4pixels         "   \
 627 "no2group:                      "   \
 628 "       cmp ebx, 0              "   \
 629 "       je      done2           "   \
 630 "finishend:                     "   \
 631 "       mov al, [esi]           "   \
 632 "       add esi, 4              "   \
 633 "       mov [edi], al           "   \
 634 "       inc edi                 "   \
 635 "       dec ebx                 "   \
 636 "       jne finishend           "   \
 637 "done2:                         ";
 638
 639 #elif !defined (NO_ASM) && defined(__GNUC__)
 640
 641 static inline void modex_copy_scanline( ubyte * src, ubyte * dest, int npixels ) {
 642 /* #pragma aux modex_copy_scanline parm [esi] [edi] [ecx] modify exact [ecx esi edi eax ebx edx] */
 643 int dummy[3];
 644  __asm__ __volatile__ (
 645 "       movl %%ecx, %%ebx;"
 646 "       andl $3, %%ebx;"
 647 "       shrl $2, %%ecx;"
 648 "       cmpl $0, %%ecx;"
 649 "       je   1f;"
 650 "0: ;"
 651 "       movb 8(%%esi), %%al;"
 652 "       movb 12(%%esi), %%ah;"
 653 "       shll $16, %%eax;"
 654 "       movb (%%esi), %%al;"
 655 "       movb 4(%%esi), %%ah;"
 656 "       movl %%eax, (%%edi);"
 657 "       addl $16, %%esi;"
 658 "       addl $4, %%edi;"
 659 "       decl %%ecx;"
 660 "       jne 0b;"
 661 "1: ;"
 662 "       cmpl $0, %%ebx;"
 663 "       je      3f;"
 664 "2: ;"
 665 "       movb (%%esi), %%al;"
 666 "       addl $4, %%esi;"
 667 "       movb %%al, (%%edi);"
 668 "       incl %%edi;"
 669 "       decl %%ebx;"
 670 "       jne 2b;"
 671 "3:"
 672  : "=c" (dummy[0]), "=S" (dummy[1]), "=D" (dummy[2])
 673  : "1" (src), "2" (dest), "0" (npixels)
 674  :      "%eax", "%ebx", "%edx" );
 675 }
 676
 677 #else
 678
 679 static void modex_copy_scanline( ubyte * src, ubyte * dest, int npixels )
 680 {
 681         src = src;
 682         dest = dest;
 683         npixels = npixels;
 684         Int3();
 685 }
 686
 687 #endif
 688
 689 static void modex_copy_scanline_2x( ubyte * src, ubyte * dest, int npixels );
 690
 691 #if !defined(NO_ASM) && defined(__WATCOMC__)
 692
 693 #pragma aux modex_copy_scanline_2x parm [esi] [edi] [ecx] modify exact [ecx esi edi eax ebx edx] = \
 694 "       mov ebx, ecx            "   \
 695 "       and ebx, 11b            "   \
 696 "       shr ecx, 2              "   \
 697 "       cmp ecx, 0              "   \
 698 "       je      no2group        "   \
 699 "next4pixels:                   "   \
 700 "       mov al, [esi+4]         "   \
 701 "       mov ah, [esi+6]         "   \
 702 "       shl eax, 16             "   \
 703 "       mov al, [esi]           "   \
 704 "       mov ah, [esi+2]         "   \
 705 "       mov [edi], eax          "   \
 706 "       add esi, 8              "   \
 707 "       add edi, 4              "   \
 708 "       dec ecx                 "   \
 709 "       jne next4pixels         "   \
 710 "no2group:                      "   \
 711 "       cmp ebx, 0              "   \
 712 "       je      done2           "   \
 713 "finishend:                     "   \
 714 "       mov al, [esi]           "   \
 715 "       add esi, 2              "   \
 716 "       mov [edi], al           "   \
 717 "       inc edi                 "   \
 718 "       dec ebx                 "   \
 719 "       jne finishend           "   \
 720 "done2:                         ";
 721
 722 #elif !defined(NO_ASM) && defined(__GNUC__)
 723
 724 static inline void modex_copy_scanline_2x( ubyte * src, ubyte * dest, int npixels ) {
 725 /* #pragma aux modex_copy_scanline_2x parm [esi] [edi] [ecx] modify exact [ecx esi edi eax ebx edx] = */
 726 int dummy[3];
 727  __asm__ __volatile__ (
 728 "       movl %%ecx, %%ebx;"
 729 "       andl $3, %%ebx;"
 730 "       shrl $2, %%ecx;"
 731 "       cmpl $0, %%ecx;"
 732 "       je 1f;"
 733 "0: ;"
 734 "       movb 4(%%esi), %%al;"
 735 "       movb 6(%%esi), %%ah;"
 736 "       shll $16, %%eax;"
 737 "       movb (%%esi), %%al;"
 738 "       movb 2(%%esi), %%ah;"
 739 "       movl %%eax, (%%edi);"
 740 "       addl $8, %%esi;"
 741 "       addl $4, %%edi;"
 742 "       decl %%ecx;"
 743 "       jne 0b;"
 744 "1: ;"
 745 "       cmp $0, %%ebx;"
 746 "       je  3f;"
 747 "2:"
 748 "       movb (%%esi),%%al;"
 749 "       addl $2, %%esi;"
 750 "       movb %%al, (%%edi);"
 751 "       incl %%edi;"
 752 "       decl %%ebx;"
 753 "       jne 2b;"
 754 "3:"
 755  : "=c" (dummy[0]), "=S" (dummy[1]), "=D" (dummy[2])
 756  : "1" (src), "2" (dest), "0" (npixels)
 757  :      "%eax", "%ebx", "%edx" );
 758 }
 759
 760 #else
 761
 762 static void modex_copy_scanline_2x( ubyte * src, ubyte * dest, int npixels )
 763 {
 764         src = src;
 765         dest = dest;
 766         npixels = npixels;
 767         Int3();
 768 }
 769
 770 #endif
 771
 772
 773 // From Linear to ModeX
 774 void gr_bm_ubitblt01(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
 775 {
 776         ubyte * dbits;
 777         ubyte * sbits;
 778         int sstep,dstep;
 779         int y,plane;
 780         int w1;
 781
 782         if ( w < 4 ) return;
 783
 784         sstep = src->bm_rowsize;
 785         dstep = dest->bm_rowsize << gr_bitblt_dest_step_shift;
 786
 787         if (!gr_bitblt_double) {
 788                 for (plane=0; plane<4; plane++ ) {
 789                         gr_modex_setplane( (plane+dx)&3 );
 790                         sbits = src->bm_data + (src->bm_rowsize * sy) + sx + plane;
 791                         dbits = &gr_video_memory[(dest->bm_rowsize * dy) + ((plane+dx)/4) ];
 792                         w1 = w >> 2;
 793                         if ( (w&3) > plane ) w1++;
 794                         for (y=dy; y < dy+h; y++ ) {
 795                                 modex_copy_scanline( sbits, dbits, w1 );
 796                                 dbits += dstep;
 797                                 sbits += sstep;
 798                         }
 799                 }
 800         } else {
 801                 for (plane=0; plane<4; plane++ ) {
 802                         gr_modex_setplane( (plane+dx)&3 );
 803                         sbits = src->bm_data + (src->bm_rowsize * sy) + sx + plane/2;
 804                         dbits = &gr_video_memory[(dest->bm_rowsize * dy) + ((plane+dx)/4) ];
 805                         w1 = w >> 2;
 806                         if ( (w&3) > plane ) w1++;
 807                         for (y=dy; y < dy+h; y++ ) {
 808                                 modex_copy_scanline_2x( sbits, dbits, w1 );
 809                                 dbits += dstep;
 810                                 sbits += sstep;
 811                         }
 812                 }
 813         }
 814 }
 815
 816
 817 // From Linear to ModeX masked
 818 void gr_bm_ubitblt01m(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
 819 {
 820         //ubyte * dbits1;
 821         //ubyte * sbits1;
 822
 823         ubyte * dbits;
 824         ubyte * sbits;
 825
 826         int x;
 827         //int y;
 828
 829         sbits =   src->bm_data  + (src->bm_rowsize * sy) + sx;
 830         dbits =   &gr_video_memory[(dest->bm_rowsize * dy) + dx/4];
 831
 832         for (x=dx; x < dx+w; x++ ) {
 833                 gr_modex_setplane( x&3 );
 834
 835                 //sbits1 = sbits;
 836                 //dbits1 = dbits;
 837                 //for (y=0; y < h; y++ )    {
 838                 //      *dbits1 = *sbits1;
 839                 //      sbits1 += src_bm_rowsize;
 840                 //      dbits1 += dest_bm_rowsize;
 841                 //}
 842                 modex_copy_column_m(sbits, dbits, h, src->bm_rowsize, dest->bm_rowsize << gr_bitblt_dest_step_shift );
 843
 844                 sbits++;
 845                 if ( (x&3)==3 )
 846                         dbits++;
 847         }
 848 }
 849
 850 #endif /* __MSDOS__ */
 851
 852
 853 void gr_ubitmap012( int x, int y, grs_bitmap *bm )
 854 {
 855         register int x1, y1;
 856         unsigned char * src;
 857
 858         src = bm->bm_data;
 859
 860         for (y1=y; y1 < (y+bm->bm_h); y1++ )    {
 861                 for (x1=x; x1 < (x+bm->bm_w); x1++ )    {
 862                         gr_setcolor( *src++ );
 863                         gr_upixel( x1, y1 );
 864                 }
 865         }
 866 }
 867
 868 void gr_ubitmap012m( int x, int y, grs_bitmap *bm )
 869 {
 870         register int x1, y1;
 871         unsigned char * src;
 872
 873         src = bm->bm_data;
 874
 875         for (y1=y; y1 < (y+bm->bm_h); y1++ ) {
 876                 for (x1=x; x1 < (x+bm->bm_w); x1++ ) {
 877                         if ( *src != TRANSPARENCY_COLOR ) {
 878                                 gr_setcolor( *src );
 879                                 gr_upixel( x1, y1 );
 880                         }
 881                         src++;
 882                 }
 883         }
 884 }
 885
 886 void gr_ubitmapGENERIC(int x, int y, grs_bitmap * bm)
 887 {
 888         register int x1, y1;
 889
 890         for (y1=0; y1 < bm->bm_h; y1++ )    {
 891                 for (x1=0; x1 < bm->bm_w; x1++ )    {
 892                         gr_setcolor( gr_gpixel(bm,x1,y1) );
 893                         gr_upixel( x+x1, y+y1 );
 894                 }
 895         }
 896 }
 897
 898 void gr_ubitmapGENERICm(int x, int y, grs_bitmap * bm)
 899 {
 900         register int x1, y1;
 901         ubyte c;
 902
 903         for (y1=0; y1 < bm->bm_h; y1++ ) {
 904                 for (x1=0; x1 < bm->bm_w; x1++ ) {
 905                         c = gr_gpixel(bm,x1,y1);
 906                         if ( c != TRANSPARENCY_COLOR ) {
 907                                 gr_setcolor( c );
 908                                 gr_upixel( x+x1, y+y1 );
 909                         }
 910                 }
 911         }
 912 }
 913
 914
 915 #ifdef __MSDOS__
 916 // From linear to SVGA
 917 void gr_bm_ubitblt02(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
 918 {
 919         unsigned char * sbits;
 920
 921         unsigned int offset, EndingOffset, VideoLocation;
 922
 923         int sbpr, dbpr, y1, page, BytesToMove;
 924
 925         sbpr = src->bm_rowsize;
 926
 927         dbpr = dest->bm_rowsize << gr_bitblt_dest_step_shift;
 928
 929         VideoLocation = (unsigned int)dest->bm_data + (dest->bm_rowsize * dy) + dx;
 930
 931         sbits = src->bm_data + ( sbpr*sy ) + sx;
 932
 933         for (y1=0; y1 < h; y1++ )    {
 934
 935                 page    = VideoLocation >> 16;
 936                 offset  = VideoLocation & 0xFFFF;
 937
 938                 gr_vesa_setpage( page );
 939
 940                 EndingOffset = offset+w-1;
 941
 942                 if ( EndingOffset <= 0xFFFF )
 943                 {
 944                         if ( gr_bitblt_double )
 945                                 gr_linear_rep_movsd_2x( (void *)sbits, (void *)(offset+0xA0000), w );
 946                         else
 947                                 gr_linear_movsd( (void *)sbits, (void *)(offset+0xA0000), w );
 948
 949                         VideoLocation += dbpr;
 950                         sbits += sbpr;
 951                 }
 952                 else
 953                 {
 954                         BytesToMove = 0xFFFF-offset+1;
 955
 956                         if ( gr_bitblt_double )
 957                                 gr_linear_rep_movsd_2x( (void *)sbits, (void *)(offset+0xA0000), BytesToMove );
 958                         else
 959                                 gr_linear_movsd( (void *)sbits, (void *)(offset+0xA0000), BytesToMove );
 960
 961                         page++;
 962                         gr_vesa_setpage(page);
 963
 964                         if ( gr_bitblt_double )
 965                                 gr_linear_rep_movsd_2x( (void *)(sbits+BytesToMove/2), (void *)0xA0000, EndingOffset - 0xFFFF );
 966                         else
 967                                 gr_linear_movsd( (void *)(sbits+BytesToMove), (void *)0xA0000, EndingOffset - 0xFFFF );
 968
 969                         VideoLocation += dbpr;
 970                         sbits += sbpr;
 971                 }
 972         }
 973 }
 974 #endif
 975
 976 #ifdef __MSDOS__
 977
 978 void gr_bm_ubitblt02m(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
 979 {
 980         unsigned char * sbits;
 981
 982         unsigned int offset, EndingOffset, VideoLocation;
 983
 984         int sbpr, dbpr, y1, page, BytesToMove;
 985
 986         sbpr = src->bm_rowsize;
 987
 988         dbpr = dest->bm_rowsize << gr_bitblt_dest_step_shift;
 989
 990         VideoLocation = (unsigned int)dest->bm_data + (dest->bm_rowsize * dy) + dx;
 991
 992         sbits = src->bm_data + ( sbpr*sy ) + sx;
 993
 994         for (y1=0; y1 < h; y1++ )    {
 995
 996                 page    = VideoLocation >> 16;
 997                 offset  = VideoLocation & 0xFFFF;
 998
 999                 gr_vesa_setpage( page );
1000
1001                 EndingOffset = offset+w-1;
1002
1003                 if ( EndingOffset <= 0xFFFF )
1004                 {
1005                         gr_linear_rep_movsdm( (void *)sbits, (void *)(offset+0xA0000), w );
1006
1007                         VideoLocation += dbpr;
1008                         sbits += sbpr;
1009                 }
1010                 else
1011                 {
1012                         BytesToMove = 0xFFFF-offset+1;
1013
1014                         gr_linear_rep_movsdm( (void *)sbits, (void *)(offset+0xA0000), BytesToMove );
1015
1016                         page++;
1017                         gr_vesa_setpage(page);
1018
1019                         gr_linear_rep_movsdm( (void *)(sbits+BytesToMove), (void *)0xA0000, EndingOffset - 0xFFFF );
1020
1021                         VideoLocation += dbpr;
1022                         sbits += sbpr;
1023                 }
1024         }
1025 }
1026
1027
1028 // From SVGA to linear
1029 void gr_bm_ubitblt20(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1030 {
1031         unsigned char * dbits;
1032
1033         unsigned int offset, offset1, offset2;
1034
1035         int sbpr, dbpr, y1, page;
1036
1037         dbpr = dest->bm_rowsize;
1038
1039         sbpr = src->bm_rowsize;
1040
1041         for (y1=0; y1 < h; y1++ )    {
1042
1043                 offset2 =   (unsigned int)src->bm_data  + (sbpr * (y1+sy)) + sx;
1044                 dbits   =   dest->bm_data + (dbpr * (y1+dy)) + dx;
1045
1046                 page = offset2 >> 16;
1047                 offset = offset2 & 0xFFFF;
1048                 offset1 = offset+w-1;
1049                 gr_vesa_setpage( page );
1050
1051                 if ( offset1 > 0xFFFF )  {
1052                         // Overlaps two pages
1053                         while( offset <= 0xFFFF )
1054                                 *dbits++ = gr_video_memory[offset++];
1055                         offset1 -= (0xFFFF+1);
1056                         offset = 0;
1057                         page++;
1058                         gr_vesa_setpage(page);
1059                 }
1060                 while( offset <= offset1 )
1061                         *dbits++ = gr_video_memory[offset++];
1062
1063         }
1064 }
1065
1066 #endif
1067
1068 //@extern int Interlacing_on;
1069
1070 // From Linear to Linear
1071 void gr_bm_ubitblt00(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1072 {
1073         unsigned char * dbits;
1074         unsigned char * sbits;
1075         //int src_bm_rowsize_2, dest_bm_rowsize_2;
1076         int dstep;
1077
1078         int i;
1079
1080         sbits =   src->bm_data  + (src->bm_rowsize * sy) + sx;
1081         dbits =   dest->bm_data + (dest->bm_rowsize * dy) + dx;
1082
1083         dstep = dest->bm_rowsize << gr_bitblt_dest_step_shift;
1084
1085         // No interlacing, copy the whole buffer.
1086         for (i=0; i < h; i++ )    {
1087                 if (gr_bitblt_double)
1088                         gr_linear_rep_movsd_2x( sbits, dbits, w );
1089                 else
1090                         gr_linear_movsd( sbits, dbits, w );
1091                 sbits += src->bm_rowsize;
1092                 dbits += dstep;
1093         }
1094 }
1095 // From Linear to Linear Masked
1096 void gr_bm_ubitblt00m(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1097 {
1098         unsigned char * dbits;
1099         unsigned char * sbits;
1100         //int src_bm_rowsize_2, dest_bm_rowsize_2;
1101
1102         int i;
1103
1104         sbits =   src->bm_data  + (src->bm_rowsize * sy) + sx;
1105         dbits =   dest->bm_data + (dest->bm_rowsize * dy) + dx;
1106
1107         // No interlacing, copy the whole buffer.
1108
1109         if (gr_bitblt_fade_table==NULL) {
1110                 for (i=0; i < h; i++ )    {
1111                         gr_linear_rep_movsdm( sbits, dbits, w );
1112                         sbits += src->bm_rowsize;
1113                         dbits += dest->bm_rowsize;
1114                 }
1115         } else {
1116                 for (i=0; i < h; i++ )    {
1117                         gr_linear_rep_movsdm_faded( sbits, dbits, w, gr_bitblt_fade_table[dy+i] );
1118                         sbits += src->bm_rowsize;
1119                         dbits += dest->bm_rowsize;
1120                 }
1121         }
1122 }
1123
1124
1125 extern void gr_lbitblt( grs_bitmap * source, grs_bitmap * dest, int height, int width );
1126
1127 #ifdef MACINTOSH
1128
1129 //extern void BlitLargeAlign(ubyte *draw_buffer, int dstRowBytes, ubyte *dstPtr, int w, int h, int modulus);
1130
1131 asm void BlitLargeAlign(ubyte *rSrcPtr, int rDblDStrd, ubyte *rDst1Ptr, int rWidth, int rHeight, int rModulus)
1132 {
1133     stw     r31,-4(SP)          // store non-volatile reg in red zone
1134     addi    r5,r5,-8            // subtract 8 from dst
1135     stw     r30,-8(SP)          // store non-volatile reg in red zone
1136
1137     la      r30,-16(SP)         // calculate copy of local 8-byte variable
1138     sub     r9,r8,r6
1139                                 // rSStrd = modulus - w
1140     add     r31,r5,r4           // dst2 = dstRowBytes + dst1
1141     sub     r4,r4,r6            // r4 = dstRowBytes - w
1142     addi    r7,r7,-1            // subtract 1 from height count
1143     srawi   r6,r6,2             // rWidth = w >> 2
1144     addi    r3,r3,-4            // subtract 4 from src
1145     addi    r6,r6,-1            // subtract 1 from width count
1146     add     r4,r4,r4            // rDblDStrd = 2 * r4
1147
1148 BlitLargeAlignY:                // y count is in r7
1149     lwzu     r10,4(r3)          // load a long into r10
1150     mr       r0,r10             // put a copy in r0
1151     mr       r11,r10
1152 // these are simplified -- can't use 'em    inslwi   r0,r10,16,8
1153 // these are simplified -- can't use 'em    insrwi   r11,r10,16,8
1154     rlwimi   r0,r10,24,8,31
1155     rlwimi   r11,r10,8,8,23
1156     rlwimi   r0,r10,16,24,31
1157     stw      r0,0(r30)
1158     rlwimi   r11,r10,16,0,7
1159     stw      r11,4(r30)
1160     mtctr       r6              // copy x count into the counter
1161     lfd      fp0,0(r30)
1162
1163 BlitLargeAlignX:
1164     lwzu     r10,4(r3)          // load a long into r10
1165     stfdu    fp0,8(r5)
1166     mr       r0,r10             // put a copy in r0
1167     mr       r11,r10
1168 // simplefied   inslwi   r0,r10,16,8
1169 // simplefied   insrwi   r11,r10,16,8
1170     rlwimi   r0,r10,24,8,31
1171     rlwimi   r11,r10,8,8,23
1172     rlwimi   r0,r10,16,24,31
1173     stw      r0,0(r30)
1174     rlwimi   r11,r10,16,0,7
1175     stw      r11,4(r30)
1176     stfdu    fp0,8(r31)
1177     lfd      fp0,0(r30)
1178     bdnz     BlitLargeAlignX    // loop over all x
1179
1180     stfdu    fp0,8(r5)
1181     addic.   r7,r7,-1           // decrement the counter
1182     add      r3,r3,r9
1183                                 // src += sstride
1184     add      r5,r5,r4
1185                                 // dst1 += dstride
1186     stfdu    fp0,8(r31)
1187     add      r31,r31,r4
1188                                 // dst2 += dstride
1189     bne      BlitLargeAlignY    // loop for all y
1190
1191     lwz     r30,-8(SP)          // restore non-volatile regs
1192     lwz     r31,-4(SP)          // restore non-volatile regs
1193     blr                         // return to caller
1194 }
1195
1196 #endif /* MACINTOSH */
1197
1198
1199 // Clipped bitmap ...
1200
1201 void gr_bitmap( int x, int y, grs_bitmap *bm )
1202 {
1203         int dx1=x, dx2=x+bm->bm_w-1;
1204         int dy1=y, dy2=y+bm->bm_h-1;
1205         int sx=0, sy=0;
1206
1207         if ((dx1 >= grd_curcanv->cv_bitmap.bm_w ) || (dx2 < 0)) return;
1208         if ((dy1 >= grd_curcanv->cv_bitmap.bm_h) || (dy2 < 0)) return;
1209         if ( dx1 < 0 ) { sx = -dx1; dx1 = 0; }
1210         if ( dy1 < 0 ) { sy = -dy1; dy1 = 0; }
1211         if ( dx2 >= grd_curcanv->cv_bitmap.bm_w ) { dx2 = grd_curcanv->cv_bitmap.bm_w-1; }
1212         if ( dy2 >= grd_curcanv->cv_bitmap.bm_h ) { dy2 = grd_curcanv->cv_bitmap.bm_h-1; }
1213
1214         // Draw bitmap bm[x,y] into (dx1,dy1)-(dx2,dy2)
1215
1216         gr_bm_ubitblt(dx2-dx1+1,dy2-dy1+1, dx1, dy1, sx, sy, bm, &grd_curcanv->cv_bitmap );
1217
1218 }
1219
1220 //-NOT-used // From linear to SVGA
1221 //-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)
1222 //-NOT-used {
1223 //-NOT-used     unsigned char * sbits;
1224 //-NOT-used
1225 //-NOT-used     unsigned int offset, EndingOffset, VideoLocation;
1226 //-NOT-used
1227 //-NOT-used     int sbpr, dbpr, y1, page, BytesToMove;
1228 //-NOT-used
1229 //-NOT-used     sbpr = src->bm_rowsize;
1230 //-NOT-used
1231 //-NOT-used     dbpr = dest->bm_rowsize << gr_bitblt_dest_step_shift;
1232 //-NOT-used
1233 //-NOT-used     VideoLocation = (unsigned int)dest->bm_data + (dest->bm_rowsize * dy) + dx;
1234 //-NOT-used
1235 //-NOT-used     sbits = src->bm_data + ( sbpr*sy ) + sx;
1236 //-NOT-used
1237 //-NOT-used     for (y1=0; y1 < h; y1++ )    {
1238 //-NOT-used
1239 //-NOT-used             page    = VideoLocation >> 16;
1240 //-NOT-used             offset  = VideoLocation & 0xFFFF;
1241 //-NOT-used
1242 //-NOT-used             gr_vesa_setpage( page );
1243 //-NOT-used
1244 //-NOT-used             EndingOffset = offset+w-1;
1245 //-NOT-used
1246 //-NOT-used             if ( EndingOffset <= 0xFFFF )
1247 //-NOT-used             {
1248 //-NOT-used                     gr_linear_rep_movsd_2x( (void *)sbits, (void *)(offset+0xA0000), w );
1249 //-NOT-used
1250 //-NOT-used                     VideoLocation += dbpr;
1251 //-NOT-used                     sbits += sbpr;
1252 //-NOT-used             }
1253 //-NOT-used             else
1254 //-NOT-used             {
1255 //-NOT-used                     BytesToMove = 0xFFFF-offset+1;
1256 //-NOT-used
1257 //-NOT-used                     gr_linear_rep_movsd_2x( (void *)sbits, (void *)(offset+0xA0000), BytesToMove );
1258 //-NOT-used
1259 //-NOT-used                     page++;
1260 //-NOT-used                     gr_vesa_setpage(page);
1261 //-NOT-used
1262 //-NOT-used                     gr_linear_rep_movsd_2x( (void *)(sbits+BytesToMove/2), (void *)0xA0000, EndingOffset - 0xFFFF );
1263 //-NOT-used
1264 //-NOT-used                     VideoLocation += dbpr;
1265 //-NOT-used                     sbits += sbpr;
1266 //-NOT-used             }
1267 //-NOT-used
1268 //-NOT-used
1269 //-NOT-used     }
1270 //-NOT-used }
1271
1272
1273 //-NOT-used // From Linear to Linear
1274 //-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)
1275 //-NOT-used {
1276 //-NOT-used     unsigned char * dbits;
1277 //-NOT-used     unsigned char * sbits;
1278 //-NOT-used     //int src_bm_rowsize_2, dest_bm_rowsize_2;
1279 //-NOT-used
1280 //-NOT-used     int i;
1281 //-NOT-used
1282 //-NOT-used     sbits =   src->bm_data  + (src->bm_rowsize * sy) + sx;
1283 //-NOT-used     dbits =   dest->bm_data + (dest->bm_rowsize * dy) + dx;
1284 //-NOT-used
1285 //-NOT-used     // No interlacing, copy the whole buffer.
1286 //-NOT-used     for (i=0; i < h; i++ )    {
1287 //-NOT-used             gr_linear_rep_movsd_2x( sbits, dbits, w );
1288 //-NOT-used
1289 //-NOT-used             sbits += src->bm_rowsize;
1290 //-NOT-used             dbits += dest->bm_rowsize << gr_bitblt_dest_step_shift;
1291 //-NOT-used     }
1292 //-NOT-used }
1293
1294 void gr_bm_ubitblt00_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1295 {
1296         unsigned char * dbits;
1297         unsigned char * sbits;
1298         int i, data_offset;
1299
1300         data_offset = 1;
1301         if (src->bm_flags & BM_FLAG_RLE_BIG)
1302                 data_offset = 2;
1303
1304         sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
1305
1306         for (i=0; i<sy; i++ )
1307                 sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
1308
1309         dbits = dest->bm_data + (dest->bm_rowsize * dy) + dx;
1310
1311         // No interlacing, copy the whole buffer.
1312         for (i=0; i < h; i++ )    {
1313                 gr_rle_expand_scanline( dbits, sbits, sx, sx+w-1 );
1314                 if ( src->bm_flags & BM_FLAG_RLE_BIG )
1315                         sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((i+sy)*data_offset)])));
1316                 else
1317                         sbits += (int)(src->bm_data[4+i+sy]);
1318                 dbits += dest->bm_rowsize << gr_bitblt_dest_step_shift;
1319         }
1320 }
1321
1322 void gr_bm_ubitblt00m_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1323 {
1324         unsigned char * dbits;
1325         unsigned char * sbits;
1326         int i, data_offset;
1327
1328         data_offset = 1;
1329         if (src->bm_flags & BM_FLAG_RLE_BIG)
1330                 data_offset = 2;
1331
1332         sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
1333         for (i=0; i<sy; i++ )
1334                 sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
1335
1336         dbits = dest->bm_data + (dest->bm_rowsize * dy) + dx;
1337
1338         // No interlacing, copy the whole buffer.
1339         for (i=0; i < h; i++ )    {
1340                 gr_rle_expand_scanline_masked( dbits, sbits, sx, sx+w-1 );
1341                 if ( src->bm_flags & BM_FLAG_RLE_BIG )
1342                         sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((i+sy)*data_offset)])));
1343                 else
1344                         sbits += (int)(src->bm_data[4+i+sy]);
1345                 dbits += dest->bm_rowsize << gr_bitblt_dest_step_shift;
1346         }
1347 }
1348
1349 // in rle.c
1350
1351 extern void gr_rle_expand_scanline_generic( grs_bitmap * dest, int dx, int dy, ubyte *src, int x1, int x2  );
1352 extern void gr_rle_expand_scanline_generic_masked( grs_bitmap * dest, int dx, int dy, ubyte *src, int x1, int x2  );
1353 extern void gr_rle_expand_scanline_svga_masked( grs_bitmap * dest, int dx, int dy, ubyte *src, int x1, int x2  );
1354
1355 void gr_bm_ubitblt0x_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1356 {
1357         int i, data_offset;
1358         register int y1;
1359         unsigned char * sbits;
1360
1361         //mprintf( 0, "SVGA RLE!\n" );
1362
1363         data_offset = 1;
1364         if (src->bm_flags & BM_FLAG_RLE_BIG)
1365                 data_offset = 2;
1366
1367         sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
1368         for (i=0; i<sy; i++ )
1369                 sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
1370
1371         for (y1=0; y1 < h; y1++ )    {
1372                 gr_rle_expand_scanline_generic( dest, dx, dy+y1,  sbits, sx, sx+w-1  );
1373                 if ( src->bm_flags & BM_FLAG_RLE_BIG )
1374                         sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((y1+sy)*data_offset)])));
1375                 else
1376                         sbits += (int)src->bm_data[4+y1+sy];
1377         }
1378
1379 }
1380
1381 void gr_bm_ubitblt0xm_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1382 {
1383         int i, data_offset;
1384         register int y1;
1385         unsigned char * sbits;
1386
1387         //mprintf( 0, "SVGA RLE!\n" );
1388
1389         data_offset = 1;
1390         if (src->bm_flags & BM_FLAG_RLE_BIG)
1391                 data_offset = 2;
1392
1393         sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
1394         for (i=0; i<sy; i++ )
1395                 sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
1396
1397         for (y1=0; y1 < h; y1++ )    {
1398                 gr_rle_expand_scanline_generic_masked( dest, dx, dy+y1,  sbits, sx, sx+w-1  );
1399                 if ( src->bm_flags & BM_FLAG_RLE_BIG )
1400                         sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((y1+sy)*data_offset)])));
1401                 else
1402                         sbits += (int)src->bm_data[4+y1+sy];
1403         }
1404
1405 }
1406
1407 #ifdef __MSDOS__
1408 void gr_bm_ubitblt02m_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1409 {
1410         int i, data_offset;
1411         register int y1;
1412         unsigned char * sbits;
1413
1414         //mprintf( 0, "SVGA RLE!\n" );
1415
1416         data_offset = 1;
1417         if (src->bm_flags & BM_FLAG_RLE_BIG)
1418                 data_offset = 2;
1419
1420         sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
1421         for (i=0; i<sy; i++ )
1422                 sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
1423
1424         for (y1=0; y1 < h; y1++ )    {
1425                 gr_rle_expand_scanline_svga_masked( dest, dx, dy+y1,  sbits, sx, sx+w-1  );
1426                 if ( src->bm_flags & BM_FLAG_RLE_BIG )
1427                         sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((y1+sy)*data_offset)])));
1428                 else
1429                         sbits += (int)src->bm_data[4+y1+sy];
1430         }
1431 }
1432 #endif
1433
1434 void gr_bm_ubitblt(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1435 {
1436         register int x1, y1;
1437
1438         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_LINEAR ))
1439         {
1440                 if ( src->bm_flags & BM_FLAG_RLE )
1441                         gr_bm_ubitblt00_rle( w, h, dx, dy, sx, sy, src, dest );
1442                 else
1443                         gr_bm_ubitblt00( w, h, dx, dy, sx, sy, src, dest );
1444                 return;
1445         }
1446
1447 #ifdef OGL
1448         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_OGL ))
1449         {
1450                 ogl_ubitblt(w, h, dx, dy, sx, sy, src, dest);
1451                 return;
1452         }
1453         if ( (src->bm_type == BM_OGL) && (dest->bm_type == BM_LINEAR ))
1454         {
1455                 ogl_ubitblt_tolinear(w, h, dx, dy, sx, sy, src, dest);
1456                 return;
1457         }
1458         if ( (src->bm_type == BM_OGL) && (dest->bm_type == BM_OGL ))
1459         {
1460                 ogl_ubitblt_copy(w, h, dx, dy, sx, sy, src, dest);
1461                 return;
1462         }
1463 #endif
1464
1465         if ( (src->bm_flags & BM_FLAG_RLE ) && (src->bm_type == BM_LINEAR) ) {
1466                 gr_bm_ubitblt0x_rle(w, h, dx, dy, sx, sy, src, dest );
1467                 return;
1468         }
1469
1470 #ifdef __MSDOS__
1471         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_SVGA ))
1472         {
1473                 gr_bm_ubitblt02( w, h, dx, dy, sx, sy, src, dest );
1474                 return;
1475         }
1476
1477         if ( (src->bm_type == BM_SVGA) && (dest->bm_type == BM_LINEAR ))
1478         {
1479                 gr_bm_ubitblt20( w, h, dx, dy, sx, sy, src, dest );
1480                 return;
1481         }
1482
1483         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_MODEX ))
1484         {
1485                 gr_bm_ubitblt01( w, h, dx+XOFFSET, dy+YOFFSET, sx, sy, src, dest );
1486                 return;
1487         }
1488 #endif
1489
1490         for (y1=0; y1 < h; y1++ )    {
1491                 for (x1=0; x1 < w; x1++ )    {
1492                         gr_bm_pixel( dest, dx+x1, dy+y1, gr_gpixel(src,sx+x1,sy+y1) );
1493                 }
1494         }
1495 }
1496
1497 void gr_bm_bitblt(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1498 {
1499         int dx1=dx, dx2=dx+dest->bm_w-1;
1500         int dy1=dy, dy2=dy+dest->bm_h-1;
1501
1502         int sx1=sx, sx2=sx+src->bm_w-1;
1503         int sy1=sy, sy2=sy+src->bm_h-1;
1504
1505         if ((dx1 >= dest->bm_w ) || (dx2 < 0)) return;
1506         if ((dy1 >= dest->bm_h ) || (dy2 < 0)) return;
1507         if ( dx1 < 0 ) { sx1 += -dx1; dx1 = 0; }
1508         if ( dy1 < 0 ) { sy1 += -dy1; dy1 = 0; }
1509         if ( dx2 >= dest->bm_w ) { dx2 = dest->bm_w-1; }
1510         if ( dy2 >= dest->bm_h ) { dy2 = dest->bm_h-1; }
1511
1512         if ((sx1 >= src->bm_w ) || (sx2 < 0)) return;
1513         if ((sy1 >= src->bm_h ) || (sy2 < 0)) return;
1514         if ( sx1 < 0 ) { dx1 += -sx1; sx1 = 0; }
1515         if ( sy1 < 0 ) { dy1 += -sy1; sy1 = 0; }
1516         if ( sx2 >= src->bm_w ) { sx2 = src->bm_w-1; }
1517         if ( sy2 >= src->bm_h ) { sy2 = src->bm_h-1; }
1518
1519         // Draw bitmap bm[x,y] into (dx1,dy1)-(dx2,dy2)
1520         if ( dx2-dx1+1 < w )
1521                 w = dx2-dx1+1;
1522         if ( dy2-dy1+1 < h )
1523                 h = dy2-dy1+1;
1524         if ( sx2-sx1+1 < w )
1525                 w = sx2-sx1+1;
1526         if ( sy2-sy1+1 < h )
1527                 h = sy2-sy1+1;
1528
1529         gr_bm_ubitblt(w,h, dx1, dy1, sx1, sy1, src, dest );
1530 }
1531
1532 void gr_ubitmap( int x, int y, grs_bitmap *bm )
1533 {
1534         int source, dest;
1535
1536         source = bm->bm_type;
1537         dest = TYPE;
1538
1539         if (source==BM_LINEAR) {
1540                 switch( dest )
1541                 {
1542                 case BM_LINEAR:
1543                         if ( bm->bm_flags & BM_FLAG_RLE )
1544                                 gr_bm_ubitblt00_rle(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap );
1545                         else
1546                                 gr_ubitmap00( x, y, bm );
1547                         return;
1548 #ifdef OGL
1549                 case BM_OGL:
1550                         ogl_ubitmapm(x,y,bm);
1551                         return;
1552 #endif
1553 #ifdef __MSDOS__
1554                 case BM_SVGA:
1555                         if ( bm->bm_flags & BM_FLAG_RLE )
1556                                 gr_bm_ubitblt0x_rle(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap );
1557                         else
1558                                 gr_vesa_bitmap( bm, &grd_curcanv->cv_bitmap, x, y );
1559                         return;
1560                 case BM_MODEX:
1561                         gr_bm_ubitblt01(bm->bm_w, bm->bm_h, x+XOFFSET, y+YOFFSET, 0, 0, bm, &grd_curcanv->cv_bitmap);
1562                         return;
1563 #endif
1564                 default:
1565                         gr_ubitmap012( x, y, bm );
1566                         return;
1567                 }
1568         } else  {
1569                 gr_ubitmapGENERIC(x, y, bm);
1570         }
1571 }
1572
1573
1574 void gr_ubitmapm( int x, int y, grs_bitmap *bm )
1575 {
1576         int source, dest;
1577
1578         source = bm->bm_type;
1579         dest = TYPE;
1580
1581         Assert(x+bm->bm_w <= grd_curcanv->cv_w);
1582 #ifndef OGL
1583         Assert(y+bm->bm_h <= grd_curcanv->cv_h);
1584 #endif
1585
1586         if (source==BM_LINEAR) {
1587                 switch( dest )
1588                 {
1589                 case BM_LINEAR:
1590                         if ( bm->bm_flags & BM_FLAG_RLE )
1591                                 gr_bm_ubitblt00m_rle(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap );
1592                         else
1593                                 gr_ubitmap00m( x, y, bm );
1594                         return;
1595 #ifdef OGL
1596                 case BM_OGL:
1597                         ogl_ubitmapm(x,y,bm);
1598                         return;
1599 #endif
1600 #ifdef __MSDOS__
1601                 case BM_SVGA:
1602                         if (bm->bm_flags & BM_FLAG_RLE)
1603                                 gr_bm_ubitblt02m_rle(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap);
1604                         //gr_bm_ubitblt0xm_rle(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap);
1605                         else
1606                                 gr_bm_ubitblt02m(bm->bm_w, bm->bm_h, x, y, 0, 0, bm, &grd_curcanv->cv_bitmap);
1607                         //gr_ubitmapGENERICm(x, y, bm);
1608                         return;
1609                 case BM_MODEX:
1610                         gr_bm_ubitblt01m(bm->bm_w, bm->bm_h, x+XOFFSET, y+YOFFSET, 0, 0, bm, &grd_curcanv->cv_bitmap);
1611                         return;
1612 #endif
1613
1614                 default:
1615                         gr_ubitmap012m( x, y, bm );
1616                         return;
1617                 }
1618         } else {
1619                 gr_ubitmapGENERICm(x, y, bm);
1620         }
1621 }
1622
1623
1624 void gr_bitmapm( int x, int y, grs_bitmap *bm )
1625 {
1626         int dx1=x, dx2=x+bm->bm_w-1;
1627         int dy1=y, dy2=y+bm->bm_h-1;
1628         int sx=0, sy=0;
1629
1630         if ((dx1 >= grd_curcanv->cv_bitmap.bm_w ) || (dx2 < 0)) return;
1631         if ((dy1 >= grd_curcanv->cv_bitmap.bm_h) || (dy2 < 0)) return;
1632         if ( dx1 < 0 ) { sx = -dx1; dx1 = 0; }
1633         if ( dy1 < 0 ) { sy = -dy1; dy1 = 0; }
1634         if ( dx2 >= grd_curcanv->cv_bitmap.bm_w ) { dx2 = grd_curcanv->cv_bitmap.bm_w-1; }
1635         if ( dy2 >= grd_curcanv->cv_bitmap.bm_h ) { dy2 = grd_curcanv->cv_bitmap.bm_h-1; }
1636
1637         // Draw bitmap bm[x,y] into (dx1,dy1)-(dx2,dy2)
1638
1639         if ( (bm->bm_type == BM_LINEAR) && (grd_curcanv->cv_bitmap.bm_type == BM_LINEAR ))
1640         {
1641                 if ( bm->bm_flags & BM_FLAG_RLE )
1642                         gr_bm_ubitblt00m_rle(dx2-dx1+1,dy2-dy1+1, dx1, dy1, sx, sy, bm, &grd_curcanv->cv_bitmap );
1643                 else
1644                         gr_bm_ubitblt00m(dx2-dx1+1,dy2-dy1+1, dx1, dy1, sx, sy, bm, &grd_curcanv->cv_bitmap );
1645                 return;
1646         }
1647 #ifdef __MSDOS__
1648         else if ( (bm->bm_type == BM_LINEAR) && (grd_curcanv->cv_bitmap.bm_type == BM_SVGA ))
1649         {
1650                 gr_bm_ubitblt02m(dx2-dx1+1,dy2-dy1+1, dx1, dy1, sx, sy, bm, &grd_curcanv->cv_bitmap );
1651                 return;
1652         }
1653 #endif
1654
1655         gr_bm_ubitbltm(dx2-dx1+1,dy2-dy1+1, dx1, dy1, sx, sy, bm, &grd_curcanv->cv_bitmap );
1656
1657 }
1658
1659 void gr_bm_ubitbltm(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, grs_bitmap * dest)
1660 {
1661         register int x1, y1;
1662         ubyte c;
1663
1664 #ifdef OGL
1665         if ( (src->bm_type == BM_LINEAR) && (dest->bm_type == BM_OGL ))
1666         {
1667                 ogl_ubitblt(w, h, dx, dy, sx, sy, src, dest);
1668                 return;
1669         }
1670         if ( (src->bm_type == BM_OGL) && (dest->bm_type == BM_LINEAR ))
1671         {
1672                 ogl_ubitblt_tolinear(w, h, dx, dy, sx, sy, src, dest);
1673                 return;
1674         }
1675         if ( (src->bm_type == BM_OGL) && (dest->bm_type == BM_OGL ))
1676         {
1677                 ogl_ubitblt_copy(w, h, dx, dy, sx, sy, src, dest);
1678                 return;
1679         }
1680 #endif
1681
1682         for (y1=0; y1 < h; y1++ )    {
1683                 for (x1=0; x1 < w; x1++ )    {
1684                         if ((c=gr_gpixel(src,sx+x1,sy+y1))!=TRANSPARENCY_COLOR)
1685                                 gr_bm_pixel( dest, dx+x1, dy+y1,c  );
1686                 }
1687         }
1688 }
1689
1690
1691 // rescalling bitmaps, 10/14/99 Jan Bobrowski jb@wizard.ae.krakow.pl
1692 void gr_bitmap_scale_line(unsigned char *in, unsigned char *out, int ilen, int olen)
1693 {
1694         int a = olen/ilen, b = olen%ilen;
1695         int c = 0, i;
1696         unsigned char *end = out + olen;
1697         while(out<end) {
1698                 i = a;
1699                 c += b;
1700                 if(c >= ilen) {
1701                         c -= ilen;
1702                         goto inside;
1703                 }
1704                 while(--i>=0) {
1705                 inside:
1706                         *out++ = *in;
1707                 }
1708                 in++;
1709         }
1710 }
1711
1712 void gr_bitmap_scale_to(grs_bitmap *src, grs_bitmap *dst)
1713 {
1714         unsigned char *s = src->bm_data;
1715         unsigned char *d = dst->bm_data;
1716         int h = src->bm_h;
1717         int a = dst->bm_h/h, b = dst->bm_h%h;
1718         int c = 0, i, y;
1719
1720         if ( src->bm_flags & BM_FLAG_RLE ) {
1721                 src = rle_expand_texture(src);
1722                 s = src->bm_data;
1723         }
1724         for(y=0; y<h; y++) {
1725                 i = a;
1726                 c += b;
1727                 if(c >= h) {
1728                         c -= h;
1729                         goto inside;
1730                 }
1731                 while(--i>=0) {
1732                 inside:
1733                         gr_bitmap_scale_line(s, d, src->bm_w, dst->bm_w);
1734                         d += dst->bm_rowsize;
1735                 }
1736                 s += src->bm_rowsize;
1737         }
1738 }
1739
1740
1741 void gr_bitmap_fullscr(grs_bitmap *bm)
1742 {
1743         grs_bitmap * const scr = &grd_curcanv->cv_bitmap;
1744
1745 #ifdef OGL
1746         if(bm->bm_type == BM_LINEAR && scr->bm_type == BM_OGL) {
1747                 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
1748                 return;
1749         }
1750 #endif
1751         if(scr->bm_type != BM_LINEAR) {
1752                 grs_bitmap *tmp = gr_create_bitmap(scr->bm_w, scr->bm_h);
1753                 gr_bitmap_scale_to(bm, tmp);
1754                 gr_bitmap(0, 0, tmp);
1755                 gr_free_bitmap(tmp);
1756                 return;
1757         }
1758         gr_bitmap_scale_to(bm, scr);
1759 }