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