arch/m68k-amiga/hidd/gfx/amigavideobitmap.c

   1 /*
   2     Copyright  1995-2010, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Bitmap class for native Amiga chipset.
   6     Lang: English.
   7
   8 */
   9
  10 /****************************************************************************************/
  11
  12 #include <stdlib.h>
  13 #include <stdio.h>
  14 #include <string.h>
  15
  16 #include <proto/oop.h>
  17 #include <proto/utility.h>
  18 #include <exec/alerts.h>
  19 #include <aros/macros.h>
  20 #include <exec/memory.h>
  21 #include <exec/lists.h>
  22 #include <graphics/rastport.h>
  23 #include <graphics/gfx.h>
  24 #include <oop/oop.h>
  25 #include <hidd/graphics.h>
  26 #include <aros/symbolsets.h>
  27
  28 #define CMDDEBUGUNIMP(x) ;
  29 #define CMDDEBUGPIXEL(x) ;
  30 #define DEBUG 0
  31 #define DB2(x) ;
  32 #define DEBUG_TEXT(x)
  33 #include <aros/debug.h>
  34
  35 #include LC_LIBDEFS_FILE
  36
  37 #include "amigavideogfx.h"
  38 #include "amigavideobitmap.h"
  39
  40 #include "chipset.h"
  41 #include "blitter.h"
  42
  43 /****************************************************************************************/
  44
  45 #define AO(x)             (aoHidd_BitMap_ ## x)
  46 #define GOT_BM_ATTR(code) GOT_ATTR(code, aoHidd_BitMap, bitmap)
  47
  48 /****************************************************************************************/
  49
  50 static void setrtg(struct amigavideo_staticdata *csd, BOOL showrtg)
  51 {
  52 }
  53
  54 OOP_Object *AmigaVideoBM__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
  55 {
  56     struct amigavideo_staticdata *csd = CSD(cl);
  57     IPTR width, height, depth, disp;
  58     BOOL ok = TRUE;
  59     struct amigabm_data *data;
  60
  61     DB2(bug("AmigaVideoBM__Root__New\n"));
  62
  63     o =(OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
  64     if (NULL == o)
  65         return NULL;
  66
  67     data = OOP_INST_DATA(cl, o);
  68     memset(data, 0, sizeof  (*data));
  69
  70     data->align = csd->aga ? 64 : 16; // AGA 64-bit fetchmode needs 8-byte alignment
  71
  72     /* Get some data about the dimensions of the bitmap */
  73     OOP_GetAttr(o, aHidd_BitMap_Width,  &width);
  74     OOP_GetAttr(o, aHidd_BitMap_Height, &height);
  75     OOP_GetAttr(o, aHidd_BitMap_Depth, &depth);
  76     OOP_GetAttr(o, aoHidd_BitMap_Displayable, &disp);
  77
  78     DB2(bug("%dx%dx%d\n", width, height, depth));
  79
  80     /* We cache some info */
  81     data->width = width;
  82     data->bytesperrow = ((width + data->align - 1) & ~(data->align - 1)) / 8;
  83     data->height = height;
  84     data->depth = depth;
  85     data->pixelcacheoffset = -1;
  86
  87     if (ok) {
  88         /* Allocate memory for plane array */
  89         data->planes = AllocVec(sizeof(UBYTE*) * depth, MEMF_PUBLIC | MEMF_CLEAR);
  90         if (NULL == data->planes) {
  91             ok = FALSE;
  92         } else {
  93             UBYTE i;
  94             /* Allocate all the planes */
  95             for (i = 0; i < depth && ok; i++) {
  96                 data->planes[i] = AllocMem(data->bytesperrow * data->height, MEMF_CHIP | MEMF_CLEAR);
  97                 if (NULL == data->planes[i])
  98                     ok = FALSE;
  99             }
 100         }
 101     }
 102
 103     if (!ok) {
 104         OOP_MethodID dispose_mid;
 105
 106         dispose_mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
 107         OOP_CoerceMethod(cl, o, (OOP_Msg)&dispose_mid);
 108
 109         o = NULL;
 110     }
 111
 112     DB2(bug("ret=%x bm=%x\n", o, data));
 113
 114     return o;
 115 }
 116
 117 VOID AmigaVideoBM__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 118 {
 119     struct amigabm_data    *data;
 120     UBYTE                   i;
 121
 122     data = OOP_INST_DATA(cl, o);
 123
 124     DB2(bug("AmigaVideoBM__Root__Dispose %x bm=%x\n", o, data));
 125     if (data->disp)
 126         DB2(bug("removing displayed bitmap?!\n"));
 127
 128     if (NULL != data->planes)
 129     {
 130         for (i = 0; i < data->depth; i ++)
 131         {
 132             if (NULL != data->planes[i])
 133             {
 134                 FreeMem(data->planes[i], data->bytesperrow * data->height);
 135             }
 136         }
 137         FreeVec(data->planes);
 138     }
 139
 140     OOP_DoSuperMethod(cl, o, msg);
 141
 142     return;
 143 }
 144
 145
 146 VOID AmigaVideoBM__Root__Set(OOP_Class *cl, OOP_Object *o, struct pRoot_Set *msg)
 147 {
 148     struct amigavideo_staticdata *csd = CSD(cl);
 149     struct amigabm_data *data = OOP_INST_DATA(cl, o);
 150     struct TagItem  *tag, *tstate;
 151     ULONG           idx;
 152     BOOL moved = FALSE;
 153
 154     DB2(bug("AmigaVideoBM__Root__Set\n"));
 155     tstate = msg->attrList;
 156     while((tag = NextTagItem((const struct TagItem **)&tstate)))
 157     {
 158         DB2(bug("%d/%d\n", tag->ti_Tag, tag->ti_Data));
 159         if(IS_BITMAP_ATTR(tag->ti_Tag, idx))
 160         {
 161             DB2(bug("->%d\n", idx));
 162             switch(idx)
 163             {
 164                 case aoHidd_BitMap_Visible:
 165                     data->disp = tag->ti_Data;
 166                     if (data->disp) {
 167                         setrtg(csd, FALSE);
 168                         setmode(csd, data);
 169                     } else {
 170                         resetmode(csd);
 171                         setrtg(csd, TRUE);
 172                     }
 173                     break;
 174                 case aoHidd_BitMap_LeftEdge:
 175                     if (data->leftedge != tag->ti_Data) {
 176                         data->leftedge = tag->ti_Data;
 177                         moved = TRUE;
 178                     }
 179                     break;
 180                 case aoHidd_BitMap_TopEdge:
 181                     if (data->topedge != tag->ti_Data) {
 182                         data->topedge = tag->ti_Data;
 183                         if (data->topedge < 0)
 184                             data->topedge = 0;
 185                         if (data->topedge >= data->height)
 186                             data->topedge = data->height - 1;
 187                         moved = TRUE;
 188                     }
 189                     break;
 190             }
 191         }
 192     }
 193     DB2(bug("AmigaVideoBM__Root__Set Exit\n"));
 194     OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 195     if (moved && csd->disp == data)
 196         setscroll(csd, data);
 197 }
 198
 199 VOID AmigaVideoBM__Root__Get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 200 {
 201     struct amigavideo_staticdata *csd = CSD(cl);
 202     struct amigabm_data *data = OOP_INST_DATA(cl, o);
 203     ULONG idx;
 204
 205     DB2(bug("AmigaVideoBM__Root__Get %d, Attr=%d AmigaVideoBitmap=%d\n", msg->attrID, __IHidd_Attr, __IHidd_AmigaVideoBitmap));
 206     if (IS_AmigaVideoBM_ATTR(msg->attrID, idx)) {
 207         DB2(bug("AVBM=%d\n", idx));
 208         switch (idx)
 209         {
 210         case aoHidd_AmigaVideoBitMap_Drawable:
 211             *msg->storage = TRUE;
 212             return;
 213         }
 214     } else if (IS_BITMAP_ATTR(msg->attrID, idx)) {
 215         DB2(bug("BM=%d\n", idx));
 216         switch (idx)
 217         {
 218         case aoHidd_BitMap_LeftEdge:
 219             *msg->storage = data->leftedge;
 220             return;
 221         case aoHidd_BitMap_TopEdge:
 222             *msg->storage = data->topedge;
 223             return;
 224         case aoHidd_BitMap_Visible:
 225             *msg->storage = data->disp;
 226             return;
 227         case aoHidd_BitMap_Align:
 228             *msg->storage = csd->aga ? 64 : 16;
 229             return;
 230         case aoHidd_BitMap_BytesPerRow:
 231             if (data->bytesperrow == 0) {
 232                 IPTR width = 0;
 233                 IPTR align = csd->aga ? 64 : 16;
 234                 OOP_GetAttr(o, aHidd_BitMap_Width, &width);
 235                 *msg->storage = ((width + align - 1) & ~(align - 1)) / 8;
 236             } else {
 237                 *msg->storage = data->bytesperrow;
 238             }
 239             return;
 240         }
 241     }
 242     DB2(bug("AmigaVideoBM__Root__Get Exit\n"));
 243     OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 244 }
 245
 246 /****************************************************************************************/
 247
 248 static int AmigaVideoBM_Init(LIBBASETYPEPTR LIBBASE)
 249 {
 250     D(bug("AmigaVideoBM_Init\n"));
 251     return TRUE; //return OOP_ObtainAttrBases(attrbases);
 252 }
 253
 254 /****************************************************************************************/
 255
 256 static int AmigaVideoBM_Expunge(LIBBASETYPEPTR LIBBASE)
 257 {
 258     D(bug("AmigaVideoBM_Expunge\n"));
 259     //OOP_ReleaseAttrBases(attrbases);
 260     return TRUE;
 261 }
 262
 263 /****************************************************************************************/
 264
 265 ADD2INITLIB(AmigaVideoBM_Init, 0);
 266 ADD2EXPUNGELIB(AmigaVideoBM_Expunge, 0);
 267
 268 /****************************************************************************************/
 269
 270 BOOL AmigaVideoBM__Hidd_BitMap__SetColors(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_SetColors *msg)
 271 {
 272     struct amigabm_data *data = OOP_INST_DATA(cl, o);
 273     struct amigavideo_staticdata *csd = CSD(cl);
 274
 275     if (!OOP_DoSuperMethod(cl, o, (OOP_Msg)msg))
 276         return FALSE;
 277     return setcolors(csd, msg, data->disp);
 278 }
 279
 280 /****************************************************************************************/
 281
 282 #define CLEARCACHE flushpixelcache(data)
 283 /* Better than nothing but m68k assembly C2P still needed for best performance */
 284 static void flushpixelcache(struct amigabm_data *data)
 285 {
 286     UBYTE i, x;
 287     ULONG offset = data->pixelcacheoffset;
 288     UBYTE **plane = data->planes;
 289
 290     if (data->writemask) {
 291         ULONG tmpplanes[8];
 292         ULONG pixel, notpixel, wmask;
 293         if (~data->writemask) {
 294             for (i = 0; i < data->depth; i++) {
 295                 if (plane[i] == (UBYTE*)-1)
 296                     tmpplanes[i] = 0xffffffff;
 297                 else if (plane[i] == NULL)
 298                     tmpplanes[i] = 0x00000000;
 299                 else
 300                     tmpplanes[i] = *((ULONG*)(plane[i] + offset));
 301             }
 302         }
 303         pixel = 0x80000000;
 304         wmask = 1;
 305         for (x = 0; pixel; x++, pixel >>= 1, wmask <<= 1) {
 306             if (data->writemask & wmask) {
 307                 UBYTE c = data->pixelcache[x];
 308                 UBYTE mask = 1;
 309                 notpixel = ~pixel;
 310                 for (i = 0; i < data->depth; i++, mask <<= 1) {
 311                     if (plane[i] != NULL && plane[i] != (UBYTE *)-1) {
 312                         if (c & mask)
 313                             tmpplanes[i] |= pixel;
 314                         else
 315                             tmpplanes[i] &= notpixel;
 316                     }
 317                 }
 318             }
 319         }
 320         for (i = 0; i < data->depth; i++) {
 321             if (plane[i] != NULL && plane[i] != (UBYTE *)-1)
 322                 *((ULONG*)(plane[i] + offset)) = tmpplanes[i];
 323         }
 324     }
 325     data->pixelcacheoffset = -1;
 326     data->writemask = 0;
 327 }
 328
 329 VOID AmigaVideoBM__Hidd_BitMap__PutPixel(OOP_Class *cl, OOP_Object *o,
 330                                 struct pHidd_BitMap_PutPixel *msg)
 331 {
 332     struct amigabm_data    *data;
 333     ULONG                   offset;
 334     UBYTE                   bit;
 335
 336     data = OOP_INST_DATA(cl, o);
 337
 338     offset = msg->x / 8 + msg->y * data->bytesperrow;
 339     if ((offset & ~3) != data->pixelcacheoffset) {
 340         CLEARCACHE;
 341         data->pixelcacheoffset = offset & ~3;
 342     }
 343     bit = (offset - data->pixelcacheoffset) * 8 + (msg->x & 7);
 344     data->pixelcache[bit] = msg->pixel;
 345     data->writemask |= 1 << bit;
 346
 347     CMDDEBUGPIXEL(bug("PutPixel: %dx%d %x\n", msg->x, msg->y, msg->pixel));
 348 }
 349
 350 /****************************************************************************************/
 351
 352 ULONG AmigaVideoBM__Hidd_BitMap__GetPixel(OOP_Class *cl, OOP_Object *o,
 353                                 struct pHidd_BitMap_GetPixel *msg)
 354 {
 355     struct amigabm_data    *data;
 356     ULONG                   offset;
 357     UBYTE                   i, c, bit;
 358
 359     data = OOP_INST_DATA(cl, o);
 360     offset = msg->x / 8 + msg->y * data->bytesperrow;
 361
 362     if ((offset & ~3) != data->pixelcacheoffset) {
 363         ULONG tmpplanes[8], mask;
 364         UBYTE x;
 365         UBYTE **plane = data->planes;
 366
 367         CLEARCACHE;
 368         data->pixelcacheoffset = offset & ~3;
 369         for (i = 0; i < data->depth; i++) {
 370             if (plane[i] == (UBYTE*)-1)
 371                 tmpplanes[i] = 0xffffffff;
 372             else if (plane[i] == NULL)
 373                 tmpplanes[i] = 0x00000000;
 374             else
 375                 tmpplanes[i] = *((ULONG*)(plane[i] + data->pixelcacheoffset));
 376         }
 377         mask = 0x80000000;
 378         for (x = 0; mask; x++, mask >>= 1) {
 379             UBYTE c = 0, pixel = 1;
 380             for(i = 0; i < data->depth; i++, pixel <<= 1) {
 381                 if (tmpplanes[i] & mask)
 382                     c |= pixel;
 383             }
 384             data->pixelcache[x] = c;
 385         }
 386     }
 387     bit = (offset - data->pixelcacheoffset) * 8 + (msg->x & 7);
 388     c = data->pixelcache[bit];
 389     CMDDEBUGPIXEL(bug("GetPixel: %dx%d %x\n", msg->x, msg->y, c));
 390     return c;
 391 }
 392
 393 /****************************************************************************************/
 394
 395 VOID AmigaVideoBM__Hidd_BitMap__DrawLine(OOP_Class *cl, OOP_Object *o,
 396                                 struct pHidd_BitMap_DrawLine *msg)
 397 {
 398     HIDDT_Pixel fg = GC_FG(msg->gc);
 399     HIDDT_DrawMode mode = GC_DRMD(msg->gc);
 400     struct amigavideo_staticdata *csd = CSD(cl);
 401     struct amigabm_data *data = OOP_INST_DATA(cl, o);
 402
 403     CLEARCACHE;
 404     if (msg->x1 == msg->x2 || msg->y1 == msg->y2) {
 405         WORD x1 = msg->x1, x2 = msg->x2;
 406         WORD y1 = msg->y1, y2 = msg->y2;
 407         if (x1 > x2) {
 408             WORD tmp = x1;
 409             x1 = x2;
 410             x2 = tmp;
 411         }
 412         if (y1 > y2) {
 413             WORD tmp = y1;
 414             y1 = y2;
 415             y2 = tmp;
 416         }
 417         if (x2 < 0)
 418             return;
 419         if (y2 < 0)
 420             return;
 421         if (x1 >= data->width)
 422             return;
 423         if (y1 >= data->height)
 424             return;
 425         if (x1 < 0)
 426             x1 = 0;
 427         if (y1 < 0)
 428             y1 = 0;
 429         if (x2 >= data->width)
 430             x2 = data->width - 1;
 431         if (y2 >= data->height)
 432             y2 = data->height - 1;
 433         if (!blit_fillrect(csd, data, x1, y1, x2, y2, fg, mode))
 434             OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 435     } else {
 436         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 437         CMDDEBUGUNIMP(bug("DrawLine\n"));
 438     }
 439 }
 440
 441 /****************************************************************************************/
 442
 443 VOID AmigaVideoBM__Hidd_BitMap__PutPattern(OOP_Class *cl, OOP_Object *o,
 444                                  struct pHidd_BitMap_PutPattern *msg)
 445 {
 446     struct amigavideo_staticdata *csd = CSD(cl);
 447     struct amigabm_data *data = OOP_INST_DATA(cl, o);
 448
 449     CLEARCACHE;
 450     D(bug("PutPattern(%dx%d,%dx%d,mask=%x,mod=%d,masksrcx=%d)\n(%x,%dx%d,h=%d,d=%d,lut=%x,inv=%d)(fg=%d,bg=%d,colexp=%d,drmd=%d)\n",
 451         msg->x, msg->y, msg->width, msg->height,
 452         msg->mask, msg->maskmodulo, msg->masksrcx,
 453         msg->pattern, msg->patternsrcx, msg->patternsrcy, msg->patternheight, msg->patterndepth, msg->patternlut, msg->invertpattern,
 454         GC_FG(msg->gc), GC_BG(msg->gc), GC_COLEXP(msg->gc), GC_DRMD(msg->gc)));
 455
 456     if (!blit_putpattern(csd, data, msg))
 457         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 458 }
 459
 460
 461 /****************************************************************************************/
 462
 463 VOID AmigaVideoBM__Hidd_BitMap__PutImageLUT(OOP_Class *cl, OOP_Object *o,
 464                                    struct pHidd_BitMap_PutImageLUT *msg)
 465 {
 466     WORD                    x, y, d;
 467     UBYTE                   *pixarray = (UBYTE *)msg->pixels;
 468     UBYTE                   **plane;
 469     ULONG                   planeoffset;
 470     struct amigabm_data   *data;
 471
 472     CMDDEBUGUNIMP(bug("PutImageLUT\n"));
 473
 474     data = OOP_INST_DATA(cl, o);
 475     CLEARCACHE;
 476
 477     planeoffset = msg->y * data->bytesperrow + msg->x / 8;
 478
 479     for(y = 0; y < msg->height; y++)
 480     {
 481         UBYTE *src = pixarray;
 482
 483         plane = data->planes;
 484
 485         for(d = 0; d < data->depth; d++)
 486         {
 487             ULONG dmask = 1L << d;
 488             ULONG pmask = 0x80 >> (msg->x & 7);
 489             UBYTE *pl = *plane;
 490
 491             if (pl == (UBYTE *)-1) continue;
 492             if (pl == NULL) continue;
 493
 494             pl += planeoffset;
 495
 496             for(x = 0; x < msg->width; x++)
 497             {
 498                 if (src[x] & dmask)
 499                 {
 500                     *pl |= pmask;
 501                 }
 502                 else
 503                 {
 504                     *pl &= ~pmask;
 505                 }
 506
 507                 if (pmask == 0x1)
 508                 {
 509                     pmask = 0x80;
 510                     pl++;
 511                 }
 512                 else
 513                 {
 514                     pmask >>= 1;
 515                 }
 516
 517             } /* for(x = 0; x < msg->width; x++) */
 518
 519             plane++;
 520
 521         } /* for(d = 0; d < data->depth; d++) */
 522
 523         pixarray += msg->modulo;
 524         planeoffset += data->bytesperrow;
 525
 526     } /* for(y = 0; y < msg->height; y++) */
 527 }
 528
 529 /****************************************************************************************/
 530
 531 VOID AmigaVideoBM__Hidd_BitMap__GetImageLUT(OOP_Class *cl, OOP_Object *o,
 532                                    struct pHidd_BitMap_GetImageLUT *msg)
 533 {
 534     WORD                    x, y, d;
 535     UBYTE                   *pixarray = (UBYTE *)msg->pixels;
 536     UBYTE                   **plane;
 537     ULONG                   planeoffset;
 538     struct amigabm_data    *data;
 539     UBYTE                   prefill;
 540
 541     data = OOP_INST_DATA(cl, o);
 542
 543     D(bug("[%s] Get %dx%d to %dx%d from %d planes to buffer at %p\n", __func__, msg->x, msg->y, msg->x + msg->width - 1, msg->y + msg->height - 1, data->depth, msg->pixels));
 544
 545     planeoffset = msg->y * data->bytesperrow + msg->x / 8;
 546
 547     prefill = 0;
 548     for (d = 0; d < data->depth; d++)
 549     {
 550         if (data->planes[d] == (UBYTE *)-1)
 551         {
 552             prefill |= (1L << d);
 553         }
 554     }
 555
 556     for (y = 0; y < msg->height; y++)
 557     {
 558         UBYTE *dest = pixarray;
 559
 560         plane = data->planes;
 561         for(x = 0; x < msg->width; x++)
 562         {
 563             dest[x] = prefill;
 564         }
 565
 566         for (d = 0; d < data->depth; d++)
 567         {
 568             ULONG dmask = 1L << d;
 569             ULONG pmask = 0x80 >> (msg->x & 7);
 570             UBYTE *pl = *plane;
 571
 572             if (pl == (UBYTE *)-1) continue;
 573             if (pl == NULL) continue;
 574
 575             pl += planeoffset;
 576
 577             for (x = 0; x < msg->width; x++)
 578             {
 579                 if (*pl & pmask)
 580                 {
 581                     dest[x] |= dmask;
 582                 }
 583                 else
 584                 {
 585                     dest[x] &= ~dmask;
 586                 }
 587
 588                 if (pmask == 0x1)
 589                 {
 590                     pmask = 0x80;
 591                     pl++;
 592                 }
 593                 else
 594                 {
 595                     pmask >>= 1;
 596                 }
 597
 598             } /* for(x = 0; x < msg->width; x++) */
 599
 600             plane++;
 601
 602         } /* for(d = 0; d < data->depth; d++) */
 603
 604         pixarray    += msg->modulo;
 605         planeoffset += data->bytesperrow;
 606
 607     } /* for(y = 0; y < msg->height; y++) */
 608
 609     D(bug("[%s] Got %d\n", __func__, *(UBYTE *)msg->pixels));
 610 }
 611
 612
 613 /****************************************************************************************/
 614
 615 VOID AmigaVideoBM__Hidd_BitMap__PutImage(OOP_Class *cl, OOP_Object *o,
 616                                 struct pHidd_BitMap_PutImage *msg)
 617 {
 618     WORD                    x, y, d;
 619     UBYTE                   *pixarray = (UBYTE *)msg->pixels;
 620     UBYTE                   **plane;
 621     ULONG                   planeoffset;
 622     struct amigabm_data    *data = OOP_INST_DATA(cl, o);
 623
 624     CLEARCACHE;
 625
 626     if ((msg->pixFmt != vHidd_StdPixFmt_Native) &&
 627         (msg->pixFmt != vHidd_StdPixFmt_Native32))
 628     {
 629         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 630         return;
 631     }
 632     CMDDEBUGUNIMP(bug("PutImage\n"));
 633
 634     planeoffset = msg->y * data->bytesperrow + msg->x / 8;
 635
 636     for(y = 0; y < msg->height; y++)
 637     {
 638         switch(msg->pixFmt)
 639         {
 640             case vHidd_StdPixFmt_Native:
 641             {
 642                 UBYTE *src = pixarray;
 643
 644                 plane = data->planes;
 645
 646                 for(d = 0; d < data->depth; d++)
 647                 {
 648                     ULONG dmask = 1L << d;
 649                     ULONG pmask = 0x80 >> (msg->x & 7);
 650                     UBYTE *pl = *plane;
 651
 652                     if (pl == (UBYTE *)-1) continue;
 653                     if (pl == NULL) continue;
 654
 655                     pl += planeoffset;
 656
 657                     for(x = 0; x < msg->width; x++)
 658                     {
 659                         if (src[x] & dmask)
 660                         {
 661                             *pl |= pmask;
 662                         }
 663                         else
 664                         {
 665                             *pl &= ~pmask;
 666                         }
 667
 668                         if (pmask == 0x1)
 669                         {
 670                             pmask = 0x80;
 671                             pl++;
 672                         }
 673                         else
 674                         {
 675                             pmask >>= 1;
 676                         }
 677
 678                     } /* for(x = 0; x < msg->width; x++) */
 679
 680                     plane++;
 681
 682                 } /* for(d = 0; d < data->depth; d++) */
 683
 684                 pixarray += msg->modulo;
 685                 planeoffset += data->bytesperrow;
 686             }
 687             break;
 688
 689             case vHidd_StdPixFmt_Native32:
 690             {
 691                 HIDDT_Pixel *src = (HIDDT_Pixel *)pixarray;
 692
 693                 plane = data->planes;
 694
 695                 for(d = 0; d < data->depth; d++)
 696                 {
 697                     ULONG dmask = 1L << d;
 698                     ULONG pmask = 0x80 >> (msg->x & 7);
 699                     UBYTE *pl = *plane;
 700
 701                     if (pl == (UBYTE *)-1) continue;
 702                     if (pl == NULL) continue;
 703
 704                     pl += planeoffset;
 705
 706                     for(x = 0; x < msg->width; x++)
 707                     {
 708                         if (src[x] & dmask)
 709                         {
 710                             *pl |= pmask;
 711                         }
 712                         else
 713                         {
 714                             *pl &= ~pmask;
 715                         }
 716
 717                         if (pmask == 0x1)
 718                         {
 719                             pmask = 0x80;
 720                             pl++;
 721                         }
 722                         else
 723                         {
 724                             pmask >>= 1;
 725                         }
 726
 727                     } /* for(x = 0; x < msg->width; x++) */
 728
 729                     plane++;
 730
 731                 } /* for(d = 0; d < data->depth; d++) */
 732
 733                 pixarray += msg->modulo;
 734                 planeoffset += data->bytesperrow;
 735             }
 736
 737             break;
 738
 739         } /* switch(msg->pixFmt) */
 740
 741     } /* for(y = 0; y < msg->height; y++) */
 742 }
 743
 744 /****************************************************************************************/
 745
 746 VOID AmigaVideoBM__Hidd_BitMap__FillRect(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawRect *msg)
 747 {
 748     HIDDT_Pixel fg = GC_FG(msg->gc);
 749     HIDDT_DrawMode mode = GC_DRMD(msg->gc);
 750     struct amigavideo_staticdata *csd = CSD(cl);
 751     struct amigabm_data *data = OOP_INST_DATA(cl, o);
 752
 753     CLEARCACHE;
 754     if (!blit_fillrect(csd, data, msg->minX, msg->minY, msg->maxX, msg->maxY, fg, mode)) {
 755         CMDDEBUGUNIMP(bug("FillRect\n"));
 756         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 757     }
 758 }
 759
 760 /****************************************************************************************/
 761
 762 VOID AmigaVideoBM__Hidd_BitMap__PutTemplate(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutTemplate *msg)
 763 {
 764     struct amigavideo_staticdata *csd = CSD(cl);
 765     struct amigabm_data *data = OOP_INST_DATA(cl, o);
 766
 767     CLEARCACHE;
 768     if (!blit_puttemplate(csd, data, msg)) {
 769         CMDDEBUGUNIMP(bug("PutTemplate: %x x=%d y=%d w=%d h=%d srcx=%d modulo=%d invert=%d\n",
 770             msg->Template, msg->x, msg->y, msg->width, msg->height, msg->srcx, msg->inverttemplate));
 771         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 772     }
 773 }
 774
 775
 776 /****************************************************************************************/
 777
 778 VOID AmigaVideoBM__Hidd_BitMap__UpdateRect(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_UpdateRect *msg)
 779 {
 780 }
 781
 782 /****************************************************************************************/
 783
 784 BOOL AmigaVideoBM__Hidd_PlanarBM__SetBitMap(OOP_Class *cl, OOP_Object *o,
 785                                    struct pHidd_PlanarBM_SetBitMap *msg)
 786 {
 787     CMDDEBUGUNIMP(bug("SetBitMap\n"));
 788     return OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 789 }
 790
 791 /****************************************************************************************/
 792
 793 BOOL AmigaVideoBM__Hidd_PlanarBM__GetBitMap(OOP_Class *cl, OOP_Object *o,
 794                                    struct pHidd_PlanarBM_GetBitMap *msg)
 795 {
 796     CMDDEBUGUNIMP(bug("GetBitMap\n"));
 797     return OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 798 }