/**
* uxa_close_screen() unwraps its wrapped screen functions and tears down UXA's
* screen private, before calling down to the next CloseSccreen.
*/
static Bool uxa_close_screen(int i, ScreenPtr pScreen)
{
uxa_screen_t *uxa_screen = uxa_get_screen(pScreen);
ScrnInfoPtr scrn = xf86Screens[pScreen->myNum];
#ifdef RENDER
PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
#endif
int n;
if (uxa_screen->solid_clear)
FreePicture(uxa_screen->solid_clear, 0);
if (uxa_screen->solid_black)
FreePicture(uxa_screen->solid_black, 0);
if (uxa_screen->solid_white)
FreePicture(uxa_screen->solid_white, 0);
for (n = 0; n < uxa_screen->solid_cache_size; n++)
FreePicture(uxa_screen->solid_cache[n].picture, 0);
uxa_glyphs_fini(pScreen);
if (pScreen->devPrivate) {
/* Destroy the pixmap created by miScreenInit() *before*
* chaining up as we finalize ourselves here and so this
* is the last chance we have of releasing our resources
* associated with the Pixmap. So do it first.
*/
(void) (*pScreen->DestroyPixmap) (pScreen->devPrivate);
pScreen->devPrivate = NULL;
}
pScreen->CreateGC = uxa_screen->SavedCreateGC;
pScreen->CloseScreen = uxa_screen->SavedCloseScreen;
pScreen->GetImage = uxa_screen->SavedGetImage;
pScreen->GetSpans = uxa_screen->SavedGetSpans;
pScreen->CreatePixmap = uxa_screen->SavedCreatePixmap;
pScreen->DestroyPixmap = uxa_screen->SavedDestroyPixmap;
pScreen->CopyWindow = uxa_screen->SavedCopyWindow;
pScreen->ChangeWindowAttributes =
uxa_screen->SavedChangeWindowAttributes;
pScreen->BitmapToRegion = uxa_screen->SavedBitmapToRegion;
scrn->EnableDisableFBAccess = uxa_screen->SavedEnableDisableFBAccess;
#ifdef RENDER
if (ps) {
ps->Composite = uxa_screen->SavedComposite;
ps->CompositeRects = uxa_screen->SavedCompositeRects;
ps->Glyphs = uxa_screen->SavedGlyphs;
ps->Trapezoids = uxa_screen->SavedTrapezoids;
ps->AddTraps = uxa_screen->SavedAddTraps;
ps->Triangles = uxa_screen->SavedTriangles;
ps->UnrealizeGlyph = uxa_screen->SavedUnrealizeGlyph;
}
#endif
free(uxa_screen);
return (*pScreen->CloseScreen) (i, pScreen);
}
static void
xf86RotateCrtcRedisplay (xf86CrtcPtr crtc, RegionPtr region)
{
ScrnInfoPtr scrn = crtc->scrn;
ScreenPtr screen = scrn->pScreen;
WindowPtr root = WindowTable[screen->myNum];
PixmapPtr dst_pixmap = crtc->rotatedPixmap;
PictFormatPtr format = compWindowFormat (WindowTable[screen->myNum]);
int error;
PicturePtr src, dst;
int n = REGION_NUM_RECTS(region);
BoxPtr b = REGION_RECTS(region);
XID include_inferiors = IncludeInferiors;
src = CreatePicture (None,
&root->drawable,
format,
CPSubwindowMode,
&include_inferiors,
serverClient,
&error);
if (!src)
return;
dst = CreatePicture (None,
&dst_pixmap->drawable,
format,
0L,
NULL,
serverClient,
&error);
if (!dst)
return;
error = SetPictureTransform (src, &crtc->crtc_to_framebuffer);
if (error)
return;
while (n--)
{
BoxRec dst_box;
dst_box = *b;
PictureTransformBounds (&dst_box, &crtc->framebuffer_to_crtc);
CompositePicture (PictOpSrc,
src, NULL, dst,
dst_box.x1, dst_box.y1, 0, 0, dst_box.x1, dst_box.y1,
dst_box.x2 - dst_box.x1,
dst_box.y2 - dst_box.y1);
b++;
}
FreePicture (src, None);
FreePicture (dst, None);
}
/**
* uxa_close_screen() unwraps its wrapped screen functions and tears down UXA's
* screen private, before calling down to the next CloseSccreen.
*/
static Bool uxa_close_screen(int i, ScreenPtr pScreen)
{
uxa_screen_t *uxa_screen = uxa_get_screen(pScreen);
ScrnInfoPtr scrn = xf86Screens[pScreen->myNum];
#ifdef RENDER
PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
#endif
int n;
if (uxa_screen->solid_clear)
FreePicture(uxa_screen->solid_clear, 0);
if (uxa_screen->solid_black)
FreePicture(uxa_screen->solid_black, 0);
if (uxa_screen->solid_white)
FreePicture(uxa_screen->solid_white, 0);
for (n = 0; n < uxa_screen->solid_cache_size; n++)
FreePicture(uxa_screen->solid_cache[n].picture, 0);
uxa_glyphs_fini(pScreen);
pScreen->CreateGC = uxa_screen->SavedCreateGC;
pScreen->CloseScreen = uxa_screen->SavedCloseScreen;
pScreen->GetImage = uxa_screen->SavedGetImage;
pScreen->GetSpans = uxa_screen->SavedGetSpans;
pScreen->CreatePixmap = uxa_screen->SavedCreatePixmap;
pScreen->DestroyPixmap = uxa_screen->SavedDestroyPixmap;
pScreen->CopyWindow = uxa_screen->SavedCopyWindow;
pScreen->ChangeWindowAttributes =
uxa_screen->SavedChangeWindowAttributes;
pScreen->BitmapToRegion = uxa_screen->SavedBitmapToRegion;
scrn->EnableDisableFBAccess = uxa_screen->SavedEnableDisableFBAccess;
#ifdef RENDER
if (ps) {
ps->Composite = uxa_screen->SavedComposite;
ps->CompositeRects = uxa_screen->SavedCompositeRects;
ps->Glyphs = uxa_screen->SavedGlyphs;
ps->Trapezoids = uxa_screen->SavedTrapezoids;
ps->AddTraps = uxa_screen->SavedAddTraps;
ps->Triangles = uxa_screen->SavedTriangles;
ps->UnrealizeGlyph = uxa_screen->SavedUnrealizeGlyph;
}
#endif
free(uxa_screen);
return (*pScreen->CloseScreen) (i, pScreen);
}
static void
exaUnrealizeGlyphCaches(ScreenPtr pScreen, unsigned int format)
{
ExaScreenPriv(pScreen);
int i;
for (i = 0; i < EXA_NUM_GLYPH_CACHES; i++) {
ExaGlyphCachePtr cache = &pExaScr->glyphCaches[i];
if (cache->format != format)
continue;
if (cache->picture) {
FreePicture((pointer) cache->picture, (XID) 0);
cache->picture = NULL;
}
free(cache->hashEntries);
cache->hashEntries = NULL;
free(cache->glyphs);
cache->glyphs = NULL;
cache->glyphCount = 0;
}
}
void DestroyPicBuff (PPicBuff* ppPicBuf) {
PPicBuff pPicBuf = NULL;
if (NULL == ppPicBuf || NULL == *ppPicBuf)
return;
pPicBuf = *ppPicBuf;
while (pPicBuf->ppPic != NULL) {
int32_t iPicIdx = 0;
while (iPicIdx < pPicBuf->iCapacity) {
PPicture pPic = pPicBuf->ppPic[iPicIdx];
if (pPic != NULL) {
FreePicture (pPic);
}
pPic = NULL;
++ iPicIdx;
}
WelsFree (pPicBuf->ppPic, "pPicBuf->queue");
pPicBuf->ppPic = NULL;
}
pPicBuf->iCapacity = 0;
pPicBuf->iCurrentIdx = 0;
WelsFree (pPicBuf, "pPicBuf");
pPicBuf = NULL;
*ppPicBuf = NULL;
}
/*****************************************************************************
* End: terminate video thread output method
*****************************************************************************
* Destroy the buffers created by vout_Init. It is called at the end of
* the thread, but also each time the window is resized.
*****************************************************************************/
static void End( vout_thread_t *p_vout )
{
int i_index;
/* Free the direct buffers we allocated */
for( i_index = I_OUTPUTPICTURES ; i_index ; )
{
i_index--;
FreePicture( p_vout, PP_OUTPUTPICTURE[ i_index ] );
}
}
void
miTrapezoids (CARD8 op,
PicturePtr pSrc,
PicturePtr pDst,
PictFormatPtr maskFormat,
INT16 xSrc,
INT16 ySrc,
int ntrap,
xTrapezoid *traps)
{
ScreenPtr pScreen = pDst->pDrawable->pScreen;
PictureScreenPtr ps = GetPictureScreen(pScreen);
/*
* Check for solid alpha add
*/
if (op == PictOpAdd && miIsSolidAlpha (pSrc))
{
for (; ntrap; ntrap--, traps++)
(*ps->RasterizeTrapezoid) (pDst, traps, 0, 0);
}
else if (maskFormat)
{
PicturePtr pPicture;
BoxRec bounds;
INT16 xDst, yDst;
INT16 xRel, yRel;
xDst = traps[0].left.p1.x >> 16;
yDst = traps[0].left.p1.y >> 16;
miTrapezoidBounds (ntrap, traps, &bounds);
if (bounds.y1 >= bounds.y2 || bounds.x1 >= bounds.x2)
return;
pPicture = miCreateAlphaPicture (pScreen, pDst, maskFormat,
bounds.x2 - bounds.x1,
bounds.y2 - bounds.y1);
if (!pPicture)
return;
for (; ntrap; ntrap--, traps++)
(*ps->RasterizeTrapezoid) (pPicture, traps,
-bounds.x1, -bounds.y1);
xRel = bounds.x1 + xSrc - xDst;
yRel = bounds.y1 + ySrc - yDst;
CompositePicture (op, pSrc, pPicture, pDst,
xRel, yRel, 0, 0, bounds.x1, bounds.y1,
bounds.x2 - bounds.x1,
bounds.y2 - bounds.y1);
FreePicture (pPicture, 0);
}
else
{
if (pDst->polyEdge == PolyEdgeSharp)
static void
cwDestroyPicturePrivate(PicturePtr pPicture)
{
cwPicturePrivate;
if (pPicturePrivate) {
if (pPicturePrivate->pBackingPicture)
FreePicture(pPicturePrivate->pBackingPicture, 0);
free(pPicturePrivate);
setCwPicture(pPicture, NULL);
}
}
/*
OUR MAIN FUNCTION
*/
HBITMAP CPicture::LoadPicture(char *FileName)
{
FreePicture();
CFileProcess cFile; //the image file
//if we couldn't open the image file then we should get out of here
if(!cFile.Open(FileName, OFM_READ))
return NULL;
//we must know exactly the buffer size to allocate
//in order to read the image in it
//so get the image file size
long nSize = cFile.GetSize();
//allocate enough memory to hold the image
//it must be allocated using GlobalAlloc
//otherwise it will fail...try using new or malloc and you'll see!!!
hGlobal = GlobalAlloc(GMEM_MOVEABLE, nSize);
//get pointer to first byte
void* pData = GlobalLock(hGlobal);
//read the file in the prev allocated memory
if(!cFile.Read(pData, nSize))
return NULL;
//we don't need the file any more so close it
cFile.Close();
GlobalUnlock(hGlobal);
IStream* pStream = NULL;
//ole routines....
//creates a stream from our handle
//don't know why and how?
if (CreateStreamOnHGlobal(hGlobal, TRUE, &pStream) != S_OK)
return NULL;
HRESULT hr;
//aha..now let ole reads the image and load it for us
//param3:Reference to the identifier of the interface
// describing the type of interface pointer to return
//param4: Address of output variable that receives interface pointer requested in riid
hr = OleLoadPicture(pStream, nSize, FALSE, IID_IPicture, (LPVOID*)&this->m_pic);
if(hr != S_OK)
return NULL;
// if ((hr = OleLoadPicture(pStream, nSize, FALSE, IID_IPicture, (LPVOID *)&this->m_pic)) != S_OK)
// return NULL;
HBITMAP hbmp = NULL;
//return an HBITMAP to our image like the LoadImage function does
//we might need the handle
this->m_pic->get_Handle((OLE_HANDLE *) &hbmp);
return hbmp;
}
void
miTriangles (CARD8 op,
PicturePtr pSrc,
PicturePtr pDst,
PictFormatPtr maskFormat,
INT16 xSrc,
INT16 ySrc,
int ntri,
xTriangle *tris)
{
ScreenPtr pScreen = pDst->pDrawable->pScreen;
PictureScreenPtr ps = GetPictureScreen(pScreen);
/*
* Check for solid alpha add
*/
if (op == PictOpAdd && miIsSolidAlpha (pSrc))
{
(*ps->AddTriangles) (pDst, 0, 0, ntri, tris);
}
else if (maskFormat)
{
BoxRec bounds;
PicturePtr pPicture;
INT16 xDst, yDst;
INT16 xRel, yRel;
xDst = tris[0].p1.x >> 16;
yDst = tris[0].p1.y >> 16;
miTriangleBounds (ntri, tris, &bounds);
if (bounds.x2 <= bounds.x1 || bounds.y2 <= bounds.y1)
return;
pPicture = miCreateAlphaPicture (pScreen, pDst, maskFormat,
bounds.x2 - bounds.x1,
bounds.y2 - bounds.y1);
if (!pPicture)
return;
(*ps->AddTriangles) (pPicture, -bounds.x1, -bounds.y1, ntri, tris);
xRel = bounds.x1 + xSrc - xDst;
yRel = bounds.y1 + ySrc - yDst;
CompositePicture (op, pSrc, pPicture, pDst,
xRel, yRel, 0, 0, bounds.x1, bounds.y1,
bounds.x2 - bounds.x1, bounds.y2 - bounds.y1);
FreePicture (pPicture, 0);
}
else
{
if (pDst->polyEdge == PolyEdgeSharp)
bool CPixelConverterRBP::Decode(const uint8_t* pData, unsigned int size)
{
if (pData == nullptr || size == 0 || m_swsContext == nullptr)
return false;
if (m_buf)
FreePicture(m_buf);
m_buf = AllocatePicture(m_width, m_height);
if (!m_buf)
{
CLog::Log(LOGERROR, "%s: Failed to allocate picture of dimensions %dx%d", __FUNCTION__, m_width, m_height);
return false;
}
uint8_t* dataMutable = const_cast<uint8_t*>(pData);
int bpp;
if (m_mmal_format == MMAL_ENCODING_ARGB ||
m_mmal_format == MMAL_ENCODING_RGBA ||
m_mmal_format == MMAL_ENCODING_ABGR ||
m_mmal_format == MMAL_ENCODING_BGRA)
bpp = 4;
else if (m_mmal_format == MMAL_ENCODING_RGB24 ||
m_mmal_format == MMAL_ENCODING_BGR24)
bpp = 4;
else if (m_mmal_format == MMAL_ENCODING_RGB16 ||
m_mmal_format == MMAL_ENCODING_BGR16)
bpp = 2;
else
{
CLog::Log(LOGERROR, "CPixelConverter::AllocatePicture, unknown format:%.4s", (char *)&m_mmal_format);
return false;
}
MMAL::CMMALYUVBuffer *omvb = static_cast<MMAL::CMMALYUVBuffer*>(m_buf->hwPic);
const int stride = size / m_height;
uint8_t* src[] = { dataMutable, 0, 0, 0 };
int srcStride[] = { stride, 0, 0, 0 };
uint8_t* dst[] = { (uint8_t *)omvb->gmem->m_arm, 0, 0, 0 };
int dstStride[] = { (int)omvb->m_aligned_width * bpp, 0, 0, 0 };
sws_scale(m_swsContext, src, srcStride, 0, m_height, dst, dstStride);
return true;
}
static PicturePtr
create_white_solid(ScreenPtr screen)
{
PicturePtr white, ret = NULL;
xRenderColor color;
int error;
color.red = color.green = color.blue = color.alpha = 0xffff;
white = CreateSolidPicture(0, &color, &error);
if (white) {
ret = uxa_acquire_solid(screen, white->pSourcePict);
FreePicture(white, 0);
}
return ret;
}
static void
FreeGlyphPicture(GlyphPtr glyph)
{
PictureScreenPtr ps;
int i;
for (i = 0; i < screenInfo.numScreens; i++) {
ScreenPtr pScreen = screenInfo.screens[i];
if (GlyphPicture(glyph)[i])
FreePicture((pointer) GlyphPicture(glyph)[i], 0);
ps = GetPictureScreenIfSet(pScreen);
if (ps)
(*ps->UnrealizeGlyph) (pScreen, glyph);
}
}
void CWelsPreProcess::FreeSpatialPictures (sWelsEncCtx* pCtx) {
CMemoryAlign* pMa = pCtx->pMemAlign;
int32_t j = 0;
while (j < pCtx->pSvcParam->iSpatialLayerNum) {
uint8_t i = 0;
uint8_t uiRefNumInTemporal = m_uiSpatialPicNum[j];
while (i < uiRefNumInTemporal) {
if (NULL != m_pSpatialPic[j][i]) {
FreePicture (pMa, &m_pSpatialPic[j][i]);
}
++ i;
}
m_uiSpatialLayersInTemporal[j] = 0;
++ j;
}
}
static void uxa_unrealize_glyph_caches(ScreenPtr pScreen)
{
uxa_screen_t *uxa_screen = uxa_get_screen(pScreen);
int i;
if (!uxa_screen->glyph_cache_initialized)
return;
for (i = 0; i < UXA_NUM_GLYPH_CACHE_FORMATS; i++) {
uxa_glyph_cache_t *cache = &uxa_screen->glyphCaches[i];
if (cache->picture)
FreePicture(cache->picture, 0);
if (cache->glyphs)
free(cache->glyphs);
}
uxa_screen->glyph_cache_initialized = FALSE;
}
static void
miDCSwitchScreenCursor(ScreenPtr pScreen, CursorPtr pCursor, PixmapPtr sourceBits, PixmapPtr maskBits, PicturePtr pPicture)
{
miDCScreenPtr pScreenPriv = dixLookupPrivate(&pScreen->devPrivates, miDCScreenKey);
if (pScreenPriv->sourceBits)
(*pScreen->DestroyPixmap)(pScreenPriv->sourceBits);
pScreenPriv->sourceBits = sourceBits;
if (pScreenPriv->maskBits)
(*pScreen->DestroyPixmap)(pScreenPriv->maskBits);
pScreenPriv->maskBits = maskBits;
if (pScreenPriv->pPicture)
FreePicture(pScreenPriv->pPicture, 0);
pScreenPriv->pPicture = pPicture;
pScreenPriv->pCursor = pCursor;
}
Bool
miDCUnrealizeCursor (ScreenPtr pScreen, CursorPtr pCursor)
{
miDCCursorPtr pPriv;
pPriv = (miDCCursorPtr)dixLookupScreenPrivate(&pCursor->bits->devPrivates,
miDCCursorBitsKey, pScreen);
if (pPriv && (pCursor->bits->refcnt <= 1))
{
if (pPriv->sourceBits)
(*pScreen->DestroyPixmap) (pPriv->sourceBits);
if (pPriv->maskBits)
(*pScreen->DestroyPixmap) (pPriv->maskBits);
#ifdef ARGB_CURSOR
if (pPriv->pPicture)
FreePicture (pPriv->pPicture, 0);
#endif
free((pointer) pPriv);
dixSetScreenPrivate(&pCursor->bits->devPrivates, miDCCursorBitsKey, pScreen, NULL);
}
return TRUE;
}
void
GlyphUninit(ScreenPtr pScreen)
{
PictureScreenPtr ps = GetPictureScreen(pScreen);
GlyphPtr glyph;
int fdepth, i;
int scrno = pScreen->myNum;
for (fdepth = 0; fdepth < GlyphFormatNum; fdepth++) {
if (!globalGlyphs[fdepth].hashSet)
continue;
for (i = 0; i < globalGlyphs[fdepth].hashSet->size; i++) {
glyph = globalGlyphs[fdepth].table[i].glyph;
if (glyph && glyph != DeletedGlyph) {
if (GlyphPicture(glyph)[scrno]) {
FreePicture((pointer) GlyphPicture(glyph)[scrno], 0);
GlyphPicture(glyph)[scrno] = NULL;
}
(*ps->UnrealizeGlyph) (pScreen, glyph);
}
}
}
}
static int32_t DecreasePicBuff (PWelsDecoderContext pCtx, PPicBuff* ppPicBuf, const int32_t kiOldSize,
const int32_t kiPicWidth, const int32_t kiPicHeight, const int32_t kiNewSize) {
PPicBuff pPicOldBuf = *ppPicBuf;
PPicBuff pPicNewBuf = NULL;
int32_t iPicIdx = 0;
if (kiOldSize <= 0 || kiNewSize <= 0 || kiPicWidth <= 0 || kiPicHeight <= 0) {
return 1;
}
pPicNewBuf = (PPicBuff)WelsMallocz (sizeof (SPicBuff), "PPicBuff");
if (NULL == pPicNewBuf) {
return 1;
}
pPicNewBuf->ppPic = (PPicture*)WelsMallocz (kiNewSize * sizeof (PPicture), "PPicture*");
if (NULL == pPicNewBuf->ppPic) {
pPicNewBuf->iCapacity = 0;
DestroyPicBuff (&pPicNewBuf);
return 1;
}
int32_t iPrevPicIdx = -1;
for (iPrevPicIdx = 0; iPrevPicIdx < kiOldSize; ++iPrevPicIdx) {
if (pCtx->pPreviousDecodedPictureInDpb == pPicOldBuf->ppPic[iPrevPicIdx]) {
break;
}
}
int32_t iDelIdx;
if (iPrevPicIdx < kiOldSize && iPrevPicIdx >= kiNewSize) {
// found pPreviousDecodedPictureInDpb,
pPicNewBuf->ppPic[0] = pPicOldBuf->ppPic[iPrevPicIdx];
pPicNewBuf->iCurrentIdx = 0;
memcpy (pPicNewBuf->ppPic + 1, pPicOldBuf->ppPic, (kiNewSize - 1) * sizeof (PPicture));
iDelIdx = kiNewSize - 1;
} else {
memcpy (pPicNewBuf->ppPic, pPicOldBuf->ppPic, kiNewSize * sizeof (PPicture));
pPicNewBuf->iCurrentIdx = iPrevPicIdx < kiNewSize ? iPrevPicIdx : 0;
iDelIdx = kiNewSize;
}
for (iPicIdx = iDelIdx; iPicIdx < kiOldSize; iPicIdx++) {
if (iPrevPicIdx != iPicIdx) {
if (pPicOldBuf->ppPic[iPicIdx] != NULL) {
FreePicture (pPicOldBuf->ppPic[iPicIdx]);
pPicOldBuf->ppPic[iPicIdx] = NULL;
}
}
}
// initialize context in queue
pPicNewBuf->iCapacity = kiNewSize;
*ppPicBuf = pPicNewBuf;
for (int32_t i = 0; i < pPicNewBuf->iCapacity; i++) {
pPicNewBuf->ppPic[i]->bUsedAsRef = false;
pPicNewBuf->ppPic[i]->bIsLongRef = false;
pPicNewBuf->ppPic[i]->uiRefCount = 0;
pPicNewBuf->ppPic[i]->bAvailableFlag = true;
pPicNewBuf->ppPic[i]->bIsComplete = false;
}
// remove old PicBuf
if (pPicOldBuf->ppPic != NULL) {
WelsFree (pPicOldBuf->ppPic, "pPicOldBuf->queue");
pPicOldBuf->ppPic = NULL;
}
pPicOldBuf->iCapacity = 0;
pPicOldBuf->iCurrentIdx = 0;
WelsFree (pPicOldBuf, "pPicOldBuf");
pPicOldBuf = NULL;
return 0;
}
static PixmapPtr
compNewPixmap (WindowPtr pWin, int x, int y, int w, int h)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
WindowPtr pParent = pWin->parent;
PixmapPtr pPixmap;
pPixmap = (*pScreen->CreatePixmap) (pScreen, w, h, pWin->drawable.depth,
CREATE_PIXMAP_USAGE_BACKING_PIXMAP);
if (!pPixmap)
return 0;
pPixmap->screen_x = x;
pPixmap->screen_y = y;
if (pParent->drawable.depth == pWin->drawable.depth)
{
GCPtr pGC = GetScratchGC (pWin->drawable.depth, pScreen);
/*
* Copy bits from the parent into the new pixmap so that it will
* have "reasonable" contents in case for background None areas.
*/
if (pGC)
{
ChangeGCVal val;
val.val = IncludeInferiors;
ValidateGC(&pPixmap->drawable, pGC);
ChangeGC (serverClient, pGC, GCSubwindowMode, &val);
(*pGC->ops->CopyArea) (&pParent->drawable,
&pPixmap->drawable,
pGC,
x - pParent->drawable.x,
y - pParent->drawable.y,
w, h, 0, 0);
FreeScratchGC (pGC);
}
}
else
{
PictFormatPtr pSrcFormat = compWindowFormat (pParent);
PictFormatPtr pDstFormat = compWindowFormat (pWin);
XID inferiors = IncludeInferiors;
int error;
PicturePtr pSrcPicture = CreatePicture (None,
&pParent->drawable,
pSrcFormat,
CPSubwindowMode,
&inferiors,
serverClient, &error);
PicturePtr pDstPicture = CreatePicture (None,
&pPixmap->drawable,
pDstFormat,
0, 0,
serverClient, &error);
if (pSrcPicture && pDstPicture)
{
CompositePicture (PictOpSrc,
pSrcPicture,
NULL,
pDstPicture,
x - pParent->drawable.x,
y - pParent->drawable.y,
0, 0, 0, 0, w, h);
}
if (pSrcPicture)
FreePicture (pSrcPicture, 0);
if (pDstPicture)
FreePicture (pDstPicture, 0);
}
return pPixmap;
}
/**
* glamor_trapezoids will generate trapezoid mask accumulating in
* system memory.
*/
void
glamor_trapezoids(CARD8 op,
PicturePtr src, PicturePtr dst,
PictFormatPtr mask_format, INT16 x_src, INT16 y_src,
int ntrap, xTrapezoid *traps)
{
ScreenPtr screen = dst->pDrawable->pScreen;
BoxRec bounds;
PicturePtr picture;
INT16 x_dst, y_dst;
INT16 x_rel, y_rel;
int width, height, stride;
PixmapPtr pixmap;
pixman_image_t *image = NULL;
/* If a mask format wasn't provided, we get to choose, but behavior should
* be as if there was no temporary mask the traps were accumulated into.
*/
if (!mask_format) {
if (dst->polyEdge == PolyEdgeSharp)
mask_format = PictureMatchFormat(screen, 1, PICT_a1);
else
mask_format = PictureMatchFormat(screen, 8, PICT_a8);
for (; ntrap; ntrap--, traps++)
glamor_trapezoids(op, src, dst, mask_format, x_src,
y_src, 1, traps);
return;
}
miTrapezoidBounds(ntrap, traps, &bounds);
if (bounds.y1 >= bounds.y2 || bounds.x1 >= bounds.x2)
return;
x_dst = traps[0].left.p1.x >> 16;
y_dst = traps[0].left.p1.y >> 16;
width = bounds.x2 - bounds.x1;
height = bounds.y2 - bounds.y1;
stride = PixmapBytePad(width, mask_format->depth);
picture = glamor_create_mask_picture(screen, dst, mask_format,
width, height);
if (!picture)
return;
image = pixman_image_create_bits(picture->format,
width, height, NULL, stride);
if (!image) {
FreePicture(picture, 0);
return;
}
for (; ntrap; ntrap--, traps++)
pixman_rasterize_trapezoid(image,
(pixman_trapezoid_t *) traps,
-bounds.x1, -bounds.y1);
pixmap = glamor_get_drawable_pixmap(picture->pDrawable);
screen->ModifyPixmapHeader(pixmap, width, height,
mask_format->depth,
BitsPerPixel(mask_format->depth),
PixmapBytePad(width,
mask_format->depth),
pixman_image_get_data(image));
x_rel = bounds.x1 + x_src - x_dst;
y_rel = bounds.y1 + y_src - y_dst;
CompositePicture(op, src, picture, dst,
x_rel, y_rel,
0, 0,
bounds.x1, bounds.y1,
bounds.x2 - bounds.x1, bounds.y2 - bounds.y1);
if (image)
pixman_image_unref(image);
FreePicture(picture, 0);
}
static void
uxa_check_glyphs(CARD8 op,
PicturePtr src,
PicturePtr dst,
PictFormatPtr maskFormat,
INT16 xSrc,
INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs)
{
pixman_image_t *image;
PixmapPtr scratch;
PicturePtr mask, mask_src = NULL, mask_dst = NULL, white = NULL;
int width = 0, height = 0;
int x, y, n;
int xDst = list->xOff, yDst = list->yOff;
BoxRec extents = { 0, 0, 0, 0 };
CARD8 mask_op = 0;
if (maskFormat) {
pixman_format_code_t format;
CARD32 component_alpha;
xRenderColor color;
int error;
uxa_glyph_extents(nlist, list, glyphs, &extents);
if (extents.x2 <= extents.x1 || extents.y2 <= extents.y1)
return;
width = extents.x2 - extents.x1;
height = extents.y2 - extents.y1;
format = maskFormat->format |
(BitsPerPixel(maskFormat->depth) << 24);
image =
pixman_image_create_bits(format, width, height, NULL, 0);
if (!image)
return;
scratch = GetScratchPixmapHeader(dst->pDrawable->pScreen, width, height,
PIXMAN_FORMAT_DEPTH(format),
PIXMAN_FORMAT_BPP(format),
pixman_image_get_stride(image),
pixman_image_get_data(image));
if (!scratch) {
pixman_image_unref(image);
return;
}
component_alpha = NeedsComponent(maskFormat->format);
mask = CreatePicture(0, &scratch->drawable,
maskFormat, CPComponentAlpha,
&component_alpha, serverClient, &error);
if (!mask) {
FreeScratchPixmapHeader(scratch);
pixman_image_unref(image);
return;
}
ValidatePicture(mask);
x = -extents.x1;
y = -extents.y1;
color.red = color.green = color.blue = color.alpha = 0xffff;
white = CreateSolidPicture(0, &color, &error);
mask_op = op;
op = PictOpAdd;
mask_src = src;
src = white;
mask_dst = dst;
dst = mask;
} else {
mask = dst;
x = 0;
y = 0;
}
while (nlist--) {
x += list->xOff;
y += list->yOff;
n = list->len;
while (n--) {
GlyphPtr glyph = *glyphs++;
PicturePtr g = GetGlyphPicture(glyph, dst->pDrawable->pScreen);
if (g) {
CompositePicture(op, src, g, dst,
xSrc + (x - glyph->info.x) - xDst,
ySrc + (y - glyph->info.y) - yDst,
0, 0,
x - glyph->info.x,
y - glyph->info.y,
glyph->info.width,
glyph->info.height);
}
x += glyph->info.xOff;
y += glyph->info.yOff;
}
list++;
}
if (white)
FreePicture(white, 0);
if (maskFormat) {
x = extents.x1;
y = extents.y1;
CompositePicture(mask_op, mask_src, mask, mask_dst,
xSrc + x - xDst,
ySrc + y - yDst,
0, 0,
x, y,
width, height);
FreePicture(mask, 0);
FreeScratchPixmapHeader(scratch);
pixman_image_unref(image);
}
}
static int
uxa_glyphs_via_mask(CARD8 op,
PicturePtr pSrc,
PicturePtr pDst,
PictFormatPtr maskFormat,
INT16 xSrc, INT16 ySrc,
int nlist, GlyphListPtr list, GlyphPtr * glyphs)
{
ScreenPtr screen = pDst->pDrawable->pScreen;
uxa_screen_t *uxa_screen = uxa_get_screen(screen);
CARD32 component_alpha;
PixmapPtr pixmap, white_pixmap;
PicturePtr glyph_atlas, mask, white;
int xDst = list->xOff, yDst = list->yOff;
int x, y, width, height;
int dst_off_x, dst_off_y;
int n, error;
BoxRec box;
uxa_glyph_extents(nlist, list, glyphs, &box);
if (box.x2 <= box.x1 || box.y2 <= box.y1)
return 0;
dst_off_x = box.x1;
dst_off_y = box.y1;
width = box.x2 - box.x1;
height = box.y2 - box.y1;
x = -box.x1;
y = -box.y1;
if (maskFormat->depth == 1) {
PictFormatPtr a8Format =
PictureMatchFormat(screen, 8, PICT_a8);
if (!a8Format)
return -1;
maskFormat = a8Format;
}
pixmap = screen->CreatePixmap(screen, width, height,
maskFormat->depth,
CREATE_PIXMAP_USAGE_SCRATCH);
if (!pixmap)
return 1;
if (!uxa_pixmap_is_offscreen(pixmap)) {
screen->DestroyPixmap(pixmap);
return -1;
}
white_pixmap = NULL;
white = create_white_solid(screen);
if (white)
white_pixmap = uxa_get_drawable_pixmap(white->pDrawable);
if (!white_pixmap) {
if (white)
FreePicture(white, 0);
screen->DestroyPixmap(pixmap);
return -1;
}
uxa_clear_pixmap(screen, uxa_screen, pixmap);
component_alpha = NeedsComponent(maskFormat->format);
mask = CreatePicture(0, &pixmap->drawable,
maskFormat, CPComponentAlpha,
&component_alpha, serverClient, &error);
screen->DestroyPixmap(pixmap);
if (!mask) {
FreePicture(white, 0);
return 1;
}
ValidatePicture(mask);
glyph_atlas = NULL;
while (nlist--) {
x += list->xOff;
y += list->yOff;
n = list->len;
while (n--) {
GlyphPtr glyph = *glyphs++;
PicturePtr this_atlas;
int glyph_x, glyph_y;
struct uxa_glyph *priv;
if (glyph->info.width == 0 || glyph->info.height == 0)
goto next_glyph;
priv = uxa_glyph_get_private(glyph);
if (priv != NULL) {
glyph_x = priv->x;
glyph_y = priv->y;
this_atlas = priv->cache->picture;
} else {
if (glyph_atlas) {
uxa_screen->info->done_composite(pixmap);
glyph_atlas = NULL;
}
this_atlas = uxa_glyph_cache(screen, glyph, &glyph_x, &glyph_y);
if (this_atlas == NULL) {
/* no cache for this glyph */
this_atlas = GetGlyphPicture(glyph, screen);
glyph_x = glyph_y = 0;
}
}
if (this_atlas != glyph_atlas) {
PixmapPtr glyph_pixmap;
if (glyph_atlas)
uxa_screen->info->done_composite(pixmap);
glyph_pixmap =
uxa_get_drawable_pixmap(this_atlas->pDrawable);
if (!uxa_pixmap_is_offscreen(glyph_pixmap) ||
!uxa_screen->info->prepare_composite(PictOpAdd,
white, this_atlas, mask,
white_pixmap, glyph_pixmap, pixmap)) {
FreePicture(white, 0);
FreePicture(mask, 0);
return -1;
}
glyph_atlas = this_atlas;
}
uxa_screen->info->composite(pixmap,
0, 0,
glyph_x, glyph_y,
x - glyph->info.x,
y - glyph->info.y,
glyph->info.width,
glyph->info.height);
next_glyph:
x += glyph->info.xOff;
y += glyph->info.yOff;
}
list++;
}
if (glyph_atlas)
uxa_screen->info->done_composite(pixmap);
uxa_composite(op,
pSrc, mask, pDst,
dst_off_x + xSrc - xDst,
dst_off_y + ySrc - yDst,
0, 0,
dst_off_x, dst_off_y,
width, height);
FreePicture(white, 0);
FreePicture(mask, 0);
return 0;
}
void
exaGlyphs(CARD8 op,
PicturePtr pSrc,
PicturePtr pDst,
PictFormatPtr maskFormat,
INT16 xSrc,
INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs)
{
PixmapPtr pMaskPixmap = 0;
PicturePtr pMask = NULL;
ScreenPtr pScreen = pDst->pDrawable->pScreen;
int width = 0, height = 0;
int x, y;
int first_xOff = list->xOff, first_yOff = list->yOff;
int n;
GlyphPtr glyph;
int error;
BoxRec extents = { 0, 0, 0, 0 };
CARD32 component_alpha;
ExaGlyphBuffer buffer;
if (maskFormat) {
ExaScreenPriv(pScreen);
GCPtr pGC;
xRectangle rect;
GlyphExtents(nlist, list, glyphs, &extents);
if (extents.x2 <= extents.x1 || extents.y2 <= extents.y1)
return;
width = extents.x2 - extents.x1;
height = extents.y2 - extents.y1;
if (maskFormat->depth == 1) {
PictFormatPtr a8Format = PictureMatchFormat(pScreen, 8, PICT_a8);
if (a8Format)
maskFormat = a8Format;
}
pMaskPixmap = (*pScreen->CreatePixmap) (pScreen, width, height,
maskFormat->depth,
CREATE_PIXMAP_USAGE_SCRATCH);
if (!pMaskPixmap)
return;
component_alpha = NeedsComponent(maskFormat->format);
pMask = CreatePicture(0, &pMaskPixmap->drawable,
maskFormat, CPComponentAlpha, &component_alpha,
serverClient, &error);
if (!pMask ||
(!component_alpha && pExaScr->info->CheckComposite &&
!(*pExaScr->info->CheckComposite) (PictOpAdd, pSrc, NULL, pMask)))
{
PictFormatPtr argbFormat;
(*pScreen->DestroyPixmap) (pMaskPixmap);
if (!pMask)
return;
/* The driver can't seem to composite to a8, let's try argb (but
* without component-alpha) */
FreePicture((pointer) pMask, (XID) 0);
argbFormat = PictureMatchFormat(pScreen, 32, PICT_a8r8g8b8);
if (argbFormat)
maskFormat = argbFormat;
pMaskPixmap = (*pScreen->CreatePixmap) (pScreen, width, height,
maskFormat->depth,
CREATE_PIXMAP_USAGE_SCRATCH);
if (!pMaskPixmap)
return;
pMask = CreatePicture(0, &pMaskPixmap->drawable, maskFormat, 0, 0,
serverClient, &error);
if (!pMask) {
(*pScreen->DestroyPixmap) (pMaskPixmap);
return;
}
}
pGC = GetScratchGC(pMaskPixmap->drawable.depth, pScreen);
ValidateGC(&pMaskPixmap->drawable, pGC);
rect.x = 0;
rect.y = 0;
rect.width = width;
rect.height = height;
(*pGC->ops->PolyFillRect) (&pMaskPixmap->drawable, pGC, 1, &rect);
FreeScratchGC(pGC);
x = -extents.x1;
y = -extents.y1;
}
else {
x = 0;
y = 0;
}
buffer.count = 0;
buffer.mask = NULL;
while (nlist--) {
x += list->xOff;
y += list->yOff;
n = list->len;
while (n--) {
glyph = *glyphs++;
if (glyph->info.width > 0 && glyph->info.height > 0) {
/* pGlyph->info.{x,y} compensate for empty space in the glyph. */
if (maskFormat) {
if (exaBufferGlyph(pScreen, &buffer, glyph, NULL, pMask,
0, 0, 0, 0, x - glyph->info.x,
y - glyph->info.y) ==
ExaGlyphNeedFlush) {
exaGlyphsToMask(pMask, &buffer);
exaBufferGlyph(pScreen, &buffer, glyph, NULL, pMask,
0, 0, 0, 0, x - glyph->info.x,
y - glyph->info.y);
}
}
else {
if (exaBufferGlyph(pScreen, &buffer, glyph, pSrc, pDst,
xSrc + (x - glyph->info.x) - first_xOff,
ySrc + (y - glyph->info.y) - first_yOff,
0, 0, x - glyph->info.x,
y - glyph->info.y)
== ExaGlyphNeedFlush) {
exaGlyphsToDst(pSrc, pDst, &buffer);
exaBufferGlyph(pScreen, &buffer, glyph, pSrc, pDst,
xSrc + (x - glyph->info.x) - first_xOff,
ySrc + (y - glyph->info.y) - first_yOff,
0, 0, x - glyph->info.x,
y - glyph->info.y);
}
}
}
x += glyph->info.xOff;
y += glyph->info.yOff;
}
list++;
}
if (buffer.count) {
if (maskFormat)
exaGlyphsToMask(pMask, &buffer);
else
exaGlyphsToDst(pSrc, pDst, &buffer);
}
if (maskFormat) {
x = extents.x1;
y = extents.y1;
CompositePicture(op,
pSrc,
pMask,
pDst,
xSrc + x - first_xOff,
ySrc + y - first_yOff, 0, 0, x, y, width, height);
FreePicture((pointer) pMask, (XID) 0);
(*pScreen->DestroyPixmap) (pMaskPixmap);
}
}
/* All caches for a single format share a single pixmap for glyph storage,
* allowing mixing glyphs of different sizes without paying a penalty
* for switching between mask pixmaps. (Note that for a size of font
* right at the border between two sizes, we might be switching for almost
* every glyph.)
*
* This function allocates the storage pixmap, and then fills in the
* rest of the allocated structures for all caches with the given format.
*/
static Bool
exaRealizeGlyphCaches(ScreenPtr pScreen, unsigned int format)
{
ExaScreenPriv(pScreen);
int depth = PIXMAN_FORMAT_DEPTH(format);
PictFormatPtr pPictFormat;
PixmapPtr pPixmap;
PicturePtr pPicture;
CARD32 component_alpha;
int height;
int i;
int error;
pPictFormat = PictureMatchFormat(pScreen, depth, format);
if (!pPictFormat)
return FALSE;
/* Compute the total vertical size needed for the format */
height = 0;
for (i = 0; i < EXA_NUM_GLYPH_CACHES; i++) {
ExaGlyphCachePtr cache = &pExaScr->glyphCaches[i];
int rows;
if (cache->format != format)
continue;
cache->yOffset = height;
rows = (cache->size + cache->columns - 1) / cache->columns;
height += rows * cache->glyphHeight;
}
/* Now allocate the pixmap and picture */
pPixmap = (*pScreen->CreatePixmap) (pScreen,
CACHE_PICTURE_WIDTH, height, depth, 0);
if (!pPixmap)
return FALSE;
component_alpha = NeedsComponent(pPictFormat->format);
pPicture = CreatePicture(0, &pPixmap->drawable, pPictFormat,
CPComponentAlpha, &component_alpha, serverClient,
&error);
(*pScreen->DestroyPixmap) (pPixmap); /* picture holds a refcount */
if (!pPicture)
return FALSE;
/* And store the picture in all the caches for the format */
for (i = 0; i < EXA_NUM_GLYPH_CACHES; i++) {
ExaGlyphCachePtr cache = &pExaScr->glyphCaches[i];
int j;
if (cache->format != format)
continue;
cache->picture = pPicture;
cache->picture->refcnt++;
cache->hashEntries = malloc(sizeof(int) * cache->hashSize);
cache->glyphs = malloc(sizeof(ExaCachedGlyphRec) * cache->size);
cache->glyphCount = 0;
if (!cache->hashEntries || !cache->glyphs)
goto bail;
for (j = 0; j < cache->hashSize; j++)
cache->hashEntries[j] = -1;
cache->evictionPosition = rand() % cache->size;
}
/* Each cache references the picture individually */
FreePicture((pointer) pPicture, (XID) 0);
return TRUE;
bail:
exaUnrealizeGlyphCaches(pScreen, format);
return FALSE;
}
static PixmapPtr
compNewPixmap (WindowPtr pWin, int x, int y, int w, int h, Bool map)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
WindowPtr pParent = pWin->parent;
PixmapPtr pPixmap;
pPixmap = (*pScreen->CreatePixmap) (pScreen, w, h, pWin->drawable.depth,
CREATE_PIXMAP_USAGE_BACKING_PIXMAP);
if (!pPixmap)
return 0;
pPixmap->screen_x = x;
pPixmap->screen_y = y;
/* resize allocations will update later in compCopyWindow, not here */
if (!map)
return pPixmap;
if (pParent->drawable.depth == pWin->drawable.depth)
{
GCPtr pGC = GetScratchGC (pWin->drawable.depth, pScreen);
if (pGC)
{
ChangeGCVal val;
val.val = IncludeInferiors;
ChangeGC (NullClient, pGC, GCSubwindowMode, &val);
ValidateGC(&pPixmap->drawable, pGC);
(*pGC->ops->CopyArea) (&pParent->drawable,
&pPixmap->drawable,
pGC,
x - pParent->drawable.x,
y - pParent->drawable.y,
w, h, 0, 0);
FreeScratchGC (pGC);
}
}
else
{
PictFormatPtr pSrcFormat = compWindowFormat (pParent);
PictFormatPtr pDstFormat = compWindowFormat (pWin);
XID inferiors = IncludeInferiors;
int error;
PicturePtr pSrcPicture = CreatePicture (None,
&pParent->drawable,
pSrcFormat,
CPSubwindowMode,
&inferiors,
serverClient, &error);
PicturePtr pDstPicture = CreatePicture (None,
&pPixmap->drawable,
pDstFormat,
0, 0,
serverClient, &error);
if (pSrcPicture && pDstPicture)
{
CompositePicture (PictOpSrc,
pSrcPicture,
NULL,
pDstPicture,
x - pParent->drawable.x,
y - pParent->drawable.y,
0, 0, 0, 0, w, h);
}
if (pSrcPicture)
FreePicture (pSrcPicture, 0);
if (pDstPicture)
FreePicture (pDstPicture, 0);
}
return pPixmap;
}
static void
xf86RotateCrtcRedisplay(xf86CrtcPtr crtc, RegionPtr region)
{
ScrnInfoPtr scrn = crtc->scrn;
ScreenPtr screen = scrn->pScreen;
WindowPtr root = screen->root;
PixmapPtr dst_pixmap = crtc->rotatedPixmap;
PictFormatPtr format = PictureWindowFormat(screen->root);
int error;
PicturePtr src, dst;
int n = RegionNumRects(region);
BoxPtr b = RegionRects(region);
XID include_inferiors = IncludeInferiors;
if (crtc->driverIsPerformingTransform)
return;
src = CreatePicture(None,
&root->drawable,
format,
CPSubwindowMode,
&include_inferiors, serverClient, &error);
if (!src)
return;
dst = CreatePicture(None,
&dst_pixmap->drawable,
format, 0L, NULL, serverClient, &error);
if (!dst)
return;
error = SetPictureTransform(src, &crtc->crtc_to_framebuffer);
if (error)
return;
if (crtc->transform_in_use && crtc->filter)
SetPicturePictFilter(src, crtc->filter, crtc->params, crtc->nparams);
if (crtc->shadowClear) {
CompositePicture(PictOpSrc,
src, NULL, dst,
0, 0, 0, 0, 0, 0,
crtc->mode.HDisplay, crtc->mode.VDisplay);
crtc->shadowClear = FALSE;
}
else {
while (n--) {
BoxRec dst_box;
dst_box = *b;
dst_box.x1 -= crtc->filter_width >> 1;
dst_box.x2 += crtc->filter_width >> 1;
dst_box.y1 -= crtc->filter_height >> 1;
dst_box.y2 += crtc->filter_height >> 1;
pixman_f_transform_bounds(&crtc->f_framebuffer_to_crtc, &dst_box);
CompositePicture(PictOpSrc,
src, NULL, dst,
dst_box.x1, dst_box.y1, 0, 0, dst_box.x1,
dst_box.y1, dst_box.x2 - dst_box.x1,
dst_box.y2 - dst_box.y1);
b++;
}
}
FreePicture(src, None);
FreePicture(dst, None);
}
fastcall static void
sna_tiling_composite_spans_done(struct sna *sna,
const struct sna_composite_spans_op *op)
{
struct sna_tile_state *tile = op->base.priv;
struct sna_composite_spans_op tmp;
int x, y, n, step;
bool force_fallback = false;
/* Use a small step to accommodate enlargement through tile alignment */
step = sna->render.max_3d_size;
if (tile->dst_x & (8*512 / tile->dst->pDrawable->bitsPerPixel - 1) ||
tile->dst_y & 63)
step /= 2;
while (step * step * 4 > sna->kgem.max_copy_tile_size)
step /= 2;
DBG(("%s -- %dx%d, count=%d, step size=%d\n", __FUNCTION__,
tile->width, tile->height, tile->rect_count, step));
if (tile->rect_count == 0)
goto done;
for (y = 0; y < tile->height; y += step) {
int height = step;
if (y + height > tile->height)
height = tile->height - y;
for (x = 0; x < tile->width; x += step) {
const struct sna_tile_span *r = (void *)tile->rects;
int width = step;
if (x + width > tile->width)
width = tile->width - x;
if (!force_fallback &&
sna->render.composite_spans(sna, tile->op,
tile->src, tile->dst,
tile->src_x + x, tile->src_y + y,
tile->dst_x + x, tile->dst_y + y,
width, height, tile->flags,
memset(&tmp, 0, sizeof(tmp)))) {
for (n = 0; n < tile->rect_count; n++) {
BoxRec b;
b.x1 = r->box.x1 - tile->dst_x;
if (b.x1 < x)
b.x1 = x;
b.y1 = r->box.y1 - tile->dst_y;
if (b.y1 < y)
b.y1 = y;
b.x2 = r->box.x2 - tile->dst_x;
if (b.x2 > x + width)
b.x2 = x + width;
b.y2 = r->box.y2 - tile->dst_y;
if (b.y2 > y + height)
b.y2 = y + height;
DBG(("%s: rect[%d] = (%d, %d)x(%d,%d), tile=(%d,%d)x(%d, %d), blt=(%d,%d),(%d,%d)\n",
__FUNCTION__, n,
r->box.x1, r->box.y1,
r->box.x2-r->box.x1, r->box.y2-r->box.y1,
x, y, width, height,
b.x1, b.y1, b.x2, b.y2));
if (b.y2 > b.y1 && b.x2 > b.x1)
tmp.box(sna, &tmp, &b, r->opacity);
r++;
}
tmp.done(sna, &tmp);
} else {
unsigned int flags;
DBG(("%s -- falback\n", __FUNCTION__));
if (tile->op <= PictOpSrc)
flags = MOVE_WRITE;
else
flags = MOVE_WRITE | MOVE_READ;
if (!sna_drawable_move_to_cpu(tile->dst->pDrawable,
flags))
goto done;
if (tile->dst->alphaMap &&
!sna_drawable_move_to_cpu(tile->dst->alphaMap->pDrawable,
flags))
goto done;
if (tile->src->pDrawable &&
!sna_drawable_move_to_cpu(tile->src->pDrawable,
MOVE_READ))
goto done;
if (tile->src->alphaMap &&
!sna_drawable_move_to_cpu(tile->src->alphaMap->pDrawable,
MOVE_READ))
goto done;
for (n = 0; n < tile->rect_count; n++) {
BoxRec b;
b.x1 = r->box.x1 - tile->dst_x;
if (b.x1 < x)
b.x1 = x;
b.y1 = r->box.y1 - tile->dst_y;
if (b.y1 < y)
b.y1 = y;
b.x2 = r->box.x2 - tile->dst_x;
if (b.x2 > x + width)
b.x2 = x + width;
b.y2 = r->box.y2 - tile->dst_y;
if (b.y2 > y + height)
b.y2 = y + height;
DBG(("%s: rect[%d] = (%d, %d)x(%d,%d), tile=(%d,%d)x(%d, %d), blt=(%d,%d),(%d,%d)\n",
__FUNCTION__, n,
r->box.x1, r->box.y1,
r->box.x2-r->box.x1, r->box.y2-r->box.y1,
x, y, width, height,
b.x1, b.y1, b.x2, b.y2));
if (b.y2 > b.y1 && b.x2 > b.x1) {
xRenderColor alpha;
PicturePtr mask;
int error;
alpha.red = alpha.green = alpha.blue = 0;
alpha.alpha = r->opacity * 0xffff;
mask = CreateSolidPicture(0, &alpha, &error);
if (!mask)
goto done;
if (sigtrap_get() == 0) {
fbComposite(tile->op,
tile->src, mask, tile->dst,
tile->src_x + x, tile->src_y + y,
0, 0,
tile->dst_x + x, tile->dst_y + y,
width, height);
sigtrap_put();
}
FreePicture(mask, 0);
}
r++;
}
force_fallback = true;
}
}
}
done:
if (tile->rects != tile->rects_embedded)
free(tile->rects);
free(tile);
}
void FreeScaledPic (Scaled_Picture* pScaledPicture, CMemoryAlign* pMemoryAlign) {
if (pScaledPicture->pScaledInputPicture) {
FreePicture (pMemoryAlign, &pScaledPicture->pScaledInputPicture);
pScaledPicture->pScaledInputPicture = NULL;
}
}
_X_EXPORT void
miCompositeRects (CARD8 op,
PicturePtr pDst,
xRenderColor *color,
int nRect,
xRectangle *rects)
{
ScreenPtr pScreen = pDst->pDrawable->pScreen;
if (color->alpha == 0xffff)
{
if (op == PictOpOver)
op = PictOpSrc;
}
if (op == PictOpClear)
color->red = color->green = color->blue = color->alpha = 0;
if (op == PictOpSrc || op == PictOpClear)
{
miColorRects (pDst, pDst, color, nRect, rects, 0, 0);
if (pDst->alphaMap)
miColorRects (pDst->alphaMap, pDst,
color, nRect, rects,
pDst->alphaOrigin.x,
pDst->alphaOrigin.y);
}
else
{
PictFormatPtr rgbaFormat;
PixmapPtr pPixmap;
PicturePtr pSrc;
xRectangle one;
int error;
Pixel pixel;
GCPtr pGC;
CARD32 tmpval[2];
rgbaFormat = PictureMatchFormat (pScreen, 32, PICT_a8r8g8b8);
if (!rgbaFormat)
goto bail1;
pPixmap = (*pScreen->CreatePixmap) (pScreen, 1, 1,
rgbaFormat->depth);
if (!pPixmap)
goto bail2;
miRenderColorToPixel (rgbaFormat, color, &pixel);
pGC = GetScratchGC (rgbaFormat->depth, pScreen);
if (!pGC)
goto bail3;
tmpval[0] = GXcopy;
tmpval[1] = pixel;
ChangeGC (pGC, GCFunction | GCForeground, tmpval);
ValidateGC (&pPixmap->drawable, pGC);
one.x = 0;
one.y = 0;
one.width = 1;
one.height = 1;
(*pGC->ops->PolyFillRect) (&pPixmap->drawable, pGC, 1, &one);
tmpval[0] = xTrue;
pSrc = CreatePicture (0, &pPixmap->drawable, rgbaFormat,
CPRepeat, tmpval, 0, &error);
if (!pSrc)
goto bail4;
while (nRect--)
{
CompositePicture (op, pSrc, 0, pDst, 0, 0, 0, 0,
rects->x,
rects->y,
rects->width,
rects->height);
rects++;
}
FreePicture ((pointer) pSrc, 0);
bail4:
FreeScratchGC (pGC);
bail3:
(*pScreen->DestroyPixmap) (pPixmap);
bail2:
bail1:
;
}
}
