static void XagCallClientStateChange( CallbackListPtr *pcbl, pointer nulldata, pointer calldata) { XaceAuthAvailRec* rec = (XaceAuthAvailRec*) calldata; ClientPtr pClient = rec->client; if (!pClient->appgroup) { SecurityAuthorizationPtr pAuth; XID authId = rec->authId; /* can't use SecurityLookupIDByType here -- client * security state hasn't been setup yet. */ pAuth = (SecurityAuthorizationPtr)LookupIDByType(authId, SecurityAuthorizationResType); if (!pAuth) return; pClient->appgroup = (AppGroupPtr)LookupIDByType(pAuth->group, RT_APPGROUP); } if (pClient->appgroup) { NewClientInfoRec clientinfo; clientinfo.client = pClient; XagClientStateChange (NULL, NULL, (pointer)&clientinfo); } }
/** When Xinerama is active, the client pixmaps are always obtained from * screen 0. When screen 0 is detached, the pixmaps must be obtained * from any other screen that is not detached. Usually, this is screen * 1. */ static DMXScreenInfo *dmxFindAlternatePixmap(DrawablePtr pDrawable, XID *draw) { #ifdef PANORAMIX PanoramiXRes *pXinPix; int i; DMXScreenInfo *dmxScreen; if (noPanoramiXExtension) return NULL; if (pDrawable->type != DRAWABLE_PIXMAP) return NULL; if (!(pXinPix = (PanoramiXRes *)LookupIDByType(pDrawable->id, XRT_PIXMAP))) return NULL; for (i = 1; i < PanoramiXNumScreens; i++) { dmxScreen = &dmxScreens[i]; if (dmxScreen->beDisplay) { PixmapPtr pSrc; dmxPixPrivPtr pSrcPriv; pSrc = (PixmapPtr)LookupIDByType(pXinPix->info[i].id, RT_PIXMAP); pSrcPriv = DMX_GET_PIXMAP_PRIV(pSrc); if (pSrcPriv->pixmap) { *draw = pSrcPriv->pixmap; return dmxScreen; } } } #endif return NULL; }
static int ProcCompositeNameWindowPixmap (ClientPtr client) { WindowPtr pWin; CompWindowPtr cw; PixmapPtr pPixmap; REQUEST(xCompositeNameWindowPixmapReq); REQUEST_SIZE_MATCH(xCompositeNameWindowPixmapReq); pWin = (WindowPtr) LookupIDByType (stuff->window, RT_WINDOW); if (!pWin) { client->errorValue = stuff->window; return BadWindow; } LEGAL_NEW_RESOURCE (stuff->pixmap, client); cw = GetCompWindow (pWin); if (!cw) return BadMatch; pPixmap = (*pWin->drawable.pScreen->GetWindowPixmap) (pWin); if (!pPixmap) return BadMatch; ++pPixmap->refcnt; if (!AddResource (stuff->pixmap, RT_PIXMAP, (pointer) pPixmap)) return BadAlloc; return(client->noClientException); }
static int ProcXDGAInstallColormap(ClientPtr client) { ColormapPtr cmap; REQUEST(xXDGAInstallColormapReq); if (stuff->screen > screenInfo.numScreens) return BadValue; if(DGAClients[stuff->screen] != client) return DGAErrorBase + XF86DGADirectNotActivated; REQUEST_SIZE_MATCH(xXDGAInstallColormapReq); cmap = (ColormapPtr)LookupIDByType(stuff->cmap, RT_COLORMAP); if (cmap) { DGAInstallCmap(cmap); return (client->noClientException); } else { client->errorValue = stuff->cmap; return (BadColor); } return (client->noClientException); }
void winMWExtWMUpdateIcon (Window id) { WindowPtr pWin; HICON hIcon, hiconOld; pWin = LookupIDByType (id, RT_WINDOW); hIcon = (HICON)winOverrideIcon ((unsigned long)pWin); if (!hIcon) hIcon = winXIconToHICON (pWin, GetSystemMetrics(SM_CXICON)); if (hIcon) { win32RootlessWindowPtr pRLWinPriv = (win32RootlessWindowPtr) RootlessFrameForWindow (pWin, FALSE); if (pRLWinPriv->hWnd) { hiconOld = (HICON) SetClassLong (pRLWinPriv->hWnd, GCL_HICON, (int) hIcon); winDestroyIcon(hiconOld); } } }
static void vfbUninstallColormap(ColormapPtr pmap) { #if XORG < 113 ColormapPtr curpmap = InstalledMaps[pmap->pScreen->myNum]; #else ColormapPtr curpmap = GetInstalledColormap(pmap->pScreen); #endif if(pmap == curpmap) { if (pmap->mid != pmap->pScreen->defColormap) { #if XORG < 111 curpmap = (ColormapPtr) LookupIDByType(pmap->pScreen->defColormap, RT_COLORMAP); #else int rc = dixLookupResourceByType((void * *) &curpmap, pmap->pScreen->defColormap, RT_COLORMAP, serverClient, DixUnknownAccess); if (rc != Success) ErrorF("Failed to uninstall color map\n"); else #endif (*pmap->pScreen->InstallColormap)(curpmap); } } }
static int ProcCompositeCreateRegionFromBorderClip (ClientPtr client) { WindowPtr pWin; CompWindowPtr cw; RegionPtr pBorderClip, pRegion; REQUEST(xCompositeCreateRegionFromBorderClipReq); REQUEST_SIZE_MATCH(xCompositeCreateRegionFromBorderClipReq); pWin = (WindowPtr) LookupIDByType (stuff->window, RT_WINDOW); if (!pWin) { client->errorValue = stuff->window; return BadWindow; } LEGAL_NEW_RESOURCE (stuff->region, client); cw = GetCompWindow (pWin); if (cw) pBorderClip = &cw->borderClip; else pBorderClip = &pWin->borderClip; pRegion = XFixesRegionCopy (pBorderClip); if (!pRegion) return BadAlloc; REGION_TRANSLATE (pScreen, pRegion, -pWin->drawable.x, -pWin->drawable.y); if (!AddResource (stuff->region, RegionResType, (pointer) pRegion)) return BadAlloc; return(client->noClientException); }
int __glXUseXFont(__GLXclientState *cl, GLbyte *pc) { ClientPtr client = cl->client; xGLXUseXFontReq *req; FontPtr pFont; GC *pGC; GLuint currentListIndex; __GLXcontext *cx; int error; req = (xGLXUseXFontReq *) pc; cx = __glXForceCurrent(cl, req->contextTag, &error); if (!cx) { return error; } glGetIntegerv(GL_LIST_INDEX, (GLint*) ¤tListIndex); if (currentListIndex != 0) { /* ** A display list is currently being made. It is an error ** to try to make a font during another lists construction. */ client->errorValue = cx->id; return __glXBadContextState; } /* ** Font can actually be either the ID of a font or the ID of a GC ** containing a font. */ pFont = (FontPtr)LookupIDByType(req->font, RT_FONT); if (!pFont) { pGC = (GC *)LookupIDByType(req->font, RT_GC); if (!pGC) { client->errorValue = req->font; return BadFont; } pFont = pGC->font; } return MakeBitmapsFromFont(pFont, req->first, req->count, req->listBase); }
int ProcCompositeGetOverlayWindow (ClientPtr client) { REQUEST(xCompositeGetOverlayWindowReq); xCompositeGetOverlayWindowReply rep; WindowPtr pWin; ScreenPtr pScreen; CompScreenPtr cs; CompOverlayClientPtr pOc; REQUEST_SIZE_MATCH(xCompositeGetOverlayWindowReq); pWin = (WindowPtr) LookupIDByType (stuff->window, RT_WINDOW); if (!pWin) { client->errorValue = stuff->window; return BadWindow; } pScreen = pWin->drawable.pScreen; cs = GetCompScreen(pScreen); if (cs->pOverlayWin == NULL) { cs->pOverlayWin = createOverlayWindow(pScreen); if (cs->pOverlayWin == NULL) { return BadAlloc; } } MapWindow(cs->pOverlayWin, serverClient); /* Record that client is using this overlay window */ pOc = findCompOverlayClient(client, pScreen); if (pOc == NULL) { int ret = createCompOverlayClient(client, pScreen); if (ret != Success) { return ret; } } rep.type = X_Reply; rep.sequenceNumber = client->sequence; rep.length = 0; rep.overlayWin = cs->pOverlayWin->drawable.id; if (client->swapped) { int n; swaps(&rep.sequenceNumber, n); swapl(&rep.length, n); swapl(&rep.overlayWin, n); } (void) WriteToClient(client, sz_xCompositeGetOverlayWindowReply, (char *)&rep); return client->noClientException; }
void __glXFreeGLXWindow(__glXWindow *pGlxWindow) { if (!pGlxWindow->idExists && !pGlxWindow->refcnt) { WindowPtr pWindow = (WindowPtr) pGlxWindow->pDraw; if (LookupIDByType(pWindow->drawable.id, RT_WINDOW) == pWindow) { (*pGlxWindow->pScreen->DestroyWindow)(pWindow); } xfree(pGlxWindow); } }
static int ProcXvMCDestroyContext(ClientPtr client) { REQUEST(xvmcDestroyContextReq); REQUEST_SIZE_MATCH(xvmcDestroyContextReq); if(!LookupIDByType(stuff->context_id, XvMCRTContext)) return (XvMCBadContext + XvMCErrorBase); FreeResource(stuff->context_id, RT_NONE); return Success; }
static int ProcXvMCDestroySubpicture(ClientPtr client) { REQUEST(xvmcDestroySubpictureReq); REQUEST_SIZE_MATCH(xvmcDestroySubpictureReq); if(!LookupIDByType(stuff->subpicture_id, XvMCRTSubpicture)) return (XvMCBadSubpicture + XvMCErrorBase); FreeResource(stuff->subpicture_id, RT_NONE); return Success; }
/* ** This hook gets called when a window moves or changes size. */ static Bool PositionWindow(WindowPtr pWin, int x, int y) { ScreenPtr pScreen; __GLXcontext *glxc; __GLXdrawablePrivate *glxPriv; Bool ret; /* ** Call wrapped position window routine */ pScreen = pWin->drawable.pScreen; pScreen->PositionWindow = __glXActiveScreens[pScreen->myNum].WrappedPositionWindow; ret = (*pScreen->PositionWindow)(pWin, x, y); pScreen->PositionWindow = PositionWindow; /* ** Tell all contexts rendering into this window that the window size ** has changed. */ glxPriv = (__GLXdrawablePrivate *) LookupIDByType(pWin->drawable.id, __glXDrawableRes); if (glxPriv == NULL) { /* ** This window is not being used by the OpenGL. */ return ret; } /* ** resize the drawable */ /* first change the drawable size */ if (__glXResizeDrawableBuffers(glxPriv) == GL_FALSE) { /* resize failed! */ /* XXX: what can we possibly do here? */ ret = False; } /* mark contexts as needing resize */ for (glxc = glxPriv->drawGlxc; glxc; glxc = glxc->nextDrawPriv) { glxc->pendingState |= __GLX_PENDING_RESIZE; } for (glxc = glxPriv->readGlxc; glxc; glxc = glxc->nextReadPriv) { glxc->pendingState |= __GLX_PENDING_RESIZE; } return ret; }
int ProcXFixesCreateRegionFromWindow (ClientPtr client) { RegionPtr pRegion; Bool copy = TRUE; WindowPtr pWin; REQUEST (xXFixesCreateRegionFromWindowReq); REQUEST_SIZE_MATCH (xXFixesCreateRegionFromWindowReq); LEGAL_NEW_RESOURCE (stuff->region, client); pWin = (WindowPtr) LookupIDByType (stuff->window, RT_WINDOW); if (!pWin) { client->errorValue = stuff->window; return BadWindow; } switch (stuff->kind) { case WindowRegionBounding: #ifdef SHAPE pRegion = wBoundingShape(pWin); if (!pRegion) #endif { pRegion = CreateBoundingShape (pWin); copy = FALSE; } break; case WindowRegionClip: #ifdef SHAPE pRegion = wClipShape(pWin); if (!pRegion) #endif { pRegion = CreateClipShape (pWin); copy = FALSE; } break; default: client->errorValue = stuff->kind; return BadValue; } if (copy && pRegion) pRegion = XFixesRegionCopy (pRegion); if (!pRegion) return BadAlloc; if (!AddResource (stuff->region, RegionResType, (pointer) pRegion)) return BadAlloc; return(client->noClientException); }
static int ProcXvMCCreateSurface(ClientPtr client) { CARD32 *data = NULL; int dwords = 0; int result; XvMCContextPtr pContext; XvMCSurfacePtr pSurface; XvMCScreenPtr pScreenPriv; xvmcCreateSurfaceReply rep; REQUEST(xvmcCreateSurfaceReq); REQUEST_SIZE_MATCH(xvmcCreateSurfaceReq); if(!(pContext = LookupIDByType(stuff->context_id, XvMCRTContext))) return (XvMCBadContext + XvMCErrorBase); pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen); if(!(pSurface = xalloc(sizeof(XvMCSurfaceRec)))) return BadAlloc; pSurface->surface_id = stuff->surface_id; pSurface->surface_type_id = pContext->surface_type_id; pSurface->context = pContext; result = (*pScreenPriv->adaptors[pContext->adapt_num].CreateSurface)( pSurface, &dwords, &data); if(result != Success) { xfree(pSurface); return result; } rep.type = X_Reply; rep.sequenceNumber = client->sequence; rep.length = dwords; WriteToClient(client, sizeof(xvmcCreateSurfaceReply), (char*)&rep); if(dwords) WriteToClient(client, dwords << 2, (char*)data); AddResource(pSurface->surface_id, XvMCRTSurface, pSurface); if(data) xfree(data); pContext->refcnt++; return Success; }
static int ProcCompositeUnredirectSubwindows (ClientPtr client) { WindowPtr pWin; REQUEST(xCompositeUnredirectSubwindowsReq); REQUEST_SIZE_MATCH(xCompositeUnredirectSubwindowsReq); pWin = (WindowPtr) LookupIDByType (stuff->window, RT_WINDOW); if (!pWin) { client->errorValue = stuff->window; return BadWindow; } return compUnredirectSubwindows (client, pWin, stuff->update); }
void winMinimizeWindow (Window id) { WindowPtr pWin; winPrivWinPtr pWinPriv; #ifdef XWIN_MULTIWINDOWEXTWM win32RootlessWindowPtr pRLWinPriv; #endif HWND hWnd; ScreenPtr pScreen = NULL; winPrivScreenPtr pScreenPriv = NULL; winScreenInfo *pScreenInfo = NULL; #if CYGWINDOWING_DEBUG ErrorF ("winMinimizeWindow\n"); #endif pWin = LookupIDByType (id, RT_WINDOW); if (!pWin) { ErrorF("%s: NULL pWin. Leaving\n", __FUNCTION__); return; } pScreen = pWin->drawable.pScreen; if (pScreen) pScreenPriv = winGetScreenPriv(pScreen); if (pScreenPriv) pScreenInfo = pScreenPriv->pScreenInfo; #ifdef XWIN_MULTIWINDOWEXTWM if (pScreenPriv && pScreenInfo->fInternalWM) { pRLWinPriv = (win32RootlessWindowPtr) RootlessFrameForWindow (pWin, FALSE); hWnd = pRLWinPriv->hWnd; } else #else if (pScreenPriv) #endif { pWinPriv = winGetWindowPriv (pWin); hWnd = pWinPriv->hWnd; } ShowWindow (hWnd, SW_MINIMIZE); }
static int AttrValidate( ClientPtr client, int attrib_mask, AppGroupPtr pAppGrp) { WindowPtr pWin; int idepth, ivids, found, rc; ScreenPtr pScreen; DepthPtr pDepth; ColormapPtr pColormap; rc = dixLookupWindow(&pWin, pAppGrp->default_root, client, DixUnknownAccess); if (rc != Success) return rc; pScreen = pWin->drawable.pScreen; if (WindowTable[pScreen->myNum]->drawable.id != pAppGrp->default_root) return BadWindow; pDepth = pScreen->allowedDepths; if (pAppGrp->root_visual) { found = FALSE; for (idepth = 0; idepth < pScreen->numDepths; idepth++, pDepth++) { for (ivids = 0; ivids < pDepth->numVids; ivids++) { if (pAppGrp->root_visual == pDepth->vids[ivids]) { found = TRUE; break; } } } if (!found) return BadMatch; } if (pAppGrp->default_colormap) { pColormap = (ColormapPtr)LookupIDByType (pAppGrp->default_colormap, RT_COLORMAP); /* XXX check that pColormap is not NULL */ if (pColormap->pScreen != pScreen) return BadColor; if (pColormap->pVisual->vid != (pAppGrp->root_visual ? pAppGrp->root_visual : pScreen->rootVisual)) return BadMatch; } return client->noClientException; }
int ProcCompositeReleaseOverlayWindow (ClientPtr client) { REQUEST(xCompositeReleaseOverlayWindowReq); WindowPtr pWin; ScreenPtr pScreen; CompOverlayClientPtr pOc; CompScreenPtr cs; REQUEST_SIZE_MATCH(xCompositeReleaseOverlayWindowReq); pWin = (WindowPtr) LookupIDByType (stuff->window, RT_WINDOW); if (!pWin) { client->errorValue = stuff->window; return BadWindow; } pScreen = pWin->drawable.pScreen; /* * Has client queried a reference to the overlay window * on this screen? If not, generate an error. */ pOc = findCompOverlayClient(client, pWin->drawable.pScreen); if (pOc == NULL) { return BadMatch; } FreeResource(pOc->resource, 0); cs = GetCompScreen(pScreen); if (cs->pOverlayClients == NULL) { UnmapWindow(cs->pOverlayWin, FALSE); } return client->noClientException; }
static int XFixesSelectSelectionInput (ClientPtr pClient, Atom selection, WindowPtr pWindow, CARD32 eventMask) { int rc; SelectionEventPtr *prev, e; rc = XaceHook(XACE_SELECTION_ACCESS, pClient, selection, DixGetAttrAccess); if (rc != Success) return rc; for (prev = &selectionEvents; (e = *prev); prev = &e->next) { if (e->selection == selection && e->pClient == pClient && e->pWindow == pWindow) { break; } } if (!eventMask) { if (e) { FreeResource (e->clientResource, 0); } return Success; } if (!e) { e = (SelectionEventPtr) xalloc (sizeof (SelectionEventRec)); if (!e) return BadAlloc; e->next = 0; e->selection = selection; e->pClient = pClient; e->pWindow = pWindow; e->clientResource = FakeClientID(pClient->index); /* * Add a resource hanging from the window to * catch window destroy */ if (!LookupIDByType(pWindow->drawable.id, SelectionWindowType)) if (!AddResource (pWindow->drawable.id, SelectionWindowType, (pointer) pWindow)) { xfree (e); return BadAlloc; } if (!AddResource (e->clientResource, SelectionClientType, (pointer) e)) return BadAlloc; *prev = e; if (!CheckSelectionCallback ()) { FreeResource (e->clientResource, 0); return BadAlloc; } } e->eventMask = eventMask; return Success; }
static int ProcXvMCCreateSubpicture(ClientPtr client) { Bool image_supported = FALSE; CARD32 *data = NULL; int i, result, dwords = 0; XvMCContextPtr pContext; XvMCSubpicturePtr pSubpicture; XvMCScreenPtr pScreenPriv; xvmcCreateSubpictureReply rep; XvMCAdaptorPtr adaptor; XvMCSurfaceInfoPtr surface = NULL; REQUEST(xvmcCreateSubpictureReq); REQUEST_SIZE_MATCH(xvmcCreateSubpictureReq); if(!(pContext = LookupIDByType(stuff->context_id, XvMCRTContext))) return (XvMCBadContext + XvMCErrorBase); pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen); adaptor = &(pScreenPriv->adaptors[pContext->adapt_num]); /* find which surface this context supports */ for(i = 0; i < adaptor->num_surfaces; i++) { if(adaptor->surfaces[i]->surface_type_id == pContext->surface_type_id){ surface = adaptor->surfaces[i]; break; } } if(!surface) return BadMatch; /* make sure this surface supports that xvimage format */ if(!surface->compatible_subpictures) return BadMatch; for(i = 0; i < surface->compatible_subpictures->num_xvimages; i++) { if(surface->compatible_subpictures->xvimage_ids[i] == stuff->xvimage_id) { image_supported = TRUE; break; } } if(!image_supported) return BadMatch; /* make sure the size is OK */ if((stuff->width > surface->subpicture_max_width) || (stuff->height > surface->subpicture_max_height)) return BadValue; if(!(pSubpicture = xalloc(sizeof(XvMCSubpictureRec)))) return BadAlloc; pSubpicture->subpicture_id = stuff->subpicture_id; pSubpicture->xvimage_id = stuff->xvimage_id; pSubpicture->width = stuff->width; pSubpicture->height = stuff->height; pSubpicture->num_palette_entries = 0; /* overwritten by DDX */ pSubpicture->entry_bytes = 0; /* overwritten by DDX */ pSubpicture->component_order[0] = 0; /* overwritten by DDX */ pSubpicture->component_order[1] = 0; pSubpicture->component_order[2] = 0; pSubpicture->component_order[3] = 0; pSubpicture->context = pContext; result = (*pScreenPriv->adaptors[pContext->adapt_num].CreateSubpicture)( pSubpicture, &dwords, &data); if(result != Success) { xfree(pSubpicture); return result; } rep.type = X_Reply; rep.sequenceNumber = client->sequence; rep.width_actual = pSubpicture->width; rep.height_actual = pSubpicture->height; rep.num_palette_entries = pSubpicture->num_palette_entries; rep.entry_bytes = pSubpicture->entry_bytes; rep.component_order[0] = pSubpicture->component_order[0]; rep.component_order[1] = pSubpicture->component_order[1]; rep.component_order[2] = pSubpicture->component_order[2]; rep.component_order[3] = pSubpicture->component_order[3]; rep.length = dwords; WriteToClient(client, sizeof(xvmcCreateSubpictureReply), (char*)&rep); if(dwords) WriteToClient(client, dwords << 2, (char*)data); AddResource(pSubpicture->subpicture_id, XvMCRTSubpicture, pSubpicture); if(data) xfree(data); pContext->refcnt++; return Success; }
int ProcXFixesSetWindowShapeRegion (ClientPtr client) { #ifdef SHAPE WindowPtr pWin; ScreenPtr pScreen; RegionPtr pRegion; RegionPtr *pDestRegion; REQUEST(xXFixesSetWindowShapeRegionReq); REQUEST_SIZE_MATCH(xXFixesSetWindowShapeRegionReq); pWin = (WindowPtr) LookupIDByType (stuff->dest, RT_WINDOW); if (!pWin) { client->errorValue = stuff->dest; return BadWindow; } VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, DixWriteAccess); pScreen = pWin->drawable.pScreen; switch (stuff->destKind) { case ShapeBounding: case ShapeClip: case ShapeInput: break; default: client->errorValue = stuff->destKind; return BadValue; } if (pRegion) { pRegion = XFixesRegionCopy (pRegion); if (!pRegion) return BadAlloc; if (!pWin->optional) MakeWindowOptional (pWin); switch (stuff->destKind) { default: case ShapeBounding: pDestRegion = &pWin->optional->boundingShape; break; case ShapeClip: pDestRegion = &pWin->optional->clipShape; break; case ShapeInput: pDestRegion = &pWin->optional->inputShape; break; } if (stuff->xOff || stuff->yOff) REGION_TRANSLATE (0, pRegion, stuff->xOff, stuff->yOff); } else { if (pWin->optional) { switch (stuff->destKind) { default: case ShapeBounding: pDestRegion = &pWin->optional->boundingShape; break; case ShapeClip: pDestRegion = &pWin->optional->clipShape; break; case ShapeInput: pDestRegion = &pWin->optional->inputShape; break; } } else pDestRegion = &pRegion; /* a NULL region pointer */ } if (*pDestRegion) REGION_DESTROY(pScreen, *pDestRegion); *pDestRegion = pRegion; (*pScreen->SetShape) (pWin); SendShapeNotify (pWin, stuff->destKind); return (client->noClientException); #else return BadRequest; #endif }
static int ProcXvShmPutImage(ClientPtr client) { ShmDescPtr shmdesc; DrawablePtr pDraw; XvPortPtr pPort; XvImagePtr pImage = NULL; GCPtr pGC; int status, size_needed, i; CARD16 width, height; REQUEST(xvShmPutImageReq); REQUEST_SIZE_MATCH(xvShmPutImageReq); VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess); if(!(pPort = LOOKUP_PORT(stuff->port, client) )) { client->errorValue = stuff->port; return (_XvBadPort); } if ((status = _AllocatePort(stuff->port, pPort)) != Success) { client->errorValue = stuff->port; return (status); } if (!(pPort->pAdaptor->type & XvImageMask) || !(pPort->pAdaptor->type & XvInputMask)) { client->errorValue = stuff->port; return (BadMatch); } status = XVCALL(diMatchPort)(pPort, pDraw); if (status != Success) { return status; } for(i = 0; i < pPort->pAdaptor->nImages; i++) { if(pPort->pAdaptor->pImages[i].id == stuff->id) { pImage = &(pPort->pAdaptor->pImages[i]); break; } } if(!pImage) return BadMatch; if(!(shmdesc = (ShmDescPtr)LookupIDByType(stuff->shmseg, ShmSegType))) { client->errorValue = stuff->shmseg; return BadShmSegCode; } width = stuff->width; height = stuff->height; size_needed = (*pPort->pAdaptor->ddQueryImageAttributes)(client, pPort, pImage, &width, &height, NULL, NULL); if((size_needed + stuff->offset) > shmdesc->size) return BadAccess; if((width < stuff->width) || (height < stuff->height)) return BadValue; status = XVCALL(diPutImage)(client, pDraw, pPort, pGC, stuff->src_x, stuff->src_y, stuff->src_w, stuff->src_h, stuff->drw_x, stuff->drw_y, stuff->drw_w, stuff->drw_h, pImage, (unsigned char *)shmdesc->addr + stuff->offset, stuff->send_event, stuff->width, stuff->height); if((status == Success) && stuff->send_event) { xShmCompletionEvent ev; ev.type = ShmCompletionCode; ev.drawable = stuff->drawable; ev.sequenceNumber = client->sequence; ev.minorEvent = xv_ShmPutImage; ev.majorEvent = XvReqCode; ev.shmseg = stuff->shmseg; ev.offset = stuff->offset; WriteEventsToClient(client, 1, (xEvent *) &ev); } return status; }