diff options
Diffstat (limited to 'hw/xfree86/xaa/xaaPCache.c')
| -rw-r--r-- | hw/xfree86/xaa/xaaPCache.c | 4123 |
1 files changed, 2138 insertions, 1985 deletions
diff --git a/hw/xfree86/xaa/xaaPCache.c b/hw/xfree86/xaa/xaaPCache.c index 86ac1cd14..02c0cd498 100644 --- a/hw/xfree86/xaa/xaaPCache.c +++ b/hw/xfree86/xaa/xaaPCache.c @@ -31,118 +31,113 @@ #define MAX_512 16 static int CacheInitIndex = -1; + #define CACHEINIT(p) ((p)->privates[CacheInitIndex].val) - typedef struct _CacheLink { - int x; - int y; - int w; - int h; - struct _CacheLink *next; + int x; + int y; + int w; + int h; + struct _CacheLink *next; } CacheLink, *CacheLinkPtr; - static void TransferList(CacheLinkPtr list, XAACacheInfoPtr array, int num) { - while(num--) { - array->x = list->x; - array->y = list->y; - array->w = list->w; - array->h = list->h; - array->serialNumber = 0; - array->fg = array->bg = -1; - list = list->next; - array++; - } + while (num--) { + array->x = list->x; + array->y = list->y; + array->w = list->w; + array->h = list->h; + array->serialNumber = 0; + array->fg = array->bg = -1; + list = list->next; + array++; + } } - - -static CacheLinkPtr +static CacheLinkPtr Enlist(CacheLinkPtr link, int x, int y, int w, int h) { CacheLinkPtr newLink; newLink = malloc(sizeof(CacheLink)); newLink->next = link; - newLink->x = x; newLink->y = y; - newLink->w = w; newLink->h = h; + newLink->x = x; + newLink->y = y; + newLink->w = w; + newLink->h = h; return newLink; } - - static CacheLinkPtr -Delist(CacheLinkPtr link) { +Delist(CacheLinkPtr link) +{ CacheLinkPtr ret = NULL; - if(link) { - ret = link->next; - free(link); - } + if (link) { + ret = link->next; + free(link); + } return ret; } - - static void -FreeList(CacheLinkPtr link) { +FreeList(CacheLinkPtr link) +{ CacheLinkPtr tmp; - while(link) { - tmp = link; - link = link->next; - free(tmp); + while (link) { + tmp = link; + link = link->next; + free(tmp); } } - - static CacheLinkPtr -QuadLinks(CacheLinkPtr big, CacheLinkPtr little) +QuadLinks(CacheLinkPtr big, CacheLinkPtr little) { /* CAUTION: This doesn't free big */ int w1, w2, h1, h2; - while(big) { - w1 = big->w >> 1; - w2 = big->w - w1; - h1 = big->h >> 1; - h2 = big->h - h1; + while (big) { + w1 = big->w >> 1; + w2 = big->w - w1; + h1 = big->h >> 1; + h2 = big->h - h1; - little = Enlist(little, big->x, big->y, w1, h1); - little = Enlist(little, big->x + w1, big->y, w2, h1); - little = Enlist(little, big->x, big->y + h1, w1, h2); - little = Enlist(little, big->x + w1, big->y + h1, w2, h2); + little = Enlist(little, big->x, big->y, w1, h1); + little = Enlist(little, big->x + w1, big->y, w2, h1); + little = Enlist(little, big->x, big->y + h1, w1, h2); + little = Enlist(little, big->x + w1, big->y + h1, w2, h2); - big = big->next; - } + big = big->next; + } return little; } - static void -SubdivideList(CacheLinkPtr *large, CacheLinkPtr *small) +SubdivideList(CacheLinkPtr * large, CacheLinkPtr * small) { - CacheLinkPtr big = *large; - CacheLinkPtr little = *small; - int size = big->w >> 1; - - little = Enlist(little, big->x, big->y, size, size); - little = Enlist(little, big->x + size, big->y, size, size); - little = Enlist(little, big->x, big->y + size, size, size); - little = Enlist(little, big->x + size, big->y + size, size, size); - *small = little; - big = Delist(big); - *large = big; + CacheLinkPtr big = *large; + CacheLinkPtr little = *small; + int size = big->w >> 1; + + little = Enlist(little, big->x, big->y, size, size); + little = Enlist(little, big->x + size, big->y, size, size); + little = Enlist(little, big->x, big->y + size, size, size); + little = Enlist(little, big->x + size, big->y + size, size, size); + *small = little; + big = Delist(big); + *large = big; } static void FreePixmapCachePrivate(XAAPixmapCachePrivatePtr pPriv) { - if(!pPriv) return; + if (!pPriv) + return; free(pPriv->Info512); free(pPriv->Info256); @@ -150,605 +145,638 @@ FreePixmapCachePrivate(XAAPixmapCachePrivatePtr pPriv) free(pPriv->InfoColor); free(pPriv->InfoMono); free(pPriv->InfoPartial); - + free(pPriv); } void XAAClosePixmapCache(ScreenPtr pScreen) { - XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen); - - if(infoRec->PixmapCachePrivate) - FreePixmapCachePrivate( - (XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate); - - infoRec->PixmapCachePrivate = NULL; -} + XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen); + if (infoRec->PixmapCachePrivate) + FreePixmapCachePrivate((XAAPixmapCachePrivatePtr) infoRec-> + PixmapCachePrivate); + infoRec->PixmapCachePrivate = NULL; +} static CacheLinkPtr -ThinOutPartials( - CacheLinkPtr ListPartial, - int *num, int *maxw, int *maxh -) { +ThinOutPartials(CacheLinkPtr ListPartial, int *num, int *maxw, int *maxh) +{ /* This guy's job is to get at least 4 big slots out of a list of fragments */ - CacheLinkPtr List64, List32, List16, List8, pCur, next, ListKeepers; - int Num64, Num32, Num16, Num8, NumKeepers; - int w, h; - - List64 = List32 = List16 = List8 = ListKeepers = NULL; - Num64 = Num32 = Num16 = Num8 = NumKeepers = 0; - w = h = 0; - - /* We sort partials by how large a square tile they can cache. - If a partial can't store a 64x64, 32x32, 16x16 or 8x8 tile, - we free it. */ - - pCur = ListPartial; - while(pCur) { - next = pCur->next; - if((pCur->w >= 64) && (pCur->h >= 64)) { - pCur->next = List64; List64 = pCur; - Num64++; - } else - if((pCur->w >= 32) && (pCur->h >= 32)) { - pCur->next = List32; List32 = pCur; - Num32++; - } else - if((pCur->w >= 16) && (pCur->h >= 16)) { - pCur->next = List16; List16 = pCur; - Num16++; - } else - if((pCur->w >= 8) && (pCur->h >= 8)) { - pCur->next = List8; List8 = pCur; - Num8++; - } else { - free(pCur); - } - - pCur = next; - } - - /* We save all the tiles from the largest bin that we can get - at least 4 of. If there are too few of a bigger slot, we - cut it in fourths to make smaller slots. */ - - if(Num64 >= 4) { - ListKeepers = List64; List64 = NULL; - NumKeepers = Num64; - goto GOT_EM; - } else if(Num64) { - List32 = QuadLinks(List64, List32); - Num32 += Num64 * 4; - Num64 = 0; - } - - if(Num32 >= 4) { - ListKeepers = List32; List32 = NULL; - NumKeepers = Num32; - goto GOT_EM; - } else if(Num32) { - List16 = QuadLinks(List32, List16); - Num16 += Num32 * 4; - Num32 = 0; - } - - if(Num16 >= 4) { - ListKeepers = List16; List16 = NULL; - NumKeepers = Num16; - goto GOT_EM; - } else if(Num16) { - List8 = QuadLinks(List16, List8); - Num8 += Num16 * 4; - Num16 = 0; - } - - if(Num8 >= 4) { - ListKeepers = List8; List8 = NULL; - NumKeepers = Num8; - goto GOT_EM; - } - -GOT_EM: - - /* Free the ones we aren't using */ - - if(List64) FreeList(List64); - if(List32) FreeList(List32); - if(List16) FreeList(List16); - if(List8) FreeList(List8); - - - /* Enlarge the slots if we can */ - - if(ListKeepers) { - CacheLinkPtr pLink = ListKeepers; - w = h = 128; - - while(pLink) { - if(pLink->w < w) w = pLink->w; - if(pLink->h < h) h = pLink->h; - pLink = pLink->next; - } - } - - *maxw = w; - *maxh = h; - *num = NumKeepers; - return ListKeepers; + CacheLinkPtr List64, List32, List16, List8, pCur, next, ListKeepers; + int Num64, Num32, Num16, Num8, NumKeepers; + int w, h; + + List64 = List32 = List16 = List8 = ListKeepers = NULL; + Num64 = Num32 = Num16 = Num8 = NumKeepers = 0; + w = h = 0; + + /* We sort partials by how large a square tile they can cache. + If a partial can't store a 64x64, 32x32, 16x16 or 8x8 tile, + we free it. */ + + pCur = ListPartial; + while (pCur) { + next = pCur->next; + if ((pCur->w >= 64) && (pCur->h >= 64)) { + pCur->next = List64; + List64 = pCur; + Num64++; + } + else if ((pCur->w >= 32) && (pCur->h >= 32)) { + pCur->next = List32; + List32 = pCur; + Num32++; + } + else if ((pCur->w >= 16) && (pCur->h >= 16)) { + pCur->next = List16; + List16 = pCur; + Num16++; + } + else if ((pCur->w >= 8) && (pCur->h >= 8)) { + pCur->next = List8; + List8 = pCur; + Num8++; + } + else { + free(pCur); + } + + pCur = next; + } + + /* We save all the tiles from the largest bin that we can get + at least 4 of. If there are too few of a bigger slot, we + cut it in fourths to make smaller slots. */ + + if (Num64 >= 4) { + ListKeepers = List64; + List64 = NULL; + NumKeepers = Num64; + goto GOT_EM; + } + else if (Num64) { + List32 = QuadLinks(List64, List32); + Num32 += Num64 * 4; + Num64 = 0; + } + + if (Num32 >= 4) { + ListKeepers = List32; + List32 = NULL; + NumKeepers = Num32; + goto GOT_EM; + } + else if (Num32) { + List16 = QuadLinks(List32, List16); + Num16 += Num32 * 4; + Num32 = 0; + } + + if (Num16 >= 4) { + ListKeepers = List16; + List16 = NULL; + NumKeepers = Num16; + goto GOT_EM; + } + else if (Num16) { + List8 = QuadLinks(List16, List8); + Num8 += Num16 * 4; + Num16 = 0; + } + + if (Num8 >= 4) { + ListKeepers = List8; + List8 = NULL; + NumKeepers = Num8; + goto GOT_EM; + } + + GOT_EM: + + /* Free the ones we aren't using */ + + if (List64) + FreeList(List64); + if (List32) + FreeList(List32); + if (List16) + FreeList(List16); + if (List8) + FreeList(List8); + + /* Enlarge the slots if we can */ + + if (ListKeepers) { + CacheLinkPtr pLink = ListKeepers; + + w = h = 128; + + while (pLink) { + if (pLink->w < w) + w = pLink->w; + if (pLink->h < h) + h = pLink->h; + pLink = pLink->next; + } + } + + *maxw = w; + *maxh = h; + *num = NumKeepers; + return ListKeepers; } static void -ConvertColorToMono( - CacheLinkPtr *ColorList, - int ColorW, int ColorH, - CacheLinkPtr *MonoList, - int MonoW, int MonoH -){ - int x, y, w; - - x = (*ColorList)->x; y = (*ColorList)->y; - *ColorList = Delist(*ColorList); - - while(ColorH) { - ColorH -= MonoH; - for(w = 0; w <= (ColorW - MonoW); w += MonoW) - *MonoList = Enlist(*MonoList, x + w, y + ColorH, MonoW, MonoH); - } +ConvertColorToMono(CacheLinkPtr * ColorList, + int ColorW, int ColorH, + CacheLinkPtr * MonoList, int MonoW, int MonoH) +{ + int x, y, w; + + x = (*ColorList)->x; + y = (*ColorList)->y; + *ColorList = Delist(*ColorList); + + while (ColorH) { + ColorH -= MonoH; + for (w = 0; w <= (ColorW - MonoW); w += MonoW) + *MonoList = Enlist(*MonoList, x + w, y + ColorH, MonoW, MonoH); + } } static void -ConvertAllPartialsTo8x8( - int *NumMono, int *NumColor, - CacheLinkPtr ListPartial, - CacheLinkPtr *ListMono, - CacheLinkPtr *ListColor, - XAAInfoRecPtr infoRec -){ +ConvertAllPartialsTo8x8(int *NumMono, int *NumColor, + CacheLinkPtr ListPartial, + CacheLinkPtr * ListMono, + CacheLinkPtr * ListColor, XAAInfoRecPtr infoRec) +{ /* This guy extracts as many 8x8 slots as it can out of fragments */ - int ColorH = infoRec->CacheHeightColor8x8Pattern; - int ColorW = infoRec->CacheWidthColor8x8Pattern; - int MonoH = infoRec->CacheHeightMono8x8Pattern; - int MonoW = infoRec->CacheWidthMono8x8Pattern; - int x, y, w, Height, Width; - Bool DoColor = (infoRec->PixmapCacheFlags & CACHE_COLOR_8x8); - Bool DoMono = (infoRec->PixmapCacheFlags & CACHE_MONO_8x8); - CacheLinkPtr pLink = ListPartial; - CacheLinkPtr MonoList = *ListMono, ColorList = *ListColor; - - if(DoColor && DoMono) { - /* we assume color patterns take more space than color ones */ - if(MonoH > ColorH) ColorH = MonoH; - if(MonoW > ColorW) ColorW = MonoW; - } - - /* Break up the area into as many Color and Mono slots as we can */ - - while(pLink) { - Height = pLink->h; - Width = pLink->w; - x = pLink->x; - y = pLink->y; - - if(DoColor) { - while(Height >= ColorH) { - Height -= ColorH; - for(w = 0; w <= (Width - ColorW); w += ColorW) { - ColorList = Enlist( - ColorList, x + w, y + Height, ColorW, ColorH); - (*NumColor)++; - } - } - } - - if(DoMono && (Height >= MonoH)) { - while(Height >= MonoH) { - Height -= MonoH; - for(w = 0; w <= (Width - MonoW); w += MonoW) { - MonoList = Enlist( - MonoList, x + w, y + Height, MonoW, MonoH); - (*NumMono)++; - } - } - } - - pLink = pLink->next; - } - - - *ListMono = MonoList; - *ListColor = ColorList; - FreeList(ListPartial); -} + int ColorH = infoRec->CacheHeightColor8x8Pattern; + int ColorW = infoRec->CacheWidthColor8x8Pattern; + int MonoH = infoRec->CacheHeightMono8x8Pattern; + int MonoW = infoRec->CacheWidthMono8x8Pattern; + int x, y, w, Height, Width; + Bool DoColor = (infoRec->PixmapCacheFlags & CACHE_COLOR_8x8); + Bool DoMono = (infoRec->PixmapCacheFlags & CACHE_MONO_8x8); + CacheLinkPtr pLink = ListPartial; + CacheLinkPtr MonoList = *ListMono, ColorList = *ListColor; + + if (DoColor && DoMono) { + /* we assume color patterns take more space than color ones */ + if (MonoH > ColorH) + ColorH = MonoH; + if (MonoW > ColorW) + ColorW = MonoW; + } + + /* Break up the area into as many Color and Mono slots as we can */ + + while (pLink) { + Height = pLink->h; + Width = pLink->w; + x = pLink->x; + y = pLink->y; + + if (DoColor) { + while (Height >= ColorH) { + Height -= ColorH; + for (w = 0; w <= (Width - ColorW); w += ColorW) { + ColorList = + Enlist(ColorList, x + w, y + Height, ColorW, ColorH); + (*NumColor)++; + } + } + } + if (DoMono && (Height >= MonoH)) { + while (Height >= MonoH) { + Height -= MonoH; + for (w = 0; w <= (Width - MonoW); w += MonoW) { + MonoList = + Enlist(MonoList, x + w, y + Height, MonoW, MonoH); + (*NumMono)++; + } + } + } + + pLink = pLink->next; + } + + *ListMono = MonoList; + *ListColor = ColorList; + FreeList(ListPartial); +} static CacheLinkPtr -ExtractOneThatFits(CacheLinkPtr *initList, int w, int h) +ExtractOneThatFits(CacheLinkPtr * initList, int w, int h) { - CacheLinkPtr list = *initList; - CacheLinkPtr prev = NULL; - - while(list) { - if((list->w >= w) && (list->h >= h)) - break; - prev = list; - list = list->next; - } - - if(list) { - if(prev) - prev->next = list->next; - else - *initList = list->next; - - list->next = NULL; - } - - return list; -} + CacheLinkPtr list = *initList; + CacheLinkPtr prev = NULL; + + while (list) { + if ((list->w >= w) && (list->h >= h)) + break; + prev = list; + list = list->next; + } + + if (list) { + if (prev) + prev->next = list->next; + else + *initList = list->next; + list->next = NULL; + } + + return list; +} static CacheLinkPtr -ConvertSomePartialsTo8x8( - int *NumMono, int *NumColor, int *NumPartial, - CacheLinkPtr ListPartial, - CacheLinkPtr *ListMono, - CacheLinkPtr *ListColor, - int *maxw, int *maxh, - XAAInfoRecPtr infoRec -){ +ConvertSomePartialsTo8x8(int *NumMono, int *NumColor, int *NumPartial, + CacheLinkPtr ListPartial, + CacheLinkPtr * ListMono, + CacheLinkPtr * ListColor, + int *maxw, int *maxh, XAAInfoRecPtr infoRec) +{ /* This guy tries to get 4 of each type of 8x8 slot requested out of a list of fragments all while trying to retain some big fragments for the cache blits */ - int ColorH = infoRec->CacheHeightColor8x8Pattern; - int ColorW = infoRec->CacheWidthColor8x8Pattern; - int MonoH = infoRec->CacheHeightMono8x8Pattern; - int MonoW = infoRec->CacheWidthMono8x8Pattern; - Bool DoColor = (infoRec->PixmapCacheFlags & CACHE_COLOR_8x8); - Bool DoMono = (infoRec->PixmapCacheFlags & CACHE_MONO_8x8); - CacheLinkPtr List64, List32, List16, List8, pCur, next, ListKeepers; - CacheLinkPtr MonoList = *ListMono, ColorList = *ListColor; - int Num64, Num32, Num16, Num8, NumKeepers; - int w, h, Width, Height; - int MonosPerColor = 1; - - if(DoColor && DoMono) { - /* we assume color patterns take more space than color ones */ - if(MonoH > ColorH) ColorH = MonoH; - if(MonoW > ColorW) ColorW = MonoW; - MonosPerColor = (ColorH/MonoH) * (ColorW/MonoW); - } - - List64 = List32 = List16 = List8 = ListKeepers = MonoList = ColorList = NULL; - Num64 = Num32 = Num16 = Num8 = NumKeepers = 0; - Width = Height = 0; - - /* We sort partials by how large a square tile they can cache. - We make 8x8 patterns from the leftovers if we can. */ - - pCur = ListPartial; - while(pCur) { - next = pCur->next; - if((pCur->w >= 64) && (pCur->h >= 64)) { - pCur->next = List64; List64 = pCur; - Num64++; - } else - if((pCur->w >= 32) && (pCur->h >= 32)) { - pCur->next = List32; List32 = pCur; - Num32++; - } else - if((pCur->w >= 16) && (pCur->h >= 16)) { - pCur->next = List16; List16 = pCur; - Num16++; - } else - if((pCur->w >= 8) && (pCur->h >= 8)) { - pCur->next = List8; List8 = pCur; - Num8++; - } else { - h = pCur->h; - if(DoColor && (pCur->w >= ColorW) && (h >= ColorH)) { - while(h >= ColorH) { - h -= ColorH; - for(w = 0; w <= (pCur->w - ColorW); w += ColorW) { - ColorList = Enlist( ColorList, - pCur->x + w, pCur->y + h, ColorW, ColorH); - (*NumColor)++; - } - } - } - if(DoMono && (pCur->w >= MonoW) && (h >= MonoH)) { - while(h >= MonoH) { - h -= MonoH; - for(w = 0; w <= (pCur->w - MonoW); w += MonoW) { - MonoList = Enlist( MonoList, - pCur->x + w, pCur->y + h, MonoW, MonoH); - (*NumMono)++; - } - } - } - free(pCur); - } - - pCur = next; - } - - /* Try to extract at least 4 of each type of 8x8 slot that we need */ - - if(DoColor) { - CacheLinkPtr theOne; - while(*NumColor < 4) { - theOne = NULL; - if(Num8) { - if((theOne = ExtractOneThatFits(&List8, ColorW, ColorH))) - Num8--; - } - if(Num16 && !theOne) { - if((theOne = ExtractOneThatFits(&List16, ColorW, ColorH))) - Num16--; - } - if(Num32 && !theOne) { - if((theOne = ExtractOneThatFits(&List32, ColorW, ColorH))) - Num32--; - } - if(Num64 && !theOne) { - if((theOne = ExtractOneThatFits(&List64, ColorW, ColorH))) - Num64--; - } - - if(!theOne) break; - - - ConvertAllPartialsTo8x8(NumMono, NumColor, theOne, - &MonoList, &ColorList, infoRec); - - if(DoMono) { - while(*NumColor && (*NumMono < 4)) { - ConvertColorToMono(&ColorList, ColorW, ColorH, - &MonoList, MonoW, MonoH); - (*NumColor)--; *NumMono += MonosPerColor; - } - } - } - } - - if(DoMono) { - CacheLinkPtr theOne; - while(*NumMono < 4) { - theOne = NULL; - if(Num8) { - if((theOne = ExtractOneThatFits(&List8, MonoW, MonoH))) - Num8--; - } - if(Num16 && !theOne) { - if((theOne = ExtractOneThatFits(&List16, MonoW, MonoH))) - Num16--; - } - if(Num32 && !theOne) { - if((theOne = ExtractOneThatFits(&List32, MonoW, MonoH))) - Num32--; - } - if(Num64 && !theOne) { - if((theOne = ExtractOneThatFits(&List64, MonoW, MonoH))) - Num64--; - } - - if(!theOne) break; - - ConvertAllPartialsTo8x8(NumMono, NumColor, theOne, - &MonoList, &ColorList, infoRec); - } - } - - /* We save all the tiles from the largest bin that we can get - at least 4 of. If there are too few of a bigger slot, we - cut it in fourths to make smaller slots. */ - - if(Num64 >= 4) { - ListKeepers = List64; List64 = NULL; - NumKeepers = Num64; - goto GOT_EM; - } else if(Num64) { - List32 = QuadLinks(List64, List32); - Num32 += Num64 * 4; - Num64 = 0; - } - - if(Num32 >= 4) { - ListKeepers = List32; List32 = NULL; - NumKeepers = Num32; - goto GOT_EM; - } else if(Num32) { - List16 = QuadLinks(List32, List16); - Num16 += Num32 * 4; - Num32 = 0; - } - - if(Num16 >= 4) { - ListKeepers = List16; List16 = NULL; - NumKeepers = Num16; - goto GOT_EM; - } else if(Num16) { - List8 = QuadLinks(List16, List8); - Num8 += Num16 * 4; - Num16 = 0; - } - - if(Num8 >= 4) { - ListKeepers = List8; List8 = NULL; - NumKeepers = Num8; - goto GOT_EM; - } - -GOT_EM: - - /* Free the ones we aren't using */ - - if(List64) - ConvertAllPartialsTo8x8(NumMono, NumColor, List64, - &MonoList, &ColorList, infoRec); - if(List32) - ConvertAllPartialsTo8x8(NumMono, NumColor, List32, - &MonoList, &ColorList, infoRec); - if(List16) - ConvertAllPartialsTo8x8(NumMono, NumColor, List16, - &MonoList, &ColorList, infoRec); - if(List8) - ConvertAllPartialsTo8x8(NumMono, NumColor, List8, - &MonoList, &ColorList, infoRec); - - - /* Enlarge the slots if we can */ - - if(ListKeepers) { - CacheLinkPtr pLink = ListKeepers; - Width = Height = 128; - - while(pLink) { - if(pLink->w < Width) Width = pLink->w; - if(pLink->h < Height) Height = pLink->h; - pLink = pLink->next; - } - } - - *ListMono = MonoList; - *ListColor = ColorList; - *maxw = Width; - *maxh = Height; - *NumPartial = NumKeepers; - return ListKeepers; -} + int ColorH = infoRec->CacheHeightColor8x8Pattern; + int ColorW = infoRec->CacheWidthColor8x8Pattern; + int MonoH = infoRec->CacheHeightMono8x8Pattern; + int MonoW = infoRec->CacheWidthMono8x8Pattern; + Bool DoColor = (infoRec->PixmapCacheFlags & CACHE_COLOR_8x8); + Bool DoMono = (infoRec->PixmapCacheFlags & CACHE_MONO_8x8); + CacheLinkPtr List64, List32, List16, List8, pCur, next, ListKeepers; + CacheLinkPtr MonoList = *ListMono, ColorList = *ListColor; + int Num64, Num32, Num16, Num8, NumKeepers; + int w, h, Width, Height; + int MonosPerColor = 1; + + if (DoColor && DoMono) { + /* we assume color patterns take more space than color ones */ + if (MonoH > ColorH) + ColorH = MonoH; + if (MonoW > ColorW) + ColorW = MonoW; + MonosPerColor = (ColorH / MonoH) * (ColorW / MonoW); + } + + List64 = List32 = List16 = List8 = ListKeepers = MonoList = ColorList = + NULL; + Num64 = Num32 = Num16 = Num8 = NumKeepers = 0; + Width = Height = 0; + + /* We sort partials by how large a square tile they can cache. + We make 8x8 patterns from the leftovers if we can. */ + + pCur = ListPartial; + while (pCur) { + next = pCur->next; + if ((pCur->w >= 64) && (pCur->h >= 64)) { + pCur->next = List64; + List64 = pCur; + Num64++; + } + else if ((pCur->w >= 32) && (pCur->h >= 32)) { + pCur->next = List32; + List32 = pCur; + Num32++; + } + else if ((pCur->w >= 16) && (pCur->h >= 16)) { + pCur->next = List16; + List16 = pCur; + Num16++; + } + else if ((pCur->w >= 8) && (pCur->h >= 8)) { + pCur->next = List8; + List8 = pCur; + Num8++; + } + else { + h = pCur->h; + if (DoColor && (pCur->w >= ColorW) && (h >= ColorH)) { + while (h >= ColorH) { + h -= ColorH; + for (w = 0; w <= (pCur->w - ColorW); w += ColorW) { + ColorList = Enlist(ColorList, + pCur->x + w, pCur->y + h, ColorW, + ColorH); + (*NumColor)++; + } + } + } + if (DoMono && (pCur->w >= MonoW) && (h >= MonoH)) { + while (h >= MonoH) { + h -= MonoH; + for (w = 0; w <= (pCur->w - MonoW); w += MonoW) { + MonoList = Enlist(MonoList, + pCur->x + w, pCur->y + h, MonoW, + MonoH); + (*NumMono)++; + } + } + } + free(pCur); + } + + pCur = next; + } + + /* Try to extract at least 4 of each type of 8x8 slot that we need */ + + if (DoColor) { + CacheLinkPtr theOne; + + while (*NumColor < 4) { + theOne = NULL; + if (Num8) { + if ((theOne = ExtractOneThatFits(&List8, ColorW, ColorH))) + Num8--; + } + if (Num16 && !theOne) { + if ((theOne = ExtractOneThatFits(&List16, ColorW, ColorH))) + Num16--; + } + if (Num32 && !theOne) { + if ((theOne = ExtractOneThatFits(&List32, ColorW, ColorH))) + Num32--; + } + if (Num64 && !theOne) { + if ((theOne = ExtractOneThatFits(&List64, ColorW, ColorH))) + Num64--; + } + + if (!theOne) + break; + + ConvertAllPartialsTo8x8(NumMono, NumColor, theOne, + &MonoList, &ColorList, infoRec); + if (DoMono) { + while (*NumColor && (*NumMono < 4)) { + ConvertColorToMono(&ColorList, ColorW, ColorH, + &MonoList, MonoW, MonoH); + (*NumColor)--; + *NumMono += MonosPerColor; + } + } + } + } + + if (DoMono) { + CacheLinkPtr theOne; + + while (*NumMono < 4) { + theOne = NULL; + if (Num8) { + if ((theOne = ExtractOneThatFits(&List8, MonoW, MonoH))) + Num8--; + } + if (Num16 && !theOne) { + if ((theOne = ExtractOneThatFits(&List16, MonoW, MonoH))) + Num16--; + } + if (Num32 && !theOne) { + if ((theOne = ExtractOneThatFits(&List32, MonoW, MonoH))) + Num32--; + } + if (Num64 && !theOne) { + if ((theOne = ExtractOneThatFits(&List64, MonoW, MonoH))) + Num64--; + } + + if (!theOne) + break; + + ConvertAllPartialsTo8x8(NumMono, NumColor, theOne, + &MonoList, &ColorList, infoRec); + } + } + + /* We save all the tiles from the largest bin that we can get + at least 4 of. If there are too few of a bigger slot, we + cut it in fourths to make smaller slots. */ + + if (Num64 >= 4) { + ListKeepers = List64; + List64 = NULL; + NumKeepers = Num64; + goto GOT_EM; + } + else if (Num64) { + List32 = QuadLinks(List64, List32); + Num32 += Num64 * 4; + Num64 = 0; + } + + if (Num32 >= 4) { + ListKeepers = List32; + List32 = NULL; + NumKeepers = Num32; + goto GOT_EM; + } + else if (Num32) { + List16 = QuadLinks(List32, List16); + Num16 += Num32 * 4; + Num32 = 0; + } + + if (Num16 >= 4) { + ListKeepers = List16; + List16 = NULL; + NumKeepers = Num16; + goto GOT_EM; + } + else if (Num16) { + List8 = QuadLinks(List16, List8); + Num8 += Num16 * 4; + Num16 = 0; + } + + if (Num8 >= 4) { + ListKeepers = List8; + List8 = NULL; + NumKeepers = Num8; + goto GOT_EM; + } + + GOT_EM: + + /* Free the ones we aren't using */ + + if (List64) + ConvertAllPartialsTo8x8(NumMono, NumColor, List64, + &MonoList, &ColorList, infoRec); + if (List32) + ConvertAllPartialsTo8x8(NumMono, NumColor, List32, + &MonoList, &ColorList, infoRec); + if (List16) + ConvertAllPartialsTo8x8(NumMono, NumColor, List16, + &MonoList, &ColorList, infoRec); + if (List8) + ConvertAllPartialsTo8x8(NumMono, NumColor, List8, + &MonoList, &ColorList, infoRec); + + /* Enlarge the slots if we can */ + + if (ListKeepers) { + CacheLinkPtr pLink = ListKeepers; + + Width = Height = 128; + + while (pLink) { + if (pLink->w < Width) + Width = pLink->w; + if (pLink->h < Height) + Height = pLink->h; + pLink = pLink->next; + } + } + + *ListMono = MonoList; + *ListColor = ColorList; + *maxw = Width; + *maxh = Height; + *NumPartial = NumKeepers; + return ListKeepers; +} void -XAAInitPixmapCache( - ScreenPtr pScreen, - RegionPtr areas, - pointer data -) { - ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; - XAAInfoRecPtr infoRec = (XAAInfoRecPtr)data; - XAAPixmapCachePrivatePtr pCachePriv; - BoxPtr pBox = RegionRects(areas); - int nBox = RegionNumRects(areas); - int Num512, Num256, Num128, NumPartial, NumColor, NumMono; - int Target512, Target256; - CacheLinkPtr List512, List256, List128, ListPartial, ListColor, ListMono; - int x, y, w, h, ntotal, granularity, width, height, i; - int MaxPartialWidth, MaxPartialHeight; - - infoRec->MaxCacheableTileWidth = 0; - infoRec->MaxCacheableTileHeight = 0; - infoRec->MaxCacheableStippleHeight = 0; - infoRec->MaxCacheableStippleWidth = 0; - infoRec->UsingPixmapCache = FALSE; - - - if(!nBox || !pBox || !(infoRec->Flags & PIXMAP_CACHE)) - return; - - /* Allocate a persistent per-screen init flag to control messages */ - if (CacheInitIndex < 0) - CacheInitIndex = xf86AllocateScrnInfoPrivateIndex(); - - /* free the old private data if it exists */ - if(infoRec->PixmapCachePrivate) { - FreePixmapCachePrivate( - (XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate); - infoRec->PixmapCachePrivate = NULL; - } - - Num512 = Num256 = Num128 = NumPartial = NumMono = NumColor = 0; - List512 = List256 = List128 = ListPartial = ListMono = ListColor = NULL; - granularity = infoRec->CachePixelGranularity; - if(granularity <= 1) granularity = 0; - - /* go through the boxes and break it into as many pieces as we can fit */ - - while(nBox--) { - x = pBox->x1; - if(granularity) { - int tmp = x % granularity; - if(tmp) x += (granularity - tmp); - } - width = pBox->x2 - x; - if(width <= 0) {pBox++; continue;} - - y = pBox->y1; +XAAInitPixmapCache(ScreenPtr pScreen, RegionPtr areas, pointer data) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + XAAInfoRecPtr infoRec = (XAAInfoRecPtr) data; + XAAPixmapCachePrivatePtr pCachePriv; + BoxPtr pBox = RegionRects(areas); + int nBox = RegionNumRects(areas); + int Num512, Num256, Num128, NumPartial, NumColor, NumMono; + int Target512, Target256; + CacheLinkPtr List512, List256, List128, ListPartial, ListColor, ListMono; + int x, y, w, h, ntotal, granularity, width, height, i; + int MaxPartialWidth, MaxPartialHeight; + + infoRec->MaxCacheableTileWidth = 0; + infoRec->MaxCacheableTileHeight = 0; + infoRec->MaxCacheableStippleHeight = 0; + infoRec->MaxCacheableStippleWidth = 0; + infoRec->UsingPixmapCache = FALSE; + + if (!nBox || !pBox || !(infoRec->Flags & PIXMAP_CACHE)) + return; + + /* Allocate a persistent per-screen init flag to control messages */ + if (CacheInitIndex < 0) + CacheInitIndex = xf86AllocateScrnInfoPrivateIndex(); + + /* free the old private data if it exists */ + if (infoRec->PixmapCachePrivate) { + FreePixmapCachePrivate((XAAPixmapCachePrivatePtr) infoRec-> + PixmapCachePrivate); + infoRec->PixmapCachePrivate = NULL; + } + + Num512 = Num256 = Num128 = NumPartial = NumMono = NumColor = 0; + List512 = List256 = List128 = ListPartial = ListMono = ListColor = NULL; + granularity = infoRec->CachePixelGranularity; + if (granularity <= 1) + granularity = 0; + + /* go through the boxes and break it into as many pieces as we can fit */ + + while (nBox--) { + x = pBox->x1; + if (granularity) { + int tmp = x % granularity; + + if (tmp) + x += (granularity - tmp); + } + width = pBox->x2 - x; + if (width <= 0) { + pBox++; + continue; + } + + y = pBox->y1; height = pBox->y2 - y; - for(h = 0; h <= (height - 512); h += 512) { - for(w = 0; w <= (width - 512); w += 512) { - List512 = Enlist(List512, x + w, y + h, 512, 512); - Num512++; - } - for(; w <= (width - 256); w += 256) { - List256 = Enlist(List256, x + w, y + h, 256, 256); - List256 = Enlist(List256, x + w, y + h + 256, 256, 256); - Num256 += 2; - } - for(; w <= (width - 128); w += 128) { - List128 = Enlist(List128, x + w, y + h, 128, 128); - List128 = Enlist(List128, x + w, y + h + 128, 128, 128); - List128 = Enlist(List128, x + w, y + h + 256, 128, 128); - List128 = Enlist(List128, x + w, y + h + 384, 128, 128); - Num128 += 4; - } - if(w < width) { - int d = width - w; - ListPartial = Enlist(ListPartial, x + w, y + h, d, 128); - ListPartial = Enlist(ListPartial, x + w, y + h + 128, d, 128); - ListPartial = Enlist(ListPartial, x + w, y + h + 256, d, 128); - ListPartial = Enlist(ListPartial, x + w, y + h + 384, d, 128); - NumPartial += 4; + for (h = 0; h <= (height - 512); h += 512) { + for (w = 0; w <= (width - 512); w += 512) { + List512 = Enlist(List512, x + w, y + h, 512, 512); + Num512++; + } + for (; w <= (width - 256); w += 256) { + List256 = Enlist(List256, x + w, y + h, 256, 256); + List256 = Enlist(List256, x + w, y + h + 256, 256, 256); + Num256 += 2; + } + for (; w <= (width - 128); w += 128) { + List128 = Enlist(List128, x + w, y + h, 128, 128); + List128 = Enlist(List128, x + w, y + h + 128, 128, 128); + List128 = Enlist(List128, x + w, y + h + 256, 128, 128); + List128 = Enlist(List128, x + w, y + h + 384, 128, 128); + Num128 += 4; } - } - for(; h <= (height - 256); h += 256) { - for(w = 0; w <= (width - 256); w += 256) { - List256 = Enlist(List256, x + w, y + h, 256, 256); - Num256++; - } - for(; w <= (width - 128); w += 128) { - List128 = Enlist(List128, x + w, y + h, 128, 128); - List128 = Enlist(List128, x + w, y + h + 128, 128, 128); - Num128 += 2; - } - if(w < width) { - int d = width - w; - ListPartial = Enlist(ListPartial, x + w, y + h, d, 128); - ListPartial = Enlist(ListPartial, x + w, y + h + 128, d, 128); - NumPartial += 2; + if (w < width) { + int d = width - w; + + ListPartial = Enlist(ListPartial, x + w, y + h, d, 128); + ListPartial = Enlist(ListPartial, x + w, y + h + 128, d, 128); + ListPartial = Enlist(ListPartial, x + w, y + h + 256, d, 128); + ListPartial = Enlist(ListPartial, x + w, y + h + 384, d, 128); + NumPartial += 4; } } - for(; h <= (height - 128); h += 128) { - for(w = 0; w <= (width - 128); w += 128) { - List128 = Enlist(List128, x + w, y + h, 128, 128); - Num128++; - } - if(w < width) { - ListPartial = Enlist( - ListPartial, x + w, y + h, width - w, 128); - NumPartial++; + for (; h <= (height - 256); h += 256) { + for (w = 0; w <= (width - 256); w += 256) { + List256 = Enlist(List256, x + w, y + h, 256, 256); + Num256++; + } + for (; w <= (width - 128); w += 128) { + List128 = Enlist(List128, x + w, y + h, 128, 128); + List128 = Enlist(List128, x + w, y + h + 128, 128, 128); + Num128 += 2; + } + if (w < width) { + int d = width - w; + + ListPartial = Enlist(ListPartial, x + w, y + h, d, 128); + ListPartial = Enlist(ListPartial, x + w, y + h + 128, d, 128); + NumPartial += 2; } } - if(h < height) { - int d = height - h; - for(w = 0; w <= (width - 128); w += 128) { - ListPartial = Enlist(ListPartial, x + w, y + h, 128, d); - NumPartial++; - } - if(w < width) { - ListPartial = Enlist(ListPartial, x + w, y + h, width - w, d); - NumPartial++; + for (; h <= (height - 128); h += 128) { + for (w = 0; w <= (width - 128); w += 128) { + List128 = Enlist(List128, x + w, y + h, 128, 128); + Num128++; + } + if (w < width) { + ListPartial = Enlist(ListPartial, x + w, y + h, width - w, 128); + NumPartial++; } } - pBox++; - } + if (h < height) { + int d = height - h; + for (w = 0; w <= (width - 128); w += 128) { + ListPartial = Enlist(ListPartial, x + w, y + h, 128, d); + NumPartial++; + } + if (w < width) { + ListPartial = Enlist(ListPartial, x + w, y + h, width - w, d); + NumPartial++; + } + } + pBox++; + } /* by this point we've carved the space into as many 512x512, 256x256 @@ -775,319 +803,374 @@ XAAInitPixmapCache( */ - ntotal = Num128 + (Num256<<2) + (Num512<<4); - + ntotal = Num128 + (Num256 << 2) + (Num512 << 4); + Target512 = ntotal >> 5; - if(Target512 < 4) Target512 = 0; - if(!Target512) Target256 = ntotal >> 3; - else Target256 = ntotal >> 4; - if(Target256 < 4) Target256 = 0; - - if(Num512 && Num256 < 4) { - while(Num512 && Num256 < Target256) { - SubdivideList(&List512, &List256); - Num256 += 4; Num512--; - } - } - - if(!Num512) { /* no room */ - } else if((Num512 < 4) || (!Target512)) { - while(Num512) { - SubdivideList(&List512, &List256); - Num256 += 4; Num512--; - } - } else if((Num512 > MAX_512) || (Num512 > Target512)){ - while(Num512 > MAX_512) { - SubdivideList(&List512, &List256); - Num256 += 4; Num512--; - } - while(Num512 > Target512) { - if(Num256 < MAX_256) { - SubdivideList(&List512, &List256); - Num256 += 4; Num512--; - } else break; - } - } - - if(!Num256) { /* no room */ - } else if((Num256 < 4) || (!Target256)) { - while(Num256) { - SubdivideList(&List256, &List128); - Num128 += 4; Num256--; - } - } else if((Num256 > MAX_256) || (Num256 > Target256)) { - while(Num256 > MAX_256) { - SubdivideList(&List256, &List128); - Num128 += 4; Num256--; - } - while(Num256 > Target256) { - if(Num128 < MAX_128) { - SubdivideList(&List256, &List128); - Num128 += 4; Num256--; - } else break; - } - } - - if(Num128 && ((Num128 < 4) || (Num128 > MAX_128))) { - CacheLinkPtr next; - int max = (Num128 > MAX_128) ? MAX_128 : 0; - - /* - * Note: next is set in this way to work around a code generation - * bug in gcc 2.7.2.3. - */ - next = List128->next; - while(Num128 > max) { - List128->next = ListPartial; - ListPartial = List128; - if((List128 = next)) - next = List128->next; - NumPartial++; Num128--; - } + if (Target512 < 4) + Target512 = 0; + if (!Target512) + Target256 = ntotal >> 3; + else + Target256 = ntotal >> 4; + if (Target256 < 4) + Target256 = 0; + + if (Num512 && Num256 < 4) { + while (Num512 && Num256 < Target256) { + SubdivideList(&List512, &List256); + Num256 += 4; + Num512--; + } + } + + if (!Num512) { /* no room */ + } + else if ((Num512 < 4) || (!Target512)) { + while (Num512) { + SubdivideList(&List512, &List256); + Num256 += 4; + Num512--; + } + } + else if ((Num512 > MAX_512) || (Num512 > Target512)) { + while (Num512 > MAX_512) { + SubdivideList(&List512, &List256); + Num256 += 4; + Num512--; + } + while (Num512 > Target512) { + if (Num256 < MAX_256) { + SubdivideList(&List512, &List256); + Num256 += 4; + Num512--; + } + else + break; + } + } + + if (!Num256) { /* no room */ + } + else if ((Num256 < 4) || (!Target256)) { + while (Num256) { + SubdivideList(&List256, &List128); + Num128 += 4; + Num256--; + } + } + else if ((Num256 > MAX_256) || (Num256 > Target256)) { + while (Num256 > MAX_256) { + SubdivideList(&List256, &List128); + Num128 += 4; + Num256--; + } + while (Num256 > Target256) { + if (Num128 < MAX_128) { + SubdivideList(&List256, &List128); + Num128 += 4; + Num256--; + } + else + break; + } + } + + if (Num128 && ((Num128 < 4) || (Num128 > MAX_128))) { + CacheLinkPtr next; + int max = (Num128 > MAX_128) ? MAX_128 : 0; + + /* + * Note: next is set in this way to work around a code generation + * bug in gcc 2.7.2.3. + */ + next = List128->next; + while (Num128 > max) { + List128->next = ListPartial; + ListPartial = List128; + if ((List128 = next)) + next = List128->next; + NumPartial++; + Num128--; + } } MaxPartialHeight = MaxPartialWidth = 0; /* at this point we have as many 512x512 and 256x256 slots as we - want but may have an excess of 128x128 slots. We still need - to find out if we need 8x8 slots. We take these from the - partials if we have them. Otherwise, we break some 128x128's */ - - if(!(infoRec->PixmapCacheFlags & (CACHE_MONO_8x8 | CACHE_COLOR_8x8))) { - if(NumPartial) { - if(Num128) { /* don't bother with partials */ - FreeList(ListPartial); - NumPartial = 0; ListPartial = NULL; - } else { - /* We have no big slots. Weed out the unusable partials */ - ListPartial = ThinOutPartials(ListPartial, &NumPartial, - &MaxPartialWidth, &MaxPartialHeight); - } - } - } else { - int MonosPerColor = 1; - int ColorH = infoRec->CacheHeightColor8x8Pattern; - int ColorW = infoRec->CacheWidthColor8x8Pattern; - int MonoH = infoRec->CacheHeightMono8x8Pattern; - int MonoW = infoRec->CacheWidthMono8x8Pattern; - Bool DoColor = (infoRec->PixmapCacheFlags & CACHE_COLOR_8x8); - Bool DoMono = (infoRec->PixmapCacheFlags & CACHE_MONO_8x8); - - if(DoColor) infoRec->CanDoColor8x8 = FALSE; - if(DoMono) infoRec->CanDoMono8x8 = FALSE; - - if(DoColor && DoMono) { - /* we assume color patterns take more space than color ones */ - if(MonoH > ColorH) ColorH = MonoH; - if(MonoW > ColorW) ColorW = MonoW; - MonosPerColor = (ColorH/MonoH) * (ColorW/MonoW); - } - - if(Num128) { - if(NumPartial) { /* use all for 8x8 slots */ - ConvertAllPartialsTo8x8(&NumMono, &NumColor, - ListPartial, &ListMono, &ListColor, infoRec); - NumPartial = 0; ListPartial = NULL; - } - - /* Get some 8x8 slots from the 128 slots */ - while((Num128 > 4) && - ((NumMono < MAX_MONO) && (NumColor < MAX_COLOR))) { - CacheLinkPtr tmp = NULL; - - tmp = Enlist(tmp, List128->x, List128->y, - List128->w, List128->h); - List128 = Delist(List128); - Num128--; - - ConvertAllPartialsTo8x8(&NumMono, &NumColor, - tmp, &ListMono, &ListColor, infoRec); - } - } else if(NumPartial) { - /* We have share partials between 8x8 slots and tiles. */ - ListPartial = ConvertSomePartialsTo8x8(&NumMono, &NumColor, - &NumPartial, ListPartial, &ListMono, &ListColor, - &MaxPartialWidth, &MaxPartialHeight, infoRec); - } - - - if(DoMono && DoColor) { - if(NumColor && ((NumColor > MAX_COLOR) || (NumColor < 4))) { - int max = (NumColor > MAX_COLOR) ? MAX_COLOR : 0; - - while(NumColor > max) { - ConvertColorToMono(&ListColor, ColorW, ColorH, - &ListMono, MonoW, MonoH); - NumColor--; NumMono += MonosPerColor; - } - } - - /* favor Mono slots over Color ones */ - while((NumColor > 4) && (NumMono < MAX_MONO)) { - ConvertColorToMono(&ListColor, ColorW, ColorH, - &ListMono, MonoW, MonoH); - NumColor--; NumMono += MonosPerColor; - } - } - - if(NumMono && ((NumMono > MAX_MONO) || (NumMono < 4))) { - int max = (NumMono > MAX_MONO) ? MAX_MONO : 0; - - while(NumMono > max) { - ListMono = Delist(ListMono); - NumMono--; - } - } - if(NumColor && ((NumColor > MAX_COLOR) || (NumColor < 4))) { - int max = (NumColor > MAX_COLOR) ? MAX_COLOR : 0; - - while(NumColor > max) { - ListColor = Delist(ListColor); - NumColor--; - } - } - } - - - pCachePriv = calloc(1,sizeof(XAAPixmapCachePrivate)); - if(!pCachePriv) { - if(Num512) FreeList(List512); - if(Num256) FreeList(List256); - if(Num128) FreeList(List128); - if(NumPartial) FreeList(ListPartial); - if(NumColor) FreeList(ListColor); - if(NumMono) FreeList(ListMono); - return; - } - - infoRec->PixmapCachePrivate = (char*)pCachePriv; - - if(Num512) { - pCachePriv->Info512 = calloc(Num512,sizeof(XAACacheInfoRec)); - if(!pCachePriv->Info512) Num512 = 0; - if(Num512) TransferList(List512, pCachePriv->Info512, Num512); - FreeList(List512); - pCachePriv->Num512x512 = Num512; - } - if(Num256) { - pCachePriv->Info256 = calloc(Num256, sizeof(XAACacheInfoRec)); - if(!pCachePriv->Info256) Num256 = 0; - if(Num256) TransferList(List256, pCachePriv->Info256, Num256); - FreeList(List256); - pCachePriv->Num256x256 = Num256; - } - if(Num128) { - pCachePriv->Info128 = calloc(Num128, sizeof(XAACacheInfoRec)); - if(!pCachePriv->Info128) Num128 = 0; - if(Num128) TransferList(List128, pCachePriv->Info128, Num128); - FreeList(List128); - pCachePriv->Num128x128 = Num128; - } - - if(NumPartial) { - pCachePriv->InfoPartial = calloc(NumPartial, sizeof(XAACacheInfoRec)); - if(!pCachePriv->InfoPartial) NumPartial = 0; - if(NumPartial) - TransferList(ListPartial, pCachePriv->InfoPartial, NumPartial); - FreeList(ListPartial); - pCachePriv->NumPartial = NumPartial; - } - - if(NumColor) { - pCachePriv->InfoColor = calloc(NumColor, sizeof(XAACacheInfoRec)); - if(!pCachePriv->InfoColor) NumColor = 0; - if(NumColor) TransferList(ListColor, pCachePriv->InfoColor, NumColor); - FreeList(ListColor); - pCachePriv->NumColor = NumColor; - } - - if(NumMono) { - pCachePriv->InfoMono = calloc(NumMono, sizeof(XAACacheInfoRec)); - if(!pCachePriv->InfoMono) NumMono = 0; - if(NumMono) TransferList(ListMono, pCachePriv->InfoMono, NumMono); - FreeList(ListMono); - pCachePriv->NumMono = NumMono; - } - - - if(NumPartial) { - infoRec->MaxCacheableTileWidth = MaxPartialWidth; - infoRec->MaxCacheableTileHeight = MaxPartialHeight; - } - if(Num128) - infoRec->MaxCacheableTileWidth = infoRec->MaxCacheableTileHeight = 128; - if(Num256) - infoRec->MaxCacheableTileWidth = infoRec->MaxCacheableTileHeight = 256; - if(Num512) - infoRec->MaxCacheableTileWidth = infoRec->MaxCacheableTileHeight = 512; - - + want but may have an excess of 128x128 slots. We still need + to find out if we need 8x8 slots. We take these from the + partials if we have them. Otherwise, we break some 128x128's */ + + if (!(infoRec->PixmapCacheFlags & (CACHE_MONO_8x8 | CACHE_COLOR_8x8))) { + if (NumPartial) { + if (Num128) { /* don't bother with partials */ + FreeList(ListPartial); + NumPartial = 0; + ListPartial = NULL; + } + else { + /* We have no big slots. Weed out the unusable partials */ + ListPartial = ThinOutPartials(ListPartial, &NumPartial, + &MaxPartialWidth, + &MaxPartialHeight); + } + } + } + else { + int MonosPerColor = 1; + int ColorH = infoRec->CacheHeightColor8x8Pattern; + int ColorW = infoRec->CacheWidthColor8x8Pattern; + int MonoH = infoRec->CacheHeightMono8x8Pattern; + int MonoW = infoRec->CacheWidthMono8x8Pattern; + Bool DoColor = (infoRec->PixmapCacheFlags & CACHE_COLOR_8x8); + Bool DoMono = (infoRec->PixmapCacheFlags & CACHE_MONO_8x8); + + if (DoColor) + infoRec->CanDoColor8x8 = FALSE; + if (DoMono) + infoRec->CanDoMono8x8 = FALSE; + + if (DoColor && DoMono) { + /* we assume color patterns take more space than color ones */ + if (MonoH > ColorH) + ColorH = MonoH; + if (MonoW > ColorW) + ColorW = MonoW; + MonosPerColor = (ColorH / MonoH) * (ColorW / MonoW); + } + + if (Num128) { + if (NumPartial) { /* use all for 8x8 slots */ + ConvertAllPartialsTo8x8(&NumMono, &NumColor, + ListPartial, &ListMono, &ListColor, + infoRec); + NumPartial = 0; + ListPartial = NULL; + } + + /* Get some 8x8 slots from the 128 slots */ + while ((Num128 > 4) && + ((NumMono < MAX_MONO) && (NumColor < MAX_COLOR))) { + CacheLinkPtr tmp = NULL; + + tmp = Enlist(tmp, List128->x, List128->y, + List128->w, List128->h); + List128 = Delist(List128); + Num128--; + + ConvertAllPartialsTo8x8(&NumMono, &NumColor, + tmp, &ListMono, &ListColor, infoRec); + } + } + else if (NumPartial) { + /* We have share partials between 8x8 slots and tiles. */ + ListPartial = ConvertSomePartialsTo8x8(&NumMono, &NumColor, + &NumPartial, ListPartial, + &ListMono, &ListColor, + &MaxPartialWidth, + &MaxPartialHeight, infoRec); + } + + if (DoMono && DoColor) { + if (NumColor && ((NumColor > MAX_COLOR) || (NumColor < 4))) { + int max = (NumColor > MAX_COLOR) ? MAX_COLOR : 0; + + while (NumColor > max) { + ConvertColorToMono(&ListColor, ColorW, ColorH, + &ListMono, MonoW, MonoH); + NumColor--; + NumMono += MonosPerColor; + } + } + + /* favor Mono slots over Color ones */ + while ((NumColor > 4) && (NumMono < MAX_MONO)) { + ConvertColorToMono(&ListColor, ColorW, ColorH, + &ListMono, MonoW, MonoH); + NumColor--; + NumMono += MonosPerColor; + } + } + + if (NumMono && ((NumMono > MAX_MONO) || (NumMono < 4))) { + int max = (NumMono > MAX_MONO) ? MAX_MONO : 0; + + while (NumMono > max) { + ListMono = Delist(ListMono); + NumMono--; + } + } + if (NumColor && ((NumColor > MAX_COLOR) || (NumColor < 4))) { + int max = (NumColor > MAX_COLOR) ? MAX_COLOR : 0; + + while (NumColor > max) { + ListColor = Delist(ListColor); + NumColor--; + } + } + } + + pCachePriv = calloc(1, sizeof(XAAPixmapCachePrivate)); + if (!pCachePriv) { + if (Num512) + FreeList(List512); + if (Num256) + FreeList(List256); + if (Num128) + FreeList(List128); + if (NumPartial) + FreeList(ListPartial); + if (NumColor) + FreeList(ListColor); + if (NumMono) + FreeList(ListMono); + return; + } + + infoRec->PixmapCachePrivate = (char *) pCachePriv; + + if (Num512) { + pCachePriv->Info512 = calloc(Num512, sizeof(XAACacheInfoRec)); + if (!pCachePriv->Info512) + Num512 = 0; + if (Num512) + TransferList(List512, pCachePriv->Info512, Num512); + FreeList(List512); + pCachePriv->Num512x512 = Num512; + } + if (Num256) { + pCachePriv->Info256 = calloc(Num256, sizeof(XAACacheInfoRec)); + if (!pCachePriv->Info256) + Num256 = 0; + if (Num256) + TransferList(List256, pCachePriv->Info256, Num256); + FreeList(List256); + pCachePriv->Num256x256 = Num256; + } + if (Num128) { + pCachePriv->Info128 = calloc(Num128, sizeof(XAACacheInfoRec)); + if (!pCachePriv->Info128) + Num128 = 0; + if (Num128) + TransferList(List128, pCachePriv->Info128, Num128); + FreeList(List128); + pCachePriv->Num128x128 = Num128; + } + + if (NumPartial) { + pCachePriv->InfoPartial = calloc(NumPartial, sizeof(XAACacheInfoRec)); + if (!pCachePriv->InfoPartial) + NumPartial = 0; + if (NumPartial) + TransferList(ListPartial, pCachePriv->InfoPartial, NumPartial); + FreeList(ListPartial); + pCachePriv->NumPartial = NumPartial; + } + + if (NumColor) { + pCachePriv->InfoColor = calloc(NumColor, sizeof(XAACacheInfoRec)); + if (!pCachePriv->InfoColor) + NumColor = 0; + if (NumColor) + TransferList(ListColor, pCachePriv->InfoColor, NumColor); + FreeList(ListColor); + pCachePriv->NumColor = NumColor; + } + + if (NumMono) { + pCachePriv->InfoMono = calloc(NumMono, sizeof(XAACacheInfoRec)); + if (!pCachePriv->InfoMono) + NumMono = 0; + if (NumMono) + TransferList(ListMono, pCachePriv->InfoMono, NumMono); + FreeList(ListMono); + pCachePriv->NumMono = NumMono; + } + + if (NumPartial) { + infoRec->MaxCacheableTileWidth = MaxPartialWidth; + infoRec->MaxCacheableTileHeight = MaxPartialHeight; + } + if (Num128) + infoRec->MaxCacheableTileWidth = infoRec->MaxCacheableTileHeight = 128; + if (Num256) + infoRec->MaxCacheableTileWidth = infoRec->MaxCacheableTileHeight = 256; + if (Num512) + infoRec->MaxCacheableTileWidth = infoRec->MaxCacheableTileHeight = 512; + infoRec->MaxCacheableStippleHeight = infoRec->MaxCacheableTileHeight; - infoRec->MaxCacheableStippleWidth = - infoRec->MaxCacheableTileWidth * pScrn->bitsPerPixel; - if(infoRec->ScreenToScreenColorExpandFillFlags & TRIPLE_BITS_24BPP) - infoRec->MaxCacheableStippleWidth /= 3; - - if(NumMono) { - if(!(infoRec->Mono8x8PatternFillFlags & - (HARDWARE_PATTERN_PROGRAMMED_ORIGIN | - HARDWARE_PATTERN_PROGRAMMED_BITS))) { - int numPerLine = - infoRec->CacheWidthMono8x8Pattern/infoRec->MonoPatternPitch; - - for(i = 0; i < 64; i++) { - pCachePriv->MonoOffsets[i].y = i/numPerLine; - pCachePriv->MonoOffsets[i].x = (i % numPerLine) * - infoRec->MonoPatternPitch; - } - } - infoRec->CanDoMono8x8 = TRUE; - } - if(NumColor) { - if(!(infoRec->Color8x8PatternFillFlags & - HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) { - - for(i = 0; i < 64; i++) { - pCachePriv->ColorOffsets[i].y = i & 0x07; - pCachePriv->ColorOffsets[i].x = i & ~0x07; - } - } - infoRec->CanDoColor8x8 = TRUE; - } - - if(!CACHEINIT(pScrn)) { - xf86ErrorF("\tSetting up tile and stipple cache:\n"); - if(NumPartial) - xf86ErrorF("\t\t%i %ix%i slots\n", - NumPartial, MaxPartialWidth, MaxPartialHeight); - if(Num128) xf86ErrorF("\t\t%i 128x128 slots\n", Num128); - if(Num256) xf86ErrorF("\t\t%i 256x256 slots\n", Num256); - if(Num512) xf86ErrorF("\t\t%i 512x512 slots\n", Num512); - if(NumColor) xf86ErrorF("\t\t%i 8x8 color pattern slots\n", NumColor); - if(NumMono) xf86ErrorF("\t\t%i 8x8 color expansion slots\n", NumMono); - } - - if(!(NumPartial | Num128 | Num256 | Num512 | NumColor | NumMono)) { - if(!CACHEINIT(pScrn)) - xf86ErrorF("\t\tNot enough video memory for pixmap cache\n"); - } else infoRec->UsingPixmapCache = TRUE; + infoRec->MaxCacheableStippleWidth = + infoRec->MaxCacheableTileWidth * pScrn->bitsPerPixel; + if (infoRec->ScreenToScreenColorExpandFillFlags & TRIPLE_BITS_24BPP) + infoRec->MaxCacheableStippleWidth /= 3; + + if (NumMono) { + if (!(infoRec->Mono8x8PatternFillFlags & + (HARDWARE_PATTERN_PROGRAMMED_ORIGIN | + HARDWARE_PATTERN_PROGRAMMED_BITS))) { + int numPerLine = + infoRec->CacheWidthMono8x8Pattern / infoRec->MonoPatternPitch; + + for (i = 0; i < 64; i++) { + pCachePriv->MonoOffsets[i].y = i / numPerLine; + pCachePriv->MonoOffsets[i].x = (i % numPerLine) * + infoRec->MonoPatternPitch; + } + } + infoRec->CanDoMono8x8 = TRUE; + } + if (NumColor) { + if (!(infoRec->Color8x8PatternFillFlags & + HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) { + + for (i = 0; i < 64; i++) { + pCachePriv->ColorOffsets[i].y = i & 0x07; + pCachePriv->ColorOffsets[i].x = i & ~0x07; + } + } + infoRec->CanDoColor8x8 = TRUE; + } + + if (!CACHEINIT(pScrn)) { + xf86ErrorF("\tSetting up tile and stipple cache:\n"); + if (NumPartial) + xf86ErrorF("\t\t%i %ix%i slots\n", + NumPartial, MaxPartialWidth, MaxPartialHeight); + if (Num128) + xf86ErrorF("\t\t%i 128x128 slots\n", Num128); + if (Num256) + xf86ErrorF("\t\t%i 256x256 slots\n", Num256); + if (Num512) + xf86ErrorF("\t\t%i 512x512 slots\n", Num512); + if (NumColor) + xf86ErrorF("\t\t%i 8x8 color pattern slots\n", NumColor); + if (NumMono) + xf86ErrorF("\t\t%i 8x8 color expansion slots\n", NumMono); + } + + if (!(NumPartial | Num128 | Num256 | Num512 | NumColor | NumMono)) { + if (!CACHEINIT(pScrn)) + xf86ErrorF("\t\tNot enough video memory for pixmap cache\n"); + } + else + infoRec->UsingPixmapCache = TRUE; CACHEINIT(pScrn) = 1; } #if X_BYTE_ORDER == X_BIG_ENDIAN static CARD32 StippleMasks[4] = { - 0x80808080, - 0xC0C0C0C0, - 0x00000000, - 0xF0F0F0F0 + 0x80808080, + 0xC0C0C0C0, + 0x00000000, + 0xF0F0F0F0 }; #else static CARD32 StippleMasks[4] = { - 0x01010101, - 0x03030303, - 0x00000000, - 0x0F0F0F0F + 0x01010101, + 0x03030303, + 0x00000000, + 0x0F0F0F0F }; #endif @@ -1096,99 +1179,111 @@ XAACheckStippleReducibility(PixmapPtr pPixmap) { XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPixmap); XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_DRAWABLE(&pPixmap->drawable); - CARD32 *IntPtr = (CARD32*)pPixmap->devPrivate.ptr; + CARD32 *IntPtr = (CARD32 *) pPixmap->devPrivate.ptr; int w = pPixmap->drawable.width; int h = pPixmap->drawable.height; int i; CARD32 bits[8]; - CARD32 mask = SHIFT_R(0xFFFFFFFF,24); + CARD32 mask = SHIFT_R(0xFFFFFFFF, 24); pPriv->flags |= REDUCIBILITY_CHECKED | REDUCIBLE_TO_2_COLOR; pPriv->flags &= ~REDUCIBLE_TO_8x8; - if((w > 32) || (h > 32) || (w & (w - 1)) || (h & (h - 1))) - return FALSE; + if ((w > 32) || (h > 32) || (w & (w - 1)) || (h & (h - 1))) + return FALSE; i = (h > 8) ? 8 : h; - switch(w) { + switch (w) { case 32: - while(i--) { - bits[i] = IntPtr[i] & mask; - if( (bits[i] != SHIFT_R((IntPtr[i] & SHIFT_L(mask, 8)), 8)) || - (bits[i] != SHIFT_R((IntPtr[i] & SHIFT_L(mask,16)),16)) || - (bits[i] != SHIFT_R((IntPtr[i] & SHIFT_L(mask,24)),24))) - return FALSE; - } - break; + while (i--) { + bits[i] = IntPtr[i] & mask; + if ((bits[i] != SHIFT_R((IntPtr[i] & SHIFT_L(mask, 8)), 8)) || + (bits[i] != SHIFT_R((IntPtr[i] & SHIFT_L(mask, 16)), 16)) || + (bits[i] != SHIFT_R((IntPtr[i] & SHIFT_L(mask, 24)), 24))) + return FALSE; + } + break; case 16: - while(i--) { - bits[i] = IntPtr[i] & mask; - if(bits[i] != ((IntPtr[i] & SHIFT_R(SHIFT_L(mask,8),8)))) - return FALSE; - } - break; - default: - while(i--) - bits[i] = IntPtr[i] & mask; - break; - } - - switch(h) { - case 32: - if( (IntPtr[8] != IntPtr[16]) || (IntPtr[9] != IntPtr[17]) || - (IntPtr[10] != IntPtr[18]) || (IntPtr[11] != IntPtr[19]) || - (IntPtr[12] != IntPtr[20]) || (IntPtr[13] != IntPtr[21]) || - (IntPtr[14] != IntPtr[22]) || (IntPtr[15] != IntPtr[23]) || - (IntPtr[16] != IntPtr[24]) || (IntPtr[17] != IntPtr[25]) || - (IntPtr[18] != IntPtr[26]) || (IntPtr[19] != IntPtr[27]) || - (IntPtr[20] != IntPtr[28]) || (IntPtr[21] != IntPtr[29]) || - (IntPtr[22] != IntPtr[30]) || (IntPtr[23] != IntPtr[31])) - return FALSE; - /* fall through */ - case 16: - if( (IntPtr[0] != IntPtr[8]) || (IntPtr[1] != IntPtr[9]) || - (IntPtr[2] != IntPtr[10]) || (IntPtr[3] != IntPtr[11]) || - (IntPtr[4] != IntPtr[12]) || (IntPtr[5] != IntPtr[13]) || - (IntPtr[6] != IntPtr[14]) || (IntPtr[7] != IntPtr[15])) - return FALSE; - case 8: break; - case 1: bits[1] = bits[0]; - case 2: bits[2] = bits[0]; bits[3] = bits[1]; - case 4: bits[4] = bits[0]; bits[5] = bits[1]; - bits[6] = bits[2]; bits[7] = bits[3]; - break; - } - - pPriv->flags |= REDUCIBLE_TO_8x8; - - pPriv->pattern0 = bits[0] | SHIFT_L(bits[1],8) | SHIFT_L(bits[2],16) | SHIFT_L(bits[3],24); - pPriv->pattern1 = bits[4] | SHIFT_L(bits[5],8) | SHIFT_L(bits[6],16) | SHIFT_L(bits[7],24); - - if(w < 8) { - pPriv->pattern0 &= StippleMasks[w - 1]; - pPriv->pattern1 &= StippleMasks[w - 1]; + while (i--) { + bits[i] = IntPtr[i] & mask; + if (bits[i] != ((IntPtr[i] & SHIFT_R(SHIFT_L(mask, 8), 8)))) + return FALSE; + } + break; + default: + while (i--) + bits[i] = IntPtr[i] & mask; + break; + } - switch(w) { - case 1: pPriv->pattern0 |= SHIFT_L(pPriv->pattern0,1); - pPriv->pattern1 |= SHIFT_L(pPriv->pattern1,1); - case 2: pPriv->pattern0 |= SHIFT_L(pPriv->pattern0,2); - pPriv->pattern1 |= SHIFT_L(pPriv->pattern1,2); - case 4: pPriv->pattern0 |= SHIFT_L(pPriv->pattern0,4); - pPriv->pattern1 |= SHIFT_L(pPriv->pattern1,4); - } + switch (h) { + case 32: + if ((IntPtr[8] != IntPtr[16]) || (IntPtr[9] != IntPtr[17]) || + (IntPtr[10] != IntPtr[18]) || (IntPtr[11] != IntPtr[19]) || + (IntPtr[12] != IntPtr[20]) || (IntPtr[13] != IntPtr[21]) || + (IntPtr[14] != IntPtr[22]) || (IntPtr[15] != IntPtr[23]) || + (IntPtr[16] != IntPtr[24]) || (IntPtr[17] != IntPtr[25]) || + (IntPtr[18] != IntPtr[26]) || (IntPtr[19] != IntPtr[27]) || + (IntPtr[20] != IntPtr[28]) || (IntPtr[21] != IntPtr[29]) || + (IntPtr[22] != IntPtr[30]) || (IntPtr[23] != IntPtr[31])) + return FALSE; + /* fall through */ + case 16: + if ((IntPtr[0] != IntPtr[8]) || (IntPtr[1] != IntPtr[9]) || + (IntPtr[2] != IntPtr[10]) || (IntPtr[3] != IntPtr[11]) || + (IntPtr[4] != IntPtr[12]) || (IntPtr[5] != IntPtr[13]) || + (IntPtr[6] != IntPtr[14]) || (IntPtr[7] != IntPtr[15])) + return FALSE; + case 8: + break; + case 1: + bits[1] = bits[0]; + case 2: + bits[2] = bits[0]; + bits[3] = bits[1]; + case 4: + bits[4] = bits[0]; + bits[5] = bits[1]; + bits[6] = bits[2]; + bits[7] = bits[3]; + break; } - if(infoRec->Mono8x8PatternFillFlags & BIT_ORDER_IN_BYTE_MSBFIRST) { - pPriv->pattern0 = SWAP_BITS_IN_BYTES(pPriv->pattern0); - pPriv->pattern1 = SWAP_BITS_IN_BYTES(pPriv->pattern1); + pPriv->flags |= REDUCIBLE_TO_8x8; + + pPriv->pattern0 = + bits[0] | SHIFT_L(bits[1], 8) | SHIFT_L(bits[2], 16) | SHIFT_L(bits[3], + 24); + pPriv->pattern1 = + bits[4] | SHIFT_L(bits[5], 8) | SHIFT_L(bits[6], 16) | SHIFT_L(bits[7], + 24); + + if (w < 8) { + pPriv->pattern0 &= StippleMasks[w - 1]; + pPriv->pattern1 &= StippleMasks[w - 1]; + + switch (w) { + case 1: + pPriv->pattern0 |= SHIFT_L(pPriv->pattern0, 1); + pPriv->pattern1 |= SHIFT_L(pPriv->pattern1, 1); + case 2: + pPriv->pattern0 |= SHIFT_L(pPriv->pattern0, 2); + pPriv->pattern1 |= SHIFT_L(pPriv->pattern1, 2); + case 4: + pPriv->pattern0 |= SHIFT_L(pPriv->pattern0, 4); + pPriv->pattern1 |= SHIFT_L(pPriv->pattern1, 4); + } } + if (infoRec->Mono8x8PatternFillFlags & BIT_ORDER_IN_BYTE_MSBFIRST) { + pPriv->pattern0 = SWAP_BITS_IN_BYTES(pPriv->pattern0); + pPriv->pattern1 = SWAP_BITS_IN_BYTES(pPriv->pattern1); + } return TRUE; } - Bool XAACheckTileReducibility(PixmapPtr pPixmap, Bool checkMono) { @@ -1202,453 +1297,513 @@ XAACheckTileReducibility(PixmapPtr pPixmap, Bool checkMono) pPriv->flags |= REDUCIBILITY_CHECKED; pPriv->flags &= ~(REDUCIBILITY_CHECKED | REDUCIBLE_TO_2_COLOR); - if((w > 32) || (h > 32) || (w & (w - 1)) || (h & (h - 1))) - return FALSE; + if ((w > 32) || (h > 32) || (w & (w - 1)) || (h & (h - 1))) + return FALSE; dwords = ((w * pPixmap->drawable.bitsPerPixel) + 31) >> 5; i = (h > 8) ? 8 : h; + if (w > 8) { + IntPtr = (CARD32 *) pPixmap->devPrivate.ptr; + switch (pPixmap->drawable.bitsPerPixel) { + case 8: + while (i--) { + for (j = 2; j < dwords; j++) + if (IntPtr[j] != IntPtr[j & 0x01]) + return FALSE; + IntPtr += pitch; + } + break; + case 16: + while (i--) { + for (j = 4; j < dwords; j++) + if (IntPtr[j] != IntPtr[j & 0x03]) + return FALSE; + IntPtr += pitch; + } + break; + case 24: + while (i--) { + for (j = 6; j < dwords; j++) + if (IntPtr[j] != IntPtr[j % 6]) + return FALSE; + IntPtr += pitch; + } + break; + case 32: + while (i--) { + for (j = 8; j < dwords; j++) + if (IntPtr[j] != IntPtr[j & 0x07]) + return FALSE; + IntPtr += pitch; + } + break; + default: + return FALSE; + } + + } - if(w > 8) { - IntPtr = (CARD32*)pPixmap->devPrivate.ptr; - switch(pPixmap->drawable.bitsPerPixel) { - case 8: - while(i--) { - for(j = 2; j < dwords; j++) - if(IntPtr[j] != IntPtr[j & 0x01]) - return FALSE; - IntPtr += pitch; - } - break; - case 16: - while(i--) { - for(j = 4; j < dwords; j++) - if(IntPtr[j] != IntPtr[j & 0x03]) - return FALSE; - IntPtr += pitch; - } - break; - case 24: - while(i--) { - for(j = 6; j < dwords; j++) - if(IntPtr[j] != IntPtr[j % 6]) - return FALSE; - IntPtr += pitch; - } - break; - case 32: - while(i--) { - for(j = 8; j < dwords; j++) - if(IntPtr[j] != IntPtr[j & 0x07]) - return FALSE; - IntPtr += pitch; - } - break; - default: return FALSE; - } - - } - - - if(h == 32) { - CARD32 *IntPtr2, *IntPtr3, *IntPtr4; - i = 8; - IntPtr = (CARD32*)pPixmap->devPrivate.ptr; - IntPtr2 = IntPtr + (pitch << 3); - IntPtr3 = IntPtr2 + (pitch << 3); - IntPtr4 = IntPtr3 + (pitch << 3); - while(i--) { - for(j = 0; j < dwords; j++) - if((IntPtr[j] != IntPtr2[j]) || (IntPtr[j] != IntPtr3[j]) || - (IntPtr[j] != IntPtr4[j])) - return FALSE; - IntPtr += pitch; - IntPtr2 += pitch; - IntPtr3 += pitch; - IntPtr4 += pitch; - } - } else if (h == 16) { + if (h == 32) { + CARD32 *IntPtr2, *IntPtr3, *IntPtr4; + + i = 8; + IntPtr = (CARD32 *) pPixmap->devPrivate.ptr; + IntPtr2 = IntPtr + (pitch << 3); + IntPtr3 = IntPtr2 + (pitch << 3); + IntPtr4 = IntPtr3 + (pitch << 3); + while (i--) { + for (j = 0; j < dwords; j++) + if ((IntPtr[j] != IntPtr2[j]) || (IntPtr[j] != IntPtr3[j]) || + (IntPtr[j] != IntPtr4[j])) + return FALSE; + IntPtr += pitch; + IntPtr2 += pitch; + IntPtr3 += pitch; + IntPtr4 += pitch; + } + } + else if (h == 16) { CARD32 *IntPtr2; - i = 8; - IntPtr = (CARD32*)pPixmap->devPrivate.ptr; - IntPtr2 = IntPtr + (pitch << 3); - while(i--) { - for(j = 0; j < dwords; j++) - if(IntPtr[j] != IntPtr2[j]) - return FALSE; - IntPtr += pitch; - IntPtr2 += pitch; - } - } - + + i = 8; + IntPtr = (CARD32 *) pPixmap->devPrivate.ptr; + IntPtr2 = IntPtr + (pitch << 3); + while (i--) { + for (j = 0; j < dwords; j++) + if (IntPtr[j] != IntPtr2[j]) + return FALSE; + IntPtr += pitch; + IntPtr2 += pitch; + } + } + pPriv->flags |= REDUCIBLE_TO_8x8; - if(checkMono) { - XAAInfoRecPtr infoRec = - GET_XAAINFORECPTR_FROM_DRAWABLE(&pPixmap->drawable); - unsigned char bits[8]; - int fg, bg = -1, x, y; - - i = (h > 8) ? 8 : h; - j = (w > 8) ? 8 : w; - - if(pPixmap->drawable.bitsPerPixel == 8) { - unsigned char *srcp = pPixmap->devPrivate.ptr; - fg = srcp[0]; - pitch = pPixmap->devKind; - for(y = 0; y < i; y++) { - bits[y] = 0; - for(x = 0; x < j; x++) { - if(srcp[x] != fg) { - if(bg == -1) bg = srcp[x]; - else if(bg != srcp[x]) return TRUE; - } else bits[y] |= 1 << x; - } - srcp += pitch; - } - } else if(pPixmap->drawable.bitsPerPixel == 16) { - unsigned short *srcp = (unsigned short*)pPixmap->devPrivate.ptr; - fg = srcp[0]; - pitch = pPixmap->devKind >> 1; - for(y = 0; y < i; y++) { - bits[y] = 0; - for(x = 0; x < j; x++) { - if(srcp[x] != fg) { - if(bg == -1) bg = srcp[x]; - else if(bg != srcp[x]) return TRUE; - } else bits[y] |= 1 << x; - } - srcp += pitch; - } - } else if(pPixmap->drawable.bitsPerPixel == 24) { - CARD32 val; - unsigned char *srcp = pPixmap->devPrivate.ptr; - fg = *((CARD32*)srcp) & 0x00FFFFFF; - pitch = pPixmap->devKind; - j *= 3; - for(y = 0; y < i; y++) { - bits[y] = 0; - for(x = 0; x < j; x+=3) { - val = *((CARD32*)(srcp+x)) & 0x00FFFFFF; - if(val != fg) { - if(bg == -1) bg = val; - else if(bg != val) - return TRUE; - } else bits[y] |= 1 << (x/3); - } - srcp += pitch; - } - } else if(pPixmap->drawable.bitsPerPixel == 32) { - IntPtr = (CARD32*)pPixmap->devPrivate.ptr; - fg = IntPtr[0]; - for(y = 0; y < i; y++) { - bits[y] = 0; - for(x = 0; x < j; x++) { - if(IntPtr[x] != fg) { - if(bg == -1) bg = IntPtr[x]; - else if(bg != IntPtr[x]) return TRUE; - } else bits[y] |= 1 << x; - } - IntPtr += pitch; - } - } else return TRUE; + if (checkMono) { + XAAInfoRecPtr infoRec = + GET_XAAINFORECPTR_FROM_DRAWABLE(&pPixmap->drawable); + unsigned char bits[8]; + int fg, bg = -1, x, y; + + i = (h > 8) ? 8 : h; + j = (w > 8) ? 8 : w; + + if (pPixmap->drawable.bitsPerPixel == 8) { + unsigned char *srcp = pPixmap->devPrivate.ptr; + + fg = srcp[0]; + pitch = pPixmap->devKind; + for (y = 0; y < i; y++) { + bits[y] = 0; + for (x = 0; x < j; x++) { + if (srcp[x] != fg) { + if (bg == -1) + bg = srcp[x]; + else if (bg != srcp[x]) + return TRUE; + } + else + bits[y] |= 1 << x; + } + srcp += pitch; + } + } + else if (pPixmap->drawable.bitsPerPixel == 16) { + unsigned short *srcp = (unsigned short *) pPixmap->devPrivate.ptr; + + fg = srcp[0]; + pitch = pPixmap->devKind >> 1; + for (y = 0; y < i; y++) { + bits[y] = 0; + for (x = 0; x < j; x++) { + if (srcp[x] != fg) { + if (bg == -1) + bg = srcp[x]; + else if (bg != srcp[x]) + return TRUE; + } + else + bits[y] |= 1 << x; + } + srcp += pitch; + } + } + else if (pPixmap->drawable.bitsPerPixel == 24) { + CARD32 val; + unsigned char *srcp = pPixmap->devPrivate.ptr; + + fg = *((CARD32 *) srcp) & 0x00FFFFFF; + pitch = pPixmap->devKind; + j *= 3; + for (y = 0; y < i; y++) { + bits[y] = 0; + for (x = 0; x < j; x += 3) { + val = *((CARD32 *) (srcp + x)) & 0x00FFFFFF; + if (val != fg) { + if (bg == -1) + bg = val; + else if (bg != val) + return TRUE; + } + else + bits[y] |= 1 << (x / 3); + } + srcp += pitch; + } + } + else if (pPixmap->drawable.bitsPerPixel == 32) { + IntPtr = (CARD32 *) pPixmap->devPrivate.ptr; + fg = IntPtr[0]; + for (y = 0; y < i; y++) { + bits[y] = 0; + for (x = 0; x < j; x++) { + if (IntPtr[x] != fg) { + if (bg == -1) + bg = IntPtr[x]; + else if (bg != IntPtr[x]) + return TRUE; + } + else + bits[y] |= 1 << x; + } + IntPtr += pitch; + } + } + else + return TRUE; pPriv->fg = fg; - if(bg == -1) pPriv->bg = fg; - else pPriv->bg = bg; - - if(h < 8) { - switch(h) { - case 1: bits[1] = bits[0]; - case 2: bits[2] = bits[0]; bits[3] = bits[1]; - case 4: bits[4] = bits[0]; bits[5] = bits[1]; - bits[6] = bits[2]; bits[7] = bits[3]; - break; - } - } - - pPriv->pattern0 = - bits[0] | (bits[1]<<8) | (bits[2]<<16) | (bits[3]<<24); - pPriv->pattern1 = - bits[4] | (bits[5]<<8) | (bits[6]<<16) | (bits[7]<<24); - - if(w < 8) { - switch(w) { - case 1: pPriv->pattern0 |= (pPriv->pattern0 << 1); - pPriv->pattern1 |= (pPriv->pattern1 << 1); - case 2: pPriv->pattern0 |= (pPriv->pattern0 << 2); - pPriv->pattern1 |= (pPriv->pattern1 << 2); - case 4: pPriv->pattern0 |= (pPriv->pattern0 << 4); - pPriv->pattern1 |= (pPriv->pattern1 << 4); - } - } - pPriv->flags |= REDUCIBLE_TO_2_COLOR; - - if(infoRec->Mono8x8PatternFillFlags & BIT_ORDER_IN_BYTE_MSBFIRST) { - pPriv->pattern0 = SWAP_BITS_IN_BYTES(pPriv->pattern0); - pPriv->pattern1 = SWAP_BITS_IN_BYTES(pPriv->pattern1); - } + if (bg == -1) + pPriv->bg = fg; + else + pPriv->bg = bg; + + if (h < 8) { + switch (h) { + case 1: + bits[1] = bits[0]; + case 2: + bits[2] = bits[0]; + bits[3] = bits[1]; + case 4: + bits[4] = bits[0]; + bits[5] = bits[1]; + bits[6] = bits[2]; + bits[7] = bits[3]; + break; + } + } + + pPriv->pattern0 = + bits[0] | (bits[1] << 8) | (bits[2] << 16) | (bits[3] << 24); + pPriv->pattern1 = + bits[4] | (bits[5] << 8) | (bits[6] << 16) | (bits[7] << 24); + + if (w < 8) { + switch (w) { + case 1: + pPriv->pattern0 |= (pPriv->pattern0 << 1); + pPriv->pattern1 |= (pPriv->pattern1 << 1); + case 2: + pPriv->pattern0 |= (pPriv->pattern0 << 2); + pPriv->pattern1 |= (pPriv->pattern1 << 2); + case 4: + pPriv->pattern0 |= (pPriv->pattern0 << 4); + pPriv->pattern1 |= (pPriv->pattern1 << 4); + } + } + pPriv->flags |= REDUCIBLE_TO_2_COLOR; + + if (infoRec->Mono8x8PatternFillFlags & BIT_ORDER_IN_BYTE_MSBFIRST) { + pPriv->pattern0 = SWAP_BITS_IN_BYTES(pPriv->pattern0); + pPriv->pattern1 = SWAP_BITS_IN_BYTES(pPriv->pattern1); + } } return TRUE; } +void +XAATileCache(ScrnInfoPtr pScrn, XAACacheInfoPtr pCache, int w, int h) +{ + XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); + + (*infoRec->SetupForScreenToScreenCopy) (pScrn, 1, 1, GXcopy, ~0, -1); + + while ((w << 1) <= pCache->w) { + (*infoRec->SubsequentScreenToScreenCopy) (pScrn, pCache->x, pCache->y, + pCache->x + w, pCache->y, w, + h); + w <<= 1; + } + if (w != pCache->w) { + (*infoRec->SubsequentScreenToScreenCopy) (pScrn, pCache->x, pCache->y, + pCache->x + w, pCache->y, + pCache->w - w, h); + w = pCache->w; + } -void XAATileCache( - ScrnInfoPtr pScrn, - XAACacheInfoPtr pCache, - int w, int h -) { - XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); - - (*infoRec->SetupForScreenToScreenCopy)(pScrn, 1, 1, GXcopy, ~0, -1); - - while((w << 1) <= pCache->w) { - (*infoRec->SubsequentScreenToScreenCopy)(pScrn, pCache->x, pCache->y, - pCache->x + w, pCache->y, w, h); - w <<= 1; - } - if(w != pCache->w) { - (*infoRec->SubsequentScreenToScreenCopy)(pScrn, pCache->x, pCache->y, - pCache->x + w, pCache->y, pCache->w - w, h); - w = pCache->w; - } - - while((h << 1) <= pCache->h) { - (*infoRec->SubsequentScreenToScreenCopy)(pScrn, pCache->x, pCache->y, - pCache->x, pCache->y + h, w, h); - h <<= 1; - } - if(h != pCache->h) { - (*infoRec->SubsequentScreenToScreenCopy)(pScrn, pCache->x, pCache->y, - pCache->x, pCache->y + h, w, pCache->h - h); - } - SET_SYNC_FLAG(infoRec); + while ((h << 1) <= pCache->h) { + (*infoRec->SubsequentScreenToScreenCopy) (pScrn, pCache->x, pCache->y, + pCache->x, pCache->y + h, w, + h); + h <<= 1; + } + if (h != pCache->h) { + (*infoRec->SubsequentScreenToScreenCopy) (pScrn, pCache->x, pCache->y, + pCache->x, pCache->y + h, w, + pCache->h - h); + } + SET_SYNC_FLAG(infoRec); } XAACacheInfoPtr XAACacheTile(ScrnInfoPtr pScrn, PixmapPtr pPix) { - int w = pPix->drawable.width; - int h = pPix->drawable.height; - int size = max(w, h); - XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); - XAAPixmapCachePrivatePtr pCachePriv = - (XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate; - XAACacheInfoPtr pCache, cacheRoot = NULL; - int i, max = 0; - int *current; - - if(size <= 128) { - if(pCachePriv->Info128) { - cacheRoot = pCachePriv->Info128; - max = pCachePriv->Num128x128; - current = &pCachePriv->Current128; - } else { - cacheRoot = pCachePriv->InfoPartial; - max = pCachePriv->NumPartial; - current = &pCachePriv->CurrentPartial; - } - } else if(size <= 256) { - cacheRoot = pCachePriv->Info256; - max = pCachePriv->Num256x256; - current = &pCachePriv->Current256; - } else if(size <= 512) { - cacheRoot = pCachePriv->Info512; - max = pCachePriv->Num512x512; - current = &pCachePriv->Current512; - } else { /* something's wrong */ - ErrorF("Something's wrong in XAACacheTile()\n"); - return pCachePriv->Info128; - } - - pCache = cacheRoot; - - /* lets look for it */ - for(i = 0; i < max; i++, pCache++) { - if(pCache->serialNumber == pPix->drawable.serialNumber) { - pCache->trans_color = -1; - return pCache; - } - } - - pCache = &cacheRoot[(*current)++]; - if(*current >= max) *current = 0; - - pCache->serialNumber = pPix->drawable.serialNumber; - pCache->trans_color = pCache->bg = pCache->fg = -1; - pCache->orig_w = w; pCache->orig_h = h; - (*infoRec->WritePixmapToCache)( - pScrn, pCache->x, pCache->y, w, h, pPix->devPrivate.ptr, - pPix->devKind, pPix->drawable.bitsPerPixel, pPix->drawable.depth); - if(!(infoRec->PixmapCacheFlags & DO_NOT_TILE_COLOR_DATA) && - ((w != pCache->w) || (h != pCache->h))) - XAATileCache(pScrn, pCache, w, h); - - return pCache; + int w = pPix->drawable.width; + int h = pPix->drawable.height; + int size = max(w, h); + XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); + XAAPixmapCachePrivatePtr pCachePriv = + (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate; + XAACacheInfoPtr pCache, cacheRoot = NULL; + int i, max = 0; + int *current; + + if (size <= 128) { + if (pCachePriv->Info128) { + cacheRoot = pCachePriv->Info128; + max = pCachePriv->Num128x128; + current = &pCachePriv->Current128; + } + else { + cacheRoot = pCachePriv->InfoPartial; + max = pCachePriv->NumPartial; + current = &pCachePriv->CurrentPartial; + } + } + else if (size <= 256) { + cacheRoot = pCachePriv->Info256; + max = pCachePriv->Num256x256; + current = &pCachePriv->Current256; + } + else if (size <= 512) { + cacheRoot = pCachePriv->Info512; + max = pCachePriv->Num512x512; + current = &pCachePriv->Current512; + } + else { /* something's wrong */ + ErrorF("Something's wrong in XAACacheTile()\n"); + return pCachePriv->Info128; + } + + pCache = cacheRoot; + + /* lets look for it */ + for (i = 0; i < max; i++, pCache++) { + if (pCache->serialNumber == pPix->drawable.serialNumber) { + pCache->trans_color = -1; + return pCache; + } + } + + pCache = &cacheRoot[(*current)++]; + if (*current >= max) + *current = 0; + + pCache->serialNumber = pPix->drawable.serialNumber; + pCache->trans_color = pCache->bg = pCache->fg = -1; + pCache->orig_w = w; + pCache->orig_h = h; + (*infoRec->WritePixmapToCache) (pScrn, pCache->x, pCache->y, w, h, + pPix->devPrivate.ptr, pPix->devKind, + pPix->drawable.bitsPerPixel, + pPix->drawable.depth); + if (!(infoRec->PixmapCacheFlags & DO_NOT_TILE_COLOR_DATA) && + ((w != pCache->w) || (h != pCache->h))) + XAATileCache(pScrn, pCache, w, h); + + return pCache; } XAACacheInfoPtr XAACacheMonoStipple(ScrnInfoPtr pScrn, PixmapPtr pPix) { - int w = pPix->drawable.width; - int h = pPix->drawable.height; - XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); - XAAPixmapCachePrivatePtr pCachePriv = - (XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate; - XAACacheInfoPtr pCache, cacheRoot = NULL; - int i, max = 0, funcNo, pad, dwords, bpp = pScrn->bitsPerPixel; - int *current; - StippleScanlineProcPtr StippleFunc; - unsigned char *data, *srcPtr, *dstPtr; - - if((h <= 128) && (w <= 128 * bpp)) { - if(pCachePriv->Info128) { - cacheRoot = pCachePriv->Info128; - max = pCachePriv->Num128x128; - current = &pCachePriv->Current128; - } else { - cacheRoot = pCachePriv->InfoPartial; - max = pCachePriv->NumPartial; - current = &pCachePriv->CurrentPartial; - } - } else if((h <= 256) && (w <= 256 * bpp)){ - cacheRoot = pCachePriv->Info256; - max = pCachePriv->Num256x256; - current = &pCachePriv->Current256; - } else if((h <= 512) && (w <= 526 * bpp)){ - cacheRoot = pCachePriv->Info512; - max = pCachePriv->Num512x512; - current = &pCachePriv->Current512; - } else { /* something's wrong */ - ErrorF("Something's wrong in XAACacheMonoStipple()\n"); - return pCachePriv->Info128; - } - - pCache = cacheRoot; - - /* lets look for it */ - for(i = 0; i < max; i++, pCache++) { - if((pCache->serialNumber == pPix->drawable.serialNumber) && - (pCache->fg == -1) && (pCache->bg == -1)) { - pCache->trans_color = -1; - return pCache; - } - } - - pCache = &cacheRoot[(*current)++]; - if(*current >= max) *current = 0; - - pCache->serialNumber = pPix->drawable.serialNumber; - pCache->trans_color = pCache->bg = pCache->fg = -1; - pCache->orig_w = w; pCache->orig_h = h; - - if(w <= 32) { - if(w & (w - 1)) funcNo = 1; - else funcNo = 0; - } else funcNo = 2; - - pad = BitmapBytePad(pCache->w * bpp); - dwords = bytes_to_int32(pad); - dstPtr = data = (unsigned char*)malloc(pad * pCache->h); - srcPtr = (unsigned char*)pPix->devPrivate.ptr; - - if(infoRec->ScreenToScreenColorExpandFillFlags & BIT_ORDER_IN_BYTE_MSBFIRST) - StippleFunc = XAAStippleScanlineFuncMSBFirst[funcNo]; - else - StippleFunc = XAAStippleScanlineFuncLSBFirst[funcNo]; - - /* don't bother generating more than we'll ever use */ - max = ((pScrn->displayWidth + w - 1) + 31) >> 5; - if(dwords > max) - dwords = max; - - for(i = 0; i < h; i++) { - (*StippleFunc)((CARD32*)dstPtr, (CARD32*)srcPtr, 0, w, dwords); - srcPtr += pPix->devKind; - dstPtr += pad; - } - - while((h<<1) <= pCache->h) { - memcpy(data + (pad * h), data, pad * h); - h <<= 1; - } - - if(h < pCache->h) - memcpy(data + (pad * h), data, pad * (pCache->h - h)); - - (*infoRec->WritePixmapToCache)( - pScrn, pCache->x, pCache->y, pCache->w, pCache->h, data, - pad, bpp, pScrn->depth); - - free(data); - - return pCache; + int w = pPix->drawable.width; + int h = pPix->drawable.height; + XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); + XAAPixmapCachePrivatePtr pCachePriv = + (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate; + XAACacheInfoPtr pCache, cacheRoot = NULL; + int i, max = 0, funcNo, pad, dwords, bpp = pScrn->bitsPerPixel; + int *current; + StippleScanlineProcPtr StippleFunc; + unsigned char *data, *srcPtr, *dstPtr; + + if ((h <= 128) && (w <= 128 * bpp)) { + if (pCachePriv->Info128) { + cacheRoot = pCachePriv->Info128; + max = pCachePriv->Num128x128; + current = &pCachePriv->Current128; + } + else { + cacheRoot = pCachePriv->InfoPartial; + max = pCachePriv->NumPartial; + current = &pCachePriv->CurrentPartial; + } + } + else if ((h <= 256) && (w <= 256 * bpp)) { + cacheRoot = pCachePriv->Info256; + max = pCachePriv->Num256x256; + current = &pCachePriv->Current256; + } + else if ((h <= 512) && (w <= 526 * bpp)) { + cacheRoot = pCachePriv->Info512; + max = pCachePriv->Num512x512; + current = &pCachePriv->Current512; + } + else { /* something's wrong */ + ErrorF("Something's wrong in XAACacheMonoStipple()\n"); + return pCachePriv->Info128; + } + + pCache = cacheRoot; + + /* lets look for it */ + for (i = 0; i < max; i++, pCache++) { + if ((pCache->serialNumber == pPix->drawable.serialNumber) && + (pCache->fg == -1) && (pCache->bg == -1)) { + pCache->trans_color = -1; + return pCache; + } + } + + pCache = &cacheRoot[(*current)++]; + if (*current >= max) + *current = 0; + + pCache->serialNumber = pPix->drawable.serialNumber; + pCache->trans_color = pCache->bg = pCache->fg = -1; + pCache->orig_w = w; + pCache->orig_h = h; + + if (w <= 32) { + if (w & (w - 1)) + funcNo = 1; + else + funcNo = 0; + } + else + funcNo = 2; + + pad = BitmapBytePad(pCache->w * bpp); + dwords = bytes_to_int32(pad); + dstPtr = data = (unsigned char *) malloc(pad * pCache->h); + srcPtr = (unsigned char *) pPix->devPrivate.ptr; + + if (infoRec-> + ScreenToScreenColorExpandFillFlags & BIT_ORDER_IN_BYTE_MSBFIRST) + StippleFunc = XAAStippleScanlineFuncMSBFirst[funcNo]; + else + StippleFunc = XAAStippleScanlineFuncLSBFirst[funcNo]; + + /* don't bother generating more than we'll ever use */ + max = ((pScrn->displayWidth + w - 1) + 31) >> 5; + if (dwords > max) + dwords = max; + + for (i = 0; i < h; i++) { + (*StippleFunc) ((CARD32 *) dstPtr, (CARD32 *) srcPtr, 0, w, dwords); + srcPtr += pPix->devKind; + dstPtr += pad; + } + + while ((h << 1) <= pCache->h) { + memcpy(data + (pad * h), data, pad * h); + h <<= 1; + } + + if (h < pCache->h) + memcpy(data + (pad * h), data, pad * (pCache->h - h)); + + (*infoRec->WritePixmapToCache) (pScrn, pCache->x, pCache->y, pCache->w, + pCache->h, data, pad, bpp, pScrn->depth); + + free(data); + + return pCache; } XAACacheInfoPtr XAACachePlanarMonoStipple(ScrnInfoPtr pScrn, PixmapPtr pPix) { - int w = pPix->drawable.width; - int h = pPix->drawable.height; - XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); - XAAPixmapCachePrivatePtr pCachePriv = - (XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate; - XAACacheInfoPtr pCache, cacheRoot = NULL; - int i, max = 0; - int *current; - - if((h <= 128) && (w <= 128)) { - if(pCachePriv->Info128) { - cacheRoot = pCachePriv->Info128; - max = pCachePriv->Num128x128; - current = &pCachePriv->Current128; - } else { - cacheRoot = pCachePriv->InfoPartial; - max = pCachePriv->NumPartial; - current = &pCachePriv->CurrentPartial; - } - } else if((h <= 256) && (w <= 256)){ - cacheRoot = pCachePriv->Info256; - max = pCachePriv->Num256x256; - current = &pCachePriv->Current256; - } else if((h <= 512) && (w <= 526)){ - cacheRoot = pCachePriv->Info512; - max = pCachePriv->Num512x512; - current = &pCachePriv->Current512; - } else { /* something's wrong */ - ErrorF("Something's wrong in XAACachePlanarMonoStipple()\n"); - return pCachePriv->Info128; - } - - pCache = cacheRoot; - - /* lets look for it */ - for(i = 0; i < max; i++, pCache++) { - if((pCache->serialNumber == pPix->drawable.serialNumber) && - (pCache->fg == -1) && (pCache->bg == -1)) { - pCache->trans_color = -1; - return pCache; - } - } - - pCache = &cacheRoot[(*current)++]; - if(*current >= max) *current = 0; - - pCache->serialNumber = pPix->drawable.serialNumber; - pCache->trans_color = pCache->bg = pCache->fg = -1; - pCache->orig_w = w; pCache->orig_h = h; - - /* Plane 0 holds the stipple. Plane 1 holds the inverted stipple */ - (*infoRec->WriteBitmapToCache)(pScrn, pCache->x, pCache->y, - pPix->drawable.width, pPix->drawable.height, pPix->devPrivate.ptr, - pPix->devKind, 1, 2); - if(!(infoRec->PixmapCacheFlags & DO_NOT_TILE_MONO_DATA) && - ((w != pCache->w) || (h != pCache->h))) - XAATileCache(pScrn, pCache, w, h); - - return pCache; + int w = pPix->drawable.width; + int h = pPix->drawable.height; + XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); + XAAPixmapCachePrivatePtr pCachePriv = + (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate; + XAACacheInfoPtr pCache, cacheRoot = NULL; + int i, max = 0; + int *current; + + if ((h <= 128) && (w <= 128)) { + if (pCachePriv->Info128) { + cacheRoot = pCachePriv->Info128; + max = pCachePriv->Num128x128; + current = &pCachePriv->Current128; + } + else { + cacheRoot = pCachePriv->InfoPartial; + max = pCachePriv->NumPartial; + current = &pCachePriv->CurrentPartial; + } + } + else if ((h <= 256) && (w <= 256)) { + cacheRoot = pCachePriv->Info256; + max = pCachePriv->Num256x256; + current = &pCachePriv->Current256; + } + else if ((h <= 512) && (w <= 526)) { + cacheRoot = pCachePriv->Info512; + max = pCachePriv->Num512x512; + current = &pCachePriv->Current512; + } + else { /* something's wrong */ + ErrorF("Something's wrong in XAACachePlanarMonoStipple()\n"); + return pCachePriv->Info128; + } + + pCache = cacheRoot; + + /* lets look for it */ + for (i = 0; i < max; i++, pCache++) { + if ((pCache->serialNumber == pPix->drawable.serialNumber) && + (pCache->fg == -1) && (pCache->bg == -1)) { + pCache->trans_color = -1; + return pCache; + } + } + + pCache = &cacheRoot[(*current)++]; + if (*current >= max) + *current = 0; + + pCache->serialNumber = pPix->drawable.serialNumber; + pCache->trans_color = pCache->bg = pCache->fg = -1; + pCache->orig_w = w; + pCache->orig_h = h; + + /* Plane 0 holds the stipple. Plane 1 holds the inverted stipple */ + (*infoRec->WriteBitmapToCache) (pScrn, pCache->x, pCache->y, + pPix->drawable.width, pPix->drawable.height, + pPix->devPrivate.ptr, pPix->devKind, 1, 2); + if (!(infoRec->PixmapCacheFlags & DO_NOT_TILE_MONO_DATA) && + ((w != pCache->w) || (h != pCache->h))) + XAATileCache(pScrn, pCache, w, h); + + return pCache; } XAACachePlanarMonoStippleProc @@ -1660,432 +1815,437 @@ XAAGetCachePlanarMonoStipple(void) XAACacheInfoPtr XAACacheStipple(ScrnInfoPtr pScrn, PixmapPtr pPix, int fg, int bg) { - int w = pPix->drawable.width; - int h = pPix->drawable.height; - int size = max(w, h); - XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); - XAAPixmapCachePrivatePtr pCachePriv = - (XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate; - XAACacheInfoPtr pCache, cacheRoot = NULL; - int i, max = 0; - int *current; - - if(size <= 128) { - if(pCachePriv->Info128) { - cacheRoot = pCachePriv->Info128; - max = pCachePriv->Num128x128; - current = &pCachePriv->Current128; - } else { - cacheRoot = pCachePriv->InfoPartial; - max = pCachePriv->NumPartial; - current = &pCachePriv->CurrentPartial; - } - } else if(size <= 256) { - cacheRoot = pCachePriv->Info256; - max = pCachePriv->Num256x256; - current = &pCachePriv->Current256; - } else if(size <= 512) { - cacheRoot = pCachePriv->Info512; - max = pCachePriv->Num512x512; - current = &pCachePriv->Current512; - } else { /* something's wrong */ - ErrorF("Something's wrong in XAACacheStipple()\n"); - return pCachePriv->Info128; - } - - pCache = cacheRoot; - /* lets look for it */ - if(bg == -1) - for(i = 0; i < max; i++, pCache++) { - if((pCache->serialNumber == pPix->drawable.serialNumber) && - (fg == pCache->fg) && (pCache->fg != pCache->bg)) { - pCache->trans_color = pCache->bg; - return pCache; - } - } - else - for(i = 0; i < max; i++, pCache++) { - if((pCache->serialNumber == pPix->drawable.serialNumber) && - (fg == pCache->fg) && (bg == pCache->bg)) { - pCache->trans_color = -1; - return pCache; - } - } - - pCache = &cacheRoot[(*current)++]; - if(*current >= max) *current = 0; - - pCache->serialNumber = pPix->drawable.serialNumber; - pCache->fg = fg; - if(bg == -1) - pCache->trans_color = bg = fg ^ 1; - else - pCache->trans_color = -1; - pCache->bg = bg; - - pCache->orig_w = w; pCache->orig_h = h; - (*infoRec->WriteBitmapToCache)(pScrn, pCache->x, pCache->y, - pPix->drawable.width, pPix->drawable.height, pPix->devPrivate.ptr, - pPix->devKind, fg, bg); - if(!(infoRec->PixmapCacheFlags & DO_NOT_TILE_COLOR_DATA) && - ((w != pCache->w) || (h != pCache->h))) - XAATileCache(pScrn, pCache, w, h); - - return pCache; -} + int w = pPix->drawable.width; + int h = pPix->drawable.height; + int size = max(w, h); + XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); + XAAPixmapCachePrivatePtr pCachePriv = + (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate; + XAACacheInfoPtr pCache, cacheRoot = NULL; + int i, max = 0; + int *current; + + if (size <= 128) { + if (pCachePriv->Info128) { + cacheRoot = pCachePriv->Info128; + max = pCachePriv->Num128x128; + current = &pCachePriv->Current128; + } + else { + cacheRoot = pCachePriv->InfoPartial; + max = pCachePriv->NumPartial; + current = &pCachePriv->CurrentPartial; + } + } + else if (size <= 256) { + cacheRoot = pCachePriv->Info256; + max = pCachePriv->Num256x256; + current = &pCachePriv->Current256; + } + else if (size <= 512) { + cacheRoot = pCachePriv->Info512; + max = pCachePriv->Num512x512; + current = &pCachePriv->Current512; + } + else { /* something's wrong */ + ErrorF("Something's wrong in XAACacheStipple()\n"); + return pCachePriv->Info128; + } + pCache = cacheRoot; + /* lets look for it */ + if (bg == -1) + for (i = 0; i < max; i++, pCache++) { + if ((pCache->serialNumber == pPix->drawable.serialNumber) && + (fg == pCache->fg) && (pCache->fg != pCache->bg)) { + pCache->trans_color = pCache->bg; + return pCache; + } + } + else + for (i = 0; i < max; i++, pCache++) { + if ((pCache->serialNumber == pPix->drawable.serialNumber) && + (fg == pCache->fg) && (bg == pCache->bg)) { + pCache->trans_color = -1; + return pCache; + } + } + pCache = &cacheRoot[(*current)++]; + if (*current >= max) + *current = 0; + + pCache->serialNumber = pPix->drawable.serialNumber; + pCache->fg = fg; + if (bg == -1) + pCache->trans_color = bg = fg ^ 1; + else + pCache->trans_color = -1; + pCache->bg = bg; + + pCache->orig_w = w; + pCache->orig_h = h; + (*infoRec->WriteBitmapToCache) (pScrn, pCache->x, pCache->y, + pPix->drawable.width, pPix->drawable.height, + pPix->devPrivate.ptr, pPix->devKind, fg, + bg); + if (!(infoRec->PixmapCacheFlags & DO_NOT_TILE_COLOR_DATA) && + ((w != pCache->w) || (h != pCache->h))) + XAATileCache(pScrn, pCache, w, h); + + return pCache; +} XAACacheInfoPtr XAACacheMono8x8Pattern(ScrnInfoPtr pScrn, int pat0, int pat1) { - XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); - XAAPixmapCachePrivatePtr pCachePriv = - (XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate; - XAACacheInfoPtr pCache = pCachePriv->InfoMono; - int i; - - for(i = 0; i < pCachePriv->NumMono; i++, pCache++) { - if(pCache->serialNumber && - (pCache->pat0 == pat0) && (pCache->pat1 == pat1)) - return pCache; - } - - /* OK, let's cache it */ - pCache = &pCachePriv->InfoMono[pCachePriv->CurrentMono++]; - if(pCachePriv->CurrentMono >= pCachePriv->NumMono) - pCachePriv->CurrentMono = 0; - - pCache->serialNumber = 1; /* we don't care since we do lookups by pattern */ - pCache->pat0 = pat0; - pCache->pat1 = pat1; - - (*infoRec->WriteMono8x8PatternToCache)(pScrn, pCache); - - return pCache; -} + XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); + XAAPixmapCachePrivatePtr pCachePriv = + (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate; + XAACacheInfoPtr pCache = pCachePriv->InfoMono; + int i; + for (i = 0; i < pCachePriv->NumMono; i++, pCache++) { + if (pCache->serialNumber && + (pCache->pat0 == pat0) && (pCache->pat1 == pat1)) + return pCache; + } + /* OK, let's cache it */ + pCache = &pCachePriv->InfoMono[pCachePriv->CurrentMono++]; + if (pCachePriv->CurrentMono >= pCachePriv->NumMono) + pCachePriv->CurrentMono = 0; + + pCache->serialNumber = 1; /* we don't care since we do lookups by pattern */ + pCache->pat0 = pat0; + pCache->pat1 = pat1; + + (*infoRec->WriteMono8x8PatternToCache) (pScrn, pCache); + + return pCache; +} XAACacheInfoPtr XAACacheColor8x8Pattern(ScrnInfoPtr pScrn, PixmapPtr pPix, int fg, int bg) { - XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); - XAAPixmapCachePrivatePtr pCachePriv = - (XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate; - XAACacheInfoPtr pCache = pCachePriv->InfoColor; - XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pPix); - int i; - - if(!(pixPriv->flags & REDUCIBLE_TO_2_COLOR)) { - for(i = 0; i < pCachePriv->NumColor; i++, pCache++) { - if(pCache->serialNumber == pPix->drawable.serialNumber) { - pCache->trans_color = -1; - return pCache; - } - } - pCache = &pCachePriv->InfoColor[pCachePriv->CurrentColor++]; - if(pCachePriv->CurrentColor >= pCachePriv->NumColor) - pCachePriv->CurrentColor = 0; - - pCache->serialNumber = pPix->drawable.serialNumber; - pCache->trans_color = pCache->fg = pCache->bg = -1; - } else { - int pat0 = pixPriv->pattern0; - int pat1 = pixPriv->pattern1; - - if(fg == -1) { /* it's a tile */ - fg = pixPriv->fg; bg = pixPriv->bg; - } - - if(bg == -1) { /* stipple */ - for(i = 0; i < pCachePriv->NumColor; i++, pCache++) { - if(pCache->serialNumber && - (pCache->pat0 == pat0) && (pCache->pat1 == pat1) && - (pCache->fg == fg) && (pCache->bg != fg)) { - pCache->trans_color = pCache->bg; - return pCache; - } - } - } else { /* opaque stipple */ - for(i = 0; i < pCachePriv->NumColor; i++, pCache++) { - if(pCache->serialNumber && - (pCache->pat0 == pat0) && (pCache->pat1 == pat1) && - (pCache->fg == fg) && (pCache->bg == bg)) { - pCache->trans_color = -1; - return pCache; - } - } - } - pCache = &pCachePriv->InfoColor[pCachePriv->CurrentColor++]; - if(pCachePriv->CurrentColor >= pCachePriv->NumColor) - pCachePriv->CurrentColor = 0; - - if(bg == -1) - pCache->trans_color = bg = fg ^ 1; - else - pCache->trans_color = -1; - - pCache->pat0 = pat0; pCache->pat1 = pat1; - pCache->fg = fg; pCache->bg = bg; - pCache->serialNumber = 1; - } - - (*infoRec->WriteColor8x8PatternToCache)(pScrn, pPix, pCache); - - return pCache; -} + XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); + XAAPixmapCachePrivatePtr pCachePriv = + (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate; + XAACacheInfoPtr pCache = pCachePriv->InfoColor; + XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pPix); + int i; + if (!(pixPriv->flags & REDUCIBLE_TO_2_COLOR)) { + for (i = 0; i < pCachePriv->NumColor; i++, pCache++) { + if (pCache->serialNumber == pPix->drawable.serialNumber) { + pCache->trans_color = -1; + return pCache; + } + } + pCache = &pCachePriv->InfoColor[pCachePriv->CurrentColor++]; + if (pCachePriv->CurrentColor >= pCachePriv->NumColor) + pCachePriv->CurrentColor = 0; -void -XAAWriteBitmapToCache( - ScrnInfoPtr pScrn, - int x, int y, int w, int h, - unsigned char *src, - int srcwidth, - int fg, int bg -) { - XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); - - (*infoRec->WriteBitmap)(pScrn, x, y, w, h, src, srcwidth, - 0, fg, bg, GXcopy, ~0); + pCache->serialNumber = pPix->drawable.serialNumber; + pCache->trans_color = pCache->fg = pCache->bg = -1; + } + else { + int pat0 = pixPriv->pattern0; + int pat1 = pixPriv->pattern1; + + if (fg == -1) { /* it's a tile */ + fg = pixPriv->fg; + bg = pixPriv->bg; + } + + if (bg == -1) { /* stipple */ + for (i = 0; i < pCachePriv->NumColor; i++, pCache++) { + if (pCache->serialNumber && + (pCache->pat0 == pat0) && (pCache->pat1 == pat1) && + (pCache->fg == fg) && (pCache->bg != fg)) { + pCache->trans_color = pCache->bg; + return pCache; + } + } + } + else { /* opaque stipple */ + for (i = 0; i < pCachePriv->NumColor; i++, pCache++) { + if (pCache->serialNumber && + (pCache->pat0 == pat0) && (pCache->pat1 == pat1) && + (pCache->fg == fg) && (pCache->bg == bg)) { + pCache->trans_color = -1; + return pCache; + } + } + } + pCache = &pCachePriv->InfoColor[pCachePriv->CurrentColor++]; + if (pCachePriv->CurrentColor >= pCachePriv->NumColor) + pCachePriv->CurrentColor = 0; + + if (bg == -1) + pCache->trans_color = bg = fg ^ 1; + else + pCache->trans_color = -1; + + pCache->pat0 = pat0; + pCache->pat1 = pat1; + pCache->fg = fg; + pCache->bg = bg; + pCache->serialNumber = 1; + } + + (*infoRec->WriteColor8x8PatternToCache) (pScrn, pPix, pCache); + + return pCache; } void -XAAWriteBitmapToCacheLinear( - ScrnInfoPtr pScrn, - int x, int y, int w, int h, - unsigned char *src, - int srcwidth, - int fg, int bg -){ - ScreenPtr pScreen = pScrn->pScreen; - PixmapPtr pScreenPix, pDstPix; - ChangeGCVal gcvals[2]; - GCPtr pGC; - - pScreenPix = (*pScreen->GetScreenPixmap)(pScreen); - - pDstPix = GetScratchPixmapHeader(pScreen, pScreenPix->drawable.width, - y + h, pScreenPix->drawable.depth, - pScreenPix->drawable.bitsPerPixel, - pScreenPix->devKind, - pScreenPix->devPrivate.ptr); - - pGC = GetScratchGC(pScreenPix->drawable.depth, pScreen); - gcvals[0].val = fg; - gcvals[1].val = bg; - ChangeGC(NullClient, pGC, GCForeground | GCBackground, gcvals); - ValidateGC((DrawablePtr)pDstPix, pGC); - - /* We've unwrapped already so these ops miss a sync */ - SYNC_CHECK(pScrn); - - (*pGC->ops->PutImage)((DrawablePtr)pDstPix, pGC, 1, x, y, w, h, 0, - XYBitmap, (pointer)src); - - FreeScratchGC(pGC); - FreeScratchPixmapHeader(pDstPix); -} +XAAWriteBitmapToCache(ScrnInfoPtr pScrn, + int x, int y, int w, int h, + unsigned char *src, int srcwidth, int fg, int bg) +{ + XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); + (*infoRec->WriteBitmap) (pScrn, x, y, w, h, src, srcwidth, + 0, fg, bg, GXcopy, ~0); +} void -XAAWritePixmapToCache( - ScrnInfoPtr pScrn, - int x, int y, int w, int h, - unsigned char *src, - int srcwidth, - int bpp, int depth -) { - XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); - - (*infoRec->WritePixmap)(pScrn, x, y, w, h, src, srcwidth, - GXcopy, ~0, -1, bpp, depth); -} +XAAWriteBitmapToCacheLinear(ScrnInfoPtr pScrn, + int x, int y, int w, int h, + unsigned char *src, int srcwidth, int fg, int bg) +{ + ScreenPtr pScreen = pScrn->pScreen; + PixmapPtr pScreenPix, pDstPix; + ChangeGCVal gcvals[2]; + GCPtr pGC; + + pScreenPix = (*pScreen->GetScreenPixmap) (pScreen); + + pDstPix = GetScratchPixmapHeader(pScreen, pScreenPix->drawable.width, + y + h, pScreenPix->drawable.depth, + pScreenPix->drawable.bitsPerPixel, + pScreenPix->devKind, + pScreenPix->devPrivate.ptr); + pGC = GetScratchGC(pScreenPix->drawable.depth, pScreen); + gcvals[0].val = fg; + gcvals[1].val = bg; + ChangeGC(NullClient, pGC, GCForeground | GCBackground, gcvals); + ValidateGC((DrawablePtr) pDstPix, pGC); + /* We've unwrapped already so these ops miss a sync */ + SYNC_CHECK(pScrn); + + (*pGC->ops->PutImage) ((DrawablePtr) pDstPix, pGC, 1, x, y, w, h, 0, + XYBitmap, (pointer) src); + + FreeScratchGC(pGC); + FreeScratchPixmapHeader(pDstPix); +} void -XAAWritePixmapToCacheLinear( - ScrnInfoPtr pScrn, - int x, int y, int w, int h, - unsigned char *src, - int srcwidth, - int bpp, int depth -){ - ScreenPtr pScreen = pScrn->pScreen; - PixmapPtr pScreenPix, pDstPix; - GCPtr pGC; - - pScreenPix = (*pScreen->GetScreenPixmap)(pScreen); - - pDstPix = GetScratchPixmapHeader(pScreen, x + w, y + h, - depth, bpp, pScreenPix->devKind, - pScreenPix->devPrivate.ptr); - - pGC = GetScratchGC(depth, pScreen); - ValidateGC((DrawablePtr)pDstPix, pGC); - - /* We've unwrapped already so these ops miss a sync */ - SYNC_CHECK(pScrn); - - if(bpp == BitsPerPixel(depth)) - (*pGC->ops->PutImage)((DrawablePtr)pDstPix, pGC, depth, x, y, w, - h, 0, ZPixmap, (pointer)src); - else { - PixmapPtr pSrcPix; - - pSrcPix = GetScratchPixmapHeader(pScreen, w, h, depth, bpp, - srcwidth, (pointer)src); - - (*pGC->ops->CopyArea)((DrawablePtr)pSrcPix, (DrawablePtr)pDstPix, - pGC, 0, 0, w, h, x, y); - - FreeScratchPixmapHeader(pSrcPix); - } - - FreeScratchGC(pGC); - FreeScratchPixmapHeader(pDstPix); +XAAWritePixmapToCache(ScrnInfoPtr pScrn, + int x, int y, int w, int h, + unsigned char *src, int srcwidth, int bpp, int depth) +{ + XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); + + (*infoRec->WritePixmap) (pScrn, x, y, w, h, src, srcwidth, + GXcopy, ~0, -1, bpp, depth); } +void +XAAWritePixmapToCacheLinear(ScrnInfoPtr pScrn, + int x, int y, int w, int h, + unsigned char *src, + int srcwidth, int bpp, int depth) +{ + ScreenPtr pScreen = pScrn->pScreen; + PixmapPtr pScreenPix, pDstPix; + GCPtr pGC; + + pScreenPix = (*pScreen->GetScreenPixmap) (pScreen); + + pDstPix = GetScratchPixmapHeader(pScreen, x + w, y + h, + depth, bpp, pScreenPix->devKind, + pScreenPix->devPrivate.ptr); + + pGC = GetScratchGC(depth, pScreen); + ValidateGC((DrawablePtr) pDstPix, pGC); + + /* We've unwrapped already so these ops miss a sync */ + SYNC_CHECK(pScrn); + + if (bpp == BitsPerPixel(depth)) + (*pGC->ops->PutImage) ((DrawablePtr) pDstPix, pGC, depth, x, y, w, + h, 0, ZPixmap, (pointer) src); + else { + PixmapPtr pSrcPix; + + pSrcPix = GetScratchPixmapHeader(pScreen, w, h, depth, bpp, + srcwidth, (pointer) src); + + (*pGC->ops->CopyArea) ((DrawablePtr) pSrcPix, (DrawablePtr) pDstPix, + pGC, 0, 0, w, h, x, y); + + FreeScratchPixmapHeader(pSrcPix); + } + + FreeScratchGC(pGC); + FreeScratchPixmapHeader(pDstPix); +} void -XAAWriteMono8x8PatternToCache( - ScrnInfoPtr pScrn, - XAACacheInfoPtr pCache -){ - XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); - XAAPixmapCachePrivatePtr pCachePriv = - (XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate; - unsigned char *data; - int pad, Bpp = (pScrn->bitsPerPixel >> 3); - - pCache->offsets = pCachePriv->MonoOffsets; - - pad = BitmapBytePad(pCache->w * pScrn->bitsPerPixel); - - data = (unsigned char*)malloc(pad * pCache->h); - if(!data) return; - - if(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_ORIGIN) { - CARD32* ptr = (CARD32*)data; - ptr[0] = pCache->pat0; ptr[1] = pCache->pat1; - } else { - CARD32 *ptr; - DDXPointPtr pPoint = pCache->offsets; - int patx, paty, i; - - for(i = 0; i < 64; i++, pPoint++) { - patx = pCache->pat0; paty = pCache->pat1; - XAARotateMonoPattern(&patx, &paty, i & 0x07, i >> 3, - (infoRec->Mono8x8PatternFillFlags & - BIT_ORDER_IN_BYTE_MSBFIRST)); - ptr = (CARD32*)(data + (pad * pPoint->y) + (Bpp * pPoint->x)); - ptr[0] = patx; ptr[1] = paty; - } - } - - (*infoRec->WritePixmapToCache)(pScrn, pCache->x, pCache->y, - pCache->w, pCache->h, data, pad, pScrn->bitsPerPixel, pScrn->depth); - - free(data); +XAAWriteMono8x8PatternToCache(ScrnInfoPtr pScrn, XAACacheInfoPtr pCache) +{ + XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); + XAAPixmapCachePrivatePtr pCachePriv = + (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate; + unsigned char *data; + int pad, Bpp = (pScrn->bitsPerPixel >> 3); + + pCache->offsets = pCachePriv->MonoOffsets; + + pad = BitmapBytePad(pCache->w * pScrn->bitsPerPixel); + + data = (unsigned char *) malloc(pad * pCache->h); + if (!data) + return; + + if (infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_ORIGIN) { + CARD32 *ptr = (CARD32 *) data; + + ptr[0] = pCache->pat0; + ptr[1] = pCache->pat1; + } + else { + CARD32 *ptr; + DDXPointPtr pPoint = pCache->offsets; + int patx, paty, i; + + for (i = 0; i < 64; i++, pPoint++) { + patx = pCache->pat0; + paty = pCache->pat1; + XAARotateMonoPattern(&patx, &paty, i & 0x07, i >> 3, + (infoRec->Mono8x8PatternFillFlags & + BIT_ORDER_IN_BYTE_MSBFIRST)); + ptr = (CARD32 *) (data + (pad * pPoint->y) + (Bpp * pPoint->x)); + ptr[0] = patx; + ptr[1] = paty; + } + } + + (*infoRec->WritePixmapToCache) (pScrn, pCache->x, pCache->y, + pCache->w, pCache->h, data, pad, + pScrn->bitsPerPixel, pScrn->depth); + + free(data); } void -XAAWriteColor8x8PatternToCache( - ScrnInfoPtr pScrn, - PixmapPtr pPix, - XAACacheInfoPtr pCache -){ - XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); - XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pPix); - XAAPixmapCachePrivatePtr pCachePriv = - (XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate; - int pad, i, w, h, nw, nh, Bpp; - unsigned char *data, *srcPtr, *dstPtr; - - pCache->offsets = pCachePriv->ColorOffsets; - - if(pixPriv->flags & REDUCIBLE_TO_2_COLOR) { - CARD32* ptr; - pad = BitmapBytePad(pCache->w); - data = (unsigned char*)malloc(pad * pCache->h); - if(!data) return; - - if(infoRec->Color8x8PatternFillFlags & - HARDWARE_PATTERN_PROGRAMMED_ORIGIN) { - ptr = (CARD32*)data; - ptr[0] = pCache->pat0; ptr[1] = pCache->pat1; - } else { - int patx, paty; - - ptr = (CARD32*)data; - ptr[0] = ptr[2] = pCache->pat0; ptr[1] = ptr[3] = pCache->pat1; - for(i = 1; i < 8; i++) { - patx = pCache->pat0; paty = pCache->pat1; - XAARotateMonoPattern(&patx, &paty, i, 0, - (infoRec->Mono8x8PatternFillFlags & - BIT_ORDER_IN_BYTE_MSBFIRST)); - ptr = (CARD32*)(data + (pad * i)); - ptr[0] = ptr[2] = patx; ptr[1] = ptr[3] = paty; - } - } - - (*infoRec->WriteBitmapToCache)(pScrn, pCache->x, pCache->y, - pCache->w, pCache->h, data, pad, pCache->fg, pCache->bg); +XAAWriteColor8x8PatternToCache(ScrnInfoPtr pScrn, + PixmapPtr pPix, XAACacheInfoPtr pCache) +{ + XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn); + XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pPix); + XAAPixmapCachePrivatePtr pCachePriv = + (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate; + int pad, i, w, h, nw, nh, Bpp; + unsigned char *data, *srcPtr, *dstPtr; + + pCache->offsets = pCachePriv->ColorOffsets; + + if (pixPriv->flags & REDUCIBLE_TO_2_COLOR) { + CARD32 *ptr; + + pad = BitmapBytePad(pCache->w); + data = (unsigned char *) malloc(pad * pCache->h); + if (!data) + return; + + if (infoRec->Color8x8PatternFillFlags & + HARDWARE_PATTERN_PROGRAMMED_ORIGIN) { + ptr = (CARD32 *) data; + ptr[0] = pCache->pat0; + ptr[1] = pCache->pat1; + } + else { + int patx, paty; + + ptr = (CARD32 *) data; + ptr[0] = ptr[2] = pCache->pat0; + ptr[1] = ptr[3] = pCache->pat1; + for (i = 1; i < 8; i++) { + patx = pCache->pat0; + paty = pCache->pat1; + XAARotateMonoPattern(&patx, &paty, i, 0, + (infoRec->Mono8x8PatternFillFlags & + BIT_ORDER_IN_BYTE_MSBFIRST)); + ptr = (CARD32 *) (data + (pad * i)); + ptr[0] = ptr[2] = patx; + ptr[1] = ptr[3] = paty; + } + } + + (*infoRec->WriteBitmapToCache) (pScrn, pCache->x, pCache->y, + pCache->w, pCache->h, data, pad, + pCache->fg, pCache->bg); free(data); - return; - } - - Bpp = pScrn->bitsPerPixel >> 3; - h = min(8,pPix->drawable.height); - w = min(8,pPix->drawable.width); - pad = BitmapBytePad(pCache->w * pScrn->bitsPerPixel); - - data = (unsigned char*)malloc(pad * pCache->h); - if(!data) return; - - /* Write and expand horizontally. */ - for (i = h, dstPtr = data, srcPtr = pPix->devPrivate.ptr; i--; - srcPtr += pPix->devKind, dstPtr += pScrn->bitsPerPixel) { - nw = w; - memcpy(dstPtr, srcPtr, w * Bpp); - while (nw != 8) { + return; + } + + Bpp = pScrn->bitsPerPixel >> 3; + h = min(8, pPix->drawable.height); + w = min(8, pPix->drawable.width); + pad = BitmapBytePad(pCache->w * pScrn->bitsPerPixel); + + data = (unsigned char *) malloc(pad * pCache->h); + if (!data) + return; + + /* Write and expand horizontally. */ + for (i = h, dstPtr = data, srcPtr = pPix->devPrivate.ptr; i--; + srcPtr += pPix->devKind, dstPtr += pScrn->bitsPerPixel) { + nw = w; + memcpy(dstPtr, srcPtr, w * Bpp); + while (nw != 8) { memcpy(dstPtr + (nw * Bpp), dstPtr, nw * Bpp); nw <<= 1; - } - } - nh = h; - /* Expand vertically. */ - while (nh != 8) { - memcpy(data + (nh*pScrn->bitsPerPixel), data, nh*pScrn->bitsPerPixel); + } + } + nh = h; + /* Expand vertically. */ + while (nh != 8) { + memcpy(data + (nh * pScrn->bitsPerPixel), data, + nh * pScrn->bitsPerPixel); nh <<= 1; - } + } - if(!(infoRec->Color8x8PatternFillFlags & - HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){ - int j; + if (!(infoRec->Color8x8PatternFillFlags & + HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) { + int j; unsigned char *ptr = data + (128 * Bpp); - memcpy(data + (64 * Bpp), data, 64 * Bpp); - for(i = 1; i < 8; i++, ptr += (128 * Bpp)) { - for(j = 0; j < 8; j++) { - memcpy(ptr + (j * 8) * Bpp, data + (j * 8 + i) * Bpp, - (8 - i) * Bpp); - memcpy(ptr + (j * 8 + 8 - i) * Bpp, data + j * 8 * Bpp, i*Bpp); - } - memcpy(ptr + (64 * Bpp), ptr, 64 * Bpp); - } - } - - (*infoRec->WritePixmapToCache)(pScrn, pCache->x, pCache->y, - pCache->w, pCache->h, data, pad, pScrn->bitsPerPixel, pScrn->depth); - - free(data); -} + memcpy(data + (64 * Bpp), data, 64 * Bpp); + for (i = 1; i < 8; i++, ptr += (128 * Bpp)) { + for (j = 0; j < 8; j++) { + memcpy(ptr + (j * 8) * Bpp, data + (j * 8 + i) * Bpp, + (8 - i) * Bpp); + memcpy(ptr + (j * 8 + 8 - i) * Bpp, data + j * 8 * Bpp, + i * Bpp); + } + memcpy(ptr + (64 * Bpp), ptr, 64 * Bpp); + } + } + (*infoRec->WritePixmapToCache) (pScrn, pCache->x, pCache->y, + pCache->w, pCache->h, data, pad, + pScrn->bitsPerPixel, pScrn->depth); + free(data); +} int XAAStippledFillChooser(GCPtr pGC) @@ -2094,84 +2254,81 @@ XAAStippledFillChooser(GCPtr pGC) PixmapPtr pPixmap = pGC->stipple; XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPixmap); - if(!(pPriv->flags & REDUCIBILITY_CHECKED) && - (infoRec->CanDoMono8x8 || infoRec->CanDoColor8x8)) { - XAACheckStippleReducibility(pPixmap); + if (!(pPriv->flags & REDUCIBILITY_CHECKED) && + (infoRec->CanDoMono8x8 || infoRec->CanDoColor8x8)) { + XAACheckStippleReducibility(pPixmap); } + if (pPriv->flags & REDUCIBLE_TO_8x8) { + if (infoRec->CanDoMono8x8 && + !(infoRec->FillMono8x8PatternSpansFlags & NO_TRANSPARENCY) && + ((pGC->alu == GXcopy) || !(infoRec->FillMono8x8PatternSpansFlags & + TRANSPARENCY_GXCOPY_ONLY)) && + CHECK_ROP(pGC, infoRec->FillMono8x8PatternSpansFlags) && + CHECK_ROPSRC(pGC, infoRec->FillMono8x8PatternSpansFlags) && + CHECK_FG(pGC, infoRec->FillMono8x8PatternSpansFlags) && + CHECK_PLANEMASK(pGC, infoRec->FillMono8x8PatternSpansFlags)) { + + return DO_MONO_8x8; + } - if(pPriv->flags & REDUCIBLE_TO_8x8) { - if(infoRec->CanDoMono8x8 && - !(infoRec->FillMono8x8PatternSpansFlags & NO_TRANSPARENCY) && - ((pGC->alu == GXcopy) || !(infoRec->FillMono8x8PatternSpansFlags & - TRANSPARENCY_GXCOPY_ONLY)) && - CHECK_ROP(pGC,infoRec->FillMono8x8PatternSpansFlags) && - CHECK_ROPSRC(pGC,infoRec->FillMono8x8PatternSpansFlags) && - CHECK_FG(pGC,infoRec->FillMono8x8PatternSpansFlags) && - CHECK_PLANEMASK(pGC,infoRec->FillMono8x8PatternSpansFlags)) { - - return DO_MONO_8x8; - } - - if(infoRec->CanDoColor8x8 && - !(infoRec->FillColor8x8PatternSpansFlags & NO_TRANSPARENCY) && - ((pGC->alu == GXcopy) || !(infoRec->FillColor8x8PatternSpansFlags & - TRANSPARENCY_GXCOPY_ONLY)) && - CHECK_ROP(pGC,infoRec->FillColor8x8PatternSpansFlags) && - CHECK_ROPSRC(pGC,infoRec->FillColor8x8PatternSpansFlags) && - CHECK_PLANEMASK(pGC,infoRec->FillColor8x8PatternSpansFlags)) { + if (infoRec->CanDoColor8x8 && + !(infoRec->FillColor8x8PatternSpansFlags & NO_TRANSPARENCY) && + ((pGC->alu == GXcopy) || !(infoRec->FillColor8x8PatternSpansFlags & + TRANSPARENCY_GXCOPY_ONLY)) && + CHECK_ROP(pGC, infoRec->FillColor8x8PatternSpansFlags) && + CHECK_ROPSRC(pGC, infoRec->FillColor8x8PatternSpansFlags) && + CHECK_PLANEMASK(pGC, infoRec->FillColor8x8PatternSpansFlags)) { - return DO_COLOR_8x8; - } + return DO_COLOR_8x8; + } } - if(infoRec->UsingPixmapCache && infoRec->FillCacheExpandSpans && - (pPixmap->drawable.height <= infoRec->MaxCacheableStippleHeight) && - (pPixmap->drawable.width <= infoRec->MaxCacheableStippleWidth / - infoRec->CacheColorExpandDensity) && - !(infoRec->FillCacheExpandSpansFlags & NO_TRANSPARENCY) && - ((pGC->alu == GXcopy) || !(infoRec->FillCacheExpandSpansFlags & - TRANSPARENCY_GXCOPY_ONLY)) && - CHECK_ROP(pGC,infoRec->FillCacheExpandSpansFlags) && - CHECK_ROPSRC(pGC,infoRec->FillCacheExpandSpansFlags) && - CHECK_FG(pGC,infoRec->FillCacheExpandSpansFlags) && - CHECK_PLANEMASK(pGC,infoRec->FillCacheExpandSpansFlags)) { - - return DO_CACHE_EXPAND; + if (infoRec->UsingPixmapCache && infoRec->FillCacheExpandSpans && + (pPixmap->drawable.height <= infoRec->MaxCacheableStippleHeight) && + (pPixmap->drawable.width <= infoRec->MaxCacheableStippleWidth / + infoRec->CacheColorExpandDensity) && + !(infoRec->FillCacheExpandSpansFlags & NO_TRANSPARENCY) && + ((pGC->alu == GXcopy) || !(infoRec->FillCacheExpandSpansFlags & + TRANSPARENCY_GXCOPY_ONLY)) && + CHECK_ROP(pGC, infoRec->FillCacheExpandSpansFlags) && + CHECK_ROPSRC(pGC, infoRec->FillCacheExpandSpansFlags) && + CHECK_FG(pGC, infoRec->FillCacheExpandSpansFlags) && + CHECK_PLANEMASK(pGC, infoRec->FillCacheExpandSpansFlags)) { + + return DO_CACHE_EXPAND; } - - if(infoRec->UsingPixmapCache && - !(infoRec->PixmapCacheFlags & DO_NOT_BLIT_STIPPLES) && - infoRec->FillCacheBltSpans && - (pPixmap->drawable.height <= infoRec->MaxCacheableTileHeight) && - (pPixmap->drawable.width <= infoRec->MaxCacheableTileWidth) && - !(infoRec->FillCacheBltSpansFlags & NO_TRANSPARENCY) && - ((pGC->alu == GXcopy) || !(infoRec->FillCacheBltSpansFlags & - TRANSPARENCY_GXCOPY_ONLY)) && - CHECK_ROP(pGC,infoRec->FillCacheBltSpansFlags) && - CHECK_ROPSRC(pGC,infoRec->FillCacheBltSpansFlags) && - CHECK_PLANEMASK(pGC,infoRec->FillCacheBltSpansFlags)) { - - return DO_CACHE_BLT; + if (infoRec->UsingPixmapCache && + !(infoRec->PixmapCacheFlags & DO_NOT_BLIT_STIPPLES) && + infoRec->FillCacheBltSpans && + (pPixmap->drawable.height <= infoRec->MaxCacheableTileHeight) && + (pPixmap->drawable.width <= infoRec->MaxCacheableTileWidth) && + !(infoRec->FillCacheBltSpansFlags & NO_TRANSPARENCY) && + ((pGC->alu == GXcopy) || !(infoRec->FillCacheBltSpansFlags & + TRANSPARENCY_GXCOPY_ONLY)) && + CHECK_ROP(pGC, infoRec->FillCacheBltSpansFlags) && + CHECK_ROPSRC(pGC, infoRec->FillCacheBltSpansFlags) && + CHECK_PLANEMASK(pGC, infoRec->FillCacheBltSpansFlags)) { + + return DO_CACHE_BLT; } - if(infoRec->FillColorExpandSpans && - !(infoRec->FillColorExpandSpansFlags & NO_TRANSPARENCY) && - ((pGC->alu == GXcopy) || !(infoRec->FillColorExpandSpansFlags & - TRANSPARENCY_GXCOPY_ONLY)) && - CHECK_ROP(pGC,infoRec->FillColorExpandSpansFlags) && - CHECK_ROPSRC(pGC,infoRec->FillColorExpandSpansFlags) && - CHECK_FG(pGC,infoRec->FillColorExpandSpansFlags) && - CHECK_PLANEMASK(pGC,infoRec->FillColorExpandSpansFlags)) { + if (infoRec->FillColorExpandSpans && + !(infoRec->FillColorExpandSpansFlags & NO_TRANSPARENCY) && + ((pGC->alu == GXcopy) || !(infoRec->FillColorExpandSpansFlags & + TRANSPARENCY_GXCOPY_ONLY)) && + CHECK_ROP(pGC, infoRec->FillColorExpandSpansFlags) && + CHECK_ROPSRC(pGC, infoRec->FillColorExpandSpansFlags) && + CHECK_FG(pGC, infoRec->FillColorExpandSpansFlags) && + CHECK_PLANEMASK(pGC, infoRec->FillColorExpandSpansFlags)) { - return DO_COLOR_EXPAND; + return DO_COLOR_EXPAND; } return 0; } - int XAAOpaqueStippledFillChooser(GCPtr pGC) { @@ -2179,74 +2336,72 @@ XAAOpaqueStippledFillChooser(GCPtr pGC) PixmapPtr pPixmap = pGC->stipple; XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPixmap); - if(XAA_DEPTH_BUG(pGC)) - return 0; + if (XAA_DEPTH_BUG(pGC)) + return 0; - if(!(pPriv->flags & REDUCIBILITY_CHECKED) && - (infoRec->CanDoMono8x8 || infoRec->CanDoColor8x8)) { - XAACheckStippleReducibility(pPixmap); + if (!(pPriv->flags & REDUCIBILITY_CHECKED) && + (infoRec->CanDoMono8x8 || infoRec->CanDoColor8x8)) { + XAACheckStippleReducibility(pPixmap); } - if(pPriv->flags & REDUCIBLE_TO_8x8) { - if(infoRec->CanDoMono8x8 && - !(infoRec->FillMono8x8PatternSpansFlags & TRANSPARENCY_ONLY) && - CHECK_ROP(pGC,infoRec->FillMono8x8PatternSpansFlags) && - CHECK_ROPSRC(pGC,infoRec->FillMono8x8PatternSpansFlags) && - CHECK_COLORS(pGC,infoRec->FillMono8x8PatternSpansFlags) && - CHECK_PLANEMASK(pGC,infoRec->FillMono8x8PatternSpansFlags)) { + if (pPriv->flags & REDUCIBLE_TO_8x8) { + if (infoRec->CanDoMono8x8 && + !(infoRec->FillMono8x8PatternSpansFlags & TRANSPARENCY_ONLY) && + CHECK_ROP(pGC, infoRec->FillMono8x8PatternSpansFlags) && + CHECK_ROPSRC(pGC, infoRec->FillMono8x8PatternSpansFlags) && + CHECK_COLORS(pGC, infoRec->FillMono8x8PatternSpansFlags) && + CHECK_PLANEMASK(pGC, infoRec->FillMono8x8PatternSpansFlags)) { - return DO_MONO_8x8; - } + return DO_MONO_8x8; + } - if(infoRec->CanDoColor8x8 && - CHECK_ROP(pGC,infoRec->FillColor8x8PatternSpansFlags) && - CHECK_ROPSRC(pGC,infoRec->FillColor8x8PatternSpansFlags) && - CHECK_PLANEMASK(pGC,infoRec->FillColor8x8PatternSpansFlags)) { + if (infoRec->CanDoColor8x8 && + CHECK_ROP(pGC, infoRec->FillColor8x8PatternSpansFlags) && + CHECK_ROPSRC(pGC, infoRec->FillColor8x8PatternSpansFlags) && + CHECK_PLANEMASK(pGC, infoRec->FillColor8x8PatternSpansFlags)) { - return DO_COLOR_8x8; - } + return DO_COLOR_8x8; + } } - if(infoRec->UsingPixmapCache && infoRec->FillCacheExpandSpans && - (pPixmap->drawable.height <= infoRec->MaxCacheableStippleHeight) && - (pPixmap->drawable.width <= infoRec->MaxCacheableStippleWidth / - infoRec->CacheColorExpandDensity) && - !(infoRec->FillCacheExpandSpansFlags & TRANSPARENCY_ONLY) && - CHECK_ROP(pGC,infoRec->FillCacheExpandSpansFlags) && - CHECK_ROPSRC(pGC,infoRec->FillCacheExpandSpansFlags) && - CHECK_COLORS(pGC,infoRec->FillCacheExpandSpansFlags) && - CHECK_PLANEMASK(pGC,infoRec->FillCacheExpandSpansFlags)) { - - return DO_CACHE_EXPAND; - } + if (infoRec->UsingPixmapCache && infoRec->FillCacheExpandSpans && + (pPixmap->drawable.height <= infoRec->MaxCacheableStippleHeight) && + (pPixmap->drawable.width <= infoRec->MaxCacheableStippleWidth / + infoRec->CacheColorExpandDensity) && + !(infoRec->FillCacheExpandSpansFlags & TRANSPARENCY_ONLY) && + CHECK_ROP(pGC, infoRec->FillCacheExpandSpansFlags) && + CHECK_ROPSRC(pGC, infoRec->FillCacheExpandSpansFlags) && + CHECK_COLORS(pGC, infoRec->FillCacheExpandSpansFlags) && + CHECK_PLANEMASK(pGC, infoRec->FillCacheExpandSpansFlags)) { + + return DO_CACHE_EXPAND; + } - if(infoRec->UsingPixmapCache && - !(infoRec->PixmapCacheFlags & DO_NOT_BLIT_STIPPLES) && - infoRec->FillCacheBltSpans && - (pPixmap->drawable.height <= infoRec->MaxCacheableTileHeight) && - (pPixmap->drawable.width <= infoRec->MaxCacheableTileWidth) && - CHECK_ROP(pGC,infoRec->FillCacheBltSpansFlags) && - CHECK_ROPSRC(pGC,infoRec->FillCacheBltSpansFlags) && - CHECK_PLANEMASK(pGC,infoRec->FillCacheBltSpansFlags)) { + if (infoRec->UsingPixmapCache && + !(infoRec->PixmapCacheFlags & DO_NOT_BLIT_STIPPLES) && + infoRec->FillCacheBltSpans && + (pPixmap->drawable.height <= infoRec->MaxCacheableTileHeight) && + (pPixmap->drawable.width <= infoRec->MaxCacheableTileWidth) && + CHECK_ROP(pGC, infoRec->FillCacheBltSpansFlags) && + CHECK_ROPSRC(pGC, infoRec->FillCacheBltSpansFlags) && + CHECK_PLANEMASK(pGC, infoRec->FillCacheBltSpansFlags)) { - return DO_CACHE_BLT; - } + return DO_CACHE_BLT; + } - if(infoRec->FillColorExpandSpans && - !(infoRec->FillColorExpandSpansFlags & TRANSPARENCY_ONLY) && - CHECK_ROP(pGC,infoRec->FillColorExpandSpansFlags) && - CHECK_ROPSRC(pGC,infoRec->FillColorExpandSpansFlags) && - CHECK_COLORS(pGC,infoRec->FillColorExpandSpansFlags) && - CHECK_PLANEMASK(pGC,infoRec->FillColorExpandSpansFlags)) { + if (infoRec->FillColorExpandSpans && + !(infoRec->FillColorExpandSpansFlags & TRANSPARENCY_ONLY) && + CHECK_ROP(pGC, infoRec->FillColorExpandSpansFlags) && + CHECK_ROPSRC(pGC, infoRec->FillColorExpandSpansFlags) && + CHECK_COLORS(pGC, infoRec->FillColorExpandSpansFlags) && + CHECK_PLANEMASK(pGC, infoRec->FillColorExpandSpansFlags)) { - return DO_COLOR_EXPAND; + return DO_COLOR_EXPAND; } return 0; } - - int XAATiledFillChooser(GCPtr pGC) { @@ -2254,121 +2409,119 @@ XAATiledFillChooser(GCPtr pGC) PixmapPtr pPixmap = pGC->tile.pixmap; XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPixmap); - if(IS_OFFSCREEN_PIXMAP(pPixmap) && infoRec->FillCacheBltSpans && - CHECK_ROP(pGC,infoRec->FillCacheBltSpansFlags) && - CHECK_ROPSRC(pGC,infoRec->FillCacheBltSpansFlags) && - CHECK_PLANEMASK(pGC,infoRec->FillCacheBltSpansFlags)) { + if (IS_OFFSCREEN_PIXMAP(pPixmap) && infoRec->FillCacheBltSpans && + CHECK_ROP(pGC, infoRec->FillCacheBltSpansFlags) && + CHECK_ROPSRC(pGC, infoRec->FillCacheBltSpansFlags) && + CHECK_PLANEMASK(pGC, infoRec->FillCacheBltSpansFlags)) { - return DO_PIXMAP_COPY; + return DO_PIXMAP_COPY; } - if(!(pPriv->flags & REDUCIBILITY_CHECKED) && - (infoRec->CanDoMono8x8 || infoRec->CanDoColor8x8)) { - XAACheckTileReducibility(pPixmap,infoRec->CanDoMono8x8); + if (!(pPriv->flags & REDUCIBILITY_CHECKED) && + (infoRec->CanDoMono8x8 || infoRec->CanDoColor8x8)) { + XAACheckTileReducibility(pPixmap, infoRec->CanDoMono8x8); } - if(pPriv->flags & REDUCIBLE_TO_8x8) { - if((pPriv->flags & REDUCIBLE_TO_2_COLOR) && infoRec->CanDoMono8x8 && - !(infoRec->FillMono8x8PatternSpansFlags & TRANSPARENCY_ONLY) && - CHECK_ROP(pGC,infoRec->FillMono8x8PatternSpansFlags) && - CHECK_ROPSRC(pGC,infoRec->FillMono8x8PatternSpansFlags) && - (!(infoRec->FillMono8x8PatternSpansFlags & RGB_EQUAL) || - (CHECK_RGB_EQUAL(pPriv->fg) && CHECK_RGB_EQUAL(pPriv->bg))) && - CHECK_PLANEMASK(pGC,infoRec->FillMono8x8PatternSpansFlags)) { + if (pPriv->flags & REDUCIBLE_TO_8x8) { + if ((pPriv->flags & REDUCIBLE_TO_2_COLOR) && infoRec->CanDoMono8x8 && + !(infoRec->FillMono8x8PatternSpansFlags & TRANSPARENCY_ONLY) && + CHECK_ROP(pGC, infoRec->FillMono8x8PatternSpansFlags) && + CHECK_ROPSRC(pGC, infoRec->FillMono8x8PatternSpansFlags) && + (!(infoRec->FillMono8x8PatternSpansFlags & RGB_EQUAL) || + (CHECK_RGB_EQUAL(pPriv->fg) && CHECK_RGB_EQUAL(pPriv->bg))) && + CHECK_PLANEMASK(pGC, infoRec->FillMono8x8PatternSpansFlags)) { - return DO_MONO_8x8; - } + return DO_MONO_8x8; + } - if(infoRec->CanDoColor8x8 && - CHECK_ROP(pGC,infoRec->FillColor8x8PatternSpansFlags) && - CHECK_ROPSRC(pGC,infoRec->FillColor8x8PatternSpansFlags) && - CHECK_PLANEMASK(pGC,infoRec->FillColor8x8PatternSpansFlags)) { + if (infoRec->CanDoColor8x8 && + CHECK_ROP(pGC, infoRec->FillColor8x8PatternSpansFlags) && + CHECK_ROPSRC(pGC, infoRec->FillColor8x8PatternSpansFlags) && + CHECK_PLANEMASK(pGC, infoRec->FillColor8x8PatternSpansFlags)) { - return DO_COLOR_8x8; - } + return DO_COLOR_8x8; + } } - if(infoRec->UsingPixmapCache && infoRec->FillCacheBltSpans && - (pPixmap->drawable.height <= infoRec->MaxCacheableTileHeight) && - (pPixmap->drawable.width <= infoRec->MaxCacheableTileWidth) && - CHECK_ROP(pGC,infoRec->FillCacheBltSpansFlags) && - CHECK_ROPSRC(pGC,infoRec->FillCacheBltSpansFlags) && - CHECK_PLANEMASK(pGC,infoRec->FillCacheBltSpansFlags)) { + if (infoRec->UsingPixmapCache && infoRec->FillCacheBltSpans && + (pPixmap->drawable.height <= infoRec->MaxCacheableTileHeight) && + (pPixmap->drawable.width <= infoRec->MaxCacheableTileWidth) && + CHECK_ROP(pGC, infoRec->FillCacheBltSpansFlags) && + CHECK_ROPSRC(pGC, infoRec->FillCacheBltSpansFlags) && + CHECK_PLANEMASK(pGC, infoRec->FillCacheBltSpansFlags)) { - return DO_CACHE_BLT; + return DO_CACHE_BLT; } - if(infoRec->FillImageWriteRects && - CHECK_NO_GXCOPY(pGC,infoRec->FillImageWriteRectsFlags) && - CHECK_ROP(pGC,infoRec->FillImageWriteRectsFlags) && - CHECK_ROPSRC(pGC,infoRec->FillImageWriteRectsFlags) && - CHECK_PLANEMASK(pGC,infoRec->FillImageWriteRectsFlags)) { + if (infoRec->FillImageWriteRects && + CHECK_NO_GXCOPY(pGC, infoRec->FillImageWriteRectsFlags) && + CHECK_ROP(pGC, infoRec->FillImageWriteRectsFlags) && + CHECK_ROPSRC(pGC, infoRec->FillImageWriteRectsFlags) && + CHECK_PLANEMASK(pGC, infoRec->FillImageWriteRectsFlags)) { - return DO_IMAGE_WRITE; + return DO_IMAGE_WRITE; } return 0; } - static int RotateMasksX[8] = { - 0xFFFFFFFF, 0x7F7F7F7F, 0x3F3F3F3F, 0x1F1F1F1F, - 0x0F0F0F0F, 0x07070707, 0x03030303, 0x01010101 + 0xFFFFFFFF, 0x7F7F7F7F, 0x3F3F3F3F, 0x1F1F1F1F, + 0x0F0F0F0F, 0x07070707, 0x03030303, 0x01010101 }; static int RotateMasksY[4] = { - 0xFFFFFFFF, 0x00FFFFFF, 0x0000FFFF, 0x000000FF + 0xFFFFFFFF, 0x00FFFFFF, 0x0000FFFF, 0x000000FF }; void -XAARotateMonoPattern( - int *pat0, int *pat1, - int xorg, int yorg, - Bool msbfirst -){ - int tmp, mask; - - if(xorg) { - if(msbfirst) xorg = 8 - xorg; - mask = RotateMasksX[xorg]; - *pat0 = ((*pat0 >> xorg) & mask) | ((*pat0 << (8 - xorg)) & ~mask); - *pat1 = ((*pat1 >> xorg) & mask) | ((*pat1 << (8 - xorg)) & ~mask); - } - if(yorg >= 4) { - tmp = *pat0; *pat0 = *pat1; *pat1 = tmp; - yorg -= 4; - } - if(yorg) { - mask = RotateMasksY[yorg]; - yorg <<= 3; - tmp = *pat0; - *pat0 = ((*pat0 >> yorg) & mask) | ((*pat1 << (32 - yorg)) & ~mask); - *pat1 = ((*pat1 >> yorg) & mask) | ((tmp << (32 - yorg)) & ~mask); +XAARotateMonoPattern(int *pat0, int *pat1, int xorg, int yorg, Bool msbfirst) +{ + int tmp, mask; + + if (xorg) { + if (msbfirst) + xorg = 8 - xorg; + mask = RotateMasksX[xorg]; + *pat0 = ((*pat0 >> xorg) & mask) | ((*pat0 << (8 - xorg)) & ~mask); + *pat1 = ((*pat1 >> xorg) & mask) | ((*pat1 << (8 - xorg)) & ~mask); + } + if (yorg >= 4) { + tmp = *pat0; + *pat0 = *pat1; + *pat1 = tmp; + yorg -= 4; + } + if (yorg) { + mask = RotateMasksY[yorg]; + yorg <<= 3; + tmp = *pat0; + *pat0 = ((*pat0 >> yorg) & mask) | ((*pat1 << (32 - yorg)) & ~mask); + *pat1 = ((*pat1 >> yorg) & mask) | ((tmp << (32 - yorg)) & ~mask); } } - - void XAAInvalidatePixmapCache(ScreenPtr pScreen) { - XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen); - XAAPixmapCachePrivatePtr pCachePriv = - (XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate; - int i; - - if(!pCachePriv) return; - - for(i = 0; i < pCachePriv->Num512x512; i++) - (pCachePriv->Info512)[i].serialNumber = 0; - for(i = 0; i < pCachePriv->Num256x256; i++) - (pCachePriv->Info256)[i].serialNumber = 0; - for(i = 0; i < pCachePriv->Num128x128; i++) - (pCachePriv->Info128)[i].serialNumber = 0; - for(i = 0; i < pCachePriv->NumPartial; i++) - (pCachePriv->InfoPartial)[i].serialNumber = 0; - for(i = 0; i < pCachePriv->NumMono; i++) - (pCachePriv->InfoMono)[i].serialNumber = 0; - for(i = 0; i < pCachePriv->NumColor; i++) - (pCachePriv->InfoColor)[i].serialNumber = 0; + XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen); + XAAPixmapCachePrivatePtr pCachePriv = + (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate; + int i; + + if (!pCachePriv) + return; + + for (i = 0; i < pCachePriv->Num512x512; i++) + (pCachePriv->Info512)[i].serialNumber = 0; + for (i = 0; i < pCachePriv->Num256x256; i++) + (pCachePriv->Info256)[i].serialNumber = 0; + for (i = 0; i < pCachePriv->Num128x128; i++) + (pCachePriv->Info128)[i].serialNumber = 0; + for (i = 0; i < pCachePriv->NumPartial; i++) + (pCachePriv->InfoPartial)[i].serialNumber = 0; + for (i = 0; i < pCachePriv->NumMono; i++) + (pCachePriv->InfoMono)[i].serialNumber = 0; + for (i = 0; i < pCachePriv->NumColor; i++) + (pCachePriv->InfoColor)[i].serialNumber = 0; } |