arch/m68k-amiga/hidd/uaegfx/uaegfx_bitmapclass.c

   1 /*
   2     Copyright  1995-2017, 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/gfx.h>
  26 #include <aros/symbolsets.h>
  27
  28 #define DEBUG 0
  29 #define DB2(x) ;
  30 #define DEBUG_TEXT(x)
  31 #define DVRAM(x) ;
  32 #include <aros/debug.h>
  33
  34 #include LC_LIBDEFS_FILE
  35
  36 #include "uaegfx_intern.h"
  37 #include "uaegfx_bitmap.h"
  38 #include "uaertg.h"
  39
  40 /* LOCK_BITMAP_MULTI:
  41
  42   swap bitmap between RAM <-> VRAM allowed only if this lock is held
  43
  44   the bitmap being swapped must also get LOCK_BITMAP lock, otherwise
  45   gfx functions (done by other tasks) could render into wrong place while
  46   bitmap is moved around.
  47
  48 */
  49
  50 static APTR allocrtgvrambitmap(struct uaegfx_staticdata *csd, struct bm_data *bm)
  51 {
  52     APTR vmem;
  53     SetMemoryMode(csd, RGBFB_CLUT);
  54     vmem = Allocate(csd->vmem, bm->memsize);
  55     SetMemoryMode(csd, bm->rgbformat);
  56     if (vmem)
  57     {
  58         DVRAM(bug("BM %p (%dx%dx%d %d): %p,%d bytes VRAM allocated.\n", bm, bm->width, bm->height, bm->bytesperpixel*8, bm->bytesperline, vmem, bm->memsize));
  59     }
  60     return vmem;
  61 }
  62
  63 static void freertgbitmap(struct uaegfx_staticdata *csd, struct bm_data *bm)
  64 {
  65     DVRAM(bug("BM %p: freeing %p:%d from %s\n", bm, bm->VideoData, bm->memsize, bm->invram ? "VRAM" : "RAM"));
  66     if (bm->invram)
  67     {
  68         SetMemoryMode(csd, RGBFB_CLUT);
  69         Deallocate(csd->vmem, bm->VideoData, bm->memsize);
  70         SetMemoryMode(csd, bm->rgbformat);
  71         csd->vram_used -= bm->memsize;
  72     }
  73     else if (bm->VideoData)
  74     {
  75         FreeMem(bm->VideoData, bm->memsize);
  76         csd->fram_used -= bm->memsize;
  77     }
  78     bm->VideoData = NULL;
  79     bm->invram = FALSE;
  80 }
  81
  82 static BOOL movebitmaptofram(struct uaegfx_staticdata *csd, struct bm_data *bm)
  83 {
  84     BOOL ok = FALSE;
  85     APTR vmem;
  86
  87     /* TRYLOCK here as we are in wrong locking order (could deadlock):
  88
  89       LOCK_BITMAP_MULTI -> LOCK_HW -> [...] <- UNLOCK_HW <- UNLOCK_BITMAP_MULTI
  90       (Correct locking order is: LOCK_BM_MULTI -> LOCK_BM -> LOCK_HW)
  91
  92       Alternative would be to always lock all (swappable) bitmaps during bitmap
  93       allocation/freeing routines. */
  94
  95
  96     if (TRYLOCK_BITMAP(bm))
  97     {
  98         vmem = AllocMem(bm->memsize, MEMF_ANY);
  99         if (vmem)
 100         {
 101             SetMemoryMode(csd, bm->rgbformat);
 102             CopyMemQuick(bm->VideoData, vmem, bm->memsize);
 103             freertgbitmap(csd, bm);
 104             bm->VideoData = vmem;
 105             bm->invram = FALSE;
 106             csd->fram_used += bm->memsize;
 107             ok = TRUE;
 108        }
 109        DVRAM(bug("BM %p: %d x %d moved to RAM %p:%d. VRAM=%d\n", bm, bm->width, bm->height, bm->VideoData, bm->memsize, csd->vram_used));
 110
 111        UNLOCK_BITMAP(bm)
 112     }
 113
 114    return ok;
 115 }
 116
 117 static BOOL allocrtgbitmap(struct uaegfx_staticdata *csd, struct bm_data *bm, BOOL usevram)
 118 {
 119     bm->memsize = (bm->bytesperline * bm->height + 7) & ~7;
 120
 121     if (!(bm->VideoData = allocrtgvrambitmap(csd, bm)))
 122     {
 123         if (usevram && bm->memsize < csd->vram_size)
 124         {
 125              struct bm_data *bmnode;
 126              ForeachNode(&csd->bitmaplist, bmnode)
 127              {
 128                 if (bmnode != bm && bmnode->invram && !bmnode->locked)
 129                 {
 130                     if (movebitmaptofram(csd, bmnode))
 131                     {
 132                         if ((bm->VideoData = allocrtgvrambitmap(csd, bm)))
 133                         {
 134                             csd->vram_used += bm->memsize;
 135                             bm->invram = TRUE;
 136                             break;
 137                         }
 138                     }
 139                 }
 140              }
 141         }
 142
 143         if (!bm->VideoData)
 144         {
 145             bm->VideoData = AllocMem(bm->memsize, MEMF_ANY);
 146             if (bm->VideoData)
 147             {
 148                 csd->fram_used += bm->memsize;
 149             }
 150         }
 151     }
 152     else
 153     {
 154         csd->vram_used += bm->memsize;
 155         bm->invram = TRUE;
 156     }
 157     DVRAM(bug("BM %p: %p,%d bytes allocated from %s. VRAM=%d\n", bm, bm->VideoData, bm->memsize, bm->invram ? "VRAM" : "RAM", csd->vram_used));
 158
 159     //if (bm->VideoData != NULL)
 160     //{
 161     //    int i;
 162     //
 163     //    for(i = 0; i < bm->memsize; i++) bm->VideoData[i] = 0xFF;
 164     //}
 165
 166     return bm->VideoData != NULL;
 167 }
 168
 169 static BOOL movethisbitmaptovram(struct uaegfx_staticdata *csd, struct bm_data *bm)
 170 {
 171     APTR vmem = allocrtgvrambitmap(csd, bm);
 172     if (vmem)
 173     {
 174         SetMemoryMode(csd, bm->rgbformat);
 175         CopyMemQuick(bm->VideoData, vmem, bm->memsize);
 176         freertgbitmap(csd, bm);
 177         bm->VideoData = vmem;
 178         bm->invram = TRUE;
 179         csd->vram_used += bm->memsize;
 180         DVRAM(bug("BM %p: %p:%d (%d x %d) moved back to VRAM\n", bm, bm->VideoData, bm->memsize, bm->width, bm->height));
 181         return TRUE;
 182     }
 183     return FALSE;
 184 }
 185
 186 static BOOL movebitmaptovram(struct uaegfx_staticdata *csd, struct bm_data *bm)
 187 {
 188      struct bm_data *bmnode;
 189
 190      if (bm->invram)
 191         return TRUE;
 192
 193      DVRAM(bug("BM %p: %p,%d needs to be in VRAM...\n", bm, bm->VideoData, bm->memsize));
 194
 195      ForeachNode(&csd->bitmaplist, bmnode)
 196      {
 197         if (bmnode != bm && bmnode->invram && !bmnode->locked)
 198         {
 199             if (movebitmaptofram(csd, bmnode))
 200             {
 201                 if (movethisbitmaptovram(csd, bm))
 202                 {
 203                     return TRUE;
 204                 }
 205             }
 206         }
 207      }
 208
 209      DVRAM(bug("-> not enough memory, VRAM=%d\n", csd->vram_used));
 210
 211      return FALSE;
 212 }
 213
 214 #if 0
 215 static BOOL maybeputinvram(struct uaegfx_staticdata *csd, struct bm_data *bm)
 216 {
 217     if (bm->invram)
 218         return TRUE;
 219     if (bm->memsize >= csd->vram_size - csd->vram_used)
 220         return FALSE;
 221     return movethisbitmaptovram(csd, bm);
 222 }
 223 #endif
 224
 225 static void hidescreen(struct uaegfx_staticdata *csd, struct bm_data *bm)
 226 {
 227     D(bug("Hide %p: (%p:%d)\n",
 228         bm, bm->VideoData, bm->memsize));
 229     SetInterrupt(csd, FALSE);
 230     SetDisplay(csd, FALSE);
 231     SetSwitch(csd, FALSE);
 232     csd->dmodeid = 0;
 233     bm->locked--;
 234     csd->disp = NULL;
 235 }
 236
 237 /****************************************************************************************/
 238
 239 #define AO(x)             (aoHidd_BitMap_ ## x)
 240 #define GOT_BM_ATTR(code) GOT_ATTR(code, aoHidd_BitMap, bitmap)
 241
 242 /****************************************************************************************/
 243
 244 OOP_Object *UAEGFXBitmap__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
 245 {
 246     struct uaegfx_staticdata *csd = CSD(cl);
 247     BOOL  ok = TRUE;
 248     struct bm_data *data;
 249     IPTR                     width, height, multi;
 250     IPTR                     displayable;
 251     struct TagItem tags[2];
 252
 253     DB2(bug("UAEGFXBitmap__Root__New\n"));
 254
 255     o =(OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 256     if (NULL == o)
 257     {
 258         return NULL;
 259     }
 260
 261     data = OOP_INST_DATA(cl, o);
 262     memset(data, 0, sizeof  (*data));
 263     InitSemaphore(&data->bmLock);
 264
 265     OOP_GetAttr(o, aHidd_BitMap_Width,  &width);
 266     OOP_GetAttr(o, aHidd_BitMap_Height, &height);
 267     OOP_GetAttr(o, aHidd_BitMap_Displayable, &displayable);
 268     OOP_GetAttr(o, aHidd_BitMap_GfxHidd, (APTR)&data->gfxhidd);
 269     OOP_GetAttr(o, aHidd_BitMap_PixFmt, (APTR)&data->pixfmtobj);
 270     OOP_GetAttr(data->pixfmtobj, aHidd_PixFmt_BytesPerPixel, &multi);
 271
 272     data->rgbformat = getrtgformat(csd, data->pixfmtobj);
 273     data->align = displayable ? 32 : 16;
 274     width = (width + data->align - 1) & ~(data->align - 1);
 275     data->bytesperline = CalculateBytesPerRow(csd, width, data->rgbformat);
 276     data->width = width;
 277     data->height = height;
 278     data->bytesperpixel = multi;
 279
 280     LOCK_MULTI_BITMAP
 281
 282     LOCK_HW /* alloc routines call SetMemoryMode */
 283     WaitBlitter(csd); /* in case bitmaps are swapped between RAM <-> VRAM during allocation */
 284     allocrtgbitmap(csd, data, TRUE);
 285     UNLOCK_HW
 286
 287     AddTail(&csd->bitmaplist, (struct Node*)&data->node);
 288
 289     UNLOCK_MULTI_BITMAP
 290
 291     tags[0].ti_Tag = aHidd_BitMap_BytesPerRow;
 292     tags[0].ti_Data = data->bytesperline;
 293     tags[1].ti_Tag = TAG_DONE;
 294     OOP_SetAttrs(o, tags);
 295
 296     DB2(bug("%dx%dx%d %d RGBF=%08x P=%08x\n", width, height, multi, data->bytesperline, data->rgbformat, data->VideoData));
 297
 298     if (data->VideoData == NULL)
 299         ok = FALSE;
 300
 301     if (!ok) {
 302         OOP_MethodID dispose_mid;
 303         dispose_mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
 304         OOP_CoerceMethod(cl, o, (OOP_Msg)&dispose_mid);
 305         o = NULL;
 306     }
 307
 308     DB2(bug("ret=%x bm=%p (%p:%d)\n", o, data, data->VideoData, data->memsize));
 309
 310     return o;
 311 }
 312
 313 VOID UAEGFXBitmap__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 314 {
 315     struct uaegfx_staticdata *csd = CSD(cl);
 316     struct bm_data    *data;
 317
 318     data = OOP_INST_DATA(cl, o);
 319
 320     LOCK_HW
 321     WaitBlitter(csd);
 322
 323     DB2(bug("UAEGFXBitmap__Root__Dispose %x bm=%x (%p,%d)\n", o, data, data->VideoData, data->memsize));
 324     if (csd->disp == data)
 325         hidescreen(csd, data);
 326
 327     UNLOCK_HW
 328
 329     FreeVec(data->palette);
 330
 331     LOCK_MULTI_BITMAP
 332
 333     LOCK_HW /* free functions call SetMemoryMode */
 334     freertgbitmap(csd, data);
 335     UNLOCK_HW
 336
 337     Remove((struct Node*)&data->node);
 338
 339     UNLOCK_MULTI_BITMAP
 340
 341     OOP_DoSuperMethod(cl, o, msg);
 342 }
 343
 344 VOID UAEGFXBitmap__Root__Set(OOP_Class *cl, OOP_Object *o, struct pRoot_Set *msg)
 345 {
 346     struct uaegfx_staticdata *csd = CSD(cl);
 347     struct bm_data *data = OOP_INST_DATA(cl, o);
 348     struct TagItem  *tag, *tstate;
 349     ULONG           idx;
 350     BOOL moved = FALSE;
 351
 352     DB2(bug("UAEGFXBitmap__Root__Set %p (%p:%d)\n", data, data->VideoData, data->memsize));
 353     tstate = msg->attrList;
 354     while((tag = NextTagItem(&tstate)))
 355     {
 356         DB2(bug("%d/%d\n", tag->ti_Tag, tag->ti_Data));
 357         if(IS_BITMAP_ATTR(tag->ti_Tag, idx))
 358         {
 359             DB2(bug("->%d\n", idx));
 360             switch(idx)
 361             {
 362                 case aoHidd_BitMap_Visible:
 363                 LOCK_MULTI_BITMAP
 364                 LOCK_BITMAP(data)
 365                 LOCK_HW
 366                 if (tag->ti_Data) {
 367                     OOP_Object *gfxhidd, *sync, *pf;
 368                     IPTR modeid = vHidd_ModeID_Invalid;
 369                     IPTR dwidth, dheight, depth, width, height;
 370                     struct ModeInfo *modeinfo;
 371
 372                     width = data->width;
 373                     height = data->height;
 374                     OOP_GetAttr(o, aHidd_BitMap_ModeID , &modeid);
 375                     OOP_GetAttr(o, aHidd_BitMap_GfxHidd, (IPTR *)&gfxhidd);
 376                     HIDD_Gfx_GetMode(gfxhidd, modeid, &sync, &pf);
 377                     OOP_GetAttr(sync, aHidd_Sync_HDisp, &dwidth);
 378                     OOP_GetAttr(sync, aHidd_Sync_VDisp, &dheight);
 379                     OOP_GetAttr(pf, aHidd_PixFmt_Depth, &depth);
 380                     data->rgbformat = getrtgformat(csd, pf);
 381                     modeinfo = getrtgmodeinfo(csd, sync, pf, csd->fakemodeinfo);
 382                     csd->modeinfo = modeinfo;
 383                     csd->rgbformat = data->rgbformat;
 384                     pw(csd->bitmapextra + PSSO_BitMapExtra_Width, width);
 385                     pw(csd->bitmapextra + PSSO_BitMapExtra_Height, height);
 386                     D(bug("Show %p: (%p:%d) %dx%dx%d (%dx%d) BF=%08x\n",
 387                         data, data->VideoData, data->memsize,
 388                         dwidth, dheight, depth, width, height, data->rgbformat));
 389
 390                     if (!data->invram)
 391                     {
 392                         WaitBlitter(csd); /* in case other bitmaps are swapped from VRAM to RAM */
 393                         if (!movebitmaptovram(csd, data))
 394                         {
 395                             struct bm_data *bmnode;
 396
 397                             /* Second try. Now lock all bitmaps first. UNLOCK_HW first, to ensure
 398                                correct locking order: multibm -> bm -> hw */
 399
 400                             UNLOCK_HW
 401
 402                             ForeachNode(&csd->bitmaplist, bmnode)
 403                             {
 404                                 if (bmnode != data) LOCK_BITMAP(bmnode)
 405                             }
 406
 407                             LOCK_HW
 408                             WaitBlitter(csd); /* in case other bitmaps are swapped from VRAM to RAM */
 409                             movebitmaptovram(csd, data); /* shouldn't fail this time. If it does we are screwed ... */
 410                             UNLOCK_HW
 411
 412                             ForeachNode(&csd->bitmaplist, bmnode)
 413                             {
 414                                 if (bmnode != data) UNLOCK_BITMAP(bmnode)
 415                             }
 416
 417                             LOCK_HW
 418                         }
 419                     }
 420
 421                     csd->dwidth = dwidth;
 422                     csd->dheight = dheight;
 423                     csd->dmodeid = modeid;
 424
 425                     if (csd->hardwaresprite && depth <= 8) {
 426                         UWORD i;
 427                         UBYTE *clut = csd->boardinfo + PSSO_BoardInfo_CLUT;
 428                         for (i = csd->spritecolors + 1; i < csd->spritecolors + 4; i++)
 429                             SetSpriteColor(csd, i - (csd->spritecolors + 1),  clut[i * 3 + 0],  clut[i * 3 + 1],  clut[i * 3 + 2]);
 430                     }
 431                     SetInterrupt(csd, FALSE);
 432                     SetColorArray(csd, 0, 256);
 433                     SetDisplay(csd, FALSE);
 434                     SetGC(csd, modeinfo, 0);
 435                     SetClock(csd);
 436                     SetDAC(csd);
 437                     SetPanning(csd, data->VideoData, width, 0, 0);
 438                     SetDisplay(csd, TRUE);
 439                     SetSwitch(csd, TRUE);
 440                     SetInterrupt(csd, TRUE);
 441                     csd->disp = data;
 442                     csd->disp->locked++;
 443                 } else {
 444                     hidescreen(csd, data);
 445                 }
 446                 UNLOCK_HW
 447                 UNLOCK_BITMAP(data)
 448                 UNLOCK_MULTI_BITMAP
 449
 450                 break;
 451                 case aoHidd_BitMap_LeftEdge:
 452                     if (data->leftedge != tag->ti_Data) {
 453                         data->leftedge = tag->ti_Data;
 454                         moved = TRUE;
 455                     }
 456                 break;
 457                 case aoHidd_BitMap_TopEdge:
 458                     if (data->topedge != tag->ti_Data) {
 459                         data->topedge = tag->ti_Data;
 460                         moved = TRUE;
 461                     }
 462                 break;
 463             }
 464         }
 465     }
 466     DB2(bug("UAEGFXBitmap__Root__Set Exit\n"));
 467     OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 468 #if 0
 469     if (moved && csd->disp == data)
 470         setscroll(csd, data);
 471 #else
 472     (void)moved;
 473 #endif
 474 }
 475
 476 VOID UAEGFXBitmap__Root__Get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 477 {
 478     struct uaegfx_staticdata *csd = CSD(cl);
 479     struct bm_data *data = OOP_INST_DATA(cl, o);
 480     ULONG idx;
 481
 482     //DB2(bug("UAEGFXBitmap__Root__Get\n"));
 483     if (IS_BITMAP_ATTR(msg->attrID, idx)) {
 484         //DB2(bug("=%d\n", idx));
 485         switch (idx) {
 486         case aoHidd_BitMap_LeftEdge:
 487             *msg->storage = 0;//data->leftedge;
 488             return;
 489         case aoHidd_BitMap_TopEdge:
 490             *msg->storage = 0;//data->topedge;
 491             return;
 492         case aoHidd_BitMap_Visible:
 493             *msg->storage = csd->disp == data;
 494             return;
 495         case aoHidd_BitMap_Align:
 496             *msg->storage = data->align;
 497             return;
 498         case aoHidd_BitMap_BytesPerRow:
 499                 *msg->storage = data->bytesperline;
 500                 return;
 501         case aoHidd_BitMap_IsLinearMem:
 502             *msg->storage = TRUE;
 503             return;
 504         }
 505     }
 506     //DB2(bug("UAEGFXBitmap__Root__Get Exit\n"));
 507     OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 508 }
 509
 510 /****************************************************************************************/
 511
 512 static int UAEGFXBitmap_Init(LIBBASETYPEPTR LIBBASE)
 513 {
 514     D(bug("UAEGFXBitmap_Init\n"));
 515     return TRUE; //return OOP_ObtainAttrBases(attrbases);
 516 }
 517
 518 /****************************************************************************************/
 519
 520 static int UAEGFXBitmap_Expunge(LIBBASETYPEPTR LIBBASE)
 521 {
 522     D(bug("UAEGFXBitmap_Expunge\n"));
 523     //OOP_ReleaseAttrBases(attrbases);
 524     return TRUE;
 525 }
 526
 527 /****************************************************************************************/
 528
 529 ADD2INITLIB(UAEGFXBitmap_Init, 0);
 530 ADD2EXPUNGELIB(UAEGFXBitmap_Expunge, 0);
 531
 532 BOOL UAEGFXBitmap__Hidd_BitMap__ObtainDirectAccess(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_ObtainDirectAccess *msg)
 533 {
 534     struct uaegfx_staticdata *csd = CSD(cl);
 535     struct bm_data *data = OOP_INST_DATA(cl, o);
 536
 537     LOCK_BITMAP(data)
 538
 539 #if 0
 540     if (!data->invram) {
 541         if (!movebitmaptovram(csd, data))
 542             return FALSE;
 543     }
 544 #endif
 545
 546     *msg->addressReturn = data->VideoData;
 547     *msg->widthReturn = data->width;
 548     *msg->heightReturn = data->height;
 549     /* undocumented, just a guess.. */
 550     *msg->bankSizeReturn = *msg->memSizeReturn = data->bytesperline * data->height;
 551     data->locked++;
 552
 553     LOCK_HW
 554     WaitBlitter(csd);
 555     UNLOCK_HW
 556
 557     return TRUE;
 558 }
 559
 560 VOID UAEGFXBitmap__Hidd_BitMap__ReleaseDirectAccess(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_ReleaseDirectAccess *msg)
 561 {
 562     struct uaegfx_staticdata *csd = CSD(cl);
 563     struct bm_data *data = OOP_INST_DATA(cl, o);
 564     data->locked--;
 565
 566     UNLOCK_BITMAP(data)
 567 }
 568
 569 BOOL UAEGFXBitmap__Hidd_BitMap__SetColors(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_SetColors *msg)
 570 {
 571     struct uaegfx_staticdata *csd = CSD(cl);
 572     WORD i, j;
 573     UBYTE *clut;
 574
 575     if (!OOP_DoSuperMethod(cl, o, (OOP_Msg)msg))
 576         return FALSE;
 577
 578     LOCK_HW
 579
 580     WaitBlitter(csd);
 581     clut = csd->boardinfo + PSSO_BoardInfo_CLUT;
 582     for (i = msg->firstColor, j = 0; j < msg->numColors; i++, j++) {
 583         clut[i * 3 + 0] = msg->colors[j].red >> 8;
 584         clut[i * 3 + 1] = msg->colors[j].green >> 8;
 585         clut[i * 3 + 2] = msg->colors[j].blue >> 8;
 586         //bug("UAESET color %d %02x%02x%02x\n", i, msg->colors[j].red >> 8, msg->colors[j].green >> 8, msg->colors[j].blue >> 8);
 587     }
 588     SetColorArray(csd, msg->firstColor, msg->numColors);
 589
 590     UNLOCK_HW
 591
 592     return TRUE;
 593 }
 594
 595 VOID UAEGFXBitmap__Hidd_BitMap__PutPixel(OOP_Class *cl, OOP_Object *o,
 596                                 struct pHidd_BitMap_PutPixel *msg)
 597 {
 598     struct uaegfx_staticdata *csd = CSD(cl);
 599     struct bm_data *data = OOP_INST_DATA(cl, o);
 600     ULONG              offset;
 601     HIDDT_Pixel       pixel = msg->pixel;
 602     UBYTE             *mem;
 603
 604     LOCK_BITMAP(data)
 605
 606     LOCK_HW
 607     WaitBlitter(csd);
 608     UNLOCK_HW
 609
 610     offset = (msg->x * data->bytesperpixel) + (msg->y * data->bytesperline);
 611     mem = data->VideoData + offset;
 612
 613     switch(data->bytesperpixel)
 614     {
 615         case 1:
 616             *(UBYTE *)mem = pixel;
 617             break;
 618
 619         case 2:
 620             *(UWORD *)mem = pixel;
 621             break;
 622
 623         case 3:
 624             *(UBYTE *)(mem) = pixel >> 16;
 625             *(UBYTE *)(mem + 1) = pixel >> 8;
 626             *(UBYTE *)(mem + 2) = pixel;
 627             break;
 628
 629         case 4:
 630             *(ULONG *)mem = pixel;
 631             break;
 632     }
 633
 634     UNLOCK_BITMAP(data)
 635
 636     return;
 637 }
 638
 639 /****************************************************************************************/
 640
 641 ULONG UAEGFXBitmap__Hidd_BitMap__GetPixel(OOP_Class *cl, OOP_Object *o,
 642                                  struct pHidd_BitMap_GetPixel *msg)
 643 {
 644     struct uaegfx_staticdata *csd = CSD(cl);
 645     struct bm_data      *data = OOP_INST_DATA(cl, o);
 646     HIDDT_Pixel          pixel = 0;
 647     ULONG                offset;
 648     UBYTE               *mem;
 649
 650     LOCK_BITMAP(data)
 651
 652     LOCK_HW
 653     WaitBlitter(csd);
 654     UNLOCK_HW
 655
 656     offset = (msg->x * data->bytesperpixel)  +(msg->y * data->bytesperline);
 657     mem = data->VideoData + offset;
 658
 659     switch(data->bytesperpixel)
 660     {
 661         case 1:
 662             pixel = *(UBYTE *)mem;
 663             break;
 664
 665         case 2:
 666             pixel = *(UWORD *)mem;
 667             break;
 668
 669         case 3:
 670             pixel = (mem[0] << 16) | (mem[1] << 8) | mem[2];
 671             break;
 672
 673         case 4:
 674             pixel = *(ULONG *)mem;
 675             break;
 676
 677     }
 678
 679     UNLOCK_BITMAP(data)
 680
 681     return pixel;
 682 }
 683
 684 /****************************************************************************************/
 685
 686 VOID UAEGFXBitmap__Hidd_BitMap__DrawLine(OOP_Class *cl, OOP_Object *o,
 687                                 struct pHidd_BitMap_DrawLine *msg)
 688 {
 689     struct uaegfx_staticdata *csd = CSD(cl);
 690
 691     LOCK_HW
 692     WaitBlitter(csd);
 693     UNLOCK_HW
 694
 695     OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 696 }
 697
 698 /****************************************************************************************/
 699
 700 VOID UAEGFXBitmap__Hidd_BitMap__GetImage(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_GetImage *msg)
 701 {
 702     struct bm_data *data = OOP_INST_DATA(cl, o);
 703     struct uaegfx_staticdata *csd = CSD(cl);
 704
 705     LOCK_BITMAP(data)
 706
 707     LOCK_HW
 708     WaitBlitter(csd);
 709     UNLOCK_HW
 710
 711     switch(msg->pixFmt)
 712     {
 713         case vHidd_StdPixFmt_Native:
 714             switch(data->bytesperpixel)
 715             {
 716                 case 1:
 717                     HIDD_BM_CopyMemBox8(o,
 718                                         data->VideoData,
 719                                         msg->x,
 720                                         msg->y,
 721                                         msg->pixels,
 722                                         0,
 723                                         0,
 724                                         msg->width,
 725                                         msg->height,
 726                                         data->bytesperline,
 727                                         msg->modulo);
 728                     break;
 729
 730                 case 2:
 731                     HIDD_BM_CopyMemBox16(o,
 732                                          data->VideoData,
 733                                          msg->x,
 734                                          msg->y,
 735                                          msg->pixels,
 736                                          0,
 737                                          0,
 738                                          msg->width,
 739                                          msg->height,
 740                                          data->bytesperline,
 741                                          msg->modulo);
 742                     break;
 743
 744                 case 3:
 745                     HIDD_BM_CopyMemBox24(o,
 746                                          data->VideoData,
 747                                          msg->x,
 748                                          msg->y,
 749                                          msg->pixels,
 750                                          0,
 751                                          0,
 752                                          msg->width,
 753                                          msg->height,
 754                                          data->bytesperline,
 755                                          msg->modulo);
 756                     break;
 757
 758                 case 4:
 759                     HIDD_BM_CopyMemBox32(o,
 760                                          data->VideoData,
 761                                          msg->x,
 762                                          msg->y,
 763                                          msg->pixels,
 764                                          0,
 765                                          0,
 766                                          msg->width,
 767                                          msg->height,
 768                                          data->bytesperline,
 769                                          msg->modulo);
 770                     break;
 771
 772             } /* switch(data->bytesperpix) */
 773             break;
 774
 775         case vHidd_StdPixFmt_Native32:
 776             switch(data->bytesperpixel)
 777             {
 778                 case 1:
 779                     HIDD_BM_GetMem32Image8(o,
 780                                            data->VideoData,
 781                                            msg->x,
 782                                            msg->y,
 783                                            msg->pixels,
 784                                            msg->width,
 785                                            msg->height,
 786                                            data->bytesperline,
 787                                            msg->modulo);
 788                     break;
 789
 790                 case 2:
 791                     HIDD_BM_GetMem32Image16(o,
 792                                             data->VideoData,
 793                                             msg->x,
 794                                             msg->y,
 795                                             msg->pixels,
 796                                             msg->width,
 797                                             msg->height,
 798                                             data->bytesperline,
 799                                             msg->modulo);
 800                     break;
 801
 802                 case 3:
 803                     HIDD_BM_GetMem32Image24(o,
 804                                             data->VideoData,
 805                                             msg->x,
 806                                             msg->y,
 807                                             msg->pixels,
 808                                             msg->width,
 809                                             msg->height,
 810                                             data->bytesperline,
 811                                             msg->modulo);
 812                     break;
 813
 814                 case 4:
 815                     HIDD_BM_CopyMemBox32(o,
 816                                          data->VideoData,
 817                                          msg->x,
 818                                          msg->y,
 819                                          msg->pixels,
 820                                          0,
 821                                          0,
 822                                          msg->width,
 823                                          msg->height,
 824                                          data->bytesperline,
 825                                          msg->modulo);
 826                     break;
 827
 828             } /* switch(data->bytesperpix) */
 829             break;
 830
 831         default:
 832             {
 833                 APTR        pixels = msg->pixels;
 834                 APTR        srcPixels = data->VideoData + msg->y * data->bytesperline + msg->x * data->bytesperpixel;
 835                 OOP_Object *dstpf;
 836
 837                 dstpf = HIDD_Gfx_GetPixFmt(data->gfxhidd, msg->pixFmt);
 838
 839                 HIDD_BM_ConvertPixels(o, &srcPixels, (HIDDT_PixelFormat *)data->pixfmtobj, data->bytesperline,
 840                                       &pixels, (HIDDT_PixelFormat *)dstpf, msg->modulo,
 841                                       msg->width, msg->height, NULL);
 842             }
 843             break;
 844
 845     } /* switch(msg->pixFmt) */
 846
 847     UNLOCK_BITMAP(data)
 848 }
 849
 850 /****************************************************************************************/
 851
 852 VOID UAEGFXBitmap__Hidd_BitMap__PutImage(OOP_Class *cl, OOP_Object *o,
 853                                 struct pHidd_BitMap_PutImage *msg)
 854 {
 855     struct bm_data *data = OOP_INST_DATA(cl, o);
 856     struct uaegfx_staticdata *csd = CSD(cl);
 857
 858     LOCK_BITMAP(data)
 859
 860     LOCK_HW
 861     WaitBlitter(csd);
 862     UNLOCK_HW
 863
 864     switch(msg->pixFmt)
 865     {
 866         case vHidd_StdPixFmt_Native:
 867             switch(data->bytesperpixel)
 868             {
 869                 case 1:
 870                     HIDD_BM_CopyMemBox8(o,
 871                                         msg->pixels,
 872                                         0,
 873                                         0,
 874                                         data->VideoData,
 875                                         msg->x,
 876                                         msg->y,
 877                                         msg->width,
 878                                         msg->height,
 879                                         msg->modulo,
 880                                         data->bytesperline);
 881                     break;
 882
 883                 case 2:
 884                     HIDD_BM_CopyMemBox16(o,
 885                                          msg->pixels,
 886                                          0,
 887                                          0,
 888                                          data->VideoData,
 889                                          msg->x,
 890                                          msg->y,
 891                                          msg->width,
 892                                          msg->height,
 893                                          msg->modulo,
 894                                          data->bytesperline);
 895                     break;
 896
 897                 case 3:
 898                     HIDD_BM_CopyMemBox24(o,
 899                                          msg->pixels,
 900                                          0,
 901                                          0,
 902                                          data->VideoData,
 903                                          msg->x,
 904                                          msg->y,
 905                                          msg->width,
 906                                          msg->height,
 907                                          msg->modulo,
 908                                          data->bytesperline);
 909                     break;
 910
 911                 case 4:
 912                     HIDD_BM_CopyMemBox32(o,
 913                                          msg->pixels,
 914                                          0,
 915                                          0,
 916                                          data->VideoData,
 917                                          msg->x,
 918                                          msg->y,
 919                                          msg->width,
 920                                          msg->height,
 921                                          msg->modulo,
 922                                          data->bytesperline);
 923                     break;
 924
 925             } /* switch(data->bytesperpix) */
 926             break;
 927
 928         case vHidd_StdPixFmt_Native32:
 929             switch(data->bytesperpixel)
 930             {
 931                 case 1:
 932                     HIDD_BM_PutMem32Image8(o,
 933                                            msg->pixels,
 934                                            data->VideoData,
 935                                            msg->x,
 936                                            msg->y,
 937                                            msg->width,
 938                                            msg->height,
 939                                            msg->modulo,
 940                                            data->bytesperline);
 941                     break;
 942
 943                 case 2:
 944                     HIDD_BM_PutMem32Image16(o,
 945                                             msg->pixels,
 946                                             data->VideoData,
 947                                             msg->x,
 948                                             msg->y,
 949                                             msg->width,
 950                                             msg->height,
 951                                             msg->modulo,
 952                                             data->bytesperline);
 953                     break;
 954
 955                 case 3:
 956                     HIDD_BM_PutMem32Image24(o,
 957                                             msg->pixels,
 958                                             data->VideoData,
 959                                             msg->x,
 960                                             msg->y,
 961                                             msg->width,
 962                                             msg->height,
 963                                             msg->modulo,
 964                                             data->bytesperline);
 965                     break;
 966
 967                 case 4:
 968                     HIDD_BM_CopyMemBox32(o,
 969                                          msg->pixels,
 970                                          0,
 971                                          0,
 972                                          data->VideoData,
 973                                          msg->x,
 974                                          msg->y,
 975                                          msg->width,
 976                                          msg->height,
 977                                          msg->modulo,
 978                                          data->bytesperline);
 979                     break;
 980
 981             } /* switch(data->bytesperpix) */
 982             break;
 983
 984         default:
 985             {
 986                 APTR        pixels = msg->pixels;
 987                 APTR        dstBuf = data->VideoData + msg->y * data->bytesperline + msg->x * data->bytesperpixel;
 988                 OOP_Object *srcpf;
 989
 990                 srcpf = HIDD_Gfx_GetPixFmt(data->gfxhidd, msg->pixFmt);
 991
 992                 HIDD_BM_ConvertPixels(o, &pixels, (HIDDT_PixelFormat *)srcpf, msg->modulo,
 993                                       &dstBuf, (HIDDT_PixelFormat *)data->pixfmtobj, data->bytesperline,
 994                                       msg->width, msg->height, NULL);
 995             }
 996             break;
 997
 998     } /* switch(msg->pixFmt) */
 999
1000     UNLOCK_BITMAP(data)
1001 }
1002
1003 /****************************************************************************************/
1004
1005 VOID UAEGFXBitmap__Hidd_BitMap__PutImageLUT(OOP_Class *cl, OOP_Object *o,
1006                                    struct pHidd_BitMap_PutImageLUT *msg)
1007 {
1008     struct bm_data *data = OOP_INST_DATA(cl, o);
1009     struct uaegfx_staticdata *csd = CSD(cl);
1010
1011     LOCK_BITMAP(data)
1012
1013     LOCK_HW
1014     WaitBlitter(csd);
1015     UNLOCK_HW
1016
1017     switch(data->bytesperpixel)
1018     {
1019         case 2:
1020             HIDD_BM_CopyLUTMemBox16(o,
1021                                  msg->pixels,
1022                                  0,
1023                                  0,
1024                                  data->VideoData,
1025                                  msg->x,
1026                                  msg->y,
1027                                  msg->width,
1028                                  msg->height,
1029                                  msg->modulo,
1030                                  data->bytesperline,
1031                                  msg->pixlut);
1032             break;
1033
1034         case 3:
1035             HIDD_BM_CopyLUTMemBox24(o,
1036                                  msg->pixels,
1037                                  0,
1038                                  0,
1039                                  data->VideoData,
1040                                  msg->x,
1041                                  msg->y,
1042                                  msg->width,
1043                                  msg->height,
1044                                  msg->modulo,
1045                                  data->bytesperline,
1046                                  msg->pixlut);
1047             break;
1048
1049         case 4:
1050             HIDD_BM_CopyLUTMemBox32(o,
1051                                     msg->pixels,
1052                                     0,
1053                                     0,
1054                                     data->VideoData,
1055                                     msg->x,
1056                                     msg->y,
1057                                     msg->width,
1058                                     msg->height,
1059                                     msg->modulo,
1060                                     data->bytesperline,
1061                                     msg->pixlut);
1062             break;
1063
1064         default:
1065             OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
1066             break;
1067
1068     } /* switch(data->bytesperpix) */
1069
1070     UNLOCK_BITMAP(data)
1071 }
1072
1073 /****************************************************************************************/
1074
1075 VOID UAEGFXBitmap__Hidd_BitMap__GetImageLUT(OOP_Class *cl, OOP_Object *o,
1076                                    struct pHidd_BitMap_GetImageLUT *msg)
1077 {
1078     struct uaegfx_staticdata *csd = CSD(cl);
1079
1080     LOCK_HW
1081     WaitBlitter(csd);
1082     UNLOCK_HW
1083
1084     OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
1085 }
1086
1087 /****************************************************************************************/
1088
1089 VOID UAEGFXBitmap__Hidd_BitMap__FillRect(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawRect *msg)
1090 {
1091     HIDDT_Pixel fg = GC_FG(msg->gc);
1092     HIDDT_DrawMode mode = GC_DRMD(msg->gc);
1093     struct uaegfx_staticdata *csd = CSD(cl);
1094     struct bm_data *data = OOP_INST_DATA(cl, o);
1095     struct RenderInfo ri;
1096     BOOL v = FALSE;
1097
1098     LOCK_BITMAP(data)
1099
1100     LOCK_HW
1101     WaitBlitter(csd);
1102     UNLOCK_HW
1103 #if 0
1104     maybeputinvram(csd, data);
1105 #endif
1106
1107     if (data->invram) {
1108         makerenderinfo(csd, &ri, data);
1109
1110         LOCK_HW
1111
1112         if (mode == vHidd_GC_DrawMode_Clear || mode == vHidd_GC_DrawMode_Set) {
1113             ULONG pen = mode == vHidd_GC_DrawMode_Clear ? 0x00000000 : 0xffffffff;
1114             v = FillRect(csd, &ri, msg->minX, msg->minY, msg->maxX - msg->minX + 1, msg->maxY - msg->minY + 1, pen, 0xff, data->rgbformat);
1115         } else if (mode == vHidd_GC_DrawMode_Copy) {
1116             v = FillRect(csd, &ri, msg->minX, msg->minY, msg->maxX - msg->minX + 1, msg->maxY - msg->minY + 1, fg, 0xff, data->rgbformat);
1117         } else if (mode == vHidd_GC_DrawMode_Invert) {
1118             v = InvertRect(csd, &ri, msg->minX, msg->minY, msg->maxX - msg->minX + 1, msg->maxY - msg->minY + 1, 0xff, data->rgbformat);
1119         }
1120
1121         UNLOCK_HW
1122     }
1123
1124     if (!v) switch(mode)
1125     {
1126         case vHidd_GC_DrawMode_Copy:
1127             switch(data->bytesperpixel)
1128             {
1129                 case 1:
1130                     HIDD_BM_FillMemRect8(o,
1131                                          data->VideoData,
1132                                          msg->minX,
1133                                          msg->minY,
1134                                          msg->maxX,
1135                                          msg->maxY,
1136                                          data->bytesperline,
1137                                          fg);
1138                     break;
1139
1140                 case 2:
1141                     HIDD_BM_FillMemRect16(o,
1142                                          data->VideoData,
1143                                          msg->minX,
1144                                          msg->minY,
1145                                          msg->maxX,
1146                                          msg->maxY,
1147                                          data->bytesperline,
1148                                          fg);
1149                     break;
1150
1151                 case 3:
1152                     HIDD_BM_FillMemRect24(o,
1153                                          data->VideoData,
1154                                          msg->minX,
1155                                          msg->minY,
1156                                          msg->maxX,
1157                                          msg->maxY,
1158                                          data->bytesperline,
1159                                          fg);
1160                     break;
1161
1162                 case 4:
1163                     HIDD_BM_FillMemRect32(o,
1164                                          data->VideoData,
1165                                          msg->minX,
1166                                          msg->minY,
1167                                          msg->maxX,
1168                                          msg->maxY,
1169                                          data->bytesperline,
1170                                          fg);
1171                     break;
1172
1173             }
1174             break;
1175
1176         case vHidd_GC_DrawMode_Invert:
1177             HIDD_BM_InvertMemRect(o,
1178                                  data->VideoData,
1179                                  msg->minX * data->bytesperpixel,
1180                                  msg->minY,
1181                                  msg->maxX * data->bytesperpixel + data->bytesperpixel - 1,
1182                                  msg->maxY,
1183                                  data->bytesperline);
1184             break;
1185
1186         default:
1187             OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
1188             break;
1189
1190     } /* switch(mode) */
1191
1192     UNLOCK_BITMAP(data)
1193
1194 }
1195
1196 /****************************************************************************************/
1197
1198 VOID UAEGFXBitmap__Hidd_BitMap__PutPattern(OOP_Class *cl, OOP_Object *o,
1199                                  struct pHidd_BitMap_PutPattern *msg)
1200 {
1201     struct uaegfx_staticdata *csd = CSD(cl);
1202     struct bm_data *data = OOP_INST_DATA(cl, o);
1203     HIDDT_Pixel fg = GC_FG(msg->gc);
1204     HIDDT_Pixel bg = GC_BG(msg->gc);
1205     struct Pattern pat;
1206     struct RenderInfo ri;
1207     UBYTE drawmode;
1208     BOOL v = FALSE;
1209
1210     LOCK_BITMAP(data)
1211
1212     LOCK_HW
1213     WaitBlitter(csd);
1214     UNLOCK_HW
1215
1216     DB2(bug("blitpattern(%d,%d)(%d,%d)(%x,%d,%d,%d,%d,%d)\n",
1217         msg->x, msg->y, msg->width, msg->height,
1218         msg->pattern, msg->patternsrcx, msg->patternsrcy, fg, bg, msg->patternheight));
1219
1220     if ((msg->mask == NULL) && (msg->patterndepth == 1))
1221     {
1222         switch (msg->patternheight)
1223         {
1224             case 1:
1225             pat.Size = 0;
1226             break;
1227             case 2:
1228             pat.Size = 1;
1229             break;
1230             case 4:
1231             pat.Size = 2;
1232             break;
1233             case 8:
1234             pat.Size = 3;
1235             break;
1236             case 16:
1237             pat.Size = 4;
1238             break;
1239             case 32:
1240             pat.Size = 5;
1241             break;
1242             case 64:
1243             pat.Size = 6;
1244             break;
1245             case 128:
1246             pat.Size = 7;
1247             break;
1248             case 256:
1249             pat.Size = 8;
1250             break;
1251             default:
1252             pat.Size = 0xff;
1253         }
1254
1255         if (pat.Size <= 8)
1256         {
1257 #if 0
1258             maybeputinvram(csd, data);
1259 #endif
1260             if (data->invram)
1261             {
1262                 makerenderinfo(csd, &ri, data);
1263                 if (GC_COLEXP(msg->gc) == vHidd_GC_ColExp_Transparent)
1264                      drawmode = JAM1;
1265                 else if (GC_DRMD(msg->gc) == vHidd_GC_DrawMode_Invert)
1266                      drawmode = COMPLEMENT;
1267                 else
1268                     drawmode = JAM2;
1269                 if (msg->invertpattern)
1270                      drawmode |= INVERSVID;
1271
1272                 pat.Memory = msg->pattern;
1273                 pat.XOffset = msg->patternsrcx;
1274                 pat.YOffset = msg->patternsrcy;
1275                 pat.FgPen = fg;
1276                 pat.BgPen = bg;
1277                 pat.DrawMode = drawmode;
1278
1279                 LOCK_HW
1280
1281                 v = BlitPattern(csd, &ri, &pat, msg->x, msg->y, msg->width, msg->height, 0xff, data->rgbformat);
1282
1283                 UNLOCK_HW
1284             }
1285         }
1286     }
1287
1288     if (!v) switch(data->bytesperpixel)
1289     {
1290         case 1:
1291             HIDD_BM_PutMemPattern8(o,
1292                                    msg->gc,
1293                                    msg->pattern,
1294                                    msg->patternsrcx,
1295                                    msg->patternsrcy,
1296                                    msg->patternheight,
1297                                    msg->patterndepth,
1298                                    msg->patternlut,
1299                                    msg->invertpattern,
1300                                    msg->mask,
1301                                    msg->maskmodulo,
1302                                    msg->masksrcx,
1303                                    data->VideoData,
1304                                    data->bytesperline,
1305                                    msg->x,
1306                                    msg->y,
1307                                    msg->width,
1308                                    msg->height);
1309             break;
1310
1311         case 2:
1312             HIDD_BM_PutMemPattern16(o,
1313                                     msg->gc,
1314                                     msg->pattern,
1315                                     msg->patternsrcx,
1316                                     msg->patternsrcy,
1317                                     msg->patternheight,
1318                                     msg->patterndepth,
1319                                     msg->patternlut,
1320                                     msg->invertpattern,
1321                                     msg->mask,
1322                                     msg->maskmodulo,
1323                                     msg->masksrcx,
1324                                     data->VideoData,
1325                                     data->bytesperline,
1326                                     msg->x,
1327                                     msg->y,
1328                                     msg->width,
1329                                     msg->height);
1330             break;
1331
1332         case 3:
1333             HIDD_BM_PutMemPattern24(o,
1334                                     msg->gc,
1335                                     msg->pattern,
1336                                     msg->patternsrcx,
1337                                     msg->patternsrcy,
1338                                     msg->patternheight,
1339                                     msg->patterndepth,
1340                                     msg->patternlut,
1341                                     msg->invertpattern,
1342                                     msg->mask,
1343                                     msg->maskmodulo,
1344                                     msg->masksrcx,
1345                                     data->VideoData,
1346                                     data->bytesperline,
1347                                     msg->x,
1348                                     msg->y,
1349                                     msg->width,
1350                                     msg->height);
1351             break;
1352
1353         case 4:
1354             HIDD_BM_PutMemPattern32(o,
1355                                     msg->gc,
1356                                     msg->pattern,
1357                                     msg->patternsrcx,
1358                                     msg->patternsrcy,
1359                                     msg->patternheight,
1360                                     msg->patterndepth,
1361                                     msg->patternlut,
1362                                     msg->invertpattern,
1363                                     msg->mask,
1364                                     msg->maskmodulo,
1365                                     msg->masksrcx,
1366                                     data->VideoData,
1367                                     data->bytesperline,
1368                                     msg->x,
1369                                     msg->y,
1370                                     msg->width,
1371                                     msg->height);
1372             break;
1373
1374         default:
1375             OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
1376             break;
1377
1378     } /* switch(data->bytesperpixel) */
1379
1380     UNLOCK_BITMAP(data)
1381
1382 }
1383
1384 /****************************************************************************************/
1385
1386 VOID UAEGFXBitmap__Hidd_BitMap__PutTemplate(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutTemplate *msg)
1387 {
1388     struct uaegfx_staticdata *csd = CSD(cl);
1389     struct bm_data *data = OOP_INST_DATA(cl, o);
1390     HIDDT_Pixel fg = GC_FG(msg->gc);
1391     HIDDT_Pixel bg = GC_BG(msg->gc);
1392     struct Template tmpl;
1393     struct RenderInfo ri;
1394     UBYTE drawmode;
1395     BOOL v = FALSE;
1396
1397     LOCK_BITMAP(data)
1398
1399     LOCK_HW
1400     WaitBlitter(csd);
1401     UNLOCK_HW
1402
1403 #if 0
1404     maybeputinvram(csd, data);
1405 #endif
1406
1407     if (data->invram) {
1408         makerenderinfo(csd, &ri, data);
1409         if (GC_COLEXP(msg->gc) == vHidd_GC_ColExp_Transparent)
1410              drawmode = JAM1;
1411         else if (GC_DRMD(msg->gc) == vHidd_GC_DrawMode_Invert)
1412              drawmode = COMPLEMENT;
1413         else
1414             drawmode = JAM2;
1415         if (msg->inverttemplate)
1416              drawmode |= INVERSVID;
1417
1418         /* tmpl.XOffset has only UBYTE size so we must fix params up [1] [2] */
1419
1420         tmpl.Memory = msg->masktemplate + ((msg->srcx / 8) & ~1); /* [1] */
1421         tmpl.BytesPerRow = msg->modulo;
1422         tmpl.XOffset = msg->srcx & 0XF; /* [2] */
1423         tmpl.DrawMode = drawmode;
1424         tmpl.FgPen = fg;
1425         tmpl.BgPen = bg;
1426
1427         LOCK_HW
1428         v = BlitTemplate(csd, &ri, &tmpl, msg->x, msg->y, msg->width, msg->height, 0xff, data->rgbformat);
1429         UNLOCK_HW
1430     }
1431
1432     if (!v) switch(data->bytesperpixel)
1433     {
1434         case 1:
1435             HIDD_BM_PutMemTemplate8(o,
1436                                     msg->gc,
1437                                     msg->masktemplate,
1438                                     msg->modulo,
1439                                     msg->srcx,
1440                                     data->VideoData,
1441                                     data->bytesperline,
1442                                     msg->x,
1443                                     msg->y,
1444                                     msg->width,
1445                                     msg->height,
1446                                     msg->inverttemplate);
1447             break;
1448
1449         case 2:
1450             HIDD_BM_PutMemTemplate16(o,
1451                                      msg->gc,
1452                                      msg->masktemplate,
1453                                      msg->modulo,
1454                                      msg->srcx,
1455                                      data->VideoData,
1456                                      data->bytesperline,
1457                                      msg->x,
1458                                      msg->y,
1459                                      msg->width,
1460                                      msg->height,
1461                                      msg->inverttemplate);
1462             break;
1463
1464         case 3:
1465             HIDD_BM_PutMemTemplate24(o,
1466                                      msg->gc,
1467                                      msg->masktemplate,
1468                                      msg->modulo,
1469                                      msg->srcx,
1470                                      data->VideoData,
1471                                      data->bytesperline,
1472                                      msg->x,
1473                                      msg->y,
1474                                      msg->width,
1475                                      msg->height,
1476                                      msg->inverttemplate);
1477             break;
1478
1479         case 4:
1480             HIDD_BM_PutMemTemplate32(o,
1481                                      msg->gc,
1482                                      msg->masktemplate,
1483                                      msg->modulo,
1484                                      msg->srcx,
1485                                      data->VideoData,
1486                                      data->bytesperline,
1487                                      msg->x,
1488                                      msg->y,
1489                                      msg->width,
1490                                      msg->height,
1491                                      msg->inverttemplate);
1492             break;
1493
1494         default:
1495             OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
1496             break;
1497
1498     } /* switch(data->bytesperpixel) */
1499
1500     UNLOCK_BITMAP(data)
1501
1502 }
1503
1504
1505 /****************************************************************************************/
1506
1507 VOID UAEGFXBitmap__Hidd_BitMap__UpdateRect(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_UpdateRect *msg)
1508 {
1509     struct uaegfx_staticdata *csd = CSD(cl);
1510
1511     LOCK_HW
1512     WaitBlitter(csd);
1513     UNLOCK_HW
1514
1515     OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
1516 }
1517
1518 /****************************************************************************************/
1519
1520 BOOL UAEGFXBitmap__Hidd_PlanarBM__SetBitMap(OOP_Class *cl, OOP_Object *o,
1521                                    struct pHidd_PlanarBM_SetBitMap *msg)
1522 {
1523     struct uaegfx_staticdata *csd = CSD(cl);
1524
1525     LOCK_HW
1526     WaitBlitter(csd);
1527     UNLOCK_HW
1528
1529     return OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
1530 }
1531
1532 /****************************************************************************************/
1533
1534 BOOL UAEGFXBitmap__Hidd_PlanarBM__GetBitMap(OOP_Class *cl, OOP_Object *o,
1535                                    struct pHidd_PlanarBM_GetBitMap *msg)
1536 {
1537     struct uaegfx_staticdata *csd = CSD(cl);
1538
1539     LOCK_HW
1540     WaitBlitter(csd);
1541     UNLOCK_HW
1542
1543     return OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
1544 }