workbench/hidds/nvidia/nvidiabitmap.c

   1 /*
   2     Copyright © 2004-2010, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: NVidia bitmap class
   6     Lang: English
   7 */
   8
   9 #include <exec/types.h>
  10 #include <exec/memory.h>
  11
  12 #include <hidd/hidd.h>
  13 #include <hidd/graphics.h>
  14
  15 #include <proto/exec.h>
  16 #include <proto/oop.h>
  17 #include <proto/utility.h>
  18
  19 #include <aros/symbolsets.h>
  20
  21 #include "nv.h"
  22 #include "nv_dma.h"
  23
  24 #define DEBUG 0
  25 #include <aros/debug.h>
  26
  27 #define _sd (&((LIBBASETYPEPTR)cl->UserData)->sd)
  28
  29 #undef HiddPCIDeviceAttrBase
  30 #undef HiddGfxAttrBase
  31 #undef HiddPixFmtAttrBase
  32 #undef HiddSyncAttrBase
  33 #undef HiddBitMapAttrBase
  34 #define HiddPCIDeviceAttrBase   (_sd->pciAttrBase)
  35 #define HiddNVidiaBitMapAttrBase (_sd->nvBitMapAttrBase)
  36 #define HiddBitMapAttrBase      (_sd->bitMapAttrBase)
  37 #define HiddPixFmtAttrBase      (_sd->pixFmtAttrBase)
  38 #define HiddGfxAttrBase         (_sd->gfxAttrBase)
  39 #define HiddSyncAttrBase        (_sd->syncAttrBase)
  40
  41 /* Class methods */
  42
  43 OOP_Object *NVOnBM__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
  44 {
  45     EnterFunc(bug("[NVBitMap] OnBitmap::New()\n"));
  46
  47     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
  48         D(bug("o=%p, cl=%p\n", o, cl));
  49
  50     if (o)
  51     {
  52         nvBitMap *bm = OOP_INST_DATA(cl, o);
  53
  54         IPTR fb;
  55         IPTR width, height, depth;
  56         UBYTE bytesPerPixel;
  57
  58         OOP_Object *pf;
  59
  60         InitSemaphore(&bm->bmLock);
  61
  62         D(bug("[NVBitMap] Super called. o=%p\n", o));
  63
  64         bm->onbm = TRUE;
  65
  66         OOP_GetAttr(o, aHidd_BitMap_Width,  &width);
  67         OOP_GetAttr(o, aHidd_BitMap_Height, &height);
  68         OOP_GetAttr(o, aHidd_BitMap_PixFmt, (APTR)&pf);
  69         OOP_GetAttr(pf, aHidd_PixFmt_Depth, &depth);
  70
  71         fb = GetTagData(aHidd_BitMap_FrameBuffer, FALSE, msg->attrList);
  72
  73         D(bug("[NVBitmap] width=%d height=%d depth=%d\n", width, height, depth));
  74
  75         if (width == 0 || height == 0 || depth == 0)
  76         {
  77             bug("[NVBitMap] size mismatch!\n");
  78         }
  79
  80         if (depth <= 8)
  81             bytesPerPixel = 1;
  82         else if (depth <= 16)
  83             bytesPerPixel = 2;
  84         else
  85             bytesPerPixel = 4;
  86
  87         if (fb)
  88         {
  89             width = 640;
  90             height = 480;
  91             bytesPerPixel = 2;
  92             depth = 16;
  93         }
  94
  95         bm->width = width;
  96         bm->height = height;
  97         bm->pitch = (width * bytesPerPixel + 63) & ~63;
  98         bm->depth = depth;
  99         bm->bpp = bytesPerPixel;
 100
 101         bm->framebuffer = AllocBitmapArea(_sd, bm->width, bm->height,
 102                                 bm->bpp, TRUE);
 103
 104         bm->fbgfx = TRUE;
 105         bm->BitMap = o;
 106         bm->usecount = 0;
 107
 108         switch(bm->depth)
 109         {
 110             case 32:
 111             case 24:
 112                 bm->surface_format = SURFACE_FORMAT_DEPTH24;
 113                 bm->pattern_format = PATTERN_FORMAT_DEPTH24;
 114                 bm->rect_format    = RECT_FORMAT_DEPTH24;
 115                 bm->line_format    = LINE_FORMAT_DEPTH24;
 116                 break;
 117             case 16:
 118             case 15:
 119                 bm->surface_format = SURFACE_FORMAT_DEPTH16;
 120                 bm->pattern_format = PATTERN_FORMAT_DEPTH16;
 121                 bm->rect_format    = RECT_FORMAT_DEPTH16;
 122                 bm->line_format    = LINE_FORMAT_DEPTH16;
 123                 break;
 124             default:
 125                 bm->surface_format = SURFACE_FORMAT_DEPTH8;
 126                 bm->pattern_format = PATTERN_FORMAT_DEPTH8;
 127                 bm->rect_format    = RECT_FORMAT_DEPTH8;
 128                 bm->line_format    = LINE_FORMAT_DEPTH8;
 129                 break;
 130         }
 131
 132         if (fb && bm->framebuffer != 0xffffffff)
 133         {
 134             bm->state = (struct CardState *)AllocPooled(_sd->memPool,
 135                                         sizeof(struct CardState));
 136
 137             bzero(_sd->Card.FrameBuffer + bm->framebuffer, 640*480*2);
 138
 139             if (bm->state)
 140             {
 141                 LOCK_HW
 142
 143                 InitMode(_sd, bm->state, 640, 480, 16, 25200, bm->framebuffer,
 144                     640, 480,
 145                     656, 752, 800,
 146                     490, 492, 525);
 147
 148                 LoadState(_sd, bm->state);
 149                 DPMS(_sd, _sd->dpms);
 150
 151                 UNLOCK_HW
 152
 153                 return o;
 154             }
 155         }
 156         else if (bm->framebuffer != 0xffffffff)
 157         {
 158             HIDDT_ModeID modeid;
 159             OOP_Object *sync;
 160
 161             /* We should be able to get modeID from the bitmap */
 162             OOP_GetAttr(o, aHidd_BitMap_ModeID, &modeid);
 163
 164             D(bug("[NVBitMap] BM_ModeID=%x\n", modeid));
 165
 166             if (modeid != vHidd_ModeID_Invalid)
 167             {
 168                 IPTR pixel;
 169                 IPTR hdisp, vdisp, hstart, hend, htotal, vstart, vend, vtotal;
 170
 171                 /* Get Sync and PixelFormat properties */
 172                 struct pHidd_Gfx_GetMode __getmodemsg = {
 173                     modeID:     modeid,
 174                     syncPtr:    &sync,
 175                     pixFmtPtr:  &pf,
 176                 }, *getmodemsg = &__getmodemsg;
 177
 178                 getmodemsg->mID = OOP_GetMethodID(IID_Hidd_Gfx, moHidd_Gfx_GetMode);
 179                 OOP_DoMethod(_sd->nvobject, (OOP_Msg)getmodemsg);
 180
 181                 OOP_GetAttr(sync, aHidd_Sync_PixelClock,        &pixel);
 182                 OOP_GetAttr(sync, aHidd_Sync_HDisp,             &hdisp);
 183                 OOP_GetAttr(sync, aHidd_Sync_VDisp,             &vdisp);
 184                 OOP_GetAttr(sync, aHidd_Sync_HSyncStart,        &hstart);
 185                 OOP_GetAttr(sync, aHidd_Sync_VSyncStart,        &vstart);
 186                 OOP_GetAttr(sync, aHidd_Sync_HSyncEnd,          &hend);
 187                 OOP_GetAttr(sync, aHidd_Sync_VSyncEnd,          &vend);
 188                 OOP_GetAttr(sync, aHidd_Sync_HTotal,            &htotal);
 189                 OOP_GetAttr(sync, aHidd_Sync_VTotal,            &vtotal);
 190
 191                 bm->state = (struct CardState *)AllocPooled(_sd->memPool,
 192                                         sizeof(struct CardState));
 193
 194                 pixel /= 1000;
 195
 196                 if (bm->state)
 197                 {
 198                     LOCK_HW
 199
 200                     InitMode(_sd, bm->state, bm->pitch/bytesPerPixel, height, depth, pixel, bm->framebuffer,
 201                         hdisp, vdisp,
 202                         hstart, hend, htotal,
 203                         vstart, vend, vtotal);
 204
 205                     LoadState(_sd, bm->state);
 206                     DPMS(_sd, _sd->dpms);
 207
 208                     UNLOCK_HW
 209
 210                     return o;
 211                 }
 212             }
 213         }
 214         OOP_MethodID disp_mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
 215         OOP_CoerceMethod(cl, o, (OOP_Msg) &disp_mid);
 216     }
 217
 218     return NULL;
 219 }
 220
 221 OOP_Object *NVOffBM__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
 222 {
 223     EnterFunc(bug("[NVBitMap] OffBitmap::New()\n"));
 224
 225     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 226
 227     if (o)
 228     {
 229         nvBitMap *bm = OOP_INST_DATA(cl, o);
 230
 231         IPTR width, height, depth;
 232         UBYTE bytesPerPixel;
 233
 234         OOP_Object *pf;
 235
 236         InitSemaphore(&bm->bmLock);
 237
 238         bm->onbm = FALSE;
 239
 240         OOP_GetAttr(o, aHidd_BitMap_Width,  &width);
 241         OOP_GetAttr(o, aHidd_BitMap_Height, &height);
 242         OOP_GetAttr(o, aHidd_BitMap_PixFmt, (APTR)&pf);
 243         OOP_GetAttr(pf, aHidd_PixFmt_Depth, &depth);
 244         D(bug("[NVBitmap] width=%d height=%d depth=%d\n", width, height, depth));
 245
 246         if (width == 0 || height == 0 || depth == 0)
 247         {
 248             bug("[NVBitMap] size mismatch!\n");
 249         }
 250
 251         if (depth <= 8)
 252             bytesPerPixel = 1;
 253         else if (depth <= 16)
 254             bytesPerPixel = 2;
 255         else
 256             bytesPerPixel = 4;
 257
 258         bm->width = width;
 259         bm->height = height;
 260         bm->pitch = (width * bytesPerPixel + 63) & ~63;
 261         bm->depth = depth;
 262         bm->state = NULL;
 263         bm->bpp = bytesPerPixel;
 264
 265         bm->framebuffer = AllocBitmapArea(_sd, bm->width, bm->height,
 266                             bm->bpp, TRUE);
 267
 268         if (bm->framebuffer == -1)
 269         {
 270             bm->framebuffer = (IPTR)AllocMem(bm->pitch * bm->height,
 271                                         MEMF_PUBLIC | MEMF_CLEAR);
 272             bm->fbgfx = FALSE;
 273         }
 274         else
 275             bm->fbgfx = TRUE;
 276
 277         bm->BitMap = o;
 278         bm->usecount = 0;
 279
 280         switch(bm->depth)
 281         {
 282             case 32:
 283             case 24:
 284                 bm->surface_format = SURFACE_FORMAT_DEPTH24;
 285                 bm->pattern_format = PATTERN_FORMAT_DEPTH24;
 286                 bm->rect_format    = RECT_FORMAT_DEPTH24;
 287                 bm->line_format    = LINE_FORMAT_DEPTH24;
 288                 break;
 289             case 16:
 290             case 15:
 291                 bm->surface_format = SURFACE_FORMAT_DEPTH16;
 292                 bm->pattern_format = PATTERN_FORMAT_DEPTH16;
 293                 bm->rect_format    = RECT_FORMAT_DEPTH16;
 294                 bm->line_format    = LINE_FORMAT_DEPTH16;
 295                 break;
 296             default:
 297                 bm->surface_format = SURFACE_FORMAT_DEPTH8;
 298                 bm->pattern_format = PATTERN_FORMAT_DEPTH8;
 299                 bm->rect_format    = RECT_FORMAT_DEPTH8;
 300                 bm->line_format    = LINE_FORMAT_DEPTH8;
 301                 break;
 302         }
 303
 304         if ((bm->framebuffer != 0xffffffff) && (bm->framebuffer != 0))
 305         {
 306             return o;
 307         }
 308     }
 309
 310     OOP_MethodID disp_mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
 311     OOP_CoerceMethod(cl, o, (OOP_Msg) &disp_mid);
 312
 313     return NULL;
 314 }
 315
 316
 317 VOID NVBM__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 318 {
 319     nvBitMap *bm = OOP_INST_DATA(cl, o);
 320
 321     LOCK_BITMAP
 322     LOCK_HW
 323     NVDmaKickoff(&_sd->Card);
 324     NVSync(_sd);
 325
 326     if (bm->fbgfx)
 327     {
 328         FreeBitmapArea(_sd, bm->framebuffer, bm->width, bm->height, bm->bpp);
 329
 330         bm->framebuffer = -1;
 331         bm->fbgfx = 0;
 332     }
 333     else
 334         FreeMem((APTR)bm->framebuffer, bm->pitch * bm->height);
 335
 336     if (bm->state)
 337         FreePooled(_sd->memPool, bm->state, sizeof(struct CardState));
 338
 339     bm->state = NULL;
 340
 341     UNLOCK_HW
 342     UNLOCK_BITMAP
 343
 344     OOP_DoSuperMethod(cl, o, msg);
 345 }
 346
 347 void NVBM__Root__Get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 348 {
 349     nvBitMap *bm = OOP_INST_DATA(cl, o);
 350     ULONG idx;
 351
 352     if (IS_NVBM_ATTR(msg->attrID, idx))
 353     {
 354         switch (idx)
 355         {
 356             case aoHidd_nvBitMap_Drawable:
 357                 if (bm->fbgfx)
 358                     *msg->storage = bm->framebuffer + (IPTR)_sd->Card.FrameBuffer;
 359                 else
 360                     *msg->storage = bm->framebuffer;
 361                 break;
 362
 363             default:
 364                 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 365         }
 366     }
 367     else
 368     {
 369         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 370     }
 371 }
 372
 373 VOID NVBM__Hidd_BitMap__Clear(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_Clear *msg)
 374 {
 375     nvBitMap *bm = OOP_INST_DATA(cl, o);
 376
 377     LOCK_BITMAP
 378
 379     D(bug("[NVBitMap] Clear()\n"));
 380
 381     if (bm->fbgfx)
 382     {
 383         LOCK_HW
 384
 385         bm->usecount++;
 386
 387         _sd->Card.DMAKickoffCallback = NVDMAKickoffCallback;
 388
 389         NVDmaStart(&_sd->Card, SURFACE_FORMAT, 4);
 390         NVDmaNext(&_sd->Card, bm->surface_format);
 391         NVDmaNext(&_sd->Card, (bm->pitch << 16) | _sd->src_pitch);
 392         NVDmaNext(&_sd->Card, _sd->src_offset);
 393         NVDmaNext(&_sd->Card, bm->framebuffer);
 394
 395         _sd->surface_format = bm->surface_format;
 396         _sd->dst_pitch  = bm->pitch;
 397         _sd->dst_offset         = bm->framebuffer;
 398
 399         NVDmaStart(&_sd->Card, RECT_FORMAT, 1);
 400         NVDmaNext(&_sd->Card, bm->rect_format);
 401         _sd->rect_format = bm->rect_format;
 402
 403         NVSetRopSolid(_sd, vHidd_GC_DrawMode_Copy, ~0 << bm->depth);
 404         NVDmaStart(&_sd->Card, RECT_SOLID_COLOR, 1);
 405         NVDmaNext(&_sd->Card, GC_BG(msg->gc));
 406
 407         NVDmaStart(&_sd->Card, RECT_SOLID_RECTS(0), 2);
 408         NVDmaNext(&_sd->Card, 0);
 409         NVDmaNext(&_sd->Card, (bm->width << 16) | (bm->height));
 410
 411         NVDmaKickoff(&_sd->Card);
 412         //NVSync(_sd);
 413
 414         UNLOCK_HW
 415     }
 416     else
 417     {
 418         ULONG *ptr = (ULONG*)bm->framebuffer;
 419         ULONG val=0;
 420         int i = bm->width * bm->height * bm->bpp / 4;
 421
 422         if (_sd->gpu_busy)
 423         {
 424             LOCK_HW
 425             NVSync(_sd);
 426             UNLOCK_HW
 427         }
 428
 429         switch (bm->bpp)
 430         {
 431             case 1:
 432                 val = GC_BG(msg->gc) & 0xff;
 433                 val |= val << 8;
 434                 val |= val << 16;
 435                 break;
 436             case 2:
 437                 val = GC_BG(msg->gc) << 16 | (GC_BG(msg->gc) & 0xffff);
 438                 break;
 439             default:
 440                 val = GC_BG(msg->gc);
 441                 break;
 442         }
 443
 444         do
 445         {
 446             *ptr++ = val;
 447         } while(--i);
 448
 449     }
 450
 451     UNLOCK_BITMAP
 452 }
 453
 454
 455 VOID NVBM__Hidd_BitMap__PutPixel(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutPixel *msg)
 456 {
 457     nvBitMap *bm = OOP_INST_DATA(cl, o);
 458
 459     LOCK_BITMAP
 460
 461     UBYTE *ptr = (UBYTE*)((IPTR)bm->framebuffer + bm->bpp * msg->x + bm->pitch * msg->y);
 462
 463     if (bm->fbgfx)
 464     {
 465         ptr += (IPTR)_sd->Card.FrameBuffer;
 466         if (_sd->gpu_busy)
 467         {
 468             LOCK_HW
 469             NVSync(_sd);
 470             UNLOCK_HW
 471         }
 472     }
 473
 474     switch (bm->bpp)
 475     {
 476         case 1:
 477             *ptr = msg->pixel;
 478             break;
 479         case 2:
 480             *(UWORD*)ptr = msg->pixel;
 481             break;
 482         case 4:
 483             *(ULONG*)ptr = msg->pixel;
 484             break;
 485     }
 486
 487     UNLOCK_BITMAP
 488 }
 489
 490 HIDDT_Pixel NVBM__Hidd_BitMap__GetPixel(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_GetPixel *msg)
 491 {
 492     HIDDT_Pixel pixel=0;
 493     nvBitMap *bm = OOP_INST_DATA(cl, o);
 494
 495     LOCK_BITMAP
 496
 497     UBYTE *ptr = (UBYTE*)((IPTR)bm->framebuffer + bm->bpp * msg->x + bm->pitch * msg->y);
 498
 499     if (bm->fbgfx)
 500     {
 501         ptr += (IPTR)_sd->Card.FrameBuffer;
 502         if (_sd->gpu_busy)
 503         {
 504             LOCK_HW
 505             NVSync(_sd);
 506             UNLOCK_HW
 507         }
 508     }
 509
 510     switch (bm->bpp)
 511     {
 512         case 1:
 513             pixel = *ptr;
 514             break;
 515         case 2:
 516             pixel = *(UWORD*)ptr;
 517             break;
 518         case 4:
 519             pixel = *(ULONG*)ptr;
 520             break;
 521     }
 522
 523     UNLOCK_BITMAP
 524
 525     /* Get pen number from colortab */
 526     return pixel;
 527 }
 528
 529 VOID NVBM__Hidd_BitMap__FillRect(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawRect *msg)
 530 {
 531     nvBitMap *bm = OOP_INST_DATA(cl, o);
 532
 533     LOCK_BITMAP
 534
 535     D(bug("[NVBitMap] FillRect(%p,%d,%d,%d,%d)\n",
 536         bm->framebuffer, msg->minX, msg->minY, msg->maxX, msg->maxY));
 537
 538     if (bm->fbgfx)
 539     {
 540         LOCK_HW
 541
 542         bm->usecount++;
 543
 544         _sd->Card.DMAKickoffCallback = NVDMAKickoffCallback;
 545         _sd->gpu_busy = TRUE;
 546
 547         NVDmaStart(&_sd->Card, SURFACE_FORMAT, 4);
 548         NVDmaNext(&_sd->Card, bm->surface_format);
 549         NVDmaNext(&_sd->Card, (bm->pitch << 16) | _sd->src_pitch);
 550         NVDmaNext(&_sd->Card, _sd->src_offset);
 551         NVDmaNext(&_sd->Card, bm->framebuffer);
 552
 553         _sd->surface_format = bm->surface_format;
 554         _sd->dst_pitch  = bm->pitch;
 555         _sd->dst_offset         = bm->framebuffer;
 556
 557         NVDmaStart(&_sd->Card, RECT_FORMAT, 1);
 558         NVDmaNext(&_sd->Card, bm->rect_format);
 559         _sd->rect_format = bm->rect_format;
 560
 561         NVSetRopSolid(_sd, GC_DRMD(msg->gc), ~0 << bm->depth);
 562         NVDmaStart(&_sd->Card, RECT_SOLID_COLOR, 1);
 563         NVDmaNext(&_sd->Card, GC_FG(msg->gc));
 564
 565         NVDmaStart(&_sd->Card, RECT_SOLID_RECTS(0), 2);
 566         NVDmaNext(&_sd->Card, (msg->minX << 16) | (msg->minY & 0xffff));
 567         NVDmaNext(&_sd->Card, ((msg->maxX - msg->minX + 1) << 16)
 568             | ((msg->maxY - msg->minY + 1) & 0xffff));
 569
 570         NVDmaKickoff(&_sd->Card);
 571
 572 //      if ((msg->maxX - msg->minX) * (msg->maxY - msg->minY) > 512)
 573 //          NVSync(_sd);
 574
 575         UNLOCK_HW
 576     }
 577     else
 578     {
 579         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 580     }
 581
 582     UNLOCK_BITMAP
 583 }
 584
 585 ULONG NVBM__Hidd_BitMap__BytesPerLine(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_BytesPerLine *msg)
 586 {
 587     nvBitMap *bm = OOP_INST_DATA(cl, o);
 588
 589     return (bm->bpp * msg->width + 63) & ~63;
 590 }
 591
 592 VOID NVBM__Hidd_BitMap__DrawLine(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawLine *msg)
 593 {
 594     OOP_Object *gc = msg->gc;
 595     nvBitMap *bm = OOP_INST_DATA(cl, o);
 596
 597     LOCK_BITMAP
 598
 599     D(bug("[NVBitmap] DrawLine(%p, %d, %d, %d, %d)\n",
 600         bm->framebuffer, msg->x1, msg->y1, msg->x2, msg->y2));
 601
 602     if ((GC_LINEPAT(gc) != (UWORD)~0) || !bm->fbgfx)
 603     {
 604         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 605     }
 606     else
 607     {
 608         LOCK_HW
 609
 610         bm->usecount++;
 611
 612
 613         _sd->Card.DMAKickoffCallback = NVDMAKickoffCallback;
 614         _sd->gpu_busy = TRUE;
 615
 616         NVDmaStart(&_sd->Card, SURFACE_OFFSET_DST, 1);
 617         NVDmaNext(&_sd->Card, bm->framebuffer);
 618         _sd->dst_offset = bm->framebuffer;
 619
 620         NVDmaStart(&_sd->Card, SURFACE_PITCH, 1);
 621         NVDmaNext(&_sd->Card, (bm->pitch << 16) | _sd->src_pitch);
 622         _sd->dst_pitch = bm->pitch;
 623
 624         if (GC_DOCLIP(gc))
 625         {
 626             NVDmaStart(&_sd->Card, CLIP_POINT, 2);
 627             NVDmaNext(&_sd->Card, (GC_CLIPY1(gc) << 16) | GC_CLIPX1(gc));
 628             NVDmaNext(&_sd->Card, ((GC_CLIPY2(gc)-GC_CLIPY1(gc)+1) << 16) |
 629                                   (GC_CLIPX2(gc)-GC_CLIPX1(gc)+1));
 630         }
 631
 632         NVSetRopSolid(_sd, GC_DRMD(gc), ~0 << bm->depth);
 633         NVDmaStart(&_sd->Card, LINE_FORMAT, 2);
 634         NVDmaNext(&_sd->Card, bm->line_format);
 635         NVDmaNext(&_sd->Card, GC_FG(gc));
 636
 637         NVDmaStart(&_sd->Card, LINE_LINES(0), 4);
 638         NVDmaNext(&_sd->Card, (msg->y1 << 16) | (msg->x1 & 0xffff));
 639         NVDmaNext(&_sd->Card, (msg->y2 << 16) | (msg->x2 & 0xffff));
 640         NVDmaNext(&_sd->Card, (msg->y2 << 16) | (msg->x2 & 0xffff));
 641         NVDmaNext(&_sd->Card, ((msg->y2 + 1) << 16) | ((msg->x2 + 1) & 0xffff));
 642
 643         if (GC_DOCLIP(gc))
 644         {
 645             NVDmaStart(&_sd->Card, CLIP_POINT, 2);
 646             NVDmaNext(&_sd->Card, 0x00000000);
 647             NVDmaNext(&_sd->Card, 0xff00ff00);
 648         }
 649
 650         NVDmaKickoff(&_sd->Card);
 651
 652         UNLOCK_HW
 653     }
 654
 655     UNLOCK_BITMAP
 656 }
 657
 658 VOID NVBM__Hidd_BitMap__PutImageLUT(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutImageLUT *msg)
 659 {
 660     nvBitMap *bm = OOP_INST_DATA(cl, o);
 661
 662     LOCK_BITMAP
 663
 664     IPTR VideoData = bm->framebuffer;
 665
 666     if (bm->fbgfx)
 667     {
 668         VideoData += (IPTR)_sd->Card.FrameBuffer;
 669
 670         if (_sd->gpu_busy)
 671         {
 672             LOCK_HW
 673             NVSync(_sd);
 674             UNLOCK_HW
 675         }
 676     }
 677
 678     switch(bm->bpp)
 679     {
 680         case 2:
 681             {
 682                 struct pHidd_BitMap_CopyLUTMemBox16 __m = {
 683                             _sd->mid_CopyLUTMemBox16,
 684                             msg->pixels,
 685                             0,
 686                             0,
 687                             (APTR)VideoData,
 688                             msg->x,
 689                             msg->y,
 690                             msg->width,
 691                             msg->height,
 692                             msg->modulo,
 693                             bm->pitch,
 694                             msg->pixlut
 695                 }, *m = &__m;
 696
 697                 OOP_DoMethod(o, (OOP_Msg)m);
 698             }
 699             break;
 700
 701         case 4:
 702             {
 703                 struct pHidd_BitMap_CopyLUTMemBox32 __m = {
 704                             _sd->mid_CopyLUTMemBox32,
 705                             msg->pixels,
 706                             0,
 707                             0,
 708                             (APTR)VideoData,
 709                             msg->x,
 710                             msg->y,
 711                             msg->width,
 712                             msg->height,
 713                             msg->modulo,
 714                             bm->pitch,
 715                             msg->pixlut
 716                 }, *m = &__m;
 717
 718                 OOP_DoMethod(o, (OOP_Msg)m);
 719             }
 720             break;
 721
 722         default:
 723             OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 724             break;
 725
 726     } /* switch(data->bytesperpix) */
 727
 728     UNLOCK_BITMAP
 729
 730 }
 731
 732 VOID NVBM__Hidd_BitMap__BlitColorExpansion(OOP_Class *cl, OOP_Object *o,
 733                 struct pHidd_BitMap_BlitColorExpansion *msg)
 734 {
 735     nvBitMap *bm = OOP_INST_DATA(cl, o);
 736
 737     LOCK_BITMAP
 738
 739     if ((OOP_OCLASS(msg->srcBitMap) == _sd->planarbmclass) && bm->fbgfx)
 740     {
 741         struct planarbm_data    *planar = OOP_INST_DATA(OOP_OCLASS(msg->srcBitMap), msg->srcBitMap);
 742         HIDDT_Pixel             bg, fg;
 743         ULONG                   cemd;
 744         ULONG                   expand;
 745         ULONG                   skipleft = msg->srcX - (msg->srcX & ~31);
 746         ULONG                   mask = ~0 << bm->depth;
 747
 748         cemd = GC_COLEXP(msg->gc);
 749         bg   = GC_BG(msg->gc) | mask;
 750         fg   = GC_FG(msg->gc) | mask;
 751
 752         ULONG bw = (msg->width + 31 + skipleft) & ~31;
 753         ULONG x = msg->destX, y = msg->destY, w = msg->width, h = msg->height;
 754
 755         LOCK_HW
 756
 757         bm->usecount++;
 758
 759         _sd->gpu_busy = TRUE;
 760
 761         NVDmaStart(&_sd->Card, SURFACE_FORMAT, 4);
 762         NVDmaNext(&_sd->Card, bm->surface_format);
 763         NVDmaNext(&_sd->Card, (bm->pitch << 16) | (_sd->src_pitch));
 764         NVDmaNext(&_sd->Card, _sd->src_offset);
 765         NVDmaNext(&_sd->Card, bm->framebuffer);
 766
 767         NVDmaStart(&_sd->Card, RECT_FORMAT, 1);
 768         NVDmaNext(&_sd->Card, bm->rect_format);
 769
 770         _sd->surface_format = bm->surface_format;
 771         _sd->dst_pitch = bm->pitch;
 772         _sd->dst_offset = bm->framebuffer;
 773
 774         NVSetRopSolid(_sd, GC_DRMD(msg->gc), ~0 << bm->depth);
 775
 776         if (cemd & vHidd_GC_ColExp_Transparent)
 777         {
 778             NVDmaStart(&_sd->Card, RECT_EXPAND_ONE_COLOR_CLIP, 5);
 779             NVDmaNext(&_sd->Card, (y << 16) | ((x) & 0xffff));
 780             NVDmaNext(&_sd->Card, ((y + h) << 16) | ((x + w) & 0xffff));
 781             NVDmaNext(&_sd->Card, fg);
 782             NVDmaNext(&_sd->Card, (h << 16) | bw);
 783             NVDmaNext(&_sd->Card, (y << 16) | ((x-skipleft) & 0xffff));
 784             expand = RECT_EXPAND_ONE_COLOR_DATA(0);
 785         }
 786         else
 787         {
 788             NVDmaStart(&_sd->Card, RECT_EXPAND_TWO_COLOR_CLIP, 7);
 789             NVDmaNext(&_sd->Card, (y << 16) | ((x) & 0xffff));
 790             NVDmaNext(&_sd->Card, ((y + h) << 16) | ((x + w) & 0xffff));
 791             NVDmaNext(&_sd->Card, bg);
 792             NVDmaNext(&_sd->Card, fg);
 793             NVDmaNext(&_sd->Card, (h << 16) | bw);
 794             NVDmaNext(&_sd->Card, (h << 16) | bw);
 795             NVDmaNext(&_sd->Card, (y << 16) | ((x-skipleft) & 0xffff));
 796             expand = RECT_EXPAND_TWO_COLOR_DATA(0);
 797         }
 798
 799         ULONG i,j;
 800         ULONG *ptr = (ULONG*)planar->planes[0];
 801
 802         ptr += (planar->bytesperrow * msg->srcY >> 2) +
 803                 (msg->srcX >> 5);
 804
 805         if ((bw >> 5) * h < RECT_EXPAND_ONE_COLOR_DATA_MAX_DWORDS)
 806         {
 807             NVDmaStart(&_sd->Card, expand, (bw >> 5) * h);
 808             for (i = 0; i < h; i++)
 809             {
 810                 for (j=0; j < (bw >> 5); j++)
 811                 {
 812                     NVDmaNext(&_sd->Card, ptr[j]);
 813                 }
 814                 ptr += planar->bytesperrow >> 2;
 815             }
 816         }
 817         else
 818         {
 819             for (i = 0; i < h; i++)
 820             {
 821                 NVDmaStart(&_sd->Card, expand, (bw >> 5));
 822
 823                 for (j=0; j < (bw >> 5); j++)
 824                 {
 825                     NVDmaNext(&_sd->Card, ptr[j]);
 826                 }
 827                 ptr += planar->bytesperrow >> 2;
 828             }
 829         }
 830
 831         NVDmaStart(&_sd->Card, BLIT_POINT_SRC, 1);
 832         NVDmaNext(&_sd->Card, 0);
 833         NVDmaKickoff(&_sd->Card);
 834
 835         UNLOCK_HW
 836     }
 837     else
 838         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 839
 840     UNLOCK_BITMAP
 841 }
 842
 843 VOID NVBM__Hidd_BitMap__DrawRect(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawRect *msg)
 844 {
 845     OOP_Object *gc = msg->gc;
 846     nvBitMap *bm = OOP_INST_DATA(cl, o);
 847     UWORD addX, addY;
 848
 849     LOCK_BITMAP
 850
 851     D(bug("[NVBitmap] DrawRect(%p, %d, %d, %d, %d)\n",
 852         bm->framebuffer, msg->minX, msg->minY, msg->maxX, msg->maxY));
 853
 854     if (msg->minX == msg->maxX) addX = 1; else addX = 0;
 855     if (msg->minY == msg->maxY) addY = 1; else addY = 0;
 856
 857     if ((GC_LINEPAT(gc) != (UWORD)~0) || !bm->fbgfx)
 858     {
 859         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 860     }
 861     else
 862     {
 863         LOCK_HW
 864
 865         _sd->gpu_busy = TRUE;
 866         bm->usecount++;
 867
 868
 869         _sd->Card.DMAKickoffCallback = NVDMAKickoffCallback;
 870
 871         NVDmaStart(&_sd->Card, SURFACE_OFFSET_DST, 1);
 872         NVDmaNext(&_sd->Card, bm->framebuffer);
 873         _sd->dst_offset = bm->framebuffer;
 874
 875         NVDmaStart(&_sd->Card, SURFACE_PITCH, 1);
 876         NVDmaNext(&_sd->Card, (bm->pitch << 16) | _sd->src_pitch);
 877         _sd->dst_pitch = bm->pitch;
 878
 879         if (GC_DOCLIP(gc))
 880         {
 881             NVDmaStart(&_sd->Card, CLIP_POINT, 2);
 882             NVDmaNext(&_sd->Card, (GC_CLIPY1(gc) << 16) | GC_CLIPX1(gc));
 883             NVDmaNext(&_sd->Card, ((GC_CLIPY2(gc)-GC_CLIPY1(gc)+1) << 16) |
 884                                   (GC_CLIPX2(gc)-GC_CLIPX1(gc)+1));
 885         }
 886
 887         NVSetRopSolid(_sd, GC_DRMD(gc), ~0 << bm->depth);
 888         NVDmaStart(&_sd->Card, LINE_FORMAT, 2);
 889         NVDmaNext(&_sd->Card, bm->line_format);
 890         NVDmaNext(&_sd->Card, GC_FG(gc));
 891
 892         NVDmaStart(&_sd->Card, LINE_LINES(0), 8);
 893
 894         NVDmaNext(&_sd->Card, (msg->minY << 16) | (msg->minX & 0xffff));
 895         NVDmaNext(&_sd->Card, (msg->minY << 16) | (msg->maxX & 0xffff));
 896
 897         NVDmaNext(&_sd->Card, ((msg->minY + addY) << 16) | (msg->maxX & 0xffff));
 898         NVDmaNext(&_sd->Card, ((msg->maxY << 16)) | (msg->maxX & 0xffff));
 899
 900         NVDmaNext(&_sd->Card, ((msg->maxY << 16)) | ((msg->maxX - addX) & 0xffff));
 901         NVDmaNext(&_sd->Card, ((msg->maxY << 16)) | ((msg->minX) & 0xffff));
 902
 903         NVDmaNext(&_sd->Card, ((msg->maxY - addY) << 16) | (msg->minX & 0xffff));
 904         NVDmaNext(&_sd->Card, ((msg->minY + addY) << 16) | (msg->minX & 0xffff));
 905
 906         if (GC_DOCLIP(gc))
 907         {
 908             NVDmaStart(&_sd->Card, CLIP_POINT, 2);
 909             NVDmaNext(&_sd->Card, 0x00000000);
 910             NVDmaNext(&_sd->Card, 0xff00ff00);
 911         }
 912
 913         NVDmaKickoff(&_sd->Card);
 914
 915         UNLOCK_HW
 916     }
 917
 918     UNLOCK_BITMAP
 919 }
 920
 921 VOID NVBM__Hidd_BitMap__DrawPolygon(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawPolygon *msg)
 922 {
 923     OOP_Object *gc = msg->gc;
 924     nvBitMap *bm = OOP_INST_DATA(cl, o);
 925     ULONG i;
 926
 927     LOCK_BITMAP
 928
 929     if ((GC_LINEPAT(gc) != (UWORD)~0) || !bm->fbgfx)
 930     {
 931         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 932     }
 933     else
 934     {
 935         LOCK_HW
 936
 937         bm->usecount++;
 938
 939
 940         _sd->Card.DMAKickoffCallback = NVDMAKickoffCallback;
 941         _sd->gpu_busy = TRUE;
 942
 943         NVDmaStart(&_sd->Card, SURFACE_OFFSET_DST, 1);
 944         NVDmaNext(&_sd->Card, bm->framebuffer);
 945         _sd->dst_offset = bm->framebuffer;
 946
 947         NVDmaStart(&_sd->Card, SURFACE_PITCH, 1);
 948         NVDmaNext(&_sd->Card, (bm->pitch << 16) | _sd->src_pitch);
 949         _sd->dst_pitch = bm->pitch;
 950
 951         if (GC_DOCLIP(gc))
 952         {
 953             NVDmaStart(&_sd->Card, CLIP_POINT, 2);
 954             NVDmaNext(&_sd->Card, (GC_CLIPY1(gc) << 16) | GC_CLIPX1(gc));
 955             NVDmaNext(&_sd->Card, ((GC_CLIPY2(gc)-GC_CLIPY1(gc)+1) << 16) |
 956                                   (GC_CLIPX2(gc)-GC_CLIPX1(gc)+1));
 957         }
 958
 959         NVSetRopSolid(_sd, GC_DRMD(gc), ~0 << bm->depth);
 960         NVDmaStart(&_sd->Card, LINE_FORMAT, 2);
 961         NVDmaNext(&_sd->Card, bm->line_format);
 962         NVDmaNext(&_sd->Card, GC_FG(gc));
 963
 964         for(i = 2; i < (2 * msg->n); i = i + 2)
 965         {
 966             NVDmaStart(&_sd->Card, LINE_LINES(0), 2);
 967             NVDmaNext(&_sd->Card, (msg->coords[i - 1] << 16) | msg->coords[i - 2]);
 968             NVDmaNext(&_sd->Card, (msg->coords[i + 1] << 16) | msg->coords[i]);
 969         }
 970
 971         if (GC_DOCLIP(gc))
 972         {
 973             NVDmaStart(&_sd->Card, CLIP_POINT, 2);
 974             NVDmaNext(&_sd->Card, 0x00000000);
 975             NVDmaNext(&_sd->Card, 0x7f007f00);
 976         }
 977
 978         NVDmaKickoff(&_sd->Card);
 979
 980         UNLOCK_HW
 981     }
 982
 983     UNLOCK_BITMAP
 984 }
 985
 986 VOID NVBM__Hidd_BitMap__PutImage(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutImage *msg)
 987 {
 988     nvBitMap *bm = OOP_INST_DATA(cl, o);
 989
 990     LOCK_BITMAP
 991
 992     IPTR VideoData = bm->framebuffer;
 993
 994     if (bm->fbgfx)
 995     {
 996         VideoData += (IPTR)_sd->Card.FrameBuffer;
 997
 998         if (_sd->gpu_busy)
 999         {
1000             LOCK_HW
1001             NVSync(_sd);
1002             UNLOCK_HW
1003         }
1004     }
1005
1006     switch(msg->pixFmt)
1007     {
1008         case vHidd_StdPixFmt_Native:
1009             switch(bm->bpp)
1010             {
1011                 case 1:
1012                     {
1013                         struct pHidd_BitMap_CopyMemBox8 __m = {
1014                                     _sd->mid_CopyMemBox8,
1015                                     msg->pixels,
1016                                     0,
1017                                     0,
1018                                     (APTR)VideoData,
1019                                     msg->x,
1020                                     msg->y,
1021                                     msg->width,
1022                                     msg->height,
1023                                     msg->modulo,
1024                                     bm->pitch
1025                         }, *m = &__m;
1026
1027                         OOP_DoMethod(o, (OOP_Msg)m);
1028                     }
1029                     break;
1030
1031                 case 2:
1032                     {
1033                         struct pHidd_BitMap_CopyMemBox16 __m = {
1034                                     _sd->mid_CopyMemBox16,
1035                                     msg->pixels,
1036                                     0,
1037                                     0,
1038                                     (APTR)VideoData,
1039                                     msg->x,
1040                                     msg->y,
1041                                     msg->width,
1042                                     msg->height,
1043                                     msg->modulo,
1044                                     bm->pitch
1045                         }, *m = &__m;
1046
1047                         OOP_DoMethod(o, (OOP_Msg)m);
1048                     }
1049                     break;
1050
1051                 case 4:
1052                     {
1053                         struct pHidd_BitMap_CopyMemBox32 __m = {
1054                                     _sd->mid_CopyMemBox32,
1055                                     msg->pixels,
1056                                     0,
1057                                     0,
1058                                     (APTR)VideoData,
1059                                     msg->x,
1060                                     msg->y,
1061                                     msg->width,
1062                                     msg->height,
1063                                     msg->modulo,
1064                                     bm->pitch
1065                         }, *m = &__m;
1066
1067                         OOP_DoMethod(o, (OOP_Msg)m);
1068                     }
1069                     break;
1070
1071             } /* switch(data->bytesperpix) */
1072             break;
1073
1074         case vHidd_StdPixFmt_Native32:
1075             switch(bm->bpp)
1076             {
1077                 case 1:
1078                     {
1079                         struct pHidd_BitMap_PutMem32Image8 __m = {
1080                                             _sd->mid_PutMem32Image8,
1081                                             msg->pixels,
1082                                             (APTR)VideoData,
1083                                             msg->x,
1084                                             msg->y,
1085                                             msg->width,
1086                                             msg->height,
1087                                             msg->modulo,
1088                                             bm->pitch
1089                             }, *m = &__m;
1090                         OOP_DoMethod(o, (OOP_Msg)m);
1091                     }
1092                     break;
1093
1094                 case 2:
1095                     {
1096                         struct pHidd_BitMap_PutMem32Image16 __m = {
1097                                             _sd->mid_PutMem32Image16,
1098                                             msg->pixels,
1099                                             (APTR)VideoData,
1100                                             msg->x,
1101                                             msg->y,
1102                                             msg->width,
1103                                             msg->height,
1104                                             msg->modulo,
1105                                             bm->pitch
1106                             }, *m = &__m;
1107                         OOP_DoMethod(o, (OOP_Msg)m);
1108                     }
1109                     break;
1110
1111                 case 4:
1112                     {
1113                         struct pHidd_BitMap_CopyMemBox32 __m = {
1114                                     _sd->mid_CopyMemBox32,
1115                                     msg->pixels,
1116                                     0,
1117                                     0,
1118                                     (APTR)VideoData,
1119                                     msg->x,
1120                                     msg->y,
1121                                     msg->width,
1122                                     msg->height,
1123                                     msg->modulo,
1124                                     bm->pitch
1125                         }, *m = &__m;
1126
1127                         OOP_DoMethod(o, (OOP_Msg)m);
1128                     }
1129                     break;
1130
1131             } /* switch(data->bytesperpix) */
1132             break;
1133
1134         default:
1135             OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
1136             break;
1137
1138     } /* switch(msg->pixFmt) */
1139
1140     UNLOCK_BITMAP
1141 }
1142
1143 VOID NVBM__Hidd_BitMap__GetImage(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_GetImage *msg)
1144 {
1145     nvBitMap *bm = OOP_INST_DATA(cl, o);
1146
1147     LOCK_BITMAP
1148
1149     IPTR VideoData = bm->framebuffer;
1150
1151     if (bm->fbgfx)
1152     {
1153         VideoData += (IPTR)_sd->Card.FrameBuffer;
1154         if (_sd->gpu_busy)
1155         {
1156             LOCK_HW
1157             NVSync(_sd);
1158             UNLOCK_HW
1159         }
1160     }
1161
1162
1163     switch(msg->pixFmt)
1164     {
1165         case vHidd_StdPixFmt_Native:
1166             switch(bm->bpp)
1167             {
1168                 case 1:
1169                     {
1170                         struct pHidd_BitMap_CopyMemBox8 __m = {
1171                                         _sd->mid_CopyMemBox8,
1172                                         (APTR)VideoData,
1173                                         msg->x,
1174                                         msg->y,
1175                                         msg->pixels,
1176                                         0,
1177                                         0,
1178                                         msg->width,
1179                                         msg->height,
1180                                         bm->pitch,
1181                                         msg->modulo
1182                         }, *m = &__m;
1183
1184                         OOP_DoMethod(o, (OOP_Msg)m);
1185                     }
1186                     break;
1187
1188                 case 2:
1189                     {
1190                         struct pHidd_BitMap_CopyMemBox16 __m = {
1191                                         _sd->mid_CopyMemBox16,
1192                                         (APTR)VideoData,
1193                                         msg->x,
1194                                         msg->y,
1195                                         msg->pixels,
1196                                         0,
1197                                         0,
1198                                         msg->width,
1199                                         msg->height,
1200                                         bm->pitch,
1201                                         msg->modulo
1202                         }, *m = &__m;
1203
1204                         OOP_DoMethod(o, (OOP_Msg)m);
1205                     }
1206                     break;
1207
1208                 case 4:
1209                     {
1210                         struct pHidd_BitMap_CopyMemBox32 __m = {
1211                                         _sd->mid_CopyMemBox32,
1212                                         (APTR)VideoData,
1213                                         msg->x,
1214                                         msg->y,
1215                                         msg->pixels,
1216                                         0,
1217                                         0,
1218                                         msg->width,
1219                                         msg->height,
1220                                         bm->pitch,
1221                                         msg->modulo
1222                         }, *m = &__m;
1223
1224                         OOP_DoMethod(o, (OOP_Msg)m);
1225                     }
1226                     break;
1227
1228             } /* switch(data->bytesperpix) */
1229             break;
1230
1231         case vHidd_StdPixFmt_Native32:
1232             switch(bm->bpp)
1233             {
1234                 case 1:
1235                     {
1236                         struct pHidd_BitMap_GetMem32Image8 __m = {
1237                             _sd->mid_GetMem32Image8,
1238                             (APTR)VideoData,
1239                             msg->x,
1240                             msg->y,
1241                             msg->pixels,
1242                             msg->width,
1243                             msg->height,
1244                             bm->pitch,
1245                             msg->modulo
1246                         }, *m = &__m;
1247
1248                         OOP_DoMethod(o, (OOP_Msg)m);
1249                     }
1250                     break;
1251
1252                 case 2:
1253                     {
1254                         struct pHidd_BitMap_GetMem32Image16 __m = {
1255                             _sd->mid_GetMem32Image16,
1256                             (APTR)VideoData,
1257                             msg->x,
1258                             msg->y,
1259                             msg->pixels,
1260                             msg->width,
1261                             msg->height,
1262                             bm->pitch,
1263                             msg->modulo
1264                         }, *m = &__m;
1265
1266                         OOP_DoMethod(o, (OOP_Msg)m);
1267                     }
1268                     break;
1269
1270                 case 4:
1271                     {
1272                         struct pHidd_BitMap_CopyMemBox32 __m = {
1273                                         _sd->mid_CopyMemBox32,
1274                                         (APTR)VideoData,
1275                                         msg->x,
1276                                         msg->y,
1277                                         msg->pixels,
1278                                         0,
1279                                         0,
1280                                         msg->width,
1281                                         msg->height,
1282                                         bm->pitch,
1283                                         msg->modulo
1284                         }, *m = &__m;
1285
1286                         OOP_DoMethod(o, (OOP_Msg)m);
1287                     }
1288                     break;
1289
1290             } /* switch(data->bytesperpix) */
1291             break;
1292
1293         default:
1294             OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
1295             break;
1296
1297     } /* switch(msg->pixFmt) */
1298
1299     UNLOCK_BITMAP
1300
1301 }
1302
1303 VOID NVBM__Hidd_BitMap__PutTemplate(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutTemplate *msg)
1304 {
1305     nvBitMap *bm = OOP_INST_DATA(cl, o);
1306
1307     LOCK_BITMAP
1308
1309     IPTR VideoData = bm->framebuffer;
1310
1311     if (bm->fbgfx)
1312     {
1313         VideoData += (IPTR)_sd->Card.FrameBuffer;
1314         if (_sd->gpu_busy)
1315         {
1316             LOCK_HW
1317             NVSync(_sd);
1318             UNLOCK_HW
1319         }
1320     }
1321
1322
1323     switch(bm->bpp)
1324     {
1325         case 1:
1326             {
1327                 struct pHidd_BitMap_PutMemTemplate8 __m = {
1328                                 _sd->mid_PutMemTemplate8,
1329                                 msg->gc,
1330                                 msg->masktemplate,
1331                                 msg->modulo,
1332                                 msg->srcx,
1333                                 (APTR)VideoData,
1334                                 bm->pitch,
1335                                 msg->x,
1336                                 msg->y,
1337                                 msg->width,
1338                                 msg->height,
1339                                 msg->inverttemplate
1340                 }, *m = &__m;
1341
1342                 OOP_DoMethod(o, (OOP_Msg)m);
1343             }
1344             break;
1345
1346         case 2:
1347             {
1348                 struct pHidd_BitMap_PutMemTemplate16 __m = {
1349                                 _sd->mid_PutMemTemplate16,
1350                                 msg->gc,
1351                                 msg->masktemplate,
1352                                 msg->modulo,
1353                                 msg->srcx,
1354                                 (APTR)VideoData,
1355                                 bm->pitch,
1356                                 msg->x,
1357                                 msg->y,
1358                                 msg->width,
1359                                 msg->height,
1360                                 msg->inverttemplate
1361                 }, *m = &__m;
1362
1363                 OOP_DoMethod(o, (OOP_Msg)m);
1364             }
1365             break;
1366
1367         case 4:
1368             {
1369                 struct pHidd_BitMap_PutMemTemplate32 __m = {
1370                                 _sd->mid_PutMemTemplate32,
1371                                 msg->gc,
1372                                 msg->masktemplate,
1373                                 msg->modulo,
1374                                 msg->srcx,
1375                                 (APTR)VideoData,
1376                                 bm->pitch,
1377                                 msg->x,
1378                                 msg->y,
1379                                 msg->width,
1380                                 msg->height,
1381                                 msg->inverttemplate
1382                 }, *m = &__m;
1383
1384                 OOP_DoMethod(o, (OOP_Msg)m);
1385             }
1386             break;
1387
1388     } /* switch(bm->bpp) */
1389
1390     UNLOCK_BITMAP
1391 }
1392
1393 VOID NVBM__Hidd_BitMap__PutPattern(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutPattern *msg)
1394 {
1395     nvBitMap *bm = OOP_INST_DATA(cl, o);
1396
1397     LOCK_BITMAP
1398
1399     IPTR VideoData = bm->framebuffer;
1400
1401     if (bm->fbgfx)
1402     {
1403         VideoData += (IPTR)_sd->Card.FrameBuffer;
1404         if (_sd->gpu_busy)
1405         {
1406             LOCK_HW
1407             NVSync(_sd);
1408             UNLOCK_HW
1409         }
1410     }
1411
1412
1413     switch(bm->bpp)
1414     {
1415         case 1:
1416             {
1417                 struct pHidd_BitMap_PutMemPattern8 __m = {
1418                                 _sd->mid_PutMemPattern8,
1419                                 msg->gc,
1420                                 msg->pattern,
1421                                 msg->patternsrcx,
1422                                 msg->patternsrcy,
1423                                 msg->patternheight,
1424                                 msg->patterndepth,
1425                                 msg->patternlut,
1426                                 msg->invertpattern,
1427                                 msg->mask,
1428                                 msg->maskmodulo,
1429                                 msg->masksrcx,
1430                                 (APTR)VideoData,
1431                                 bm->pitch,
1432                                 msg->x,
1433                                 msg->y,
1434                                 msg->width,
1435                                 msg->height
1436                 }, *m = &__m;
1437
1438                 OOP_DoMethod(o, (OOP_Msg)m);
1439             }
1440             break;
1441
1442         case 2:
1443             {
1444                 struct pHidd_BitMap_PutMemPattern16 __m = {
1445                                 _sd->mid_PutMemPattern16,
1446                                 msg->gc,
1447                                 msg->pattern,
1448                                 msg->patternsrcx,
1449                                 msg->patternsrcy,
1450                                 msg->patternheight,
1451                                 msg->patterndepth,
1452                                 msg->patternlut,
1453                                 msg->invertpattern,
1454                                 msg->mask,
1455                                 msg->maskmodulo,
1456                                 msg->masksrcx,
1457                                 (APTR)VideoData,
1458                                 bm->pitch,
1459                                 msg->x,
1460                                 msg->y,
1461                                 msg->width,
1462                                 msg->height
1463                 }, *m = &__m;
1464
1465                 OOP_DoMethod(o, (OOP_Msg)m);
1466             }
1467             break;
1468
1469         case 4:
1470             {
1471                 struct pHidd_BitMap_PutMemPattern32 __m = {
1472                                 _sd->mid_PutMemPattern32,
1473                                 msg->gc,
1474                                 msg->pattern,
1475                                 msg->patternsrcx,
1476                                 msg->patternsrcy,
1477                                 msg->patternheight,
1478                                 msg->patterndepth,
1479                                 msg->patternlut,
1480                                 msg->invertpattern,
1481                                 msg->mask,
1482                                 msg->maskmodulo,
1483                                 msg->masksrcx,
1484                                 (APTR)VideoData,
1485                                 bm->pitch,
1486                                 msg->x,
1487                                 msg->y,
1488                                 msg->width,
1489                                 msg->height
1490                 }, *m = &__m;
1491
1492                 OOP_DoMethod(o, (OOP_Msg)m);
1493             }
1494             break;
1495
1496     } /* switch(bm->bpp) */
1497
1498     UNLOCK_BITMAP
1499 }
1500
1501
1502 BOOL NVBM__Hidd_BitMap__ObtainDirectAccess(OOP_Class *cl, OOP_Object *o,
1503                 struct pHidd_BitMap_ObtainDirectAccess *msg)
1504 {
1505     nvBitMap *bm = OOP_INST_DATA(cl, o);
1506     LOCK_BITMAP
1507
1508     IPTR VideoData = bm->framebuffer;
1509
1510     if (bm->fbgfx)
1511     {
1512         VideoData += (IPTR)_sd->Card.FrameBuffer;
1513         if (_sd->gpu_busy)
1514         {
1515             LOCK_HW
1516             NVSync(_sd);
1517             UNLOCK_HW
1518         }
1519     }
1520
1521     *msg->addressReturn = (UBYTE*)VideoData;
1522     *msg->widthReturn = bm->pitch / bm->bpp;
1523     *msg->heightReturn = bm->height;
1524     *msg->bankSizeReturn = *msg->memSizeReturn = bm->pitch * bm->height;
1525
1526     return TRUE;
1527 }
1528
1529 VOID NVBM__Hidd_BitMap__ReleaseDirectAccess(OOP_Class *cl, OOP_Object *o,
1530                 struct pHidd_BitMap_ReleaseDirectAccess *msg)
1531 {
1532     nvBitMap *bm = OOP_INST_DATA(cl, o);
1533
1534
1535
1536     UNLOCK_BITMAP
1537 }
1538
1539
1540 static int Init_BMMethodIDs(LIBBASETYPEPTR LIBBASE)
1541 {
1542     LIBBASE->sd.mid_CopyMemBox8         = OOP_GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_CopyMemBox8);
1543     LIBBASE->sd.mid_CopyMemBox16        = OOP_GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_CopyMemBox16);
1544     LIBBASE->sd.mid_CopyMemBox32        = OOP_GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_CopyMemBox32);
1545     LIBBASE->sd.mid_PutMem32Image8      = OOP_GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_PutMem32Image8);
1546     LIBBASE->sd.mid_PutMem32Image16     = OOP_GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_PutMem32Image16);
1547     LIBBASE->sd.mid_GetMem32Image8      = OOP_GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_GetMem32Image8);
1548     LIBBASE->sd.mid_GetMem32Image16     = OOP_GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_GetMem32Image16);
1549     LIBBASE->sd.mid_Clear               = OOP_GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_Clear);
1550     LIBBASE->sd.mid_PutMemTemplate8     = OOP_GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_PutMemTemplate8);
1551     LIBBASE->sd.mid_PutMemTemplate16    = OOP_GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_PutMemTemplate16);
1552     LIBBASE->sd.mid_PutMemTemplate32    = OOP_GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_PutMemTemplate32);
1553     LIBBASE->sd.mid_PutMemPattern8      = OOP_GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_PutMemPattern8);
1554     LIBBASE->sd.mid_PutMemPattern16     = OOP_GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_PutMemPattern16);
1555     LIBBASE->sd.mid_PutMemPattern32     = OOP_GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_PutMemPattern32);
1556     LIBBASE->sd.mid_CopyLUTMemBox16     = OOP_GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_CopyLUTMemBox16);
1557     LIBBASE->sd.mid_CopyLUTMemBox32     = OOP_GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_CopyLUTMemBox32);
1558     LIBBASE->sd.mid_GetImage = OOP_GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_GetImage);
1559
1560     return TRUE;
1561 }
1562
1563 ADD2INITLIB(Init_BMMethodIDs, 0)