rom/hidds/graphics/gfx_bitmapmemblit.c

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