arch/m68k-amiga/hidd/uaegfx/uaegfxbitmap.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 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.h"
  37 #include "uaegfxbitmap.h"
  38 #include "uaertg.h"
  39
  40 static APTR allocrtgvrambitmap(struct uaegfx_staticdata *csd, struct bm_data *bm)
  41 {
  42     APTR vmem;
  43     SetMemoryMode(csd, RGBFB_CLUT);
  44     vmem = Allocate(csd->vmem, bm->memsize);
  45     SetMemoryMode(csd, bm->rgbformat);
  46     DVRAM(bug("BM %p: %p,%d VRAM allocated.\n", bm, vmem, bm->memsize));
  47     return vmem;
  48 }
  49
  50 static void freertgbitmap(struct uaegfx_staticdata *csd, struct bm_data *bm)
  51 {
  52     DVRAM(bug("BM %p: freeing %p:%d from %s\n", bm, bm->VideoData, bm->memsize, bm->invram ? "VRAM" : "RAM"));
  53     if (bm->invram) {
  54         SetMemoryMode(csd, RGBFB_CLUT);
  55         Deallocate(csd->vmem, bm->VideoData, bm->memsize);
  56         SetMemoryMode(csd, bm->rgbformat);
  57         csd->vram_used -= bm->memsize;
  58     } else {
  59         FreeMem(bm->VideoData, bm->memsize);
  60         csd->fram_used -= bm->memsize;
  61     }
  62     bm->VideoData = NULL;
  63     bm->invram = FALSE;
  64 }
  65
  66 static BOOL movebitmaptofram(struct uaegfx_staticdata *csd, struct bm_data *bm)
  67 {
  68     BOOL ok = FALSE;
  69     APTR vmem;
  70
  71     vmem = AllocMem(bm->memsize, MEMF_ANY);
  72     if (vmem) {
  73         SetMemoryMode(csd, bm->rgbformat);
  74         CopyMemQuick(bm->VideoData, vmem, bm->memsize);
  75         freertgbitmap(csd, bm);
  76         bm->VideoData = vmem;
  77         csd->fram_used += bm->memsize;
  78         ok = TRUE;
  79    }
  80    DVRAM(bug("BM %p: moved to RAM %p:%d. VRAM=%d\n", bm, bm->VideoData, bm->memsize, csd->vram_used));
  81    return ok;
  82 }
  83
  84 static BOOL allocrtgbitmap(struct uaegfx_staticdata *csd, struct bm_data *bm, BOOL usevram)
  85 {
  86     bm->memsize = (bm->bytesperline * bm->height + 7) & ~7;
  87     if (!(bm->VideoData = allocrtgvrambitmap(csd, bm))) {
  88         if (usevram && bm->memsize < csd->vram_size) {
  89              struct bm_data *bmnode;
  90              ForeachNode(&csd->bitmaplist, bmnode) {
  91                 if (bmnode != bm && bmnode->invram && !bmnode->locked) {
  92                     if (movebitmaptofram(csd, bmnode)) {
  93                         if ((bm->VideoData = allocrtgvrambitmap(csd, bm))) {
  94                             csd->vram_used += bm->memsize;
  95                             bm->invram = TRUE;
  96                             break;
  97                         }
  98                     }
  99                 }
 100              }
 101         }
 102         if (!bm->VideoData) {
 103             bm->VideoData = AllocMem(bm->memsize, MEMF_ANY);
 104             if (bm->VideoData)
 105                 csd->fram_used += bm->memsize;
 106         }
 107     } else {
 108         csd->vram_used += bm->memsize;
 109         bm->invram = TRUE;
 110     }
 111     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));
 112     return bm->VideoData != NULL;
 113 }
 114
 115 static BOOL movethisbitmaptovram(struct uaegfx_staticdata *csd, struct bm_data *bm)
 116 {
 117     APTR vmem = allocrtgvrambitmap(csd, bm);
 118     if (vmem) {
 119         SetMemoryMode(csd, bm->rgbformat);
 120         CopyMemQuick(bm->VideoData, vmem, bm->memsize);
 121         freertgbitmap(csd, bm);
 122         bm->VideoData = vmem;
 123         bm->invram = TRUE;
 124         csd->vram_used += bm->memsize;
 125         DVRAM(bug("BM %p: %p:%d moved back to VRAM\n", bm, bm->VideoData, bm->memsize));
 126         return TRUE;
 127     }
 128     return FALSE;
 129 }
 130
 131 static BOOL movebitmaptovram(struct uaegfx_staticdata *csd, struct bm_data *bm)
 132 {
 133      struct bm_data *bmnode;
 134
 135      if (bm->invram)
 136         return TRUE;
 137      DVRAM(bug("BM %p: %p,%d needs to be in VRAM...\n", bm, bm->VideoData, bm->memsize));
 138      ForeachNode(&csd->bitmaplist, bmnode) {
 139         if (bmnode != bm && bmnode->invram && !bmnode->locked) {
 140             if (movebitmaptofram(csd, bmnode)) {
 141                 if (movethisbitmaptovram(csd, bm)) {
 142                     return TRUE;
 143                 }
 144             }
 145         }
 146      }
 147      DVRAM(bug("-> not enough memory, VRAM=%d\n", csd->vram_used));
 148      return FALSE;
 149 }
 150
 151 static BOOL maybeputinvram(struct uaegfx_staticdata *csd, struct bm_data *bm)
 152 {
 153     if (bm->invram)
 154         return TRUE;
 155     if (bm->memsize >= csd->vram_size - csd->vram_used)
 156         return FALSE;
 157     return movethisbitmaptovram(csd, bm);
 158 }
 159
 160 static void hidescreen(struct uaegfx_staticdata *csd, struct bm_data *bm)
 161 {
 162     D(bug("Hide %p: (%p:%d)\n",
 163         bm, bm->VideoData, bm->memsize));
 164     SetInterrupt(csd, FALSE);
 165     SetDisplay(csd, FALSE);
 166     SetSwitch(csd, FALSE);
 167     csd->dmodeid = 0;
 168     bm->locked--;
 169     bm->disp = FALSE;
 170     csd->disp = NULL;
 171 }
 172
 173 /****************************************************************************************/
 174
 175 #define AO(x)             (aoHidd_BitMap_ ## x)
 176 #define GOT_BM_ATTR(code) GOT_ATTR(code, aoHidd_BitMap, bitmap)
 177
 178 /****************************************************************************************/
 179
 180 OOP_Object *UAEGFXBitmap__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
 181 {
 182     struct uaegfx_staticdata *csd = CSD(cl);
 183     struct Library *OOPBase = csd->cs_OOPBase;
 184     BOOL  ok = TRUE;
 185     struct bm_data *data;
 186     IPTR                     width, height, multi;
 187     IPTR                     displayable;
 188     HIDDT_ModeID             modeid;
 189
 190     DB2(bug("UAEGFXBitmap__Root__New\n"));
 191
 192     o =(OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 193     if (NULL == o)
 194         return NULL;
 195
 196     data = OOP_INST_DATA(cl, o);
 197     memset(data, 0, sizeof  (*data));
 198
 199     WaitBlitter(csd);
 200
 201     OOP_GetAttr(o, aHidd_BitMap_Width,  &width);
 202     OOP_GetAttr(o, aHidd_BitMap_Height, &height);
 203     OOP_GetAttr(o, aHidd_BitMap_Displayable, &displayable);
 204     OOP_GetAttr(o, aHidd_BitMap_GfxHidd, (APTR)&data->gfxhidd);
 205     OOP_GetAttr(o, aHidd_BitMap_PixFmt, (APTR)&data->pixfmtobj);
 206     OOP_GetAttr(data->pixfmtobj, aHidd_PixFmt_BytesPerPixel, &multi);
 207
 208     data->rgbformat = getrtgformat(csd, data->pixfmtobj);
 209     data->width = width;
 210     width = CalculateBytesPerRow(csd, width, data->rgbformat);
 211     data->bytesperline = width;
 212     data->height = height;
 213     data->bytesperpixel = multi;
 214     allocrtgbitmap(csd, data, TRUE);
 215     AddTail(&csd->bitmaplist, (struct Node*)&data->node);
 216
 217     DB2(bug("%dx%dx%d RGBF=%08x P=%08x\n", width, height, multi, data->rgbformat, data->VideoData));
 218
 219     if (data->VideoData == NULL)
 220         ok = FALSE;
 221
 222     OOP_GetAttr(o, aHidd_BitMap_ModeID, &modeid);
 223     if (ok && modeid != vHidd_ModeID_Invalid) {
 224         OOP_Object *sync, *pf;
 225         IPTR dwidth, dheight;
 226
 227         HIDD_Gfx_GetMode(data->gfxhidd, modeid, &sync, &pf);
 228         OOP_GetAttr(sync, aHidd_Sync_HDisp, &dwidth);
 229         OOP_GetAttr(sync, aHidd_Sync_VDisp, &dheight);
 230         data->disp_width  = dwidth;
 231         data->disp_height = dheight;
 232     }
 233
 234     if (!ok) {
 235         OOP_MethodID dispose_mid;
 236         dispose_mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
 237         OOP_CoerceMethod(cl, o, (OOP_Msg)&dispose_mid);
 238         o = NULL;
 239     }
 240
 241     DB2(bug("ret=%x bm=%p (%p:%d)\n", o, data, data->VideoData, data->memsize));
 242
 243     return o;
 244 }
 245
 246 VOID UAEGFXBitmap__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 247 {
 248     struct uaegfx_staticdata *csd = CSD(cl);
 249     struct bm_data    *data;
 250
 251     data = OOP_INST_DATA(cl, o);
 252     WaitBlitter(csd);
 253
 254     DB2(bug("UAEGFXBitmap__Root__Dispose %x bm=%x (%p,%d)\n", o, data, data->VideoData, data->memsize));
 255     if (data->disp)
 256         hidescreen(csd, data);
 257
 258     FreeVec(data->palette);
 259     freertgbitmap(csd, data);
 260     Remove((struct Node*)&data->node);
 261
 262     OOP_DoSuperMethod(cl, o, msg);
 263 }
 264
 265 VOID UAEGFXBitmap__Root__Set(OOP_Class *cl, OOP_Object *o, struct pRoot_Set *msg)
 266 {
 267     struct uaegfx_staticdata *csd = CSD(cl);
 268     struct Library *OOPBase = csd->cs_OOPBase;
 269     struct bm_data *data = OOP_INST_DATA(cl, o);
 270     struct TagItem  *tag, *tstate;
 271     ULONG           idx;
 272     BOOL moved = FALSE;
 273
 274     DB2(bug("UAEGFXBitmap__Root__Set %p (%p:%d)\n", data, data->VideoData, data->memsize));
 275     tstate = msg->attrList;
 276     while((tag = NextTagItem((const struct TagItem **)&tstate)))
 277     {
 278         DB2(bug("%d/%d\n", tag->ti_Tag, tag->ti_Data));
 279         if(IS_BITMAP_ATTR(tag->ti_Tag, idx))
 280         {
 281             DB2(bug("->%d\n", idx));
 282             switch(idx)
 283             {
 284                 case aoHidd_BitMap_Visible:
 285                 if (tag->ti_Data) {
 286                     OOP_Object *gfxhidd, *sync, *pf;
 287                     IPTR modeid = vHidd_ModeID_Invalid;
 288                     IPTR dwidth, dheight, depth, width, height;
 289                     struct ModeInfo *modeinfo;
 290
 291                     OOP_GetAttr(o, aHidd_BitMap_Width,  &width);
 292                     OOP_GetAttr(o, aHidd_BitMap_Height, &height);
 293                     OOP_GetAttr(o, aHidd_BitMap_ModeID , &modeid);
 294                     OOP_GetAttr(o, aHidd_BitMap_GfxHidd, (IPTR *)&gfxhidd);
 295                     HIDD_Gfx_GetMode(gfxhidd, modeid, &sync, &pf);
 296                     OOP_GetAttr(sync, aHidd_Sync_HDisp, &dwidth);
 297                     OOP_GetAttr(sync, aHidd_Sync_VDisp, &dheight);
 298                     OOP_GetAttr(pf, aHidd_PixFmt_Depth, &depth);
 299                     data->rgbformat = getrtgformat(csd, pf);
 300                     modeinfo = getrtgmodeinfo(csd, sync, pf, csd->fakemodeinfo);
 301                     csd->modeinfo = modeinfo;
 302                     csd->rgbformat = data->rgbformat;
 303                     pw(csd->bitmapextra + PSSO_BitMapExtra_Width, width);
 304                     pw(csd->bitmapextra + PSSO_BitMapExtra_Height, height);
 305                     D(bug("Show %p: (%p:%d) %dx%dx%d (%dx%d) BF=%08x\n",
 306                         data, data->VideoData, data->memsize,
 307                         dwidth, dheight, depth, width, height, data->rgbformat));
 308
 309                     if (!data->invram)
 310                         movebitmaptovram(csd, data);
 311
 312                     csd->dwidth = dwidth;
 313                     csd->dheight = dheight;
 314                     csd->dmodeid = modeid;
 315
 316                     if (csd->hardwaresprite && depth <= 8) {
 317                         UWORD i;
 318                         UBYTE *clut = csd->boardinfo + PSSO_BoardInfo_CLUT;
 319                         for (i = csd->spritecolors + 1; i < csd->spritecolors + 4; i++)
 320                             SetSpriteColor(csd, i - (csd->spritecolors + 1),  clut[i * 3 + 0],  clut[i * 3 + 1],  clut[i * 3 + 2]);
 321                     }
 322                     SetInterrupt(csd, FALSE);
 323                     SetColorArray(csd, 0, 256);
 324                     SetDisplay(csd, FALSE);
 325                     SetGC(csd, modeinfo, 0);
 326                     SetClock(csd);
 327                     SetDAC(csd);
 328                     SetPanning(csd, data->VideoData, dwidth, 0, 0);
 329                     SetDisplay(csd, TRUE);
 330                     SetSwitch(csd, TRUE);
 331                     SetInterrupt(csd, TRUE);
 332                     data->disp = TRUE;
 333                     csd->disp = data;
 334                     csd->disp->locked++;
 335                 } else {
 336                     hidescreen(csd, data);
 337                 }
 338                 break;
 339                 case aoHidd_BitMap_LeftEdge:
 340                     if (data->leftedge != tag->ti_Data) {
 341                         data->leftedge = tag->ti_Data;
 342                         moved = TRUE;
 343                     }
 344                 break;
 345                 case aoHidd_BitMap_TopEdge:
 346                     if (data->topedge != tag->ti_Data) {
 347                         data->topedge = tag->ti_Data;
 348                         moved = TRUE;
 349                     }
 350                 break;
 351             }
 352         }
 353     }
 354     DB2(bug("UAEGFXBitmap__Root__Set Exit\n"));
 355     OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 356 #if 0
 357     if (moved && csd->disp == data)
 358         setscroll(csd, data);
 359 #else
 360     (void)moved;
 361 #endif
 362 }
 363
 364 VOID UAEGFXBitmap__Root__Get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 365 {
 366     struct uaegfx_staticdata *csd = CSD(cl);
 367     struct bm_data *data = OOP_INST_DATA(cl, o);
 368     ULONG idx;
 369
 370     //DB2(bug("UAEGFXBitmap__Root__Get\n"));
 371     if (IS_BITMAP_ATTR(msg->attrID, idx)) {
 372         //DB2(bug("=%d\n", idx));
 373         switch (idx) {
 374         case aoHidd_BitMap_LeftEdge:
 375             *msg->storage = 0;//data->leftedge;
 376             return;
 377         case aoHidd_BitMap_TopEdge:
 378             *msg->storage = 0;//data->topedge;
 379             return;
 380         case aoHidd_BitMap_Visible:
 381             *msg->storage = data->disp;
 382             return;
 383         case aoHidd_BitMap_Align:
 384             *msg->storage = 16;
 385             return;
 386         case aoHidd_BitMap_IsLinearMem:
 387             *msg->storage = TRUE;
 388             return;
 389         }
 390     }
 391     //DB2(bug("UAEGFXBitmap__Root__Get Exit\n"));
 392     OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 393 }
 394
 395 /****************************************************************************************/
 396
 397 static int UAEGFXBitmap_Init(LIBBASETYPEPTR LIBBASE)
 398 {
 399     D(bug("UAEGFXBitmap_Init\n"));
 400     return TRUE; //return OOP_ObtainAttrBases(attrbases);
 401 }
 402
 403 /****************************************************************************************/
 404
 405 static int UAEGFXBitmap_Expunge(LIBBASETYPEPTR LIBBASE)
 406 {
 407     D(bug("UAEGFXBitmap_Expunge\n"));
 408     //OOP_ReleaseAttrBases(attrbases);
 409     return TRUE;
 410 }
 411
 412 /****************************************************************************************/
 413
 414 ADD2INITLIB(UAEGFXBitmap_Init, 0);
 415 ADD2EXPUNGELIB(UAEGFXBitmap_Expunge, 0);
 416
 417 BOOL UAEGFXBitmap__Hidd_BitMap__ObtainDirectAccess(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_ObtainDirectAccess *msg)
 418 {
 419     struct uaegfx_staticdata *csd = CSD(cl);
 420     struct bm_data *data = OOP_INST_DATA(cl, o);
 421
 422     if (!data->invram) {
 423         if (!movebitmaptovram(csd, data))
 424             return FALSE;
 425     }
 426
 427     *msg->addressReturn = data->VideoData;
 428     *msg->widthReturn = data->width;
 429     *msg->heightReturn = data->height;
 430     /* undocumented, just a guess.. */
 431     *msg->bankSizeReturn = *msg->memSizeReturn = data->bytesperline * data->height;
 432     data->locked++;
 433     WaitBlitter(csd);
 434     return TRUE;
 435 }
 436
 437 VOID UAEGFXBitmap__Hidd_BitMap__ReleaseDirectAccess(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_ReleaseDirectAccess *msg)
 438 {
 439     struct bm_data *data = OOP_INST_DATA(cl, o);
 440     data->locked--;
 441 }
 442
 443 BOOL UAEGFXBitmap__Hidd_BitMap__SetColors(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_SetColors *msg)
 444 {
 445     struct uaegfx_staticdata *csd = CSD(cl);
 446     WORD i, j;
 447     UBYTE *clut;
 448
 449     if (!OOP_DoSuperMethod(cl, o, (OOP_Msg)msg))
 450         return FALSE;
 451     WaitBlitter(csd);
 452     clut = csd->boardinfo + PSSO_BoardInfo_CLUT;
 453     for (i = msg->firstColor, j = 0; j < msg->numColors; i++, j++) {
 454         clut[i * 3 + 0] = msg->colors[j].red >> 8;
 455         clut[i * 3 + 1] = msg->colors[j].green >> 8;
 456         clut[i * 3 + 2] = msg->colors[j].blue >> 8;
 457         //bug("%d %02x%02x%02x\n", i, msg->colors[j].red >> 8, msg->colors[j].green >> 8, msg->colors[j].blue >> 8);
 458     }
 459     SetColorArray(csd, msg->firstColor, msg->numColors);
 460     return TRUE;
 461 }
 462
 463 VOID UAEGFXBitmap__Hidd_BitMap__PutPixel(OOP_Class *cl, OOP_Object *o,
 464                                 struct pHidd_BitMap_PutPixel *msg)
 465 {
 466     struct uaegfx_staticdata *csd = CSD(cl);
 467     struct bm_data *data = OOP_INST_DATA(cl, o);
 468     ULONG              offset;
 469     HIDDT_Pixel       pixel = msg->pixel;
 470     UBYTE             *mem;
 471
 472     WaitBlitter(csd);
 473     offset = (msg->x * data->bytesperpixel) + (msg->y * data->bytesperline);
 474     mem = data->VideoData + offset;
 475
 476     switch(data->bytesperpixel)
 477     {
 478         case 1:
 479             *(UBYTE *)mem = pixel;
 480             break;
 481
 482         case 2:
 483             *(UWORD *)mem = pixel;
 484             break;
 485
 486         case 3:
 487             *(UBYTE *)(mem) = pixel >> 16;
 488             *(UBYTE *)(mem + 1) = pixel >> 8;
 489             *(UBYTE *)(mem + 2) = pixel;
 490             break;
 491
 492         case 4:
 493             *(ULONG *)mem = pixel;
 494             break;
 495     }
 496
 497     return;
 498 }
 499
 500 /****************************************************************************************/
 501
 502 ULONG UAEGFXBitmap__Hidd_BitMap__GetPixel(OOP_Class *cl, OOP_Object *o,
 503                                  struct pHidd_BitMap_GetPixel *msg)
 504 {
 505     struct uaegfx_staticdata *csd = CSD(cl);
 506     struct bm_data      *data = OOP_INST_DATA(cl, o);
 507     HIDDT_Pixel          pixel = 0;
 508     ULONG                offset;
 509     UBYTE               *mem;
 510
 511     WaitBlitter(csd);
 512     offset = (msg->x * data->bytesperpixel)  +(msg->y * data->bytesperline);
 513     mem = data->VideoData + offset;
 514
 515     switch(data->bytesperpixel)
 516     {
 517         case 1:
 518             pixel = *(UBYTE *)mem;
 519             break;
 520
 521         case 2:
 522             pixel = *(UWORD *)mem;
 523             break;
 524
 525         case 3:
 526             pixel = (mem[0] << 16) | (mem[1] << 8) | mem[2];
 527             break;
 528
 529         case 4:
 530             pixel = *(ULONG *)mem;
 531             break;
 532
 533     }
 534
 535     return pixel;
 536 }
 537
 538 /****************************************************************************************/
 539
 540 VOID UAEGFXBitmap__Hidd_BitMap__DrawLine(OOP_Class *cl, OOP_Object *o,
 541                                 struct pHidd_BitMap_DrawLine *msg)
 542 {
 543     struct uaegfx_staticdata *csd = CSD(cl);
 544
 545     WaitBlitter(csd);
 546     OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 547 }
 548
 549 /****************************************************************************************/
 550
 551 VOID UAEGFXBitmap__Hidd_BitMap__GetImage(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_GetImage *msg)
 552 {
 553     struct bm_data *data = OOP_INST_DATA(cl, o);
 554     struct uaegfx_staticdata *csd = CSD(cl);
 555
 556     WaitBlitter(csd);
 557     switch(msg->pixFmt)
 558     {
 559         case vHidd_StdPixFmt_Native:
 560             switch(data->bytesperpixel)
 561             {
 562                 case 1:
 563                     HIDD_BM_CopyMemBox8(o,
 564                                         data->VideoData,
 565                                         msg->x,
 566                                         msg->y,
 567                                         msg->pixels,
 568                                         0,
 569                                         0,
 570                                         msg->width,
 571                                         msg->height,
 572                                         data->bytesperline,
 573                                         msg->modulo);
 574                     break;
 575
 576                 case 2:
 577                     HIDD_BM_CopyMemBox16(o,
 578                                          data->VideoData,
 579                                          msg->x,
 580                                          msg->y,
 581                                          msg->pixels,
 582                                          0,
 583                                          0,
 584                                          msg->width,
 585                                          msg->height,
 586                                          data->bytesperline,
 587                                          msg->modulo);
 588                     break;
 589
 590                 case 3:
 591                     HIDD_BM_CopyMemBox24(o,
 592                                          data->VideoData,
 593                                          msg->x,
 594                                          msg->y,
 595                                          msg->pixels,
 596                                          0,
 597                                          0,
 598                                          msg->width,
 599                                          msg->height,
 600                                          data->bytesperline,
 601                                          msg->modulo);
 602                     break;
 603
 604                 case 4:
 605                     HIDD_BM_CopyMemBox32(o,
 606                                          data->VideoData,
 607                                          msg->x,
 608                                          msg->y,
 609                                          msg->pixels,
 610                                          0,
 611                                          0,
 612                                          msg->width,
 613                                          msg->height,
 614                                          data->bytesperline,
 615                                          msg->modulo);
 616                     break;
 617
 618             } /* switch(data->bytesperpix) */
 619             break;
 620
 621         case vHidd_StdPixFmt_Native32:
 622             switch(data->bytesperpixel)
 623             {
 624                 case 1:
 625                     HIDD_BM_GetMem32Image8(o,
 626                                            data->VideoData,
 627                                            msg->x,
 628                                            msg->y,
 629                                            msg->pixels,
 630                                            msg->width,
 631                                            msg->height,
 632                                            data->bytesperline,
 633                                            msg->modulo);
 634                     break;
 635
 636                 case 2:
 637                     HIDD_BM_GetMem32Image16(o,
 638                                             data->VideoData,
 639                                             msg->x,
 640                                             msg->y,
 641                                             msg->pixels,
 642                                             msg->width,
 643                                             msg->height,
 644                                             data->bytesperline,
 645                                             msg->modulo);
 646                     break;
 647
 648                 case 3:
 649                     HIDD_BM_GetMem32Image24(o,
 650                                             data->VideoData,
 651                                             msg->x,
 652                                             msg->y,
 653                                             msg->pixels,
 654                                             msg->width,
 655                                             msg->height,
 656                                             data->bytesperline,
 657                                             msg->modulo);
 658                     break;
 659
 660                 case 4:
 661                     HIDD_BM_CopyMemBox32(o,
 662                                          data->VideoData,
 663                                          msg->x,
 664                                          msg->y,
 665                                          msg->pixels,
 666                                          0,
 667                                          0,
 668                                          msg->width,
 669                                          msg->height,
 670                                          data->bytesperline,
 671                                          msg->modulo);
 672                     break;
 673
 674             } /* switch(data->bytesperpix) */
 675             break;
 676
 677         default:
 678             {
 679                 APTR        pixels = msg->pixels;
 680                 APTR        srcPixels = data->VideoData + msg->y * data->bytesperline + msg->x * data->bytesperpixel;
 681                 OOP_Object *dstpf;
 682
 683                 dstpf = HIDD_Gfx_GetPixFmt(data->gfxhidd, msg->pixFmt);
 684
 685                 HIDD_BM_ConvertPixels(o, &srcPixels, (HIDDT_PixelFormat *)data->pixfmtobj, data->bytesperline,
 686                                       &pixels, (HIDDT_PixelFormat *)dstpf, msg->modulo,
 687                                       msg->width, msg->height, NULL);
 688             }
 689             break;
 690
 691     } /* switch(msg->pixFmt) */
 692 }
 693
 694 /****************************************************************************************/
 695
 696 VOID UAEGFXBitmap__Hidd_BitMap__PutImage(OOP_Class *cl, OOP_Object *o,
 697                                 struct pHidd_BitMap_PutImage *msg)
 698 {
 699     struct bm_data *data = OOP_INST_DATA(cl, o);
 700     struct uaegfx_staticdata *csd = CSD(cl);
 701
 702     WaitBlitter(csd);
 703     switch(msg->pixFmt)
 704     {
 705         case vHidd_StdPixFmt_Native:
 706             switch(data->bytesperpixel)
 707             {
 708                 case 1:
 709                     HIDD_BM_CopyMemBox8(o,
 710                                         msg->pixels,
 711                                         0,
 712                                         0,
 713                                         data->VideoData,
 714                                         msg->x,
 715                                         msg->y,
 716                                         msg->width,
 717                                         msg->height,
 718                                         msg->modulo,
 719                                         data->bytesperline);
 720                     break;
 721
 722                 case 2:
 723                     HIDD_BM_CopyMemBox16(o,
 724                                          msg->pixels,
 725                                          0,
 726                                          0,
 727                                          data->VideoData,
 728                                          msg->x,
 729                                          msg->y,
 730                                          msg->width,
 731                                          msg->height,
 732                                          msg->modulo,
 733                                          data->bytesperline);
 734                     break;
 735
 736                 case 3:
 737                     HIDD_BM_CopyMemBox24(o,
 738                                          msg->pixels,
 739                                          0,
 740                                          0,
 741                                          data->VideoData,
 742                                          msg->x,
 743                                          msg->y,
 744                                          msg->width,
 745                                          msg->height,
 746                                          msg->modulo,
 747                                          data->bytesperline);
 748                     break;
 749
 750                 case 4:
 751                     HIDD_BM_CopyMemBox32(o,
 752                                          msg->pixels,
 753                                          0,
 754                                          0,
 755                                          data->VideoData,
 756                                          msg->x,
 757                                          msg->y,
 758                                          msg->width,
 759                                          msg->height,
 760                                          msg->modulo,
 761                                          data->bytesperline);
 762                     break;
 763
 764             } /* switch(data->bytesperpix) */
 765             break;
 766
 767         case vHidd_StdPixFmt_Native32:
 768             switch(data->bytesperpixel)
 769             {
 770                 case 1:
 771                     HIDD_BM_PutMem32Image8(o,
 772                                            msg->pixels,
 773                                            data->VideoData,
 774                                            msg->x,
 775                                            msg->y,
 776                                            msg->width,
 777                                            msg->height,
 778                                            msg->modulo,
 779                                            data->bytesperline);
 780                     break;
 781
 782                 case 2:
 783                     HIDD_BM_PutMem32Image16(o,
 784                                             msg->pixels,
 785                                             data->VideoData,
 786                                             msg->x,
 787                                             msg->y,
 788                                             msg->width,
 789                                             msg->height,
 790                                             msg->modulo,
 791                                             data->bytesperline);
 792                     break;
 793
 794                 case 3:
 795                     HIDD_BM_PutMem32Image24(o,
 796                                             msg->pixels,
 797                                             data->VideoData,
 798                                             msg->x,
 799                                             msg->y,
 800                                             msg->width,
 801                                             msg->height,
 802                                             msg->modulo,
 803                                             data->bytesperline);
 804                     break;
 805
 806                 case 4:
 807                     HIDD_BM_CopyMemBox32(o,
 808                                          msg->pixels,
 809                                          0,
 810                                          0,
 811                                          data->VideoData,
 812                                          msg->x,
 813                                          msg->y,
 814                                          msg->width,
 815                                          msg->height,
 816                                          msg->modulo,
 817                                          data->bytesperline);
 818                     break;
 819
 820             } /* switch(data->bytesperpix) */
 821             break;
 822
 823         default:
 824             {
 825                 APTR        pixels = msg->pixels;
 826                 APTR        dstBuf = data->VideoData + msg->y * data->bytesperline + msg->x * data->bytesperpixel;
 827                 OOP_Object *srcpf;
 828
 829                 srcpf = HIDD_Gfx_GetPixFmt(data->gfxhidd, msg->pixFmt);
 830
 831                 HIDD_BM_ConvertPixels(o, &pixels, (HIDDT_PixelFormat *)srcpf, msg->modulo,
 832                                       &dstBuf, (HIDDT_PixelFormat *)data->pixfmtobj, data->bytesperline,
 833                                       msg->width, msg->height, NULL);
 834             }
 835             break;
 836
 837     } /* switch(msg->pixFmt) */
 838 }
 839
 840 /****************************************************************************************/
 841
 842 VOID UAEGFXBitmap__Hidd_BitMap__PutImageLUT(OOP_Class *cl, OOP_Object *o,
 843                                    struct pHidd_BitMap_PutImageLUT *msg)
 844 {
 845     struct bm_data *data = OOP_INST_DATA(cl, o);
 846     struct uaegfx_staticdata *csd = CSD(cl);
 847
 848     WaitBlitter(csd);
 849     switch(data->bytesperpixel)
 850     {
 851         case 2:
 852             HIDD_BM_CopyLUTMemBox16(o,
 853                                  msg->pixels,
 854                                  0,
 855                                  0,
 856                                  data->VideoData,
 857                                  msg->x,
 858                                  msg->y,
 859                                  msg->width,
 860                                  msg->height,
 861                                  msg->modulo,
 862                                  data->bytesperline,
 863                                  msg->pixlut);
 864             break;
 865
 866         case 3:
 867             HIDD_BM_CopyLUTMemBox24(o,
 868                                  msg->pixels,
 869                                  0,
 870                                  0,
 871                                  data->VideoData,
 872                                  msg->x,
 873                                  msg->y,
 874                                  msg->width,
 875                                  msg->height,
 876                                  msg->modulo,
 877                                  data->bytesperline,
 878                                  msg->pixlut);
 879             break;
 880
 881         case 4:
 882             HIDD_BM_CopyLUTMemBox32(o,
 883                                     msg->pixels,
 884                                     0,
 885                                     0,
 886                                     data->VideoData,
 887                                     msg->x,
 888                                     msg->y,
 889                                     msg->width,
 890                                     msg->height,
 891                                     msg->modulo,
 892                                     data->bytesperline,
 893                                     msg->pixlut);
 894             break;
 895
 896         default:
 897             OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 898             break;
 899
 900     } /* switch(data->bytesperpix) */
 901 }
 902
 903 /****************************************************************************************/
 904
 905 VOID UAEGFXBitmap__Hidd_BitMap__GetImageLUT(OOP_Class *cl, OOP_Object *o,
 906                                    struct pHidd_BitMap_GetImageLUT *msg)
 907 {
 908     struct uaegfx_staticdata *csd = CSD(cl);
 909
 910     WaitBlitter(csd);
 911     OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 912 }
 913
 914 /****************************************************************************************/
 915
 916 VOID UAEGFXBitmap__Hidd_BitMap__FillRect(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawRect *msg)
 917 {
 918     HIDDT_Pixel fg = GC_FG(msg->gc);
 919     HIDDT_DrawMode mode = GC_DRMD(msg->gc);
 920     struct uaegfx_staticdata *csd = CSD(cl);
 921     struct bm_data *data = OOP_INST_DATA(cl, o);
 922     struct RenderInfo ri;
 923     BOOL v = FALSE;
 924
 925     WaitBlitter(csd);
 926     maybeputinvram(csd, data);
 927     if (data->invram) {
 928         makerenderinfo(csd, &ri, data);
 929         if (mode == vHidd_GC_DrawMode_Clear || mode == vHidd_GC_DrawMode_Set) {
 930             ULONG pen = mode == vHidd_GC_DrawMode_Clear ? 0x00000000 : 0xffffffff;
 931             v = FillRect(csd, &ri, msg->minX, msg->minY, msg->maxX - msg->minX + 1, msg->maxY - msg->minY + 1, pen, 0xff, data->rgbformat);
 932         } else if (mode == vHidd_GC_DrawMode_Copy) {
 933             v = FillRect(csd, &ri, msg->minX, msg->minY, msg->maxX - msg->minX + 1, msg->maxY - msg->minY + 1, fg, 0xff, data->rgbformat);
 934         } else if (mode == vHidd_GC_DrawMode_Invert) {
 935             v = InvertRect(csd, &ri, msg->minX, msg->minY, msg->maxX - msg->minX + 1, msg->maxY - msg->minY + 1, 0xff, data->rgbformat);
 936         }
 937     }
 938     if (!v)
 939         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 940 }
 941
 942 /****************************************************************************************/
 943
 944 VOID UAEGFXBitmap__Hidd_BitMap__PutPattern(OOP_Class *cl, OOP_Object *o,
 945                                  struct pHidd_BitMap_PutPattern *msg)
 946 {
 947     struct uaegfx_staticdata *csd = CSD(cl);
 948     struct bm_data *data = OOP_INST_DATA(cl, o);
 949     HIDDT_Pixel fg = GC_FG(msg->gc);
 950     HIDDT_Pixel bg = GC_BG(msg->gc);
 951     struct Pattern pat;
 952     struct RenderInfo ri;
 953     UBYTE drawmode;
 954     BOOL v = FALSE;
 955
 956     WaitBlitter(csd);
 957
 958     DB2(bug("blitpattern(%d,%d)(%d,%d)(%x,%d,%d,%d,%d,%d)\n",
 959         msg->x, msg->y, msg->width, msg->height,
 960         msg->pattern, msg->patternsrcx, msg->patternsrcy, fg, bg, msg->patternheight));
 961
 962     if (msg->mask || msg->patterndepth > 1) {
 963         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 964         return;
 965     }
 966
 967     maybeputinvram(csd, data);
 968     if (data->invram) {
 969         makerenderinfo(csd, &ri, data);
 970         if (GC_COLEXP(msg->gc) == vHidd_GC_ColExp_Transparent)
 971              drawmode = JAM1;
 972         else if (GC_DRMD(msg->gc) == vHidd_GC_DrawMode_Invert)
 973              drawmode = COMPLEMENT;
 974         else
 975             drawmode = JAM2;
 976         if (msg->invertpattern)
 977              drawmode |= INVERSVID;
 978
 979         pat.Memory = msg->pattern;
 980         pat.XOffset = msg->patternsrcx;
 981         pat.YOffset = msg->patternsrcy;
 982         pat.FgPen = fg;
 983         pat.BgPen = bg;
 984         pat.DrawMode = drawmode;
 985         switch (msg->patternheight)
 986         {
 987             case 1:
 988             pat.Size = 0;
 989             break;
 990             case 2:
 991             pat.Size = 1;
 992             break;
 993             case 4:
 994             pat.Size = 2;
 995             break;
 996             case 8:
 997             pat.Size = 3;
 998             break;
 999             case 16:
1000             pat.Size = 4;
1001             break;
1002             case 32:
1003             pat.Size = 5;
1004             break;
1005             case 64:
1006             pat.Size = 6;
1007             break;
1008             case 128:
1009             pat.Size = 7;
1010             break;
1011             case 256:
1012             pat.Size = 8;
1013             break;
1014             default:
1015             pat.Size = 0xff;
1016         }
1017
1018         if (pat.Size <= 8) {
1019             v = BlitPattern(csd, &ri, &pat, msg->x, msg->y, msg->width, msg->height, 0xff, data->rgbformat);
1020         }
1021     }
1022
1023     if (!v)
1024         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
1025 }
1026
1027 /****************************************************************************************/
1028
1029 VOID UAEGFXBitmap__Hidd_BitMap__PutTemplate(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutTemplate *msg)
1030 {
1031     struct uaegfx_staticdata *csd = CSD(cl);
1032     struct bm_data *data = OOP_INST_DATA(cl, o);
1033     HIDDT_Pixel fg = GC_FG(msg->gc);
1034     HIDDT_Pixel bg = GC_BG(msg->gc);
1035     struct Template tmpl;
1036     struct RenderInfo ri;
1037     UBYTE drawmode;
1038     BOOL v = FALSE;
1039
1040     WaitBlitter(csd);
1041     maybeputinvram(csd, data);
1042     if (data->invram) {
1043         makerenderinfo(csd, &ri, data);
1044         if (GC_COLEXP(msg->gc) == vHidd_GC_ColExp_Transparent)
1045              drawmode = JAM1;
1046         else if (GC_DRMD(msg->gc) == vHidd_GC_DrawMode_Invert)
1047              drawmode = COMPLEMENT;
1048         else
1049             drawmode = JAM2;
1050         if (msg->inverttemplate)
1051              drawmode |= INVERSVID;
1052
1053         tmpl.Memory = msg->Template;
1054         tmpl.BytesPerRow = msg->modulo;
1055         tmpl.XOffset = msg->srcx;
1056         tmpl.DrawMode = drawmode;
1057         tmpl.FgPen = fg;
1058         tmpl.BgPen = bg;
1059         v = BlitTemplate(csd, &ri, &tmpl, msg->x, msg->y, msg->width, msg->height, 0xff, data->rgbformat);
1060     }
1061     if (!v)
1062         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
1063 }
1064
1065
1066 /****************************************************************************************/
1067
1068 VOID UAEGFXBitmap__Hidd_BitMap__UpdateRect(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_UpdateRect *msg)
1069 {
1070     struct uaegfx_staticdata *csd = CSD(cl);
1071
1072     WaitBlitter(csd);
1073     OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
1074 }
1075
1076 /****************************************************************************************/
1077
1078 BOOL UAEGFXBitmap__Hidd_PlanarBM__SetBitMap(OOP_Class *cl, OOP_Object *o,
1079                                    struct pHidd_PlanarBM_SetBitMap *msg)
1080 {
1081     struct uaegfx_staticdata *csd = CSD(cl);
1082
1083     WaitBlitter(csd);
1084     return OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
1085 }
1086
1087 /****************************************************************************************/
1088
1089 BOOL UAEGFXBitmap__Hidd_PlanarBM__GetBitMap(OOP_Class *cl, OOP_Object *o,
1090                                    struct pHidd_PlanarBM_GetBitMap *msg)
1091 {
1092     struct uaegfx_staticdata *csd = CSD(cl);
1093
1094     WaitBlitter(csd);
1095     return OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
1096 }