workbench/hidds/graphics/memblit.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <string.h>
   7
   8 #include <hidd/graphics.h>
   9 #include "graphics_intern.h"
  10
  11 #define DEBUG 0
  12 #include <aros/debug.h>
  13
  14 /****************************************************************************************/
  15
  16 VOID BM__Hidd_BitMap__FillMemRect8(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_FillMemRect8 *msg)
  17 {
  18     UBYTE *start;
  19     LONG phase, width, height, w, p;
  20     ULONG fill32;
  21     ULONG start_add;
  22
  23     start = msg->dstBuf + msg->minY * msg->dstMod + msg->minX;
  24     width = msg->maxX - msg->minX + 1;
  25     height = msg->maxY - msg->minY + 1;
  26     start_add = msg->dstMod - width;
  27
  28     if ((phase = (IPTR)start & 3L))
  29     {
  30         phase = 4 - phase;
  31         if (phase > width) phase = width;
  32         width -= phase;
  33     }
  34
  35     fill32 = msg->fill;
  36     fill32 |= (fill32 << 8);
  37     fill32 |= (fill32 << 16);
  38
  39     while(height--)
  40     {
  41         w = width;
  42         p = phase;
  43
  44         while(p--)
  45         {
  46             *start++ = (UBYTE)fill32;
  47         }
  48         while(w >= 4)
  49         {
  50             *((ULONG *)start) = fill32;
  51             w -= 4; start += 4;
  52         }
  53         while(w--)
  54         {
  55             *start++ = (UBYTE)fill32;
  56         }
  57         start += start_add;
  58     }
  59
  60 };
  61
  62 /****************************************************************************************/
  63
  64 VOID BM__Hidd_BitMap__FillMemRect16(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_FillMemRect16 *msg)
  65 {
  66     UBYTE *start;
  67     LONG phase, width, height, w, p;
  68     ULONG fill32;
  69     ULONG start_add;
  70
  71     start = msg->dstBuf + msg->minY * msg->dstMod + msg->minX * 2;
  72     width = msg->maxX - msg->minX + 1;
  73     height = msg->maxY - msg->minY + 1;
  74     start_add = msg->dstMod - width * 2;
  75
  76     if ((phase = (IPTR)start & 1L))
  77     {
  78         phase = 2 - phase;
  79         if (phase > width) phase = width;
  80         width -= phase;
  81     }
  82
  83     fill32 = msg->fill;
  84     fill32 |= (fill32 << 16);
  85
  86     while(height--)
  87     {
  88         w = width;
  89         p = phase;
  90
  91         while(p--)
  92         {
  93             *((UWORD *)start) = (UWORD)fill32;
  94             start += 2;
  95         }
  96         while(w >= 2)
  97         {
  98             *((ULONG *)start) = fill32;
  99             w -= 2; start += 4;
 100         }
 101         while(w--)
 102         {
 103             *((UWORD *)start) = (UWORD)fill32;
 104             start += 2;
 105         }
 106         start += start_add;
 107     }
 108
 109 }
 110
 111 /****************************************************************************************/
 112
 113 VOID BM__Hidd_BitMap__FillMemRect24(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_FillMemRect24 *msg)
 114 {
 115     UBYTE *start;
 116     LONG width, height, w;
 117     UBYTE fill1, fill2, fill3;
 118     ULONG start_add;
 119
 120     start = msg->dstBuf + msg->minY * msg->dstMod + msg->minX * 3;
 121     width = msg->maxX - msg->minX + 1;
 122     height = msg->maxY - msg->minY + 1;
 123     start_add = msg->dstMod - width * 3;
 124
 125 #if AROS_BIG_ENDIAN
 126     fill1 = (msg->fill >> 16) & 0xFF;
 127     fill2 = (msg->fill >> 8) & 0xFF;
 128     fill3 =  msg->fill & 0xFF;
 129 #else
 130     fill1 =  msg->fill & 0xFF;
 131     fill2 = (msg->fill >> 8) & 0xFF;
 132     fill3 = (msg->fill >> 16) & 0xFF;
 133 #endif
 134
 135     while(height--)
 136     {
 137         w = width;
 138
 139         while(w--)
 140         {
 141             *start++ = fill1;
 142             *start++ = fill2;
 143             *start++ = fill3;
 144         }
 145
 146         start += start_add;
 147     }
 148 }
 149
 150 /****************************************************************************************/
 151
 152 VOID BM__Hidd_BitMap__FillMemRect32(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_FillMemRect32 *msg)
 153 {
 154     UBYTE *start;
 155     LONG width, height, w;
 156     ULONG fill32;
 157     ULONG start_add;
 158
 159     start = msg->dstBuf + msg->minY * msg->dstMod + msg->minX * 4;
 160     width = msg->maxX - msg->minX + 1;
 161     height = msg->maxY - msg->minY + 1;
 162     start_add = msg->dstMod - width * 4;
 163
 164     fill32 = msg->fill;
 165
 166     while(height--)
 167     {
 168         w = width;
 169
 170         while(w--)
 171         {
 172             *((ULONG *)start) = fill32;
 173             start += 4;
 174         }
 175
 176         start += start_add;
 177     }
 178 }
 179
 180 /****************************************************************************************/
 181
 182 VOID BM__Hidd_BitMap__InvertMemRect(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_InvertMemRect *msg)
 183 {
 184     UBYTE *start;
 185     LONG phase, width, height, w, p;
 186     ULONG start_add;
 187
 188     start = msg->dstBuf + msg->minY * msg->dstMod + msg->minX;
 189     width = msg->maxX - msg->minX + 1;
 190     height = msg->maxY - msg->minY + 1;
 191     start_add = msg->dstMod - width;
 192
 193     if ((phase = (IPTR)start & 3L))
 194     {
 195         phase = 4 - phase;
 196         if (phase > width) phase = width;
 197         width -= phase;
 198     }
 199
 200     while(height--)
 201     {
 202         UBYTE bg;
 203         ULONG bg32;
 204
 205         w = width;
 206         p = phase;
 207
 208         while(p--)
 209         {
 210             bg = *start;
 211             *start++ = ~bg;
 212         }
 213         while(w >= 4)
 214         {
 215             bg32 = *(ULONG *)start;
 216             *((ULONG *)start) = ~bg32;
 217             w -= 4; start += 4;
 218         }
 219         while(w--)
 220         {
 221             bg = *start;
 222             *start++ = ~bg;
 223         }
 224         start += start_add;
 225     }
 226
 227 }
 228
 229 /****************************************************************************************/
 230
 231 VOID BM__Hidd_BitMap__CopyMemBox8(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_CopyMemBox8 *msg)
 232 {
 233     UBYTE *src_start, *dst_start;
 234     LONG phase, width, height, w, p;
 235     ULONG src_start_add, dst_start_add;
 236     BOOL descending;
 237
 238     width = msg->width;
 239     height = msg->height;
 240
 241     src_start = msg->src + msg->srcY * msg->srcMod + msg->srcX;
 242     src_start_add = msg->srcMod - width;
 243
 244     dst_start = msg->dst + msg->dstY * msg->dstMod + msg->dstX;
 245     dst_start_add = msg->dstMod - width;
 246
 247     if ((IPTR)src_start > (IPTR)dst_start)
 248     {
 249         if ((phase = (IPTR)src_start & 3L))
 250         {
 251             phase = 4 - phase;
 252             if (phase > width) phase = width;
 253             width -= phase;
 254         }
 255         descending = FALSE;
 256     }
 257     else
 258     {
 259         src_start += (height - 1) * msg->srcMod + width;
 260         dst_start += (height - 1) * msg->dstMod + width;
 261
 262         phase = ((IPTR)src_start & 3L);
 263         if (phase > width) phase = width;
 264         width -= phase;
 265
 266         descending = TRUE;
 267     }
 268
 269     /* NOTE: This can write LONGs to odd addresses, which might not work
 270        on some CPUs (MC68000) */
 271
 272     if (!descending)
 273     {
 274         while(height--)
 275         {
 276             w = width;
 277             p = phase;
 278
 279             while(p--)
 280             {
 281                 *dst_start++ = *src_start++;
 282             }
 283             while(w >= 4)
 284             {
 285                 *((ULONG *)dst_start) = *((ULONG *)src_start);
 286                 w -= 4; dst_start += 4; src_start += 4;
 287             }
 288             while(w--)
 289             {
 290                 *dst_start++ = *src_start++;
 291             }
 292             src_start += src_start_add;
 293             dst_start += dst_start_add;
 294         }
 295     }
 296     else
 297     {
 298         while(height--)
 299         {
 300             w = width;
 301             p = phase;
 302
 303             while(p--)
 304             {
 305                 *--dst_start = *--src_start;
 306             }
 307             while(w >= 4)
 308             {
 309                 dst_start -= 4; src_start -= 4;
 310                 *(ULONG *)dst_start = *(ULONG *)src_start;
 311                 w -= 4;
 312             }
 313             while(w--)
 314             {
 315                 *--dst_start = *--src_start;
 316             }
 317             src_start -= src_start_add;
 318             dst_start -= dst_start_add;
 319         }
 320      }
 321
 322 }
 323
 324 /****************************************************************************************/
 325
 326 VOID BM__Hidd_BitMap__CopyMemBox16(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_CopyMemBox16 *msg)
 327 {
 328     UBYTE *src_start, *dst_start;
 329     LONG phase, width, height, w, p;
 330     ULONG src_start_add, dst_start_add;
 331     BOOL descending;
 332
 333     width = msg->width;
 334     height = msg->height;
 335
 336     src_start = msg->src + msg->srcY * msg->srcMod + msg->srcX * 2;
 337     src_start_add = msg->srcMod - width * 2;
 338
 339     dst_start = msg->dst + msg->dstY * msg->dstMod + msg->dstX * 2;
 340     dst_start_add = msg->dstMod - width * 2;
 341
 342     if ((IPTR)src_start > (IPTR)dst_start)
 343     {
 344         if ((phase = (IPTR)src_start & 1L))
 345         {
 346             phase = 2 - phase;
 347             if (phase > width) phase = width;
 348             width -= phase;
 349         }
 350         descending = FALSE;
 351     }
 352     else
 353     {
 354         src_start += (height - 1) * msg->srcMod + width * 2;
 355         dst_start += (height - 1) * msg->dstMod + width * 2;
 356
 357         phase = ((IPTR)src_start & 1L);
 358         if (phase > width) phase = width;
 359         width -= phase;
 360
 361         descending = TRUE;
 362     }
 363
 364     if (!descending)
 365     {
 366         while(height--)
 367         {
 368             w = width;
 369             p = phase;
 370
 371             while(p--)
 372             {
 373                 *((UWORD *)dst_start) = *((UWORD *)src_start);
 374                 dst_start += 2; src_start += 2;
 375             }
 376             while(w >= 2)
 377             {
 378                 *((ULONG *)dst_start) = *((ULONG *)src_start);
 379                 w -= 2; dst_start += 4; src_start += 4;
 380             }
 381             while(w--)
 382             {
 383                 *((UWORD *)dst_start) = *((UWORD *)src_start);
 384                 dst_start += 2; src_start += 2;
 385             }
 386             src_start += src_start_add;
 387             dst_start += dst_start_add;
 388         }
 389     }
 390     else
 391     {
 392         while(height--)
 393         {
 394             w = width;
 395             p = phase;
 396
 397             while(p--)
 398             {
 399                 dst_start -= 2; src_start -= 2;
 400                 *(UWORD *)dst_start = *(UWORD *)src_start;
 401             }
 402             while(w >= 2)
 403             {
 404                 dst_start -= 4; src_start -= 4;
 405                 *(ULONG *)dst_start = *(ULONG *)src_start;
 406                 w -= 2;
 407             }
 408             while(w--)
 409             {
 410                 dst_start -= 2; src_start -= 2;
 411                 *(UWORD *)dst_start = *(UWORD *)src_start;
 412             }
 413             src_start -= src_start_add;
 414             dst_start -= dst_start_add;
 415         }
 416      }
 417
 418 }
 419
 420 /****************************************************************************************/
 421
 422 VOID BM__Hidd_BitMap__CopyMemBox24(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_CopyMemBox24 *msg)
 423 {
 424     UBYTE *src_start, *dst_start;
 425     LONG width, height, w;
 426     ULONG src_start_add, dst_start_add;
 427     BOOL descending;
 428
 429     width = msg->width;
 430     height = msg->height;
 431
 432     src_start = msg->src + msg->srcY * msg->srcMod + msg->srcX * 3;
 433     src_start_add = msg->srcMod - width * 3;
 434
 435     dst_start = msg->dst + msg->dstY * msg->dstMod + msg->dstX * 3;
 436     dst_start_add = msg->dstMod - width * 3;
 437
 438     if ((IPTR)src_start > (IPTR)dst_start)
 439     {
 440         descending = FALSE;
 441     }
 442     else
 443     {
 444         src_start += (height - 1) * msg->srcMod + width * 3;
 445         dst_start += (height - 1) * msg->dstMod + width * 3;
 446
 447         descending = TRUE;
 448     }
 449
 450     if (!descending)
 451     {
 452         while(height--)
 453         {
 454             w = width;
 455
 456             while(w--)
 457             {
 458                 *dst_start++ = *src_start++;
 459                 *dst_start++ = *src_start++;
 460                 *dst_start++ = *src_start++;
 461             }
 462
 463             src_start += src_start_add;
 464             dst_start += dst_start_add;
 465         }
 466     }
 467     else
 468     {
 469         while(height--)
 470         {
 471             w = width;
 472
 473             while(w--)
 474             {
 475                 *--dst_start = *--src_start;
 476                 *--dst_start = *--src_start;
 477                 *--dst_start = *--src_start;
 478             }
 479
 480             src_start -= src_start_add;
 481             dst_start -= dst_start_add;
 482         }
 483      }
 484
 485 }
 486
 487 /****************************************************************************************/
 488
 489 VOID BM__Hidd_BitMap__CopyMemBox32(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_CopyMemBox32 *msg)
 490 {
 491     UBYTE *src_start, *dst_start;
 492     LONG width, height, w;
 493     ULONG src_start_add, dst_start_add;
 494     BOOL descending;
 495
 496     width = msg->width;
 497     height = msg->height;
 498
 499     src_start = msg->src + msg->srcY * msg->srcMod + msg->srcX * 4;
 500     src_start_add = msg->srcMod - width * 4;
 501
 502     dst_start = msg->dst + msg->dstY * msg->dstMod + msg->dstX * 4;
 503     dst_start_add = msg->dstMod - width * 4;
 504
 505     if ((IPTR)src_start > (IPTR)dst_start)
 506     {
 507         descending = FALSE;
 508     }
 509     else
 510     {
 511         src_start += (height - 1) * msg->srcMod + width * 4;
 512         dst_start += (height - 1) * msg->dstMod + width * 4;
 513
 514         descending = TRUE;
 515     }
 516
 517     if (!descending)
 518     {
 519         while(height--)
 520         {
 521             w = width;
 522
 523             while(w--)
 524             {
 525                 *((ULONG *)dst_start) = *((ULONG *)src_start);
 526                 dst_start += 4; src_start += 4;
 527             }
 528
 529             src_start += src_start_add;
 530             dst_start += dst_start_add;
 531         }
 532     }
 533     else
 534     {
 535         while(height--)
 536         {
 537             w = width;
 538
 539             while(w--)
 540             {
 541                 dst_start -= 4; src_start -= 4;
 542                 *(ULONG *)dst_start = *(ULONG *)src_start;
 543             }
 544
 545             src_start -= src_start_add;
 546             dst_start -= dst_start_add;
 547         }
 548      }
 549
 550 }
 551
 552 /****************************************************************************************/
 553
 554 VOID BM__Hidd_BitMap__CopyLUTMemBox16(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_CopyLUTMemBox16 *msg)
 555 {
 556     HIDDT_Pixel *pixlut = msg->pixlut->pixels;
 557     UBYTE *src_start, *dst_start;
 558     LONG width, height, w;
 559     ULONG src_start_add, dst_start_add;
 560
 561     if (!pixlut) return;
 562
 563     width = msg->width;
 564     height = msg->height;
 565
 566     src_start = msg->src + msg->srcY * msg->srcMod + msg->srcX;
 567     src_start_add = msg->srcMod - width;
 568
 569     dst_start = msg->dst + msg->dstY * msg->dstMod + msg->dstX * 2;
 570     dst_start_add = msg->dstMod - width * 2;
 571
 572     while(height--)
 573     {
 574         w = width;
 575
 576         while(w--)
 577         {
 578             *(UWORD *)dst_start = (UWORD)(pixlut[*src_start++]);
 579             dst_start += 2;
 580         }
 581         src_start += src_start_add;
 582         dst_start += dst_start_add;
 583     }
 584 }
 585
 586 /****************************************************************************************/
 587
 588 VOID BM__Hidd_BitMap__CopyLUTMemBox24(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_CopyLUTMemBox24 *msg)
 589 {
 590     HIDDT_Pixel *pixlut = msg->pixlut->pixels;
 591     UBYTE *src_start, *dst_start;
 592     LONG width, height, w;
 593     ULONG src_start_add, dst_start_add;
 594
 595     if (!pixlut) return;
 596
 597     width = msg->width;
 598     height = msg->height;
 599
 600     src_start = msg->src + msg->srcY * msg->srcMod + msg->srcX;
 601     src_start_add = msg->srcMod - width;
 602
 603     dst_start = msg->dst + msg->dstY * msg->dstMod + msg->dstX * 3;
 604     dst_start_add = msg->dstMod - width * 3;
 605
 606     while(height--)
 607     {
 608         w = width;
 609
 610         while(w--)
 611         {
 612             HIDDT_Pixel pix = pixlut[*src_start++];
 613
 614         #if AROS_BIG_ENDIAN
 615             *dst_start++ = (pix >> 16) & 0xFF;
 616             *dst_start++ = (pix >> 8) & 0xFF;
 617             *dst_start++ =  pix & 0xFF;
 618         #else
 619             *dst_start++ =  pix & 0xFF;
 620             *dst_start++ = (pix >> 8) & 0xFF;
 621             *dst_start++ = (pix >> 16) & 0xFF;
 622         #endif
 623         }
 624         src_start += src_start_add;
 625         dst_start += dst_start_add;
 626     }
 627 }
 628
 629 /****************************************************************************************/
 630
 631 VOID BM__Hidd_BitMap__CopyLUTMemBox32(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_CopyLUTMemBox32 *msg)
 632 {
 633     HIDDT_Pixel *pixlut = msg->pixlut->pixels;
 634     UBYTE *src_start, *dst_start;
 635     LONG width, height, w;
 636     ULONG src_start_add, dst_start_add;
 637
 638     if (!pixlut) return;
 639
 640     width = msg->width;
 641     height = msg->height;
 642
 643     src_start = msg->src + msg->srcY * msg->srcMod + msg->srcX;
 644     src_start_add = msg->srcMod - width;
 645
 646     dst_start = msg->dst + msg->dstY * msg->dstMod + msg->dstX * 4;
 647     dst_start_add = msg->dstMod - width * 4;
 648
 649     while(height--)
 650     {
 651         w = width;
 652
 653         while(w--)
 654         {
 655             *((ULONG *)dst_start) = (ULONG)(pixlut[*src_start++]);
 656             dst_start += 4;
 657         }
 658         src_start += src_start_add;
 659         dst_start += dst_start_add;
 660     }
 661 }
 662
 663 /****************************************************************************************/
 664
 665 VOID BM__Hidd_BitMap__PutMem32Image8(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutMem32Image8 *msg)
 666 {
 667     UBYTE *src_start, *dst_start;
 668     LONG width, height, w;
 669     ULONG src_start_add, dst_start_add;
 670
 671     width = msg->width;
 672     height = msg->height;
 673
 674     src_start = msg->src;
 675     src_start_add = msg->srcMod - width * 4;
 676
 677     dst_start = msg->dst + msg->dstY * msg->dstMod + msg->dstX;
 678     dst_start_add = msg->dstMod - width;
 679
 680     while(height--)
 681     {
 682         w = width;
 683
 684         while(w--)
 685         {
 686             *dst_start++ = (UBYTE)(*(ULONG *)src_start);
 687             src_start += 4;
 688         }
 689         src_start += src_start_add;
 690         dst_start += dst_start_add;
 691     }
 692 }
 693
 694 /****************************************************************************************/
 695
 696 VOID BM__Hidd_BitMap__PutMem32Image16(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutMem32Image16 *msg)
 697 {
 698     UBYTE *src_start, *dst_start;
 699     LONG width, height, w;
 700     ULONG src_start_add, dst_start_add;
 701
 702     width = msg->width;
 703     height = msg->height;
 704
 705     src_start = msg->src;
 706     src_start_add = msg->srcMod - width * 4;
 707
 708     dst_start = msg->dst + msg->dstY * msg->dstMod + msg->dstX * 2;
 709     dst_start_add = msg->dstMod - width * 2;
 710
 711     while(height--)
 712     {
 713         w = width;
 714
 715         while(w--)
 716         {
 717             *(UWORD *)dst_start = (UWORD)(*(ULONG *)src_start);
 718             dst_start += 2; src_start += 4;
 719         }
 720         src_start += src_start_add;
 721         dst_start += dst_start_add;
 722     }
 723 }
 724
 725 /****************************************************************************************/
 726
 727 VOID BM__Hidd_BitMap__PutMem32Image24(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutMem32Image24 *msg)
 728 {
 729     UBYTE *src_start, *dst_start;
 730     LONG width, height, w;
 731     ULONG src_start_add, dst_start_add;
 732
 733     width = msg->width;
 734     height = msg->height;
 735
 736     src_start = msg->src;
 737     src_start_add = msg->srcMod - width * 4;
 738
 739     dst_start = msg->dst + msg->dstY * msg->dstMod + msg->dstX * 3;
 740     dst_start_add = msg->dstMod - width * 3;
 741
 742     while(height--)
 743     {
 744         w = width;
 745
 746         while(w--)
 747         {
 748             ULONG pix = *(ULONG *)src_start;
 749
 750             src_start += 4;
 751
 752         #if AROS_BIG_ENDIAN
 753             *dst_start++ = (pix >> 16) & 0xFF;
 754             *dst_start++ = (pix >> 8) & 0xFF;
 755             *dst_start++ =  pix & 0xFF;
 756         #else
 757             *dst_start++ =  pix & 0xFF;
 758             *dst_start++ = (pix >> 8) & 0xFF;
 759             *dst_start++ = (pix >> 16) & 0xFF;
 760         #endif
 761
 762         }
 763         src_start += src_start_add;
 764         dst_start += dst_start_add;
 765     }
 766 }
 767
 768 /****************************************************************************************/
 769
 770 VOID BM__Hidd_BitMap__GetMem32Image8(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_GetMem32Image8 *msg)
 771 {
 772     UBYTE *src_start, *dst_start;
 773     LONG width, height, w;
 774     ULONG src_start_add, dst_start_add;
 775
 776     width = msg->width;
 777     height = msg->height;
 778
 779     src_start = msg->src + msg->srcY * msg->srcMod + msg->srcX;
 780     src_start_add = msg->srcMod - width;
 781
 782     dst_start = msg->dst;
 783     dst_start_add = msg->dstMod - width * 4;
 784
 785     while(height--)
 786     {
 787         w = width;
 788
 789         while(w--)
 790         {
 791             *(ULONG *)dst_start = (ULONG)(*src_start++);
 792             dst_start += 4;
 793         }
 794         src_start += src_start_add;
 795         dst_start += dst_start_add;
 796     }
 797 }
 798
 799 /****************************************************************************************/
 800
 801 VOID BM__Hidd_BitMap__GetMem32Image16(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_GetMem32Image16 *msg)
 802 {
 803     UBYTE *src_start, *dst_start;
 804     LONG width, height, w;
 805     ULONG src_start_add, dst_start_add;
 806
 807     width = msg->width;
 808     height = msg->height;
 809
 810     src_start = msg->src + msg->srcY * msg->srcMod + msg->srcX * 2;
 811     src_start_add = msg->srcMod - width * 2;
 812
 813     dst_start = msg->dst;
 814     dst_start_add = msg->dstMod - width * 4;
 815
 816     while(height--)
 817     {
 818         w = width;
 819
 820         while(w--)
 821         {
 822             *(ULONG *)dst_start = (ULONG)(*(UWORD *)src_start);
 823             dst_start += 4; src_start += 2;
 824         }
 825         src_start += src_start_add;
 826         dst_start += dst_start_add;
 827     }
 828 }
 829
 830 /****************************************************************************************/
 831
 832 VOID BM__Hidd_BitMap__GetMem32Image24(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_GetMem32Image24 *msg)
 833 {
 834     UBYTE *src_start, *dst_start;
 835     LONG width, height, w;
 836     ULONG src_start_add, dst_start_add;
 837
 838     width = msg->width;
 839     height = msg->height;
 840
 841     src_start = msg->src + msg->srcY * msg->srcMod + msg->srcX * 3;
 842     src_start_add = msg->srcMod - width * 3;
 843
 844     dst_start = msg->dst;
 845     dst_start_add = msg->dstMod - width * 4;
 846
 847     while(height--)
 848     {
 849         w = width;
 850
 851         while(w--)
 852         {
 853             UBYTE pix1 = *src_start++;
 854             UBYTE pix2 = *src_start++;
 855             UBYTE pix3 = *src_start++;
 856
 857         #if AROS_BIG_ENDIAN
 858             *(ULONG *)dst_start = (pix1 << 16) | (pix2 << 8) | pix3;
 859         #else
 860             *(ULONG *)dst_start = (pix3 << 16) | (pix2 << 8) | pix1;
 861         #endif
 862
 863             dst_start += 4;
 864         }
 865         src_start += src_start_add;
 866         dst_start += dst_start_add;
 867     }
 868 }
 869
 870 /****************************************************************************************/
 871
 872 VOID BM__Hidd_BitMap__PutMemTemplate8(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutMemTemplate8 *msg)
 873 {
 874     WORD                     x, y;
 875     UBYTE                   *bitarray, *buf;
 876     UWORD                    bitmask;
 877     OOP_Object              *gc = msg->gc;
 878     ULONG                    fg = GC_FG(gc);
 879     ULONG                    bg = GC_BG(gc);
 880     WORD                     type = 0;
 881
 882     if (msg->width <= 0 || msg->height <= 0)
 883         return;
 884
 885     if (GC_COLEXP(gc) == vHidd_GC_ColExp_Transparent)
 886     {
 887         type = 0;
 888     }
 889     else if (GC_DRMD(gc) == vHidd_GC_DrawMode_Invert)
 890     {
 891         type = 2;
 892     }
 893     else
 894     {
 895         type = 4;
 896     }
 897
 898     if (msg->inverttemplate) type++;
 899
 900     bitarray = msg->template + ((msg->srcx / 16) * 2);
 901     bitmask = 0x8000 >> (msg->srcx & 0xF);
 902
 903     buf = msg->dst + msg->y * msg->dstMod + msg->x;
 904
 905     for(y = 0; y < msg->height; y++)
 906     {
 907         ULONG  mask = bitmask;
 908         UWORD *array = (UWORD *)bitarray;
 909         UWORD  bitword = AROS_BE2WORD(*array);
 910         UBYTE *xbuf = buf;
 911
 912         switch(type)
 913         {
 914             case 0:     /* JAM1 */
 915                 for(x = 0; x < msg->width; x++, xbuf++)
 916                 {
 917                     if (bitword & mask) *xbuf = fg;
 918
 919                     mask >>= 1;
 920                     if (!mask)
 921                     {
 922                         mask = 0x8000;
 923                         array++;
 924                         bitword = AROS_BE2WORD(*array);
 925                     }
 926
 927                 } /* for(x = 0; x < msg->width; x++) */
 928                 break;
 929
 930             case 1:     /* JAM1 | INVERSVID */
 931                 for(x = 0; x < msg->width; x++, xbuf++)
 932                 {
 933                     if (!(bitword & mask)) *xbuf = fg;
 934
 935                     mask >>= 1;
 936                     if (!mask)
 937                     {
 938                         mask = 0x8000;
 939                         array++;
 940                         bitword = AROS_BE2WORD(*array);
 941                     }
 942
 943                 } /* for(x = 0; x < msg->width; x++) */
 944                 break;
 945
 946             case 2: /* COMPLEMENT */
 947                 for(x = 0; x < msg->width; x++, xbuf++)
 948                 {
 949                     if (bitword & mask) *xbuf = ~(*xbuf);
 950
 951                     mask >>= 1;
 952                     if (!mask)
 953                     {
 954                         mask = 0x8000;
 955                         array++;
 956                         bitword = AROS_BE2WORD(*array);
 957                     }
 958                 } /* for(x = 0; x < msg->width; x++) */
 959                 break;
 960
 961             case 3: /* COMPLEMENT | INVERSVID*/
 962                 for(x = 0; x < msg->width; x++, xbuf++)
 963                 {
 964                     if (!(bitword & mask)) *xbuf = ~(*xbuf);
 965
 966                     mask >>= 1;
 967                     if (!mask)
 968                     {
 969                         mask = 0x8000;
 970                         array++;
 971                         bitword = AROS_BE2WORD(*array);
 972                     }
 973                  } /* for(x = 0; x < msg->width; x++) */
 974                 break;
 975
 976             case 4:     /* JAM2 */
 977                 for(x = 0; x < msg->width; x++)
 978                 {
 979                     *xbuf++ = (bitword & mask) ? fg : bg;
 980
 981                     mask >>= 1;
 982                     if (!mask)
 983                     {
 984                         mask = 0x8000;
 985                         array++;
 986                         bitword = AROS_BE2WORD(*array);
 987                     }
 988
 989                 } /* for(x = 0; x < msg->width; x++) */
 990                 break;
 991
 992             case 5:     /* JAM2 | INVERSVID */
 993                 for(x = 0; x < msg->width; x++)
 994                 {
 995                     *xbuf++ = (bitword & mask) ? bg : fg;
 996
 997                     mask >>= 1;
 998                     if (!mask)
 999                     {
1000                         mask = 0x8000;
1001                         array++;
1002                         bitword = AROS_BE2WORD(*array);
1003                     }
1004                 } /* for(x = 0; x < msg->width; x++) */
1005                 break;
1006
1007         } /* switch(type) */
1008
1009         buf += msg->dstMod;
1010         bitarray += msg->modulo;
1011
1012     } /* for(y = 0; y < msg->height; y++) */
1013 }
1014
1015 /****************************************************************************************/
1016
1017 VOID BM__Hidd_BitMap__PutMemTemplate16(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutMemTemplate16 *msg)
1018 {
1019     WORD                     x, y;
1020     UBYTE                   *bitarray, *buf;
1021     UWORD                    bitmask;
1022     OOP_Object              *gc = msg->gc;
1023     ULONG                    fg = GC_FG(gc);
1024     ULONG                    bg = GC_BG(gc);
1025     WORD                     type = 0;
1026
1027     if (msg->width <= 0 || msg->height <= 0)
1028         return;
1029
1030     if (GC_COLEXP(gc) == vHidd_GC_ColExp_Transparent)
1031     {
1032         type = 0;
1033     }
1034     else if (GC_DRMD(gc) == vHidd_GC_DrawMode_Invert)
1035     {
1036         type = 2;
1037     }
1038     else
1039     {
1040         type = 4;
1041     }
1042
1043     if (msg->inverttemplate) type++;
1044
1045     bitarray = msg->template + ((msg->srcx / 16) * 2);
1046     bitmask = 0x8000 >> (msg->srcx & 0xF);
1047
1048     buf = msg->dst + msg->y * msg->dstMod + msg->x * 2;
1049
1050     for(y = 0; y < msg->height; y++)
1051     {
1052         ULONG  mask = bitmask;
1053         UWORD *array = (UWORD *)bitarray;
1054         UWORD  bitword = AROS_BE2WORD(*array);
1055         UWORD *xbuf = (UWORD *)buf;
1056
1057         switch(type)
1058         {
1059             case 0:     /* JAM1 */
1060                 for(x = 0; x < msg->width; x++, xbuf++)
1061                 {
1062                     if (bitword & mask) *xbuf = fg;
1063
1064                     mask >>= 1;
1065                     if (!mask)
1066                     {
1067                         mask = 0x8000;
1068                         array++;
1069                         bitword = AROS_BE2WORD(*array);
1070                     }
1071
1072                 } /* for(x = 0; x < msg->width; x++) */
1073                 break;
1074
1075             case 1:     /* JAM1 | INVERSVID */
1076                 for(x = 0; x < msg->width; x++, xbuf++)
1077                 {
1078                     if (!(bitword & mask)) *xbuf = fg;
1079
1080                     mask >>= 1;
1081                     if (!mask)
1082                     {
1083                         mask = 0x8000;
1084                         array++;
1085                         bitword = AROS_BE2WORD(*array);
1086                     }
1087
1088                 } /* for(x = 0; x < msg->width; x++) */
1089                 break;
1090
1091             case 2: /* COMPLEMENT */
1092                 for(x = 0; x < msg->width; x++, xbuf++)
1093                 {
1094                     if (bitword & mask) *xbuf = ~(*xbuf);
1095
1096                     mask >>= 1;
1097                     if (!mask)
1098                     {
1099                         mask = 0x8000;
1100                         array++;
1101                         bitword = AROS_BE2WORD(*array);
1102                     }
1103                 } /* for(x = 0; x < msg->width; x++) */
1104                 break;
1105
1106             case 3: /* COMPLEMENT | INVERSVID*/
1107                 for(x = 0; x < msg->width; x++, xbuf++)
1108                 {
1109                     if (!(bitword & mask)) *xbuf = ~(*xbuf);
1110
1111                     mask >>= 1;
1112                     if (!mask)
1113                     {
1114                         mask = 0x8000;
1115                         array++;
1116                         bitword = AROS_BE2WORD(*array);
1117                     }
1118                  } /* for(x = 0; x < msg->width; x++) */
1119                 break;
1120
1121             case 4:     /* JAM2 */
1122                 for(x = 0; x < msg->width; x++)
1123                 {
1124                     *xbuf++ = (bitword & mask) ? fg : bg;
1125
1126                     mask >>= 1;
1127                     if (!mask)
1128                     {
1129                         mask = 0x8000;
1130                         array++;
1131                         bitword = AROS_BE2WORD(*array);
1132                     }
1133
1134                 } /* for(x = 0; x < msg->width; x++) */
1135                 break;
1136
1137             case 5:     /* JAM2 | INVERSVID */
1138                 for(x = 0; x < msg->width; x++)
1139                 {
1140                     *xbuf++ = (bitword & mask) ? bg : fg;
1141
1142                     mask >>= 1;
1143                     if (!mask)
1144                     {
1145                         mask = 0x8000;
1146                         array++;
1147                         bitword = AROS_BE2WORD(*array);
1148                     }
1149                 } /* for(x = 0; x < msg->width; x++) */
1150                 break;
1151
1152         } /* switch(type) */
1153
1154         buf += msg->dstMod;
1155         bitarray += msg->modulo;
1156
1157     } /* for(y = 0; y < msg->height; y++) */
1158
1159 }
1160
1161 /****************************************************************************************/
1162
1163 VOID BM__Hidd_BitMap__PutMemTemplate24(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutMemTemplate24 *msg)
1164 {
1165     WORD                     x, y;
1166     UBYTE                   *bitarray, *buf;
1167     UWORD                    bitmask;
1168     OOP_Object              *gc = msg->gc;
1169     ULONG                    fg = GC_FG(gc);
1170     UBYTE                    fg1, fg2, fg3;
1171     ULONG                    bg = GC_BG(gc);
1172     UBYTE                    bg1, bg2, bg3;
1173     WORD                     type = 0;
1174
1175     if (msg->width <= 0 || msg->height <= 0)
1176         return;
1177
1178 #if AROS_BIG_ENDIAN
1179     fg1 = (fg >> 16) & 0xFF;
1180     fg2 = (fg >> 8) & 0xFF;
1181     fg3 =  fg & 0xFF;
1182
1183     bg1 = (bg >> 16) & 0xFF;
1184     bg2 = (bg >> 8) & 0xFF;
1185     bg3 =  bg & 0xFF;
1186 #else
1187     fg1 =  fg & 0xFF;
1188     fg2 = (fg >> 8) & 0xFF;
1189     fg3 = (fg >> 16) & 0xFF;
1190
1191     bg1 =  bg & 0xFF;
1192     bg2 = (bg >> 8) & 0xFF;
1193     bg3 = (bg >> 16) & 0xFF;
1194 #endif
1195
1196     if (GC_COLEXP(gc) == vHidd_GC_ColExp_Transparent)
1197     {
1198         type = 0;
1199     }
1200     else if (GC_DRMD(gc) == vHidd_GC_DrawMode_Invert)
1201     {
1202         type = 2;
1203     }
1204     else
1205     {
1206         type = 4;
1207     }
1208
1209     if (msg->inverttemplate) type++;
1210
1211     bitarray = msg->template + ((msg->srcx / 16) * 2);
1212     bitmask = 0x8000 >> (msg->srcx & 0xF);
1213
1214     buf = msg->dst + msg->y * msg->dstMod + msg->x * 3;
1215
1216     for(y = 0; y < msg->height; y++)
1217     {
1218         ULONG  mask = bitmask;
1219         UWORD *array = (UWORD *)bitarray;
1220         UWORD  bitword = AROS_BE2WORD(*array);
1221         UBYTE *xbuf = buf;
1222
1223         switch(type)
1224         {
1225             case 0:     /* JAM1 */
1226                 for(x = 0; x < msg->width; x++, xbuf += 3)
1227                 {
1228                     if (bitword & mask)
1229                     {
1230                         xbuf[0] = fg1;
1231                         xbuf[1] = fg2;
1232                         xbuf[2] = fg3;
1233                     }
1234
1235                     mask >>= 1;
1236                     if (!mask)
1237                     {
1238                         mask = 0x8000;
1239                         array++;
1240                         bitword = AROS_BE2WORD(*array);
1241                     }
1242
1243                 } /* for(x = 0; x < msg->width; x++) */
1244                 break;
1245
1246             case 1:     /* JAM1 | INVERSVID */
1247                 for(x = 0; x < msg->width; x++, xbuf += 3)
1248                 {
1249                     if (!(bitword & mask))
1250                     {
1251                         xbuf[0] = fg1;
1252                         xbuf[1] = fg2;
1253                         xbuf[2] = fg3;
1254                     }
1255
1256                     mask >>= 1;
1257                     if (!mask)
1258                     {
1259                         mask = 0x8000;
1260                         array++;
1261                         bitword = AROS_BE2WORD(*array);
1262                     }
1263
1264                 } /* for(x = 0; x < msg->width; x++) */
1265                 break;
1266
1267             case 2: /* COMPLEMENT */
1268                 for(x = 0; x < msg->width; x++, xbuf += 3)
1269                 {
1270                     if (bitword & mask)
1271                     {
1272                         xbuf[0] = ~xbuf[0];
1273                         xbuf[1] = ~xbuf[1];
1274                         xbuf[2] = ~xbuf[2];
1275                     }
1276
1277                     mask >>= 1;
1278                     if (!mask)
1279                     {
1280                         mask = 0x8000;
1281                         array++;
1282                         bitword = AROS_BE2WORD(*array);
1283                     }
1284                 } /* for(x = 0; x < msg->width; x++) */
1285                 break;
1286
1287             case 3: /* COMPLEMENT | INVERSVID*/
1288                 for(x = 0; x < msg->width; x++, xbuf += 3)
1289                 {
1290                     if (!(bitword & mask))
1291                     {
1292                         xbuf[0] = ~xbuf[0];
1293                         xbuf[1] = ~xbuf[1];
1294                         xbuf[2] = ~xbuf[2];
1295                     }
1296
1297                     mask >>= 1;
1298                     if (!mask)
1299                     {
1300                         mask = 0x8000;
1301                         array++;
1302                         bitword = AROS_BE2WORD(*array);
1303                     }
1304                  } /* for(x = 0; x < msg->width; x++) */
1305                 break;
1306
1307             case 4:     /* JAM2 */
1308                 for(x = 0; x < msg->width; x++)
1309                 {
1310                     if (bitword & mask)
1311                     {
1312                         *xbuf++ = fg1;
1313                         *xbuf++ = fg2;
1314                         *xbuf++ = fg3;
1315                     }
1316                     else
1317                     {
1318                         *xbuf++ = bg1;
1319                         *xbuf++ = bg2;
1320                         *xbuf++ = bg3;
1321                     }
1322
1323                     mask >>= 1;
1324                     if (!mask)
1325                     {
1326                         mask = 0x8000;
1327                         array++;
1328                         bitword = AROS_BE2WORD(*array);
1329                     }
1330
1331                 } /* for(x = 0; x < msg->width; x++) */
1332                 break;
1333
1334             case 5:     /* JAM2 | INVERSVID */
1335                 for(x = 0; x < msg->width; x++)
1336                 {
1337                     if (bitword & mask)
1338                     {
1339                         *xbuf++ = bg1;
1340                         *xbuf++ = bg2;
1341                         *xbuf++ = bg3;
1342                     }
1343                     else
1344                     {
1345                         *xbuf++ = fg1;
1346                         *xbuf++ = fg2;
1347                         *xbuf++ = fg3;
1348                     }
1349
1350                     mask >>= 1;
1351                     if (!mask)
1352                     {
1353                         mask = 0x8000;
1354                         array++;
1355                         bitword = AROS_BE2WORD(*array);
1356                     }
1357                 } /* for(x = 0; x < msg->width; x++) */
1358                 break;
1359
1360         } /* switch(type) */
1361
1362         buf += msg->dstMod;
1363         bitarray += msg->modulo;
1364
1365     } /* for(y = 0; y < msg->height; y++) */
1366
1367 }
1368
1369 /****************************************************************************************/
1370
1371 VOID BM__Hidd_BitMap__PutMemTemplate32(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutMemTemplate32 *msg)
1372 {
1373     WORD                     x, y;
1374     UBYTE                   *bitarray, *buf;
1375     UWORD                    bitmask;
1376     OOP_Object              *gc = msg->gc;
1377     ULONG                    fg = GC_FG(gc);
1378     ULONG                    bg = GC_BG(gc);
1379     WORD                     type = 0;
1380
1381     if (msg->width <= 0 || msg->height <= 0)
1382         return;
1383
1384     if (GC_COLEXP(gc) == vHidd_GC_ColExp_Transparent)
1385     {
1386         type = 0;
1387     }
1388     else if (GC_DRMD(gc) == vHidd_GC_DrawMode_Invert)
1389     {
1390         type = 2;
1391     }
1392     else
1393     {
1394         type = 4;
1395     }
1396
1397     if (msg->inverttemplate) type++;
1398
1399     bitarray = msg->template + ((msg->srcx / 16) * 2);
1400     bitmask = 0x8000 >> (msg->srcx & 0xF);
1401
1402     buf = msg->dst + msg->y * msg->dstMod + msg->x * 4;
1403
1404     for(y = 0; y < msg->height; y++)
1405     {
1406         ULONG  mask = bitmask;
1407         UWORD *array = (UWORD *)bitarray;
1408         UWORD  bitword = AROS_BE2WORD(*array);
1409         ULONG *xbuf = (ULONG *)buf;
1410
1411         switch(type)
1412         {
1413             case 0:     /* JAM1 */
1414                 for(x = 0; x < msg->width; x++, xbuf++)
1415                 {
1416                     if (bitword & mask) *xbuf = fg;
1417
1418                     mask >>= 1;
1419                     if (!mask)
1420                     {
1421                         mask = 0x8000;
1422                         array++;
1423                         bitword = AROS_BE2WORD(*array);
1424                     }
1425
1426                 } /* for(x = 0; x < msg->width; x++) */
1427                 break;
1428
1429             case 1:     /* JAM1 | INVERSVID */
1430                 for(x = 0; x < msg->width; x++, xbuf++)
1431                 {
1432                     if (!(bitword & mask)) *xbuf = fg;
1433
1434                     mask >>= 1;
1435                     if (!mask)
1436                     {
1437                         mask = 0x8000;
1438                         array++;
1439                         bitword = AROS_BE2WORD(*array);
1440                     }
1441
1442                 } /* for(x = 0; x < msg->width; x++) */
1443                 break;
1444
1445             case 2: /* COMPLEMENT */
1446                 for(x = 0; x < msg->width; x++, xbuf++)
1447                 {
1448                     if (bitword & mask) *xbuf = ~(*xbuf);
1449
1450                     mask >>= 1;
1451                     if (!mask)
1452                     {
1453                         mask = 0x8000;
1454                         array++;
1455                         bitword = AROS_BE2WORD(*array);
1456                     }
1457                 } /* for(x = 0; x < msg->width; x++) */
1458                 break;
1459
1460             case 3: /* COMPLEMENT | INVERSVID*/
1461                 for(x = 0; x < msg->width; x++, xbuf++)
1462                 {
1463                     if (!(bitword & mask)) *xbuf = ~(*xbuf);
1464
1465                     mask >>= 1;
1466                     if (!mask)
1467                     {
1468                         mask = 0x8000;
1469                         array++;
1470                         bitword = AROS_BE2WORD(*array);
1471                     }
1472                  } /* for(x = 0; x < msg->width; x++) */
1473                 break;
1474
1475             case 4:     /* JAM2 */
1476                 for(x = 0; x < msg->width; x++)
1477                 {
1478                     *xbuf++ = (bitword & mask) ? fg : bg;
1479
1480                     mask >>= 1;
1481                     if (!mask)
1482                     {
1483                         mask = 0x8000;
1484                         array++;
1485                         bitword = AROS_BE2WORD(*array);
1486                     }
1487
1488                 } /* for(x = 0; x < msg->width; x++) */
1489                 break;
1490
1491             case 5:     /* JAM2 | INVERSVID */
1492                 for(x = 0; x < msg->width; x++)
1493                 {
1494                     *xbuf++ = (bitword & mask) ? bg : fg;
1495
1496                     mask >>= 1;
1497                     if (!mask)
1498                     {
1499                         mask = 0x8000;
1500                         array++;
1501                         bitword = AROS_BE2WORD(*array);
1502                     }
1503                 } /* for(x = 0; x < msg->width; x++) */
1504                 break;
1505
1506         } /* switch(type) */
1507
1508         buf += msg->dstMod;
1509         bitarray += msg->modulo;
1510
1511     } /* for(y = 0; y < msg->height; y++) */
1512
1513 }
1514
1515 /****************************************************************************************/
1516
1517 VOID BM__Hidd_BitMap__PutMemPattern8(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutMemPattern8 *msg)
1518 {
1519     WORD                     x, y;
1520     UBYTE                   *patarray, *buf, *maskarray = 0;
1521     UWORD                    patmask, maskmask;
1522     OOP_Object              *gc = msg->gc;
1523     ULONG                    fg = GC_FG(gc);
1524     ULONG                    bg = GC_BG(gc);
1525     WORD                     type = 0;
1526
1527     if (msg->width <= 0 || msg->height <= 0)
1528         return;
1529
1530     if (msg->patterndepth > 1)
1531     {
1532         type = 6;
1533     }
1534     else
1535     {
1536         if (GC_COLEXP(gc) == vHidd_GC_ColExp_Transparent)
1537         {
1538             type = 0;
1539         }
1540         else if (GC_DRMD(gc) == vHidd_GC_DrawMode_Invert)
1541         {
1542             type = 2;
1543         }
1544         else
1545         {
1546             type = 4;
1547         }
1548
1549         if (msg->invertpattern) type++;
1550     }
1551
1552     patarray = msg->pattern;
1553     patmask = 0x8000 >> (msg->patternsrcx & 0xF);
1554
1555     if ((maskarray = msg->mask))
1556     {
1557         maskarray += (msg->masksrcx / 16) * 2;
1558         maskmask = 0x8000 >> (msg->masksrcx & 0xF);
1559     }
1560
1561     buf = msg->dst + msg->y * msg->dstMod + msg->x;
1562
1563     for(y = 0; y < msg->height; y++)
1564     {
1565         UWORD  pmask = patmask;
1566         UWORD  mmask = maskmask;
1567         UWORD *parray = ((UWORD *)patarray) + ((y + msg->patternsrcy) % msg->patternheight);
1568         UWORD  patword = AROS_BE2WORD(*parray);
1569         UWORD *marray;
1570         UWORD  maskword;
1571         UBYTE *xbuf = (UBYTE *)buf;
1572
1573         if (maskarray)
1574         {
1575             marray = (UWORD *)maskarray;
1576             maskword = AROS_BE2WORD(*marray);
1577         }
1578
1579         switch(type)
1580         {
1581             case 0:     /* JAM1 */
1582                 for(x = 0; x < msg->width; x++, xbuf++)
1583                 {
1584                     if (!maskarray || (maskword & mmask))
1585                     {
1586                         if (patword & pmask) *xbuf = fg;
1587                     }
1588
1589                     if (maskarray)
1590                     {
1591                         mmask >>= 1;
1592                         if (!mmask)
1593                         {
1594                             mmask = 0x8000;
1595                             marray++;
1596                             maskword = AROS_BE2WORD(*marray);
1597                         }
1598                     }
1599
1600                     pmask >>= 1;
1601                     if (!pmask) pmask = 0x8000;
1602
1603                 } /* for(x = 0; x < msg->width; x++) */
1604                 break;
1605
1606             case 1:     /* JAM1 | INVERSVID */
1607                 for(x = 0; x < msg->width; x++, xbuf++)
1608                 {
1609                     if (!maskarray || (maskword & mmask))
1610                     {
1611                         if (!(patword & pmask)) *xbuf = fg;
1612                     }
1613
1614                     if (maskarray)
1615                     {
1616                         mmask >>= 1;
1617                         if (!mmask)
1618                         {
1619                             mmask = 0x8000;
1620                             marray++;
1621                             maskword = AROS_BE2WORD(*marray);
1622                         }
1623                     }
1624
1625                     pmask >>= 1;
1626                     if (!pmask) pmask = 0x8000;
1627                 } /* for(x = 0; x < msg->width; x++) */
1628                 break;
1629
1630             case 2: /* COMPLEMENT */
1631                 for(x = 0; x < msg->width; x++, xbuf++)
1632                 {
1633                     if (!maskarray || (maskword & mmask))
1634                     {
1635                         if (patword & pmask) *xbuf = ~(*xbuf);
1636                     }
1637
1638                     if (maskarray)
1639                     {
1640                         mmask >>= 1;
1641                         if (!mmask)
1642                         {
1643                             mmask = 0x8000;
1644                             marray++;
1645                             maskword = AROS_BE2WORD(*marray);
1646                         }
1647                     }
1648
1649                     pmask >>= 1;
1650                     if (!pmask) pmask = 0x8000;
1651
1652                 } /* for(x = 0; x < msg->width; x++) */
1653                 break;
1654
1655             case 3: /* COMPLEMENT | INVERSVID*/
1656                 for(x = 0; x < msg->width; x++, xbuf++)
1657                 {
1658                     if (!maskarray || (maskword & mmask))
1659                     {
1660                         if (!(patword & pmask)) *xbuf = ~(*xbuf);
1661                     }
1662
1663                     if (maskarray)
1664                     {
1665                         mmask >>= 1;
1666                         if (!mmask)
1667                         {
1668                             mmask = 0x8000;
1669                             marray++;
1670                             maskword = AROS_BE2WORD(*marray);
1671                         }
1672                     }
1673
1674                     pmask >>= 1;
1675                     if (!pmask) pmask = 0x8000;
1676
1677                 } /* for(x = 0; x < msg->width; x++) */
1678                 break;
1679
1680             case 4:     /* JAM2 */
1681                 for(x = 0; x < msg->width; x++)
1682                 {
1683                     if (!maskarray || (maskword & mmask))
1684                     {
1685                         xbuf[x] = (patword & pmask) ? fg : bg;
1686                     }
1687
1688                     if (maskarray)
1689                     {
1690                         mmask >>= 1;
1691                         if (!mmask)
1692                         {
1693                             mmask = 0x8000;
1694                             marray++;
1695                             maskword = AROS_BE2WORD(*marray);
1696                         }
1697                     }
1698
1699                     pmask >>= 1;
1700                     if (!pmask) pmask = 0x8000;
1701
1702                 } /* for(x = 0; x < msg->width; x++) */
1703                 break;
1704
1705             case 5:     /* JAM2 | INVERSVID */
1706                 for(x = 0; x < msg->width; x++)
1707                 {
1708                     if (!maskarray || (maskword & mmask))
1709                     {
1710                         xbuf[x] = (patword & pmask) ? bg : fg;
1711                     }
1712
1713                     if (maskarray)
1714                     {
1715                         mmask >>= 1;
1716                         if (!mmask)
1717                         {
1718                             mmask = 0x8000;
1719                             marray++;
1720                             maskword = AROS_BE2WORD(*marray);
1721                         }
1722                     }
1723
1724                     pmask >>= 1;
1725                     if (!pmask) pmask = 0x8000;
1726
1727                 } /* for(x = 0; x < msg->width; x++) */
1728                 break;
1729
1730             case 6: /* multi color pattern */
1731                 for(x = 0; x < msg->width; x++)
1732                 {
1733                     if (!maskarray || (maskword & mmask))
1734                     {
1735                         WORD plane;
1736                         ULONG pixel = (patword & pmask) ? 1 : 0;
1737
1738                         for(plane = 1; plane < msg->patterndepth; plane++)
1739                         {
1740                             UWORD *_parray = parray + plane * msg->patternheight;
1741                             UWORD _patword = AROS_BE2WORD(*_parray);
1742
1743                             if (_patword & pmask) pixel |= 1L << plane;
1744                         }
1745
1746                         if (msg->patternlut) pixel = msg->patternlut->pixels[pixel];
1747
1748                         xbuf[x] = pixel;
1749                     }
1750
1751                     if (maskarray)
1752                     {
1753                         mmask >>= 1;
1754                         if (!mmask)
1755                         {
1756                             mmask = 0x8000;
1757                             marray++;
1758                             maskword = AROS_BE2WORD(*marray);
1759                         }
1760                     }
1761
1762                     pmask >>= 1;
1763                     if (!pmask) pmask = 0x8000;
1764
1765                 } /* for(x = 0; x < msg->width; x++) */
1766                 break;
1767
1768         } /* switch(type) */
1769
1770         buf += msg->dstMod;
1771         if (maskarray) maskarray += msg->maskmodulo;
1772
1773     } /* for(y = 0; y < msg->height; y++) */
1774
1775 }
1776
1777 /****************************************************************************************/
1778
1779 VOID BM__Hidd_BitMap__PutMemPattern16(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutMemPattern16 *msg)
1780 {
1781     WORD                     x, y;
1782     UBYTE                   *patarray, *buf, *maskarray = 0;
1783     UWORD                    patmask, maskmask;
1784     OOP_Object              *gc = msg->gc;
1785     ULONG                    fg = GC_FG(gc);
1786     ULONG                    bg = GC_BG(gc);
1787     WORD                     type = 0;
1788
1789     if (msg->width <= 0 || msg->height <= 0)
1790         return;
1791
1792     if (msg->patterndepth > 1)
1793     {
1794         type = 6;
1795     }
1796     else
1797     {
1798         if (GC_COLEXP(gc) == vHidd_GC_ColExp_Transparent)
1799         {
1800             type = 0;
1801         }
1802         else if (GC_DRMD(gc) == vHidd_GC_DrawMode_Invert)
1803         {
1804             type = 2;
1805         }
1806         else
1807         {
1808             type = 4;
1809         }
1810
1811         if (msg->invertpattern) type++;
1812     }
1813
1814     patarray = msg->pattern;
1815     patmask = 0x8000 >> (msg->patternsrcx & 0xF);
1816
1817     if ((maskarray = msg->mask))
1818     {
1819         maskarray += (msg->masksrcx / 16) * 2;
1820         maskmask = 0x8000 >> (msg->masksrcx & 0xF);
1821     }
1822
1823     buf = msg->dst + msg->y * msg->dstMod + msg->x * 2;
1824
1825     for(y = 0; y < msg->height; y++)
1826     {
1827         UWORD  pmask = patmask;
1828         UWORD  mmask = maskmask;
1829         UWORD *parray = ((UWORD *)patarray) + ((y + msg->patternsrcy) % msg->patternheight);
1830         UWORD  patword = AROS_BE2WORD(*parray);
1831         UWORD *marray;
1832         UWORD  maskword;
1833         UWORD *xbuf = (UWORD *)buf;
1834
1835         if (maskarray)
1836         {
1837             marray = (UWORD *)maskarray;
1838             maskword = AROS_BE2WORD(*marray);
1839         }
1840
1841         switch(type)
1842         {
1843             case 0:     /* JAM1 */
1844                 for(x = 0; x < msg->width; x++, xbuf++)
1845                 {
1846                     if (!maskarray || (maskword & mmask))
1847                     {
1848                         if (patword & pmask) *xbuf = fg;
1849                     }
1850
1851                     if (maskarray)
1852                     {
1853                         mmask >>= 1;
1854                         if (!mmask)
1855                         {
1856                             mmask = 0x8000;
1857                             marray++;
1858                             maskword = AROS_BE2WORD(*marray);
1859                         }
1860                     }
1861
1862                     pmask >>= 1;
1863                     if (!pmask) pmask = 0x8000;
1864
1865                 } /* for(x = 0; x < msg->width; x++) */
1866                 break;
1867
1868             case 1:     /* JAM1 | INVERSVID */
1869                 for(x = 0; x < msg->width; x++, xbuf++)
1870                 {
1871                     if (!maskarray || (maskword & mmask))
1872                     {
1873                         if (!(patword & pmask)) *xbuf = fg;
1874                     }
1875
1876                     if (maskarray)
1877                     {
1878                         mmask >>= 1;
1879                         if (!mmask)
1880                         {
1881                             mmask = 0x8000;
1882                             marray++;
1883                             maskword = AROS_BE2WORD(*marray);
1884                         }
1885                     }
1886
1887                     pmask >>= 1;
1888                     if (!pmask) pmask = 0x8000;
1889                 } /* for(x = 0; x < msg->width; x++) */
1890                 break;
1891
1892             case 2: /* COMPLEMENT */
1893                 for(x = 0; x < msg->width; x++, xbuf++)
1894                 {
1895                     if (!maskarray || (maskword & mmask))
1896                     {
1897                         if (patword & pmask) *xbuf = ~(*xbuf);
1898                     }
1899
1900                     if (maskarray)
1901                     {
1902                         mmask >>= 1;
1903                         if (!mmask)
1904                         {
1905                             mmask = 0x8000;
1906                             marray++;
1907                             maskword = AROS_BE2WORD(*marray);
1908                         }
1909                     }
1910
1911                     pmask >>= 1;
1912                     if (!pmask) pmask = 0x8000;
1913
1914                 } /* for(x = 0; x < msg->width; x++) */
1915                 break;
1916
1917             case 3: /* COMPLEMENT | INVERSVID*/
1918                 for(x = 0; x < msg->width; x++, xbuf++)
1919                 {
1920                     if (!maskarray || (maskword & mmask))
1921                     {
1922                         if (!(patword & pmask)) *xbuf = ~(*xbuf);
1923                     }
1924
1925                     if (maskarray)
1926                     {
1927                         mmask >>= 1;
1928                         if (!mmask)
1929                         {
1930                             mmask = 0x8000;
1931                             marray++;
1932                             maskword = AROS_BE2WORD(*marray);
1933                         }
1934                     }
1935
1936                     pmask >>= 1;
1937                     if (!pmask) pmask = 0x8000;
1938
1939                 } /* for(x = 0; x < msg->width; x++) */
1940                 break;
1941
1942             case 4:     /* JAM2 */
1943                 for(x = 0; x < msg->width; x++)
1944                 {
1945                     if (!maskarray || (maskword & mmask))
1946                     {
1947                         xbuf[x] = (patword & pmask) ? fg : bg;
1948                     }
1949
1950                     if (maskarray)
1951                     {
1952                         mmask >>= 1;
1953                         if (!mmask)
1954                         {
1955                             mmask = 0x8000;
1956                             marray++;
1957                             maskword = AROS_BE2WORD(*marray);
1958                         }
1959                     }
1960
1961                     pmask >>= 1;
1962                     if (!pmask) pmask = 0x8000;
1963
1964                 } /* for(x = 0; x < msg->width; x++) */
1965                 break;
1966
1967             case 5:     /* JAM2 | INVERSVID */
1968                 for(x = 0; x < msg->width; x++)
1969                 {
1970                     if (!maskarray || (maskword & mmask))
1971                     {
1972                         xbuf[x] = (patword & pmask) ? bg : fg;
1973                     }
1974
1975                     if (maskarray)
1976                     {
1977                         mmask >>= 1;
1978                         if (!mmask)
1979                         {
1980                             mmask = 0x8000;
1981                             marray++;
1982                             maskword = AROS_BE2WORD(*marray);
1983                         }
1984                     }
1985
1986                     pmask >>= 1;
1987                     if (!pmask) pmask = 0x8000;
1988
1989                 } /* for(x = 0; x < msg->width; x++) */
1990                 break;
1991
1992             case 6: /* multi color pattern */
1993                 for(x = 0; x < msg->width; x++)
1994                 {
1995                     if (!maskarray || (maskword & mmask))
1996                     {
1997                         WORD plane;
1998                         ULONG pixel = (patword & pmask) ? 1 : 0;
1999
2000                         for(plane = 1; plane < msg->patterndepth; plane++)
2001                         {
2002                             UWORD *_parray = parray + plane * msg->patternheight;
2003                             UWORD _patword = AROS_BE2WORD(*_parray);
2004
2005                             if (_patword & pmask) pixel |= 1L << plane;
2006                         }
2007
2008                         if (msg->patternlut) pixel = msg->patternlut->pixels[pixel];
2009
2010                         xbuf[x] = pixel;
2011                     }
2012
2013                     if (maskarray)
2014                     {
2015                         mmask >>= 1;
2016                         if (!mmask)
2017                         {
2018                             mmask = 0x8000;
2019                             marray++;
2020                             maskword = AROS_BE2WORD(*marray);
2021                         }
2022                     }
2023
2024                     pmask >>= 1;
2025                     if (!pmask) pmask = 0x8000;
2026
2027                 } /* for(x = 0; x < msg->width; x++) */
2028                 break;
2029
2030         } /* switch(type) */
2031
2032         buf += msg->dstMod;
2033         if (maskarray) maskarray += msg->maskmodulo;
2034
2035     } /* for(y = 0; y < msg->height; y++) */
2036
2037 }
2038 /****************************************************************************************/
2039
2040 VOID BM__Hidd_BitMap__PutMemPattern24(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutMemPattern24 *msg)
2041 {
2042     WORD                     x, y;
2043     UBYTE                   *patarray, *buf, *maskarray = 0;
2044     UWORD                    patmask, maskmask;
2045     OOP_Object              *gc = msg->gc;
2046     ULONG                    fg = GC_FG(gc);
2047     UBYTE                    fg1, fg2, fg3;
2048     ULONG                    bg = GC_BG(gc);
2049     UBYTE                    bg1, bg2, bg3;
2050     WORD                     type = 0;
2051
2052     if (msg->width <= 0 || msg->height <= 0)
2053         return;
2054
2055 #if AROS_BIG_ENDIAN
2056     fg1 = (fg >> 16) & 0xFF;
2057     fg2 = (fg >> 8) & 0xFF;
2058     fg3 =  fg & 0xFF;
2059
2060     bg1 = (bg >> 16) & 0xFF;
2061     bg2 = (bg >> 8) & 0xFF;
2062     bg3 =  bg & 0xFF;
2063 #else
2064     fg1 =  fg & 0xFF;
2065     fg2 = (fg >> 8) & 0xFF;
2066     fg3 = (fg >> 16) & 0xFF;
2067
2068     bg1 =  bg & 0xFF;
2069     bg2 = (bg >> 8) & 0xFF;
2070     bg3 = (bg >> 16) & 0xFF;
2071 #endif
2072
2073     if (msg->patterndepth > 1)
2074     {
2075         type = 6;
2076     }
2077     else
2078     {
2079         if (GC_COLEXP(gc) == vHidd_GC_ColExp_Transparent)
2080         {
2081             type = 0;
2082         }
2083         else if (GC_DRMD(gc) == vHidd_GC_DrawMode_Invert)
2084         {
2085             type = 2;
2086         }
2087         else
2088         {
2089             type = 4;
2090         }
2091
2092         if (msg->invertpattern) type++;
2093     }
2094
2095     patarray = msg->pattern;
2096     patmask = 0x8000 >> (msg->patternsrcx & 0xF);
2097
2098     if ((maskarray = msg->mask))
2099     {
2100         maskarray += (msg->masksrcx / 16) * 2;
2101         maskmask = 0x8000 >> (msg->masksrcx & 0xF);
2102     }
2103
2104     buf = msg->dst + msg->y * msg->dstMod + msg->x * 3;
2105
2106     for(y = 0; y < msg->height; y++)
2107     {
2108         UWORD  pmask = patmask;
2109         UWORD  mmask = maskmask;
2110         UWORD *parray = ((UWORD *)patarray) + ((y + msg->patternsrcy) % msg->patternheight);
2111         UWORD  patword = AROS_BE2WORD(*parray);
2112         UWORD *marray;
2113         UWORD  maskword;
2114         UBYTE *xbuf = (UBYTE *)buf;
2115
2116         if (maskarray)
2117         {
2118             marray = (UWORD *)maskarray;
2119             maskword = AROS_BE2WORD(*marray);
2120         }
2121
2122         switch(type)
2123         {
2124             case 0:     /* JAM1 */
2125                 for(x = 0; x < msg->width; x++, xbuf += 3)
2126                 {
2127                     if (!maskarray || (maskword & mmask))
2128                     {
2129                         if (patword & pmask)
2130                         {
2131                             xbuf[0] = fg1;
2132                             xbuf[1] = fg2;
2133                             xbuf[2] = fg3;
2134                         }
2135                     }
2136
2137                     if (maskarray)
2138                     {
2139                         mmask >>= 1;
2140                         if (!mmask)
2141                         {
2142                             mmask = 0x8000;
2143                             marray++;
2144                             maskword = AROS_BE2WORD(*marray);
2145                         }
2146                     }
2147
2148                     pmask >>= 1;
2149                     if (!pmask) pmask = 0x8000;
2150
2151                 } /* for(x = 0; x < msg->width; x++) */
2152                 break;
2153
2154             case 1:     /* JAM1 | INVERSVID */
2155                 for(x = 0; x < msg->width; x++, xbuf += 3)
2156                 {
2157                     if (!maskarray || (maskword & mmask))
2158                     {
2159                         if (!(patword & pmask))
2160                         {
2161                             xbuf[0] = fg1;
2162                             xbuf[1] = fg2;
2163                             xbuf[2] = fg3;
2164                         }
2165
2166                     }
2167
2168                     if (maskarray)
2169                     {
2170                         mmask >>= 1;
2171                         if (!mmask)
2172                         {
2173                             mmask = 0x8000;
2174                             marray++;
2175                             maskword = AROS_BE2WORD(*marray);
2176                         }
2177                     }
2178
2179                     pmask >>= 1;
2180                     if (!pmask) pmask = 0x8000;
2181                 } /* for(x = 0; x < msg->width; x++) */
2182                 break;
2183
2184             case 2: /* COMPLEMENT */
2185                 for(x = 0; x < msg->width; x++, xbuf += 3)
2186                 {
2187                     if (!maskarray || (maskword & mmask))
2188                     {
2189                         if (patword & pmask)
2190                         {
2191                             xbuf[0] = ~xbuf[0];
2192                             xbuf[1] = ~xbuf[1];
2193                             xbuf[2] = ~xbuf[2];
2194                         }
2195                     }
2196
2197                     if (maskarray)
2198                     {
2199                         mmask >>= 1;
2200                         if (!mmask)
2201                         {
2202                             mmask = 0x8000;
2203                             marray++;
2204                             maskword = AROS_BE2WORD(*marray);
2205                         }
2206                     }
2207
2208                     pmask >>= 1;
2209                     if (!pmask) pmask = 0x8000;
2210
2211                 } /* for(x = 0; x < msg->width; x++) */
2212                 break;
2213
2214             case 3: /* COMPLEMENT | INVERSVID*/
2215                 for(x = 0; x < msg->width; x++, xbuf += 3)
2216                 {
2217                     if (!maskarray || (maskword & mmask))
2218                     {
2219                         if (!(patword & pmask))
2220                         {
2221                             xbuf[0] = ~xbuf[0];
2222                             xbuf[1] = ~xbuf[1];
2223                             xbuf[2] = ~xbuf[2];
2224                         }
2225                     }
2226
2227                     if (maskarray)
2228                     {
2229                         mmask >>= 1;
2230                         if (!mmask)
2231                         {
2232                             mmask = 0x8000;
2233                             marray++;
2234                             maskword = AROS_BE2WORD(*marray);
2235                         }
2236                     }
2237
2238                     pmask >>= 1;
2239                     if (!pmask) pmask = 0x8000;
2240
2241                 } /* for(x = 0; x < msg->width; x++) */
2242                 break;
2243
2244             case 4:     /* JAM2 */
2245                 for(x = 0; x < msg->width; x++, xbuf += 3)
2246                 {
2247                     if (!maskarray || (maskword & mmask))
2248                     {
2249                         if (patword & pmask)
2250                         {
2251                             xbuf[0] = fg1;
2252                             xbuf[1] = fg2;
2253                             xbuf[2] = fg3;
2254                         }
2255                         else
2256                         {
2257                             xbuf[0] = bg1;
2258                             xbuf[1] = bg2;
2259                             xbuf[2] = bg3;
2260                         }
2261
2262                     }
2263
2264                     if (maskarray)
2265                     {
2266                         mmask >>= 1;
2267                         if (!mmask)
2268                         {
2269                             mmask = 0x8000;
2270                             marray++;
2271                             maskword = AROS_BE2WORD(*marray);
2272                         }
2273                     }
2274
2275                     pmask >>= 1;
2276                     if (!pmask) pmask = 0x8000;
2277
2278                 } /* for(x = 0; x < msg->width; x++) */
2279                 break;
2280
2281             case 5:     /* JAM2 | INVERSVID */
2282                 for(x = 0; x < msg->width; x++, xbuf += 3)
2283                 {
2284                     if (!maskarray || (maskword & mmask))
2285                     {
2286                         if (patword & pmask)
2287                         {
2288                             xbuf[0] = bg1;
2289                             xbuf[1] = bg2;
2290                             xbuf[2] = bg3;
2291                         }
2292                         else
2293                         {
2294                             xbuf[0] = fg1;
2295                             xbuf[1] = fg2;
2296                             xbuf[2] = fg3;
2297                         }
2298
2299                     }
2300
2301                     if (maskarray)
2302                     {
2303                         mmask >>= 1;
2304                         if (!mmask)
2305                         {
2306                             mmask = 0x8000;
2307                             marray++;
2308                             maskword = AROS_BE2WORD(*marray);
2309                         }
2310                     }
2311
2312                     pmask >>= 1;
2313                     if (!pmask) pmask = 0x8000;
2314
2315                 } /* for(x = 0; x < msg->width; x++) */
2316                 break;
2317
2318             case 6: /* multi color pattern */
2319                 for(x = 0; x < msg->width; x++, xbuf += 3)
2320                 {
2321                     if (!maskarray || (maskword & mmask))
2322                     {
2323                         WORD plane;
2324                         ULONG pixel = (patword & pmask) ? 1 : 0;
2325
2326                         for(plane = 1; plane < msg->patterndepth; plane++)
2327                         {
2328                             UWORD *_parray = parray + plane * msg->patternheight;
2329                             UWORD _patword = AROS_BE2WORD(*_parray);
2330
2331                             if (_patword & pmask) pixel |= 1L << plane;
2332                         }
2333
2334                         if (msg->patternlut) pixel = msg->patternlut->pixels[pixel];
2335
2336                     #if AROS_BIG_ENDIAN
2337                         xbuf[0] = (pixel >> 16) & 0xFF;
2338                         xbuf[1] = (pixel >> 8) & 0xFF;
2339                         xbuf[2] = (pixel) & 0xFF;
2340                     #else
2341                         xbuf[0] = (pixel) & 0xFF;
2342                         xbuf[1] = (pixel >> 8) & 0xFF;
2343                         xbuf[2] = (pixel >> 16) & 0xFF;
2344                     #endif
2345                     }
2346
2347                     if (maskarray)
2348                     {
2349                         mmask >>= 1;
2350                         if (!mmask)
2351                         {
2352                             mmask = 0x8000;
2353                             marray++;
2354                             maskword = AROS_BE2WORD(*marray);
2355                         }
2356                     }
2357
2358                     pmask >>= 1;
2359                     if (!pmask) pmask = 0x8000;
2360
2361                 } /* for(x = 0; x < msg->width; x++) */
2362                 break;
2363
2364         } /* switch(type) */
2365
2366         buf += msg->dstMod;
2367         if (maskarray) maskarray += msg->maskmodulo;
2368
2369     } /* for(y = 0; y < msg->height; y++) */
2370
2371 }
2372
2373 /****************************************************************************************/
2374
2375 VOID BM__Hidd_BitMap__PutMemPattern32(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutMemPattern32 *msg)
2376 {
2377     WORD                     x, y;
2378     UBYTE                   *patarray, *buf, *maskarray = 0;
2379     UWORD                    patmask, maskmask;
2380     OOP_Object              *gc = msg->gc;
2381     ULONG                    fg = GC_FG(gc);
2382     ULONG                    bg = GC_BG(gc);
2383     WORD                     type = 0;
2384
2385     if (msg->width <= 0 || msg->height <= 0)
2386         return;
2387
2388     if (msg->patterndepth > 1)
2389     {
2390         type = 6;
2391     }
2392     else
2393     {
2394         if (GC_COLEXP(gc) == vHidd_GC_ColExp_Transparent)
2395         {
2396             type = 0;
2397         }
2398         else if (GC_DRMD(gc) == vHidd_GC_DrawMode_Invert)
2399         {
2400             type = 2;
2401         }
2402         else
2403         {
2404             type = 4;
2405         }
2406
2407         if (msg->invertpattern) type++;
2408     }
2409
2410     patarray = msg->pattern;
2411     patmask = 0x8000 >> (msg->patternsrcx & 0xF);
2412
2413     if ((maskarray = msg->mask))
2414     {
2415         maskarray += (msg->masksrcx / 16) * 2;
2416         maskmask = 0x8000 >> (msg->masksrcx & 0xF);
2417     }
2418
2419     buf = msg->dst + msg->y * msg->dstMod + msg->x * 4;
2420
2421     for(y = 0; y < msg->height; y++)
2422     {
2423         UWORD  pmask = patmask;
2424         UWORD  mmask = maskmask;
2425         UWORD *parray = ((UWORD *)patarray) + ((y + msg->patternsrcy) % msg->patternheight);
2426         UWORD  patword = AROS_BE2WORD(*parray);
2427         UWORD *marray;
2428         UWORD  maskword;
2429         ULONG *xbuf = (ULONG *)buf;
2430
2431         if (maskarray)
2432         {
2433             marray = (UWORD *)maskarray;
2434             maskword = AROS_BE2WORD(*marray);
2435         }
2436
2437         switch(type)
2438         {
2439             case 0:     /* JAM1 */
2440                 for(x = 0; x < msg->width; x++, xbuf++)
2441                 {
2442                     if (!maskarray || (maskword & mmask))
2443                     {
2444                         if (patword & pmask) *xbuf = fg;
2445                     }
2446
2447                     if (maskarray)
2448                     {
2449                         mmask >>= 1;
2450                         if (!mmask)
2451                         {
2452                             mmask = 0x8000;
2453                             marray++;
2454                             maskword = AROS_BE2WORD(*marray);
2455                         }
2456                     }
2457
2458                     pmask >>= 1;
2459                     if (!pmask) pmask = 0x8000;
2460
2461                 } /* for(x = 0; x < msg->width; x++) */
2462                 break;
2463
2464             case 1:     /* JAM1 | INVERSVID */
2465                 for(x = 0; x < msg->width; x++, xbuf++)
2466                 {
2467                     if (!maskarray || (maskword & mmask))
2468                     {
2469                         if (!(patword & pmask)) *xbuf = fg;
2470                     }
2471
2472                     if (maskarray)
2473                     {
2474                         mmask >>= 1;
2475                         if (!mmask)
2476                         {
2477                             mmask = 0x8000;
2478                             marray++;
2479                             maskword = AROS_BE2WORD(*marray);
2480                         }
2481                     }
2482
2483                     pmask >>= 1;
2484                     if (!pmask) pmask = 0x8000;
2485                 } /* for(x = 0; x < msg->width; x++) */
2486                 break;
2487
2488             case 2: /* COMPLEMENT */
2489                 for(x = 0; x < msg->width; x++, xbuf++)
2490                 {
2491                     if (!maskarray || (maskword & mmask))
2492                     {
2493                         if (patword & pmask) *xbuf = ~(*xbuf);
2494                     }
2495
2496                     if (maskarray)
2497                     {
2498                         mmask >>= 1;
2499                         if (!mmask)
2500                         {
2501                             mmask = 0x8000;
2502                             marray++;
2503                             maskword = AROS_BE2WORD(*marray);
2504                         }
2505                     }
2506
2507                     pmask >>= 1;
2508                     if (!pmask) pmask = 0x8000;
2509
2510                 } /* for(x = 0; x < msg->width; x++) */
2511                 break;
2512
2513             case 3: /* COMPLEMENT | INVERSVID*/
2514                 for(x = 0; x < msg->width; x++, xbuf++)
2515                 {
2516                     if (!maskarray || (maskword & mmask))
2517                     {
2518                         if (!(patword & pmask)) *xbuf = ~(*xbuf);
2519                     }
2520
2521                     if (maskarray)
2522                     {
2523                         mmask >>= 1;
2524                         if (!mmask)
2525                         {
2526                             mmask = 0x8000;
2527                             marray++;
2528                             maskword = AROS_BE2WORD(*marray);
2529                         }
2530                     }
2531
2532                     pmask >>= 1;
2533                     if (!pmask) pmask = 0x8000;
2534
2535                 } /* for(x = 0; x < msg->width; x++) */
2536                 break;
2537
2538             case 4:     /* JAM2 */
2539                 for(x = 0; x < msg->width; x++)
2540                 {
2541                     if (!maskarray || (maskword & mmask))
2542                     {
2543                         xbuf[x] = (patword & pmask) ? fg : bg;
2544                     }
2545
2546                     if (maskarray)
2547                     {
2548                         mmask >>= 1;
2549                         if (!mmask)
2550                         {
2551                             mmask = 0x8000;
2552                             marray++;
2553                             maskword = AROS_BE2WORD(*marray);
2554                         }
2555                     }
2556
2557                     pmask >>= 1;
2558                     if (!pmask) pmask = 0x8000;
2559
2560                 } /* for(x = 0; x < msg->width; x++) */
2561                 break;
2562
2563             case 5:     /* JAM2 | INVERSVID */
2564                 for(x = 0; x < msg->width; x++)
2565                 {
2566                     if (!maskarray || (maskword & mmask))
2567                     {
2568                         xbuf[x] = (patword & pmask) ? bg : fg;
2569                     }
2570
2571                     if (maskarray)
2572                     {
2573                         mmask >>= 1;
2574                         if (!mmask)
2575                         {
2576                             mmask = 0x8000;
2577                             marray++;
2578                             maskword = AROS_BE2WORD(*marray);
2579                         }
2580                     }
2581
2582                     pmask >>= 1;
2583                     if (!pmask) pmask = 0x8000;
2584
2585                 } /* for(x = 0; x < msg->width; x++) */
2586                 break;
2587
2588             case 6: /* multi color pattern */
2589                 for(x = 0; x < msg->width; x++)
2590                 {
2591                     if (!maskarray || (maskword & mmask))
2592                     {
2593                         WORD plane;
2594                         ULONG pixel = (patword & pmask) ? 1 : 0;
2595
2596                         for(plane = 1; plane < msg->patterndepth; plane++)
2597                         {
2598                             UWORD *_parray = parray + plane * msg->patternheight;
2599                             UWORD _patword = AROS_BE2WORD(*_parray);
2600
2601                             if (_patword & pmask) pixel |= 1L << plane;
2602                         }
2603
2604                         if (msg->patternlut) pixel = msg->patternlut->pixels[pixel];
2605
2606                         xbuf[x] = pixel;
2607                     }
2608
2609                     if (maskarray)
2610                     {
2611                         mmask >>= 1;
2612                         if (!mmask)
2613                         {
2614                             mmask = 0x8000;
2615                             marray++;
2616                             maskword = AROS_BE2WORD(*marray);
2617                         }
2618                     }
2619
2620                     pmask >>= 1;
2621                     if (!pmask) pmask = 0x8000;
2622
2623                 } /* for(x = 0; x < msg->width; x++) */
2624                 break;
2625
2626         } /* switch(type) */
2627
2628         buf += msg->dstMod;
2629         if (maskarray) maskarray += msg->maskmodulo;
2630
2631     } /* for(y = 0; y < msg->height; y++) */
2632
2633 }
2634
2635 /****************************************************************************************/