1 2 #ifdef HAVE_XORG_CONFIG_H 3 #include <xorg-config.h> 4 #endif 5 6 #include "misc.h" 7 #include "xf86.h" 8 #include "xf86_OSproc.h" 9 10 #include <X11/X.h> 11 #include "scrnintstr.h" 12 #include "pixmapstr.h" 13 #include "windowstr.h" 14 #include "xf86str.h" 15 #include "mi.h" 16 #include "miline.h" 17 #include "xaa.h" 18 #include "xaalocal.h" 19 #include "xaawrap.h" 20 #include "xf86fbman.h" 21 #include "servermd.h" 22 #ifdef COMPOSITE 23 #include "cw.h" 24 #endif 25 26 #define MAX_PREALLOC_MEM 65536 /* MUST be >= 1024 */ 27 28 #define MIN_OFFPIX_SIZE (320*200) 29 30 static Bool XAACloseScreen(int i, ScreenPtr pScreen); 31 static void XAAGetImage(DrawablePtr pDrawable, int sx, int sy, int w, int h, 32 unsigned int format, unsigned long planemask, 33 char *pdstLine); 34 static void XAAGetSpans(DrawablePtr pDrawable, int wMax, DDXPointPtr ppt, 35 int *pwidth, int nspans, char *pdstStart); 36 static PixmapPtr XAACreatePixmap(ScreenPtr pScreen, int w, int h, int depth, 37 unsigned usage_hint); 38 static Bool XAADestroyPixmap(PixmapPtr pPixmap); 39 static Bool XAAEnterVT (int index, int flags); 40 static void XAALeaveVT (int index, int flags); 41 static int XAASetDGAMode(int index, int num, DGADevicePtr devRet); 42 static void XAAEnableDisableFBAccess (int index, Bool enable); 43 static Bool XAAChangeWindowAttributes (WindowPtr pWin, unsigned long mask); 44 45 static DevPrivateKeyRec XAAScreenKeyRec; 46 #define XAAScreenKey (&XAAScreenKeyRec) 47 static DevPrivateKeyRec XAAGCKeyRec; 48 #define XAAGCKey (&XAAGCKeyRec) 49 static DevPrivateKeyRec XAAPixmapKeyRec; 50 #define XAAPixmapKey (&XAAPixmapKeyRec) 51 52 DevPrivateKey XAAGetScreenKey(void) { 53 return XAAScreenKey; 54 } 55 56 DevPrivateKey XAAGetGCKey(void) { 57 return XAAGCKey; 58 } 59 60 DevPrivateKey XAAGetPixmapKey(void) { 61 return XAAPixmapKey; 62 } 63 64 /* temp kludge */ 65 static Bool SwitchedOut = FALSE; 66 67 XAAInfoRecPtr 68 XAACreateInfoRec(void) 69 { 70 XAAInfoRecPtr infoRec; 71 72 infoRec = calloc(1, sizeof(XAAInfoRec)); 73 if(infoRec) 74 infoRec->CachePixelGranularity = -1; 75 76 return infoRec; 77 } 78 79 void 80 XAADestroyInfoRec(XAAInfoRecPtr infoRec) 81 { 82 if(!infoRec) return; 83 84 if(infoRec->ClosePixmapCache) 85 (*infoRec->ClosePixmapCache)(infoRec->pScrn->pScreen); 86 87 free(infoRec->PreAllocMem); 88 89 free(infoRec->PixmapCachePrivate); 90 91 free(infoRec); 92 } 93 94 95 Bool 96 XAAInit(ScreenPtr pScreen, XAAInfoRecPtr infoRec) 97 { 98 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; 99 XAAScreenPtr pScreenPriv; 100 int i; 101 PictureScreenPtr ps = GetPictureScreenIfSet(pScreen); 102 103 /* Return successfully if no acceleration wanted */ 104 if (!infoRec) 105 return TRUE; 106 107 if (!dixRegisterPrivateKey(&XAAGCKeyRec, PRIVATE_GC, sizeof(XAAGCRec))) 108 return FALSE; 109 110 if (!dixRegisterPrivateKey(&XAAPixmapKeyRec, PRIVATE_PIXMAP, sizeof(XAAPixmapRec))) 111 return FALSE; 112 113 if (!dixRegisterPrivateKey(&XAAScreenKeyRec, PRIVATE_SCREEN, 0)) 114 return FALSE; 115 116 if (!(pScreenPriv = malloc(sizeof(XAAScreenRec)))) 117 return FALSE; 118 119 dixSetPrivate(&pScreen->devPrivates, XAAScreenKey, pScreenPriv); 120 121 if(!xf86FBManagerRunning(pScreen)) 122 infoRec->Flags &= ~(PIXMAP_CACHE | OFFSCREEN_PIXMAPS); 123 if(!(infoRec->Flags & LINEAR_FRAMEBUFFER)) 124 infoRec->Flags &= ~OFFSCREEN_PIXMAPS; 125 126 if(!infoRec->FullPlanemask) { /* for backwards compatibility */ 127 infoRec->FullPlanemask = (1 << pScrn->depth) - 1; 128 infoRec->FullPlanemasks[pScrn->depth - 1] = infoRec->FullPlanemask; 129 } 130 131 for(i = 0; i < 32; i++) { 132 if(!infoRec->FullPlanemasks[i]) /* keep any set by caller */ 133 infoRec->FullPlanemasks[i] = (1 << (i+1)) - 1; 134 } 135 136 if(!XAAInitAccel(pScreen, infoRec)) return FALSE; 137 pScreenPriv->AccelInfoRec = infoRec; 138 infoRec->ScratchGC.pScreen = pScreen; 139 140 141 if(!infoRec->GetImage) 142 infoRec->GetImage = XAAGetImage; 143 if(!infoRec->GetSpans) 144 infoRec->GetSpans = XAAGetSpans; 145 if(!infoRec->CopyWindow) 146 infoRec->CopyWindow = XAACopyWindow; 147 148 pScreenPriv->CreateGC = pScreen->CreateGC; 149 pScreen->CreateGC = XAACreateGC; 150 pScreenPriv->CloseScreen = pScreen->CloseScreen; 151 pScreen->CloseScreen = XAACloseScreen; 152 pScreenPriv->GetImage = pScreen->GetImage; 153 pScreen->GetImage = infoRec->GetImage; 154 pScreenPriv->GetSpans = pScreen->GetSpans; 155 pScreen->GetSpans = infoRec->GetSpans; 156 pScreenPriv->CopyWindow = pScreen->CopyWindow; 157 pScreen->CopyWindow = infoRec->CopyWindow; 158 pScreenPriv->CreatePixmap = pScreen->CreatePixmap; 159 pScreen->CreatePixmap = XAACreatePixmap; 160 pScreenPriv->DestroyPixmap = pScreen->DestroyPixmap; 161 pScreen->DestroyPixmap = XAADestroyPixmap; 162 pScreenPriv->ChangeWindowAttributes = pScreen->ChangeWindowAttributes; 163 pScreen->ChangeWindowAttributes = XAAChangeWindowAttributes; 164 165 pScreenPriv->EnterVT = pScrn->EnterVT; 166 pScrn->EnterVT = XAAEnterVT; 167 pScreenPriv->LeaveVT = pScrn->LeaveVT; 168 pScrn->LeaveVT = XAALeaveVT; 169 pScreenPriv->SetDGAMode = pScrn->SetDGAMode; 170 pScrn->SetDGAMode = XAASetDGAMode; 171 pScreenPriv->EnableDisableFBAccess = pScrn->EnableDisableFBAccess; 172 pScrn->EnableDisableFBAccess = XAAEnableDisableFBAccess; 173 174 pScreenPriv->WindowExposures = pScreen->WindowExposures; 175 if (ps) 176 { 177 pScreenPriv->Composite = ps->Composite; 178 ps->Composite = XAAComposite; 179 pScreenPriv->Glyphs = ps->Glyphs; 180 ps->Glyphs = XAAGlyphs; 181 } 182 if(pScrn->overlayFlags & OVERLAY_8_32_PLANAR) 183 XAASetupOverlay8_32Planar(pScreen); 184 185 infoRec->PreAllocMem = malloc(MAX_PREALLOC_MEM); 186 if(infoRec->PreAllocMem) 187 infoRec->PreAllocSize = MAX_PREALLOC_MEM; 188 189 if(infoRec->Flags & PIXMAP_CACHE) 190 xf86RegisterFreeBoxCallback(pScreen, infoRec->InitPixmapCache, 191 (pointer)infoRec); 192 193 if(infoRec->Flags & MICROSOFT_ZERO_LINE_BIAS) 194 miSetZeroLineBias(pScreen, OCTANT1 | OCTANT2 | OCTANT3 | OCTANT4); 195 196 #ifdef COMPOSITE 197 /* Initialize the composite wrapper. This needs to happen after the 198 * wrapping above (so it comes before us), but before all other extensions, 199 * so it doesn't confuse them. (particularly damage). 200 */ 201 miInitializeCompositeWrapper(pScreen); 202 #endif 203 204 return TRUE; 205 } 206 207 208 209 static Bool 210 XAACloseScreen (int i, ScreenPtr pScreen) 211 { 212 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; 213 XAAScreenPtr pScreenPriv = 214 (XAAScreenPtr)dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey); 215 216 pScrn->EnterVT = pScreenPriv->EnterVT; 217 pScrn->LeaveVT = pScreenPriv->LeaveVT; 218 pScrn->EnableDisableFBAccess = pScreenPriv->EnableDisableFBAccess; 219 220 pScreen->CreateGC = pScreenPriv->CreateGC; 221 pScreen->CloseScreen = pScreenPriv->CloseScreen; 222 pScreen->GetImage = pScreenPriv->GetImage; 223 pScreen->GetSpans = pScreenPriv->GetSpans; 224 pScreen->CopyWindow = pScreenPriv->CopyWindow; 225 pScreen->WindowExposures = pScreenPriv->WindowExposures; 226 pScreen->CreatePixmap = pScreenPriv->CreatePixmap; 227 pScreen->DestroyPixmap = pScreenPriv->DestroyPixmap; 228 pScreen->ChangeWindowAttributes = pScreenPriv->ChangeWindowAttributes; 229 230 /* We leave it up to the client to free the XAAInfoRec */ 231 232 free((pointer) pScreenPriv); 233 234 return (*pScreen->CloseScreen) (i, pScreen); 235 } 236 237 static void 238 XAAGetImage ( 239 DrawablePtr pDraw, 240 int sx, int sy, int w, int h, 241 unsigned int format, 242 unsigned long planemask, 243 char *pdstLine 244 ) 245 { 246 ScreenPtr pScreen = pDraw->pScreen; 247 XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen); 248 ScrnInfoPtr pScrn = infoRec->pScrn; 249 250 if(pScrn->vtSema && 251 ((pDraw->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pDraw))) 252 { 253 if(infoRec->ReadPixmap && (format == ZPixmap) && 254 ((planemask & infoRec->FullPlanemasks[pDraw->depth - 1]) == 255 infoRec->FullPlanemasks[pDraw->depth - 1]) && 256 (pDraw->bitsPerPixel == BitsPerPixel(pDraw->depth))) 257 { 258 (*infoRec->ReadPixmap)(pScrn, 259 sx + pDraw->x, sy + pDraw->y, w, h, 260 (unsigned char *)pdstLine, 261 PixmapBytePad(w, pDraw->depth), 262 pDraw->bitsPerPixel, pDraw->depth); 263 return; 264 } 265 SYNC_CHECK(pDraw); 266 } 267 268 XAA_SCREEN_PROLOGUE (pScreen, GetImage); 269 (*pScreen->GetImage) (pDraw, sx, sy, w, h, format, planemask, pdstLine); 270 XAA_SCREEN_EPILOGUE (pScreen, GetImage, XAAGetImage); 271 } 272 273 static void 274 XAAGetSpans ( 275 DrawablePtr pDraw, 276 int wMax, 277 DDXPointPtr ppt, 278 int *pwidth, 279 int nspans, 280 char *pdstStart 281 ) 282 { 283 ScreenPtr pScreen = pDraw->pScreen; 284 XAA_SCREEN_PROLOGUE (pScreen, GetSpans); 285 if(xf86Screens[pScreen->myNum]->vtSema && 286 ((pDraw->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pDraw))) { 287 SYNC_CHECK(pDraw); 288 } 289 (*pScreen->GetSpans) (pDraw, wMax, ppt, pwidth, nspans, pdstStart); 290 XAA_SCREEN_EPILOGUE (pScreen, GetSpans, XAAGetSpans); 291 } 292 293 294 static int 295 XAAPixmapBPP (ScreenPtr pScreen, int depth) 296 { 297 PixmapPtr pPix; 298 int bpp; 299 DestroyPixmapProcPtr destroyPixmap; 300 301 XAA_SCREEN_PROLOGUE (pScreen, CreatePixmap); 302 pPix = (*pScreen->CreatePixmap) (pScreen, 1, 1, depth, 303 CREATE_PIXMAP_USAGE_SCRATCH); 304 XAA_SCREEN_EPILOGUE (pScreen, CreatePixmap, XAACreatePixmap); 305 if (!pPix) 306 return 0; 307 bpp = pPix->drawable.bitsPerPixel; 308 destroyPixmap = pScreen->DestroyPixmap; 309 XAA_SCREEN_PROLOGUE (pScreen, DestroyPixmap); 310 (*pScreen->DestroyPixmap) (pPix); 311 XAA_SCREEN_EPILOGUE (pScreen, DestroyPixmap, destroyPixmap); 312 return bpp; 313 } 314 315 static void 316 XAAInitializeOffscreenDepths (ScreenPtr pScreen) 317 { 318 XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen); 319 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; 320 int d, dep; 321 322 infoRec->offscreenDepthsInitialized = TRUE; 323 infoRec->offscreenDepths = 0; 324 if (infoRec->Flags & OFFSCREEN_PIXMAPS) { 325 for (d = 0; d < pScreen->numDepths; d++) { 326 dep = pScreen->allowedDepths[d].depth; 327 if (XAAPixmapBPP (pScreen, dep) == pScrn->bitsPerPixel) 328 infoRec->offscreenDepths |= (1 << (dep - 1)); 329 } 330 } 331 } 332 333 static PixmapPtr 334 XAACreatePixmap(ScreenPtr pScreen, int w, int h, int depth, unsigned usage_hint) 335 { 336 XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen); 337 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; 338 XAAPixmapPtr pPriv; 339 PixmapPtr pPix = NULL; 340 int size = w * h; 341 342 if (w > 32767 || h > 32767) 343 return NullPixmap; 344 345 if (!infoRec->offscreenDepthsInitialized) 346 XAAInitializeOffscreenDepths (pScreen); 347 348 if(pScrn->vtSema && 349 (usage_hint != CREATE_PIXMAP_USAGE_GLYPH_PICTURE) && 350 (infoRec->offscreenDepths & (1 << (depth - 1))) && 351 (size >= MIN_OFFPIX_SIZE) && !SwitchedOut && 352 (!infoRec->maxOffPixWidth || (w <= infoRec->maxOffPixWidth)) && 353 (!infoRec->maxOffPixHeight || (h <= infoRec->maxOffPixHeight)) ) 354 { 355 PixmapLinkPtr pLink; 356 PixmapPtr pScreenPix; 357 FBAreaPtr area; 358 int gran = 0; 359 360 switch(pScrn->bitsPerPixel) { 361 case 24: 362 case 8: gran = 4; break; 363 case 16: gran = 2; break; 364 case 32: gran = 1; break; 365 default: break; 366 } 367 368 if(BITMAP_SCANLINE_PAD == 64) 369 gran *= 2; 370 371 if(!(area = xf86AllocateOffscreenArea(pScreen, w, h, gran, 0, 372 XAARemoveAreaCallback, NULL))) { 373 goto BAILOUT; 374 } 375 376 if(!(pLink = malloc(sizeof(PixmapLink)))) { 377 xf86FreeOffscreenArea(area); 378 goto BAILOUT; 379 } 380 381 XAA_SCREEN_PROLOGUE (pScreen, CreatePixmap); 382 pPix = (*pScreen->CreatePixmap) (pScreen, 0, 0, depth, usage_hint); 383 XAA_SCREEN_EPILOGUE (pScreen, CreatePixmap, XAACreatePixmap); 384 385 if (!pPix) { 386 free(pLink); 387 xf86FreeOffscreenArea(area); 388 goto BAILOUT; 389 } 390 391 pScreenPix = (*pScreen->GetScreenPixmap)(pScreen); 392 393 pPriv = XAA_GET_PIXMAP_PRIVATE(pPix); 394 pPix->drawable.x = area->box.x1; 395 pPix->drawable.y = area->box.y1; 396 pPix->drawable.width = w; 397 pPix->drawable.height = h; 398 pPix->drawable.bitsPerPixel = pScrn->bitsPerPixel; 399 pPix->devKind = pScreenPix->devKind; 400 pPix->devPrivate.ptr = pScreenPix->devPrivate.ptr; 401 area->devPrivate.ptr = pPix; 402 403 pPriv->flags = OFFSCREEN; 404 pPriv->offscreenArea = area; 405 pPriv->freeData = FALSE; 406 407 pLink->next = infoRec->OffscreenPixmaps; 408 pLink->pPix = pPix; 409 infoRec->OffscreenPixmaps = pLink; 410 return pPix; 411 } 412 BAILOUT: 413 XAA_SCREEN_PROLOGUE (pScreen, CreatePixmap); 414 pPix = (*pScreen->CreatePixmap) (pScreen, w, h, depth, usage_hint); 415 XAA_SCREEN_EPILOGUE (pScreen, CreatePixmap, XAACreatePixmap); 416 417 if(pPix) { 418 pPriv = XAA_GET_PIXMAP_PRIVATE(pPix); 419 pPriv->flags = 0; 420 pPriv->offscreenArea = NULL; 421 pPriv->freeData = FALSE; 422 if(!w || !h) /* either scratch or shared memory */ 423 pPriv->flags |= SHARED_PIXMAP; 424 } 425 426 return pPix; 427 } 428 429 static Bool 430 XAADestroyPixmap(PixmapPtr pPix) 431 { 432 ScreenPtr pScreen = pPix->drawable.pScreen; 433 XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen); 434 XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPix); 435 Bool ret; 436 437 if(pPix->refcnt == 1) { 438 if(pPriv->flags & OFFSCREEN) { 439 if(pPriv->flags & DGA_PIXMAP) 440 free(pPriv->offscreenArea); 441 else { 442 FBAreaPtr area = pPriv->offscreenArea; 443 PixmapLinkPtr pLink = infoRec->OffscreenPixmaps; 444 PixmapLinkPtr prev = NULL; 445 446 while(pLink->pPix != pPix) { 447 prev = pLink; 448 pLink = pLink->next; 449 } 450 451 if(prev) prev->next = pLink->next; 452 else infoRec->OffscreenPixmaps = pLink->next; 453 454 if(!area) area = pLink->area; 455 456 xf86FreeOffscreenArea(area); 457 pPriv->offscreenArea = NULL; 458 free(pLink); 459 } 460 } 461 462 if(pPriv->freeData) { /* pixmaps that were once in video ram */ 463 free(pPix->devPrivate.ptr); 464 pPix->devPrivate.ptr = NULL; 465 } 466 } 467 468 XAA_SCREEN_PROLOGUE (pScreen, DestroyPixmap); 469 ret = (*pScreen->DestroyPixmap) (pPix); 470 XAA_SCREEN_EPILOGUE (pScreen, DestroyPixmap, XAADestroyPixmap); 471 472 return ret; 473 } 474 475 static Bool 476 XAAChangeWindowAttributes (WindowPtr pWin, unsigned long mask) 477 { 478 ScreenPtr pScreen = pWin->drawable.pScreen; 479 Bool ret; 480 481 XAA_SCREEN_PROLOGUE (pScreen, ChangeWindowAttributes); 482 ret = (*pScreen->ChangeWindowAttributes) (pWin, mask); 483 XAA_SCREEN_EPILOGUE (pScreen, ChangeWindowAttributes, XAAChangeWindowAttributes); 484 485 /* we have to assume that shared memory pixmaps are dirty 486 because we can't wrap operations on them */ 487 488 if((mask & CWBackPixmap) && (pWin->backgroundState == BackgroundPixmap) && 489 PIXMAP_IS_SHARED(pWin->background.pixmap)) 490 { 491 XAAPixmapPtr pPixPriv = XAA_GET_PIXMAP_PRIVATE(pWin->background.pixmap); 492 pPixPriv->flags |= DIRTY; 493 } 494 if((mask & CWBorderPixmap) && !(pWin->borderIsPixel) && 495 PIXMAP_IS_SHARED(pWin->border.pixmap)) 496 { 497 XAAPixmapPtr pPixPriv = XAA_GET_PIXMAP_PRIVATE(pWin->border.pixmap); 498 pPixPriv->flags |= DIRTY; 499 } 500 501 return ret; 502 } 503 504 505 506 /* These two aren't really needed for anything */ 507 508 static Bool 509 XAAEnterVT(int index, int flags) 510 { 511 ScrnInfoPtr pScrn = xf86Screens[index]; 512 Bool ret; 513 ScreenPtr pScreen = screenInfo.screens[index]; 514 XAAScreenPtr pScreenPriv = 515 (XAAScreenPtr)dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey); 516 517 pScrn->EnterVT = pScreenPriv->EnterVT; 518 ret = ((*pScreenPriv->EnterVT)(index, flags)); 519 pScreenPriv->EnterVT = pScrn->EnterVT; 520 pScrn->EnterVT = XAAEnterVT; 521 return ret; 522 } 523 524 static void 525 XAALeaveVT(int index, int flags) 526 { 527 ScrnInfoPtr pScrn = xf86Screens[index]; 528 ScreenPtr pScreen = screenInfo.screens[index]; 529 XAAScreenPtr pScreenPriv = 530 (XAAScreenPtr)dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey); 531 XAAInfoRecPtr infoRec = pScreenPriv->AccelInfoRec; 532 533 if(infoRec->NeedToSync) { 534 (*infoRec->Sync)(infoRec->pScrn); 535 infoRec->NeedToSync = FALSE; 536 } 537 538 pScrn->LeaveVT = pScreenPriv->LeaveVT; 539 (*pScreenPriv->LeaveVT)(index, flags); 540 pScreenPriv->LeaveVT = pScrn->LeaveVT; 541 pScrn->LeaveVT = XAALeaveVT; 542 } 543 544 typedef struct { 545 Bool UsingPixmapCache; 546 Bool CanDoColor8x8; 547 Bool CanDoMono8x8; 548 } SavedCacheState, *SavedCacheStatePtr; 549 550 static int 551 XAASetDGAMode(int index, int num, DGADevicePtr devRet) 552 { 553 ScreenPtr pScreen = screenInfo.screens[index]; 554 XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen); 555 XAAScreenPtr pScreenPriv = 556 (XAAScreenPtr)dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey); 557 int ret; 558 559 if (!num && infoRec->dgaSaves) { /* restore old pixmap cache state */ 560 SavedCacheStatePtr state = (SavedCacheStatePtr)infoRec->dgaSaves; 561 562 infoRec->UsingPixmapCache = state->UsingPixmapCache; 563 infoRec->CanDoColor8x8 = state->CanDoColor8x8; 564 infoRec->CanDoMono8x8 = state->CanDoMono8x8; 565 free(infoRec->dgaSaves); 566 infoRec->dgaSaves = NULL; 567 } 568 569 ret = (*pScreenPriv->SetDGAMode)(index, num, devRet); 570 if(ret != Success) return ret; 571 572 if(num && devRet->pPix) { /* accelerate this pixmap */ 573 XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(devRet->pPix); 574 FBAreaPtr area; 575 576 if((area = malloc(sizeof(FBArea)))) { 577 area->pScreen = pScreen; 578 area->box.x1 = 0; 579 area->box.x2 = 0; 580 area->box.y1 = devRet->mode->pixmapWidth; 581 area->box.y2 = devRet->mode->pixmapHeight; 582 area->granularity = 0; 583 area->MoveAreaCallback = 0; 584 area->RemoveAreaCallback = 0; 585 area->devPrivate.ptr = 0; 586 587 pixPriv->flags |= OFFSCREEN | DGA_PIXMAP; 588 pixPriv->offscreenArea = area; 589 590 if(!infoRec->dgaSaves) { /* save pixmap cache state */ 591 SavedCacheStatePtr state = malloc(sizeof(SavedCacheState)); 592 593 state->UsingPixmapCache = infoRec->UsingPixmapCache; 594 state->CanDoColor8x8 = infoRec->CanDoColor8x8; 595 state->CanDoMono8x8 = infoRec->CanDoMono8x8; 596 infoRec->dgaSaves = (char*)state; 597 598 infoRec->UsingPixmapCache = FALSE; 599 if(infoRec->PixmapCacheFlags & CACHE_MONO_8x8) 600 infoRec->CanDoMono8x8 = FALSE; 601 if(infoRec->PixmapCacheFlags & CACHE_COLOR_8x8) 602 infoRec->CanDoColor8x8 = FALSE; 603 } 604 } 605 } 606 607 return ret; 608 } 609 610 611 612 static void 613 XAAEnableDisableFBAccess (int index, Bool enable) 614 { 615 ScreenPtr pScreen = screenInfo.screens[index]; 616 XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen); 617 XAAScreenPtr pScreenPriv = 618 (XAAScreenPtr)dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey); 619 620 if(!enable) { 621 if((infoRec->Flags & OFFSCREEN_PIXMAPS) && (infoRec->OffscreenPixmaps)) 622 XAAMoveOutOffscreenPixmaps(pScreen); 623 if(infoRec->Flags & PIXMAP_CACHE) 624 XAAInvalidatePixmapCache(pScreen); 625 SwitchedOut = TRUE; 626 } 627 628 (*pScreenPriv->EnableDisableFBAccess)(index, enable); 629 630 if(enable) { 631 if((infoRec->Flags & OFFSCREEN_PIXMAPS) && (infoRec->OffscreenPixmaps)) 632 XAAMoveInOffscreenPixmaps(pScreen); 633 SwitchedOut = FALSE; 634 } 635 } 636
Indexes created Fri Jul 03 00:25:33 UTC 2026