File: | render/render.c |
Location: | line 1034, column 5 |
Description: | Value stored to 'err' is never read |
1 | /* |
2 | * |
3 | * Copyright © 2000 SuSE, Inc. |
4 | * |
5 | * Permission to use, copy, modify, distribute, and sell this software and its |
6 | * documentation for any purpose is hereby granted without fee, provided that |
7 | * the above copyright notice appear in all copies and that both that |
8 | * copyright notice and this permission notice appear in supporting |
9 | * documentation, and that the name of SuSE not be used in advertising or |
10 | * publicity pertaining to distribution of the software without specific, |
11 | * written prior permission. SuSE makes no representations about the |
12 | * suitability of this software for any purpose. It is provided "as is" |
13 | * without express or implied warranty. |
14 | * |
15 | * SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL |
16 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE |
17 | * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
18 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
19 | * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
20 | * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
21 | * |
22 | * Author: Keith Packard, SuSE, Inc. |
23 | */ |
24 | |
25 | #ifdef HAVE_DIX_CONFIG_H1 |
26 | #include <dix-config.h> |
27 | #endif |
28 | |
29 | #include <X11/X.h> |
30 | #include <X11/Xproto.h> |
31 | #include "misc.h" |
32 | #include "os.h" |
33 | #include "dixstruct.h" |
34 | #include "resource.h" |
35 | #include "scrnintstr.h" |
36 | #include "windowstr.h" |
37 | #include "pixmapstr.h" |
38 | #include "colormapst.h" |
39 | #include "extnsionst.h" |
40 | #include "extinit.h" |
41 | #include "servermd.h" |
42 | #include <X11/extensions/render.h> |
43 | #include <X11/extensions/renderproto.h> |
44 | #include "picturestr.h" |
45 | #include "glyphstr.h" |
46 | #include <X11/Xfuncproto.h> |
47 | #include "cursorstr.h" |
48 | #include "xace.h" |
49 | #include "protocol-versions.h" |
50 | |
51 | #ifdef PANORAMIX1 |
52 | #include "panoramiX.h" |
53 | #include "panoramiXsrv.h" |
54 | #endif |
55 | |
56 | #include <stdint.h> |
57 | |
58 | static int ProcRenderQueryVersion(ClientPtr pClient); |
59 | static int ProcRenderQueryPictFormats(ClientPtr pClient); |
60 | static int ProcRenderQueryPictIndexValues(ClientPtr pClient); |
61 | static int ProcRenderQueryDithers(ClientPtr pClient); |
62 | static int ProcRenderCreatePicture(ClientPtr pClient); |
63 | static int ProcRenderChangePicture(ClientPtr pClient); |
64 | static int ProcRenderSetPictureClipRectangles(ClientPtr pClient); |
65 | static int ProcRenderFreePicture(ClientPtr pClient); |
66 | static int ProcRenderComposite(ClientPtr pClient); |
67 | static int ProcRenderScale(ClientPtr pClient); |
68 | static int ProcRenderTrapezoids(ClientPtr pClient); |
69 | static int ProcRenderTriangles(ClientPtr pClient); |
70 | static int ProcRenderTriStrip(ClientPtr pClient); |
71 | static int ProcRenderTriFan(ClientPtr pClient); |
72 | static int ProcRenderColorTrapezoids(ClientPtr pClient); |
73 | static int ProcRenderColorTriangles(ClientPtr pClient); |
74 | static int ProcRenderTransform(ClientPtr pClient); |
75 | static int ProcRenderCreateGlyphSet(ClientPtr pClient); |
76 | static int ProcRenderReferenceGlyphSet(ClientPtr pClient); |
77 | static int ProcRenderFreeGlyphSet(ClientPtr pClient); |
78 | static int ProcRenderAddGlyphs(ClientPtr pClient); |
79 | static int ProcRenderAddGlyphsFromPicture(ClientPtr pClient); |
80 | static int ProcRenderFreeGlyphs(ClientPtr pClient); |
81 | static int ProcRenderCompositeGlyphs(ClientPtr pClient); |
82 | static int ProcRenderFillRectangles(ClientPtr pClient); |
83 | static int ProcRenderCreateCursor(ClientPtr pClient); |
84 | static int ProcRenderSetPictureTransform(ClientPtr pClient); |
85 | static int ProcRenderQueryFilters(ClientPtr pClient); |
86 | static int ProcRenderSetPictureFilter(ClientPtr pClient); |
87 | static int ProcRenderCreateAnimCursor(ClientPtr pClient); |
88 | static int ProcRenderAddTraps(ClientPtr pClient); |
89 | static int ProcRenderCreateSolidFill(ClientPtr pClient); |
90 | static int ProcRenderCreateLinearGradient(ClientPtr pClient); |
91 | static int ProcRenderCreateRadialGradient(ClientPtr pClient); |
92 | static int ProcRenderCreateConicalGradient(ClientPtr pClient); |
93 | |
94 | static int ProcRenderDispatch(ClientPtr pClient); |
95 | |
96 | static int SProcRenderQueryVersion(ClientPtr pClient); |
97 | static int SProcRenderQueryPictFormats(ClientPtr pClient); |
98 | static int SProcRenderQueryPictIndexValues(ClientPtr pClient); |
99 | static int SProcRenderQueryDithers(ClientPtr pClient); |
100 | static int SProcRenderCreatePicture(ClientPtr pClient); |
101 | static int SProcRenderChangePicture(ClientPtr pClient); |
102 | static int SProcRenderSetPictureClipRectangles(ClientPtr pClient); |
103 | static int SProcRenderFreePicture(ClientPtr pClient); |
104 | static int SProcRenderComposite(ClientPtr pClient); |
105 | static int SProcRenderScale(ClientPtr pClient); |
106 | static int SProcRenderTrapezoids(ClientPtr pClient); |
107 | static int SProcRenderTriangles(ClientPtr pClient); |
108 | static int SProcRenderTriStrip(ClientPtr pClient); |
109 | static int SProcRenderTriFan(ClientPtr pClient); |
110 | static int SProcRenderColorTrapezoids(ClientPtr pClient); |
111 | static int SProcRenderColorTriangles(ClientPtr pClient); |
112 | static int SProcRenderTransform(ClientPtr pClient); |
113 | static int SProcRenderCreateGlyphSet(ClientPtr pClient); |
114 | static int SProcRenderReferenceGlyphSet(ClientPtr pClient); |
115 | static int SProcRenderFreeGlyphSet(ClientPtr pClient); |
116 | static int SProcRenderAddGlyphs(ClientPtr pClient); |
117 | static int SProcRenderAddGlyphsFromPicture(ClientPtr pClient); |
118 | static int SProcRenderFreeGlyphs(ClientPtr pClient); |
119 | static int SProcRenderCompositeGlyphs(ClientPtr pClient); |
120 | static int SProcRenderFillRectangles(ClientPtr pClient); |
121 | static int SProcRenderCreateCursor(ClientPtr pClient); |
122 | static int SProcRenderSetPictureTransform(ClientPtr pClient); |
123 | static int SProcRenderQueryFilters(ClientPtr pClient); |
124 | static int SProcRenderSetPictureFilter(ClientPtr pClient); |
125 | static int SProcRenderCreateAnimCursor(ClientPtr pClient); |
126 | static int SProcRenderAddTraps(ClientPtr pClient); |
127 | static int SProcRenderCreateSolidFill(ClientPtr pClient); |
128 | static int SProcRenderCreateLinearGradient(ClientPtr pClient); |
129 | static int SProcRenderCreateRadialGradient(ClientPtr pClient); |
130 | static int SProcRenderCreateConicalGradient(ClientPtr pClient); |
131 | |
132 | static int SProcRenderDispatch(ClientPtr pClient); |
133 | |
134 | int (*ProcRenderVector[RenderNumberRequests(36 +1)]) (ClientPtr) = { |
135 | ProcRenderQueryVersion, |
136 | ProcRenderQueryPictFormats, |
137 | ProcRenderQueryPictIndexValues, |
138 | ProcRenderQueryDithers, |
139 | ProcRenderCreatePicture, |
140 | ProcRenderChangePicture, |
141 | ProcRenderSetPictureClipRectangles, |
142 | ProcRenderFreePicture, |
143 | ProcRenderComposite, |
144 | ProcRenderScale, |
145 | ProcRenderTrapezoids, |
146 | ProcRenderTriangles, |
147 | ProcRenderTriStrip, |
148 | ProcRenderTriFan, |
149 | ProcRenderColorTrapezoids, |
150 | ProcRenderColorTriangles, |
151 | ProcRenderTransform, |
152 | ProcRenderCreateGlyphSet, |
153 | ProcRenderReferenceGlyphSet, |
154 | ProcRenderFreeGlyphSet, |
155 | ProcRenderAddGlyphs, |
156 | ProcRenderAddGlyphsFromPicture, |
157 | ProcRenderFreeGlyphs, |
158 | ProcRenderCompositeGlyphs, |
159 | ProcRenderCompositeGlyphs, |
160 | ProcRenderCompositeGlyphs, |
161 | ProcRenderFillRectangles, |
162 | ProcRenderCreateCursor, |
163 | ProcRenderSetPictureTransform, |
164 | ProcRenderQueryFilters, |
165 | ProcRenderSetPictureFilter, |
166 | ProcRenderCreateAnimCursor, |
167 | ProcRenderAddTraps, |
168 | ProcRenderCreateSolidFill, |
169 | ProcRenderCreateLinearGradient, |
170 | ProcRenderCreateRadialGradient, ProcRenderCreateConicalGradient}; |
171 | |
172 | int (*SProcRenderVector[RenderNumberRequests(36 +1)]) (ClientPtr) = { |
173 | SProcRenderQueryVersion, |
174 | SProcRenderQueryPictFormats, |
175 | SProcRenderQueryPictIndexValues, |
176 | SProcRenderQueryDithers, |
177 | SProcRenderCreatePicture, |
178 | SProcRenderChangePicture, |
179 | SProcRenderSetPictureClipRectangles, |
180 | SProcRenderFreePicture, |
181 | SProcRenderComposite, |
182 | SProcRenderScale, |
183 | SProcRenderTrapezoids, |
184 | SProcRenderTriangles, |
185 | SProcRenderTriStrip, |
186 | SProcRenderTriFan, |
187 | SProcRenderColorTrapezoids, |
188 | SProcRenderColorTriangles, |
189 | SProcRenderTransform, |
190 | SProcRenderCreateGlyphSet, |
191 | SProcRenderReferenceGlyphSet, |
192 | SProcRenderFreeGlyphSet, |
193 | SProcRenderAddGlyphs, |
194 | SProcRenderAddGlyphsFromPicture, |
195 | SProcRenderFreeGlyphs, |
196 | SProcRenderCompositeGlyphs, |
197 | SProcRenderCompositeGlyphs, |
198 | SProcRenderCompositeGlyphs, |
199 | SProcRenderFillRectangles, |
200 | SProcRenderCreateCursor, |
201 | SProcRenderSetPictureTransform, |
202 | SProcRenderQueryFilters, |
203 | SProcRenderSetPictureFilter, |
204 | SProcRenderCreateAnimCursor, |
205 | SProcRenderAddTraps, |
206 | SProcRenderCreateSolidFill, |
207 | SProcRenderCreateLinearGradient, |
208 | SProcRenderCreateRadialGradient, SProcRenderCreateConicalGradient}; |
209 | |
210 | int RenderErrBase; |
211 | static DevPrivateKeyRec RenderClientPrivateKeyRec; |
212 | |
213 | #define RenderClientPrivateKey(&RenderClientPrivateKeyRec ) (&RenderClientPrivateKeyRec ) |
214 | |
215 | typedef struct _RenderClient { |
216 | int major_version; |
217 | int minor_version; |
218 | } RenderClientRec, *RenderClientPtr; |
219 | |
220 | #define GetRenderClient(pClient)((RenderClientPtr)dixLookupPrivate(&(pClient)->devPrivates , (&RenderClientPrivateKeyRec ))) ((RenderClientPtr)dixLookupPrivate(&(pClient)->devPrivates, RenderClientPrivateKey(&RenderClientPrivateKeyRec ))) |
221 | |
222 | static void |
223 | RenderClientCallback(CallbackListPtr *list, void *closure, void *data) |
224 | { |
225 | NewClientInfoRec *clientinfo = (NewClientInfoRec *) data; |
226 | ClientPtr pClient = clientinfo->client; |
227 | RenderClientPtr pRenderClient = GetRenderClient(pClient)((RenderClientPtr)dixLookupPrivate(&(pClient)->devPrivates , (&RenderClientPrivateKeyRec ))); |
228 | |
229 | pRenderClient->major_version = 0; |
230 | pRenderClient->minor_version = 0; |
231 | } |
232 | |
233 | #ifdef PANORAMIX1 |
234 | RESTYPE XRT_PICTURE; |
235 | #endif |
236 | |
237 | void |
238 | RenderExtensionInit(void) |
239 | { |
240 | ExtensionEntry *extEntry; |
241 | |
242 | if (!PictureType) |
243 | return; |
244 | if (!PictureFinishInit()) |
245 | return; |
246 | if (!dixRegisterPrivateKey |
247 | (&RenderClientPrivateKeyRec, PRIVATE_CLIENT, sizeof(RenderClientRec))) |
248 | return; |
249 | if (!AddCallback(&ClientStateCallback, RenderClientCallback, 0)) |
250 | return; |
251 | |
252 | extEntry = AddExtension(RENDER_NAME"RENDER", 0, RenderNumberErrors(4 +1), |
253 | ProcRenderDispatch, SProcRenderDispatch, |
254 | NULL((void*)0), StandardMinorOpcode); |
255 | if (!extEntry) |
256 | return; |
257 | RenderErrBase = extEntry->errorBase; |
258 | #ifdef PANORAMIX1 |
259 | if (XRT_PICTURE) |
260 | SetResourceTypeErrorValue(XRT_PICTURE, RenderErrBase + BadPicture1); |
261 | #endif |
262 | SetResourceTypeErrorValue(PictureType, RenderErrBase + BadPicture1); |
263 | SetResourceTypeErrorValue(PictFormatType, RenderErrBase + BadPictFormat0); |
264 | SetResourceTypeErrorValue(GlyphSetType, RenderErrBase + BadGlyphSet3); |
265 | } |
266 | |
267 | static int |
268 | ProcRenderQueryVersion(ClientPtr client) |
269 | { |
270 | RenderClientPtr pRenderClient = GetRenderClient(client)((RenderClientPtr)dixLookupPrivate(&(client)->devPrivates , (&RenderClientPrivateKeyRec ))); |
271 | xRenderQueryVersionReply rep = { |
272 | .type = X_Reply1, |
273 | .sequenceNumber = client->sequence, |
274 | .length = 0 |
275 | }; |
276 | |
277 | REQUEST(xRenderQueryVersionReq)xRenderQueryVersionReq *stuff = (xRenderQueryVersionReq *)client ->requestBuffer; |
278 | |
279 | REQUEST_SIZE_MATCH(xRenderQueryVersionReq)if ((sizeof(xRenderQueryVersionReq) >> 2) != client-> req_len) return(16); |
280 | |
281 | pRenderClient->major_version = stuff->majorVersion; |
282 | pRenderClient->minor_version = stuff->minorVersion; |
283 | |
284 | if ((stuff->majorVersion * 1000 + stuff->minorVersion) < |
285 | (SERVER_RENDER_MAJOR_VERSION0 * 1000 + SERVER_RENDER_MINOR_VERSION11)) { |
286 | rep.majorVersion = stuff->majorVersion; |
287 | rep.minorVersion = stuff->minorVersion; |
288 | } |
289 | else { |
290 | rep.majorVersion = SERVER_RENDER_MAJOR_VERSION0; |
291 | rep.minorVersion = SERVER_RENDER_MINOR_VERSION11; |
292 | } |
293 | |
294 | if (client->swapped) { |
295 | swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size( ); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber ) & 1) && ((uintptr_t)(&rep.sequenceNumber) & 1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber )); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); } while (0); |
296 | swapl(&rep.length)do { if (sizeof(*(&rep.length)) != 4) wrong_size(); if (__builtin_constant_p ((uintptr_t)(&rep.length) & 3) && ((uintptr_t )(&rep.length) & 3) == 0) *(&rep.length) = lswapl (*(&rep.length)); else swap_uint32((uint32_t *)(&rep. length)); } while (0); |
297 | swapl(&rep.majorVersion)do { if (sizeof(*(&rep.majorVersion)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&rep.majorVersion) & 3) && ((uintptr_t)(&rep.majorVersion) & 3) == 0) *(&rep.majorVersion) = lswapl(*(&rep.majorVersion )); else swap_uint32((uint32_t *)(&rep.majorVersion)); } while (0); |
298 | swapl(&rep.minorVersion)do { if (sizeof(*(&rep.minorVersion)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&rep.minorVersion) & 3) && ((uintptr_t)(&rep.minorVersion) & 3) == 0) *(&rep.minorVersion) = lswapl(*(&rep.minorVersion )); else swap_uint32((uint32_t *)(&rep.minorVersion)); } while (0); |
299 | } |
300 | WriteToClient(client, sizeof(xRenderQueryVersionReply), &rep); |
301 | return Success0; |
302 | } |
303 | |
304 | static VisualPtr |
305 | findVisual(ScreenPtr pScreen, VisualID vid) |
306 | { |
307 | VisualPtr pVisual; |
308 | int v; |
309 | |
310 | for (v = 0; v < pScreen->numVisuals; v++) { |
311 | pVisual = pScreen->visuals + v; |
312 | if (pVisual->vid == vid) |
313 | return pVisual; |
314 | } |
315 | return 0; |
316 | } |
317 | |
318 | static int |
319 | ProcRenderQueryPictFormats(ClientPtr client) |
320 | { |
321 | RenderClientPtr pRenderClient = GetRenderClient(client)((RenderClientPtr)dixLookupPrivate(&(client)->devPrivates , (&RenderClientPrivateKeyRec ))); |
322 | xRenderQueryPictFormatsReply *reply; |
323 | xPictScreen *pictScreen; |
324 | xPictDepth *pictDepth; |
325 | xPictVisual *pictVisual; |
326 | xPictFormInfo *pictForm; |
327 | CARD32 *pictSubpixel; |
328 | ScreenPtr pScreen; |
329 | VisualPtr pVisual; |
330 | DepthPtr pDepth; |
331 | int v, d; |
332 | PictureScreenPtr ps; |
333 | PictFormatPtr pFormat; |
334 | int nformat; |
335 | int ndepth; |
336 | int nvisual; |
337 | int rlength; |
338 | int s; |
339 | int numScreens; |
340 | int numSubpixel; |
341 | |
342 | /* REQUEST(xRenderQueryPictFormatsReq); */ |
343 | |
344 | REQUEST_SIZE_MATCH(xRenderQueryPictFormatsReq)if ((sizeof(xRenderQueryPictFormatsReq) >> 2) != client ->req_len) return(16); |
345 | |
346 | #ifdef PANORAMIX1 |
347 | if (noPanoramiXExtension) |
348 | numScreens = screenInfo.numScreens; |
349 | else |
350 | numScreens = ((xConnSetup *) ConnectionInfo)->numRoots; |
351 | #else |
352 | numScreens = screenInfo.numScreens; |
353 | #endif |
354 | ndepth = nformat = nvisual = 0; |
355 | for (s = 0; s < numScreens; s++) { |
356 | pScreen = screenInfo.screens[s]; |
357 | for (d = 0; d < pScreen->numDepths; d++) { |
358 | pDepth = pScreen->allowedDepths + d; |
359 | ++ndepth; |
360 | |
361 | for (v = 0; v < pDepth->numVids; v++) { |
362 | pVisual = findVisual(pScreen, pDepth->vids[v]); |
363 | if (pVisual && |
364 | PictureMatchVisual(pScreen, pDepth->depth, pVisual)) |
365 | ++nvisual; |
366 | } |
367 | } |
368 | ps = GetPictureScreenIfSet(pScreen)(dixPrivateKeyRegistered((&PictureScreenPrivateKeyRec)) ? ((PictureScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates , (&PictureScreenPrivateKeyRec))) : ((void*)0)); |
369 | if (ps) |
370 | nformat += ps->nformats; |
371 | } |
372 | if (pRenderClient->major_version == 0 && pRenderClient->minor_version < 6) |
373 | numSubpixel = 0; |
374 | else |
375 | numSubpixel = numScreens; |
376 | |
377 | rlength = (sizeof(xRenderQueryPictFormatsReply) + |
378 | nformat * sizeof(xPictFormInfo) + |
379 | numScreens * sizeof(xPictScreen) + |
380 | ndepth * sizeof(xPictDepth) + |
381 | nvisual * sizeof(xPictVisual) + numSubpixel * sizeof(CARD32)); |
382 | reply = (xRenderQueryPictFormatsReply *) calloc(1, rlength); |
383 | if (!reply) |
384 | return BadAlloc11; |
385 | reply->type = X_Reply1; |
386 | reply->sequenceNumber = client->sequence; |
387 | reply->length = bytes_to_int32(rlength - sizeof(xGenericReply)); |
388 | reply->numFormats = nformat; |
389 | reply->numScreens = numScreens; |
390 | reply->numDepths = ndepth; |
391 | reply->numVisuals = nvisual; |
392 | reply->numSubpixel = numSubpixel; |
393 | |
394 | pictForm = (xPictFormInfo *) (reply + 1); |
395 | |
396 | for (s = 0; s < numScreens; s++) { |
397 | pScreen = screenInfo.screens[s]; |
398 | ps = GetPictureScreenIfSet(pScreen)(dixPrivateKeyRegistered((&PictureScreenPrivateKeyRec)) ? ((PictureScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates , (&PictureScreenPrivateKeyRec))) : ((void*)0)); |
399 | if (ps) { |
400 | for (nformat = 0, pFormat = ps->formats; |
401 | nformat < ps->nformats; nformat++, pFormat++) { |
402 | pictForm->id = pFormat->id; |
403 | pictForm->type = pFormat->type; |
404 | pictForm->depth = pFormat->depth; |
405 | pictForm->direct.red = pFormat->direct.red; |
406 | pictForm->direct.redMask = pFormat->direct.redMask; |
407 | pictForm->direct.green = pFormat->direct.green; |
408 | pictForm->direct.greenMask = pFormat->direct.greenMask; |
409 | pictForm->direct.blue = pFormat->direct.blue; |
410 | pictForm->direct.blueMask = pFormat->direct.blueMask; |
411 | pictForm->direct.alpha = pFormat->direct.alpha; |
412 | pictForm->direct.alphaMask = pFormat->direct.alphaMask; |
413 | if (pFormat->type == PictTypeIndexed0 && |
414 | pFormat->index.pColormap) |
415 | pictForm->colormap = pFormat->index.pColormap->mid; |
416 | else |
417 | pictForm->colormap = None0L; |
418 | if (client->swapped) { |
419 | swapl(&pictForm->id)do { if (sizeof(*(&pictForm->id)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&pictForm->id) & 3) && ((uintptr_t)(&pictForm->id) & 3) == 0) *(&pictForm->id) = lswapl(*(&pictForm->id)) ; else swap_uint32((uint32_t *)(&pictForm->id)); } while (0); |
420 | swaps(&pictForm->direct.red)do { if (sizeof(*(&pictForm->direct.red)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictForm->direct .red) & 1) && ((uintptr_t)(&pictForm->direct .red) & 1) == 0) *(&pictForm->direct.red) = lswaps (*(&pictForm->direct.red)); else swap_uint16((uint16_t *)(&pictForm->direct.red)); } while (0); |
421 | swaps(&pictForm->direct.redMask)do { if (sizeof(*(&pictForm->direct.redMask)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictForm->direct .redMask) & 1) && ((uintptr_t)(&pictForm-> direct.redMask) & 1) == 0) *(&pictForm->direct.redMask ) = lswaps(*(&pictForm->direct.redMask)); else swap_uint16 ((uint16_t *)(&pictForm->direct.redMask)); } while (0); |
422 | swaps(&pictForm->direct.green)do { if (sizeof(*(&pictForm->direct.green)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictForm->direct .green) & 1) && ((uintptr_t)(&pictForm->direct .green) & 1) == 0) *(&pictForm->direct.green) = lswaps (*(&pictForm->direct.green)); else swap_uint16((uint16_t *)(&pictForm->direct.green)); } while (0); |
423 | swaps(&pictForm->direct.greenMask)do { if (sizeof(*(&pictForm->direct.greenMask)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictForm->direct .greenMask) & 1) && ((uintptr_t)(&pictForm-> direct.greenMask) & 1) == 0) *(&pictForm->direct.greenMask ) = lswaps(*(&pictForm->direct.greenMask)); else swap_uint16 ((uint16_t *)(&pictForm->direct.greenMask)); } while ( 0); |
424 | swaps(&pictForm->direct.blue)do { if (sizeof(*(&pictForm->direct.blue)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictForm->direct .blue) & 1) && ((uintptr_t)(&pictForm->direct .blue) & 1) == 0) *(&pictForm->direct.blue) = lswaps (*(&pictForm->direct.blue)); else swap_uint16((uint16_t *)(&pictForm->direct.blue)); } while (0); |
425 | swaps(&pictForm->direct.blueMask)do { if (sizeof(*(&pictForm->direct.blueMask)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictForm->direct .blueMask) & 1) && ((uintptr_t)(&pictForm-> direct.blueMask) & 1) == 0) *(&pictForm->direct.blueMask ) = lswaps(*(&pictForm->direct.blueMask)); else swap_uint16 ((uint16_t *)(&pictForm->direct.blueMask)); } while (0 ); |
426 | swaps(&pictForm->direct.alpha)do { if (sizeof(*(&pictForm->direct.alpha)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictForm->direct .alpha) & 1) && ((uintptr_t)(&pictForm->direct .alpha) & 1) == 0) *(&pictForm->direct.alpha) = lswaps (*(&pictForm->direct.alpha)); else swap_uint16((uint16_t *)(&pictForm->direct.alpha)); } while (0); |
427 | swaps(&pictForm->direct.alphaMask)do { if (sizeof(*(&pictForm->direct.alphaMask)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictForm->direct .alphaMask) & 1) && ((uintptr_t)(&pictForm-> direct.alphaMask) & 1) == 0) *(&pictForm->direct.alphaMask ) = lswaps(*(&pictForm->direct.alphaMask)); else swap_uint16 ((uint16_t *)(&pictForm->direct.alphaMask)); } while ( 0); |
428 | swapl(&pictForm->colormap)do { if (sizeof(*(&pictForm->colormap)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictForm->colormap ) & 3) && ((uintptr_t)(&pictForm->colormap ) & 3) == 0) *(&pictForm->colormap) = lswapl(*(& pictForm->colormap)); else swap_uint32((uint32_t *)(&pictForm ->colormap)); } while (0); |
429 | } |
430 | pictForm++; |
431 | } |
432 | } |
433 | } |
434 | |
435 | pictScreen = (xPictScreen *) pictForm; |
436 | for (s = 0; s < numScreens; s++) { |
437 | pScreen = screenInfo.screens[s]; |
438 | pictDepth = (xPictDepth *) (pictScreen + 1); |
439 | ndepth = 0; |
440 | for (d = 0; d < pScreen->numDepths; d++) { |
441 | pictVisual = (xPictVisual *) (pictDepth + 1); |
442 | pDepth = pScreen->allowedDepths + d; |
443 | |
444 | nvisual = 0; |
445 | for (v = 0; v < pDepth->numVids; v++) { |
446 | pVisual = findVisual(pScreen, pDepth->vids[v]); |
447 | if (pVisual && (pFormat = PictureMatchVisual(pScreen, |
448 | pDepth->depth, |
449 | pVisual))) { |
450 | pictVisual->visual = pVisual->vid; |
451 | pictVisual->format = pFormat->id; |
452 | if (client->swapped) { |
453 | swapl(&pictVisual->visual)do { if (sizeof(*(&pictVisual->visual)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictVisual-> visual) & 3) && ((uintptr_t)(&pictVisual-> visual) & 3) == 0) *(&pictVisual->visual) = lswapl (*(&pictVisual->visual)); else swap_uint32((uint32_t * )(&pictVisual->visual)); } while (0); |
454 | swapl(&pictVisual->format)do { if (sizeof(*(&pictVisual->format)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictVisual-> format) & 3) && ((uintptr_t)(&pictVisual-> format) & 3) == 0) *(&pictVisual->format) = lswapl (*(&pictVisual->format)); else swap_uint32((uint32_t * )(&pictVisual->format)); } while (0); |
455 | } |
456 | pictVisual++; |
457 | nvisual++; |
458 | } |
459 | } |
460 | pictDepth->depth = pDepth->depth; |
461 | pictDepth->nPictVisuals = nvisual; |
462 | if (client->swapped) { |
463 | swaps(&pictDepth->nPictVisuals)do { if (sizeof(*(&pictDepth->nPictVisuals)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictDepth->nPictVisuals ) & 1) && ((uintptr_t)(&pictDepth->nPictVisuals ) & 1) == 0) *(&pictDepth->nPictVisuals) = lswaps( *(&pictDepth->nPictVisuals)); else swap_uint16((uint16_t *)(&pictDepth->nPictVisuals)); } while (0); |
464 | } |
465 | ndepth++; |
466 | pictDepth = (xPictDepth *) pictVisual; |
467 | } |
468 | pictScreen->nDepth = ndepth; |
469 | ps = GetPictureScreenIfSet(pScreen)(dixPrivateKeyRegistered((&PictureScreenPrivateKeyRec)) ? ((PictureScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates , (&PictureScreenPrivateKeyRec))) : ((void*)0)); |
470 | if (ps) |
471 | pictScreen->fallback = ps->fallback->id; |
472 | else |
473 | pictScreen->fallback = 0; |
474 | if (client->swapped) { |
475 | swapl(&pictScreen->nDepth)do { if (sizeof(*(&pictScreen->nDepth)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictScreen-> nDepth) & 3) && ((uintptr_t)(&pictScreen-> nDepth) & 3) == 0) *(&pictScreen->nDepth) = lswapl (*(&pictScreen->nDepth)); else swap_uint32((uint32_t * )(&pictScreen->nDepth)); } while (0); |
476 | swapl(&pictScreen->fallback)do { if (sizeof(*(&pictScreen->fallback)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictScreen-> fallback) & 3) && ((uintptr_t)(&pictScreen-> fallback) & 3) == 0) *(&pictScreen->fallback) = lswapl (*(&pictScreen->fallback)); else swap_uint32((uint32_t *)(&pictScreen->fallback)); } while (0); |
477 | } |
478 | pictScreen = (xPictScreen *) pictDepth; |
479 | } |
480 | pictSubpixel = (CARD32 *) pictScreen; |
481 | |
482 | for (s = 0; s < numSubpixel; s++) { |
483 | pScreen = screenInfo.screens[s]; |
484 | ps = GetPictureScreenIfSet(pScreen)(dixPrivateKeyRegistered((&PictureScreenPrivateKeyRec)) ? ((PictureScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates , (&PictureScreenPrivateKeyRec))) : ((void*)0)); |
485 | if (ps) |
486 | *pictSubpixel = ps->subpixel; |
487 | else |
488 | *pictSubpixel = SubPixelUnknown0; |
489 | if (client->swapped) { |
490 | swapl(pictSubpixel)do { if (sizeof(*(pictSubpixel)) != 4) wrong_size(); if (__builtin_constant_p ((uintptr_t)(pictSubpixel) & 3) && ((uintptr_t)(pictSubpixel ) & 3) == 0) *(pictSubpixel) = lswapl(*(pictSubpixel)); else swap_uint32((uint32_t *)(pictSubpixel)); } while (0); |
491 | } |
492 | ++pictSubpixel; |
493 | } |
494 | |
495 | if (client->swapped) { |
496 | swaps(&reply->sequenceNumber)do { if (sizeof(*(&reply->sequenceNumber)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->sequenceNumber ) & 1) && ((uintptr_t)(&reply->sequenceNumber ) & 1) == 0) *(&reply->sequenceNumber) = lswaps(*( &reply->sequenceNumber)); else swap_uint16((uint16_t * )(&reply->sequenceNumber)); } while (0); |
497 | swapl(&reply->length)do { if (sizeof(*(&reply->length)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&reply->length) & 3) && ((uintptr_t)(&reply->length) & 3) == 0) *(&reply->length) = lswapl(*(&reply->length )); else swap_uint32((uint32_t *)(&reply->length)); } while (0); |
498 | swapl(&reply->numFormats)do { if (sizeof(*(&reply->numFormats)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->numFormats ) & 3) && ((uintptr_t)(&reply->numFormats) & 3) == 0) *(&reply->numFormats) = lswapl(*(& reply->numFormats)); else swap_uint32((uint32_t *)(&reply ->numFormats)); } while (0); |
499 | swapl(&reply->numScreens)do { if (sizeof(*(&reply->numScreens)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->numScreens ) & 3) && ((uintptr_t)(&reply->numScreens) & 3) == 0) *(&reply->numScreens) = lswapl(*(& reply->numScreens)); else swap_uint32((uint32_t *)(&reply ->numScreens)); } while (0); |
500 | swapl(&reply->numDepths)do { if (sizeof(*(&reply->numDepths)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->numDepths ) & 3) && ((uintptr_t)(&reply->numDepths) & 3) == 0) *(&reply->numDepths) = lswapl(*(&reply-> numDepths)); else swap_uint32((uint32_t *)(&reply->numDepths )); } while (0); |
501 | swapl(&reply->numVisuals)do { if (sizeof(*(&reply->numVisuals)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->numVisuals ) & 3) && ((uintptr_t)(&reply->numVisuals) & 3) == 0) *(&reply->numVisuals) = lswapl(*(& reply->numVisuals)); else swap_uint32((uint32_t *)(&reply ->numVisuals)); } while (0); |
502 | swapl(&reply->numSubpixel)do { if (sizeof(*(&reply->numSubpixel)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->numSubpixel ) & 3) && ((uintptr_t)(&reply->numSubpixel ) & 3) == 0) *(&reply->numSubpixel) = lswapl(*(& reply->numSubpixel)); else swap_uint32((uint32_t *)(&reply ->numSubpixel)); } while (0); |
503 | } |
504 | WriteToClient(client, rlength, reply); |
505 | free(reply); |
506 | return Success0; |
507 | } |
508 | |
509 | static int |
510 | ProcRenderQueryPictIndexValues(ClientPtr client) |
511 | { |
512 | PictFormatPtr pFormat; |
513 | int rc, num; |
514 | int rlength; |
515 | int i; |
516 | |
517 | REQUEST(xRenderQueryPictIndexValuesReq)xRenderQueryPictIndexValuesReq *stuff = (xRenderQueryPictIndexValuesReq *)client->requestBuffer; |
518 | xRenderQueryPictIndexValuesReply *reply; |
519 | xIndexValue *values; |
520 | |
521 | REQUEST_AT_LEAST_SIZE(xRenderQueryPictIndexValuesReq)if ((sizeof(xRenderQueryPictIndexValuesReq) >> 2) > client ->req_len ) return(16); |
522 | |
523 | rc = dixLookupResourceByType((void **) &pFormat, stuff->format, |
524 | PictFormatType, client, DixReadAccess(1<<0)); |
525 | if (rc != Success0) |
526 | return rc; |
527 | |
528 | if (pFormat->type != PictTypeIndexed0) { |
529 | client->errorValue = stuff->format; |
530 | return BadMatch8; |
531 | } |
532 | num = pFormat->index.nvalues; |
533 | rlength = (sizeof(xRenderQueryPictIndexValuesReply) + |
534 | num * sizeof(xIndexValue)); |
535 | reply = (xRenderQueryPictIndexValuesReply *) calloc(1, rlength); |
536 | if (!reply) |
537 | return BadAlloc11; |
538 | |
539 | reply->type = X_Reply1; |
540 | reply->sequenceNumber = client->sequence; |
541 | reply->length = bytes_to_int32(rlength - sizeof(xGenericReply)); |
542 | reply->numIndexValues = num; |
543 | |
544 | values = (xIndexValue *) (reply + 1); |
545 | |
546 | memcpy(reply + 1, pFormat->index.pValues, num * sizeof(xIndexValue))__builtin___memcpy_chk (reply + 1, pFormat->index.pValues, num * sizeof(xIndexValue), __builtin_object_size (reply + 1, 0)); |
547 | |
548 | if (client->swapped) { |
549 | for (i = 0; i < num; i++) { |
550 | swapl(&values[i].pixel)do { if (sizeof(*(&values[i].pixel)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&values[i].pixel) & 3) && ((uintptr_t)(&values[i].pixel) & 3) == 0) *(&values[i].pixel) = lswapl(*(&values[i].pixel)) ; else swap_uint32((uint32_t *)(&values[i].pixel)); } while (0); |
551 | swaps(&values[i].red)do { if (sizeof(*(&values[i].red)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&values[i].red) & 1 ) && ((uintptr_t)(&values[i].red) & 1) == 0) * (&values[i].red) = lswaps(*(&values[i].red)); else swap_uint16 ((uint16_t *)(&values[i].red)); } while (0); |
552 | swaps(&values[i].green)do { if (sizeof(*(&values[i].green)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&values[i].green) & 1) && ((uintptr_t)(&values[i].green) & 1) == 0) *(&values[i].green) = lswaps(*(&values[i].green)) ; else swap_uint16((uint16_t *)(&values[i].green)); } while (0); |
553 | swaps(&values[i].blue)do { if (sizeof(*(&values[i].blue)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&values[i].blue) & 1) && ((uintptr_t)(&values[i].blue) & 1) == 0 ) *(&values[i].blue) = lswaps(*(&values[i].blue)); else swap_uint16((uint16_t *)(&values[i].blue)); } while (0); |
554 | swaps(&values[i].alpha)do { if (sizeof(*(&values[i].alpha)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&values[i].alpha) & 1) && ((uintptr_t)(&values[i].alpha) & 1) == 0) *(&values[i].alpha) = lswaps(*(&values[i].alpha)) ; else swap_uint16((uint16_t *)(&values[i].alpha)); } while (0); |
555 | } |
556 | swaps(&reply->sequenceNumber)do { if (sizeof(*(&reply->sequenceNumber)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->sequenceNumber ) & 1) && ((uintptr_t)(&reply->sequenceNumber ) & 1) == 0) *(&reply->sequenceNumber) = lswaps(*( &reply->sequenceNumber)); else swap_uint16((uint16_t * )(&reply->sequenceNumber)); } while (0); |
557 | swapl(&reply->length)do { if (sizeof(*(&reply->length)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&reply->length) & 3) && ((uintptr_t)(&reply->length) & 3) == 0) *(&reply->length) = lswapl(*(&reply->length )); else swap_uint32((uint32_t *)(&reply->length)); } while (0); |
558 | swapl(&reply->numIndexValues)do { if (sizeof(*(&reply->numIndexValues)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->numIndexValues ) & 3) && ((uintptr_t)(&reply->numIndexValues ) & 3) == 0) *(&reply->numIndexValues) = lswapl(*( &reply->numIndexValues)); else swap_uint32((uint32_t * )(&reply->numIndexValues)); } while (0); |
559 | } |
560 | |
561 | WriteToClient(client, rlength, reply); |
562 | free(reply); |
563 | return Success0; |
564 | } |
565 | |
566 | static int |
567 | ProcRenderQueryDithers(ClientPtr client) |
568 | { |
569 | return BadImplementation17; |
570 | } |
571 | |
572 | static int |
573 | ProcRenderCreatePicture(ClientPtr client) |
574 | { |
575 | PicturePtr pPicture; |
576 | DrawablePtr pDrawable; |
577 | PictFormatPtr pFormat; |
578 | int len, error, rc; |
579 | |
580 | REQUEST(xRenderCreatePictureReq)xRenderCreatePictureReq *stuff = (xRenderCreatePictureReq *)client ->requestBuffer; |
581 | |
582 | REQUEST_AT_LEAST_SIZE(xRenderCreatePictureReq)if ((sizeof(xRenderCreatePictureReq) >> 2) > client-> req_len ) return(16); |
583 | |
584 | LEGAL_NEW_RESOURCE(stuff->pid, client)if (!LegalNewID(stuff->pid,client)) { client->errorValue = stuff->pid; return 14; }; |
585 | rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0, |
586 | DixReadAccess(1<<0) | DixAddAccess(1<<12)); |
587 | if (rc != Success0) |
588 | return rc; |
589 | |
590 | rc = dixLookupResourceByType((void **) &pFormat, stuff->format, |
591 | PictFormatType, client, DixReadAccess(1<<0)); |
592 | if (rc != Success0) |
593 | return rc; |
594 | |
595 | if (pFormat->depth != pDrawable->depth) |
596 | return BadMatch8; |
597 | len = client->req_len - bytes_to_int32(sizeof(xRenderCreatePictureReq)); |
598 | if (Ones(stuff->mask) != len) |
599 | return BadLength16; |
600 | |
601 | pPicture = CreatePicture(stuff->pid, |
602 | pDrawable, |
603 | pFormat, |
604 | stuff->mask, (XID *) (stuff + 1), client, &error); |
605 | if (!pPicture) |
606 | return error; |
607 | if (!AddResourceDarwin_X_AddResource(stuff->pid, PictureType, (void *) pPicture)) |
608 | return BadAlloc11; |
609 | return Success0; |
610 | } |
611 | |
612 | static int |
613 | ProcRenderChangePicture(ClientPtr client) |
614 | { |
615 | PicturePtr pPicture; |
616 | |
617 | REQUEST(xRenderChangePictureReq)xRenderChangePictureReq *stuff = (xRenderChangePictureReq *)client ->requestBuffer; |
618 | int len; |
619 | |
620 | REQUEST_AT_LEAST_SIZE(xRenderChangePictureReq)if ((sizeof(xRenderChangePictureReq) >> 2) > client-> req_len ) return(16); |
621 | VERIFY_PICTURE(pPicture, stuff->picture, client, DixSetAttrAccess){ int tmprc = dixLookupResourceByType((void *)&(pPicture) , stuff->picture, PictureType, client, (1<<5)); if ( tmprc != 0) return tmprc;}; |
622 | |
623 | len = client->req_len - bytes_to_int32(sizeof(xRenderChangePictureReq)); |
624 | if (Ones(stuff->mask) != len) |
625 | return BadLength16; |
626 | |
627 | return ChangePicture(pPicture, stuff->mask, (XID *) (stuff + 1), |
628 | (DevUnion *) 0, client); |
629 | } |
630 | |
631 | static int |
632 | ProcRenderSetPictureClipRectangles(ClientPtr client) |
633 | { |
634 | REQUEST(xRenderSetPictureClipRectanglesReq)xRenderSetPictureClipRectanglesReq *stuff = (xRenderSetPictureClipRectanglesReq *)client->requestBuffer; |
635 | PicturePtr pPicture; |
636 | int nr; |
637 | |
638 | REQUEST_AT_LEAST_SIZE(xRenderSetPictureClipRectanglesReq)if ((sizeof(xRenderSetPictureClipRectanglesReq) >> 2) > client->req_len ) return(16); |
639 | VERIFY_PICTURE(pPicture, stuff->picture, client, DixSetAttrAccess){ int tmprc = dixLookupResourceByType((void *)&(pPicture) , stuff->picture, PictureType, client, (1<<5)); if ( tmprc != 0) return tmprc;}; |
640 | if (!pPicture->pDrawable) |
641 | return RenderErrBase + BadPicture1; |
642 | |
643 | nr = (client->req_len << 2) - sizeof(xRenderSetPictureClipRectanglesReq); |
644 | if (nr & 4) |
645 | return BadLength16; |
646 | nr >>= 3; |
647 | return SetPictureClipRects(pPicture, |
648 | stuff->xOrigin, stuff->yOrigin, |
649 | nr, (xRectangle *) &stuff[1]); |
650 | } |
651 | |
652 | static int |
653 | ProcRenderFreePicture(ClientPtr client) |
654 | { |
655 | PicturePtr pPicture; |
656 | |
657 | REQUEST(xRenderFreePictureReq)xRenderFreePictureReq *stuff = (xRenderFreePictureReq *)client ->requestBuffer; |
658 | |
659 | REQUEST_SIZE_MATCH(xRenderFreePictureReq)if ((sizeof(xRenderFreePictureReq) >> 2) != client-> req_len) return(16); |
660 | |
661 | VERIFY_PICTURE(pPicture, stuff->picture, client, DixDestroyAccess){ int tmprc = dixLookupResourceByType((void *)&(pPicture) , stuff->picture, PictureType, client, (1<<2)); if ( tmprc != 0) return tmprc;}; |
662 | FreeResource(stuff->picture, RT_NONE((RESTYPE)0)); |
663 | return Success0; |
664 | } |
665 | |
666 | static Bool |
667 | PictOpValid(CARD8 op) |
668 | { |
669 | if ( /*PictOpMinimum <= op && */ op <= PictOpMaximum13) |
670 | return TRUE1; |
671 | if (PictOpDisjointMinimum0x10 <= op && op <= PictOpDisjointMaximum0x1b) |
672 | return TRUE1; |
673 | if (PictOpConjointMinimum0x20 <= op && op <= PictOpConjointMaximum0x2b) |
674 | return TRUE1; |
675 | if (PictOpBlendMinimum0x30 <= op && op <= PictOpBlendMaximum0x3e) |
676 | return TRUE1; |
677 | return FALSE0; |
678 | } |
679 | |
680 | static int |
681 | ProcRenderComposite(ClientPtr client) |
682 | { |
683 | PicturePtr pSrc, pMask, pDst; |
684 | |
685 | REQUEST(xRenderCompositeReq)xRenderCompositeReq *stuff = (xRenderCompositeReq *)client-> requestBuffer; |
686 | |
687 | REQUEST_SIZE_MATCH(xRenderCompositeReq)if ((sizeof(xRenderCompositeReq) >> 2) != client->req_len ) return(16); |
688 | if (!PictOpValid(stuff->op)) { |
689 | client->errorValue = stuff->op; |
690 | return BadValue2; |
691 | } |
692 | VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess){ int tmprc = dixLookupResourceByType((void *)&(pDst), stuff ->dst, PictureType, client, (1<<1)); if (tmprc != 0) return tmprc;}; |
693 | if (!pDst->pDrawable) |
694 | return BadDrawable9; |
695 | VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess){ int tmprc = dixLookupResourceByType((void *)&(pSrc), stuff ->src, PictureType, client, (1<<0)); if (tmprc != 0) return tmprc;}; |
696 | VERIFY_ALPHA(pMask, stuff->mask, client, DixReadAccess){ if (stuff->mask == 0L) pMask = 0; else { { int tmprc = dixLookupResourceByType ((void *)&(pMask), stuff->mask, PictureType, client, ( 1<<0)); if (tmprc != 0) return tmprc;}; } }; |
697 | if ((pSrc->pDrawable && |
698 | pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) || (pMask && |
699 | pMask-> |
700 | pDrawable && |
701 | pDst-> |
702 | pDrawable-> |
703 | pScreen != |
704 | pMask-> |
705 | pDrawable-> |
706 | pScreen)) |
707 | return BadMatch8; |
708 | CompositePicture(stuff->op, |
709 | pSrc, |
710 | pMask, |
711 | pDst, |
712 | stuff->xSrc, |
713 | stuff->ySrc, |
714 | stuff->xMask, |
715 | stuff->yMask, |
716 | stuff->xDst, stuff->yDst, stuff->width, stuff->height); |
717 | return Success0; |
718 | } |
719 | |
720 | static int |
721 | ProcRenderScale(ClientPtr client) |
722 | { |
723 | return BadImplementation17; |
724 | } |
725 | |
726 | static int |
727 | ProcRenderTrapezoids(ClientPtr client) |
728 | { |
729 | int rc, ntraps; |
730 | PicturePtr pSrc, pDst; |
731 | PictFormatPtr pFormat; |
732 | |
733 | REQUEST(xRenderTrapezoidsReq)xRenderTrapezoidsReq *stuff = (xRenderTrapezoidsReq *)client-> requestBuffer; |
734 | |
735 | REQUEST_AT_LEAST_SIZE(xRenderTrapezoidsReq)if ((sizeof(xRenderTrapezoidsReq) >> 2) > client-> req_len ) return(16); |
736 | if (!PictOpValid(stuff->op)) { |
737 | client->errorValue = stuff->op; |
738 | return BadValue2; |
739 | } |
740 | VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess){ int tmprc = dixLookupResourceByType((void *)&(pSrc), stuff ->src, PictureType, client, (1<<0)); if (tmprc != 0) return tmprc;}; |
741 | VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess){ int tmprc = dixLookupResourceByType((void *)&(pDst), stuff ->dst, PictureType, client, (1<<1)); if (tmprc != 0) return tmprc;}; |
742 | if (!pDst->pDrawable) |
743 | return BadDrawable9; |
744 | if (pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) |
745 | return BadMatch8; |
746 | if (stuff->maskFormat) { |
747 | rc = dixLookupResourceByType((void **) &pFormat, stuff->maskFormat, |
748 | PictFormatType, client, DixReadAccess(1<<0)); |
749 | if (rc != Success0) |
750 | return rc; |
751 | } |
752 | else |
753 | pFormat = 0; |
754 | ntraps = (client->req_len << 2) - sizeof(xRenderTrapezoidsReq); |
755 | if (ntraps % sizeof(xTrapezoid)) |
756 | return BadLength16; |
757 | ntraps /= sizeof(xTrapezoid); |
758 | if (ntraps) |
759 | CompositeTrapezoids(stuff->op, pSrc, pDst, pFormat, |
760 | stuff->xSrc, stuff->ySrc, |
761 | ntraps, (xTrapezoid *) &stuff[1]); |
762 | return Success0; |
763 | } |
764 | |
765 | static int |
766 | ProcRenderTriangles(ClientPtr client) |
767 | { |
768 | int rc, ntris; |
769 | PicturePtr pSrc, pDst; |
770 | PictFormatPtr pFormat; |
771 | |
772 | REQUEST(xRenderTrianglesReq)xRenderTrianglesReq *stuff = (xRenderTrianglesReq *)client-> requestBuffer; |
773 | |
774 | REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq)if ((sizeof(xRenderTrianglesReq) >> 2) > client-> req_len ) return(16); |
775 | if (!PictOpValid(stuff->op)) { |
776 | client->errorValue = stuff->op; |
777 | return BadValue2; |
778 | } |
779 | VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess){ int tmprc = dixLookupResourceByType((void *)&(pSrc), stuff ->src, PictureType, client, (1<<0)); if (tmprc != 0) return tmprc;}; |
780 | VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess){ int tmprc = dixLookupResourceByType((void *)&(pDst), stuff ->dst, PictureType, client, (1<<1)); if (tmprc != 0) return tmprc;}; |
781 | if (!pDst->pDrawable) |
782 | return BadDrawable9; |
783 | if (pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) |
784 | return BadMatch8; |
785 | if (stuff->maskFormat) { |
786 | rc = dixLookupResourceByType((void **) &pFormat, stuff->maskFormat, |
787 | PictFormatType, client, DixReadAccess(1<<0)); |
788 | if (rc != Success0) |
789 | return rc; |
790 | } |
791 | else |
792 | pFormat = 0; |
793 | ntris = (client->req_len << 2) - sizeof(xRenderTrianglesReq); |
794 | if (ntris % sizeof(xTriangle)) |
795 | return BadLength16; |
796 | ntris /= sizeof(xTriangle); |
797 | if (ntris) |
798 | CompositeTriangles(stuff->op, pSrc, pDst, pFormat, |
799 | stuff->xSrc, stuff->ySrc, |
800 | ntris, (xTriangle *) &stuff[1]); |
801 | return Success0; |
802 | } |
803 | |
804 | static int |
805 | ProcRenderTriStrip(ClientPtr client) |
806 | { |
807 | int rc, npoints; |
808 | PicturePtr pSrc, pDst; |
809 | PictFormatPtr pFormat; |
810 | |
811 | REQUEST(xRenderTrianglesReq)xRenderTrianglesReq *stuff = (xRenderTrianglesReq *)client-> requestBuffer; |
812 | |
813 | REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq)if ((sizeof(xRenderTrianglesReq) >> 2) > client-> req_len ) return(16); |
814 | if (!PictOpValid(stuff->op)) { |
815 | client->errorValue = stuff->op; |
816 | return BadValue2; |
817 | } |
818 | VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess){ int tmprc = dixLookupResourceByType((void *)&(pSrc), stuff ->src, PictureType, client, (1<<0)); if (tmprc != 0) return tmprc;}; |
819 | VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess){ int tmprc = dixLookupResourceByType((void *)&(pDst), stuff ->dst, PictureType, client, (1<<1)); if (tmprc != 0) return tmprc;}; |
820 | if (!pDst->pDrawable) |
821 | return BadDrawable9; |
822 | if (pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) |
823 | return BadMatch8; |
824 | if (stuff->maskFormat) { |
825 | rc = dixLookupResourceByType((void **) &pFormat, stuff->maskFormat, |
826 | PictFormatType, client, DixReadAccess(1<<0)); |
827 | if (rc != Success0) |
828 | return rc; |
829 | } |
830 | else |
831 | pFormat = 0; |
832 | npoints = ((client->req_len << 2) - sizeof(xRenderTriStripReq)); |
833 | if (npoints & 4) |
834 | return BadLength16; |
835 | npoints >>= 3; |
836 | if (npoints >= 3) |
837 | CompositeTriStrip(stuff->op, pSrc, pDst, pFormat, |
838 | stuff->xSrc, stuff->ySrc, |
839 | npoints, (xPointFixed *) &stuff[1]); |
840 | return Success0; |
841 | } |
842 | |
843 | static int |
844 | ProcRenderTriFan(ClientPtr client) |
845 | { |
846 | int rc, npoints; |
847 | PicturePtr pSrc, pDst; |
848 | PictFormatPtr pFormat; |
849 | |
850 | REQUEST(xRenderTrianglesReq)xRenderTrianglesReq *stuff = (xRenderTrianglesReq *)client-> requestBuffer; |
851 | |
852 | REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq)if ((sizeof(xRenderTrianglesReq) >> 2) > client-> req_len ) return(16); |
853 | if (!PictOpValid(stuff->op)) { |
854 | client->errorValue = stuff->op; |
855 | return BadValue2; |
856 | } |
857 | VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess){ int tmprc = dixLookupResourceByType((void *)&(pSrc), stuff ->src, PictureType, client, (1<<0)); if (tmprc != 0) return tmprc;}; |
858 | VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess){ int tmprc = dixLookupResourceByType((void *)&(pDst), stuff ->dst, PictureType, client, (1<<1)); if (tmprc != 0) return tmprc;}; |
859 | if (!pDst->pDrawable) |
860 | return BadDrawable9; |
861 | if (pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) |
862 | return BadMatch8; |
863 | if (stuff->maskFormat) { |
864 | rc = dixLookupResourceByType((void **) &pFormat, stuff->maskFormat, |
865 | PictFormatType, client, DixReadAccess(1<<0)); |
866 | if (rc != Success0) |
867 | return rc; |
868 | } |
869 | else |
870 | pFormat = 0; |
871 | npoints = ((client->req_len << 2) - sizeof(xRenderTriStripReq)); |
872 | if (npoints & 4) |
873 | return BadLength16; |
874 | npoints >>= 3; |
875 | if (npoints >= 3) |
876 | CompositeTriFan(stuff->op, pSrc, pDst, pFormat, |
877 | stuff->xSrc, stuff->ySrc, |
878 | npoints, (xPointFixed *) &stuff[1]); |
879 | return Success0; |
880 | } |
881 | |
882 | static int |
883 | ProcRenderColorTrapezoids(ClientPtr client) |
884 | { |
885 | return BadImplementation17; |
886 | } |
887 | |
888 | static int |
889 | ProcRenderColorTriangles(ClientPtr client) |
890 | { |
891 | return BadImplementation17; |
892 | } |
893 | |
894 | static int |
895 | ProcRenderTransform(ClientPtr client) |
896 | { |
897 | return BadImplementation17; |
898 | } |
899 | |
900 | static int |
901 | ProcRenderCreateGlyphSet(ClientPtr client) |
902 | { |
903 | GlyphSetPtr glyphSet; |
904 | PictFormatPtr format; |
905 | int rc, f; |
906 | |
907 | REQUEST(xRenderCreateGlyphSetReq)xRenderCreateGlyphSetReq *stuff = (xRenderCreateGlyphSetReq * )client->requestBuffer; |
908 | |
909 | REQUEST_SIZE_MATCH(xRenderCreateGlyphSetReq)if ((sizeof(xRenderCreateGlyphSetReq) >> 2) != client-> req_len) return(16); |
910 | |
911 | LEGAL_NEW_RESOURCE(stuff->gsid, client)if (!LegalNewID(stuff->gsid,client)) { client->errorValue = stuff->gsid; return 14; }; |
912 | rc = dixLookupResourceByType((void **) &format, stuff->format, |
913 | PictFormatType, client, DixReadAccess(1<<0)); |
914 | if (rc != Success0) |
915 | return rc; |
916 | |
917 | switch (format->depth) { |
918 | case 1: |
919 | f = GlyphFormat10; |
920 | break; |
921 | case 4: |
922 | f = GlyphFormat41; |
923 | break; |
924 | case 8: |
925 | f = GlyphFormat82; |
926 | break; |
927 | case 16: |
928 | f = GlyphFormat163; |
929 | break; |
930 | case 32: |
931 | f = GlyphFormat324; |
932 | break; |
933 | default: |
934 | return BadMatch8; |
935 | } |
936 | if (format->type != PictTypeDirect1) |
937 | return BadMatch8; |
938 | glyphSet = AllocateGlyphSet(f, format); |
939 | if (!glyphSet) |
940 | return BadAlloc11; |
941 | /* security creation/labeling check */ |
942 | rc = XaceHook(XACE_RESOURCE_ACCESS2, client, stuff->gsid, GlyphSetType, |
943 | glyphSet, RT_NONE((RESTYPE)0), NULL((void*)0), DixCreateAccess(1<<3)); |
944 | if (rc != Success0) |
945 | return rc; |
946 | if (!AddResourceDarwin_X_AddResource(stuff->gsid, GlyphSetType, (void *) glyphSet)) |
947 | return BadAlloc11; |
948 | return Success0; |
949 | } |
950 | |
951 | static int |
952 | ProcRenderReferenceGlyphSet(ClientPtr client) |
953 | { |
954 | GlyphSetPtr glyphSet; |
955 | int rc; |
956 | |
957 | REQUEST(xRenderReferenceGlyphSetReq)xRenderReferenceGlyphSetReq *stuff = (xRenderReferenceGlyphSetReq *)client->requestBuffer; |
958 | |
959 | REQUEST_SIZE_MATCH(xRenderReferenceGlyphSetReq)if ((sizeof(xRenderReferenceGlyphSetReq) >> 2) != client ->req_len) return(16); |
960 | |
961 | LEGAL_NEW_RESOURCE(stuff->gsid, client)if (!LegalNewID(stuff->gsid,client)) { client->errorValue = stuff->gsid; return 14; }; |
962 | |
963 | rc = dixLookupResourceByType((void **) &glyphSet, stuff->existing, |
964 | GlyphSetType, client, DixGetAttrAccess(1<<4)); |
965 | if (rc != Success0) { |
966 | client->errorValue = stuff->existing; |
967 | return rc; |
968 | } |
969 | glyphSet->refcnt++; |
970 | if (!AddResourceDarwin_X_AddResource(stuff->gsid, GlyphSetType, (void *) glyphSet)) |
971 | return BadAlloc11; |
972 | return Success0; |
973 | } |
974 | |
975 | #define NLOCALDELTA64 64 |
976 | #define NLOCALGLYPH256 256 |
977 | |
978 | static int |
979 | ProcRenderFreeGlyphSet(ClientPtr client) |
980 | { |
981 | GlyphSetPtr glyphSet; |
982 | int rc; |
983 | |
984 | REQUEST(xRenderFreeGlyphSetReq)xRenderFreeGlyphSetReq *stuff = (xRenderFreeGlyphSetReq *)client ->requestBuffer; |
985 | |
986 | REQUEST_SIZE_MATCH(xRenderFreeGlyphSetReq)if ((sizeof(xRenderFreeGlyphSetReq) >> 2) != client-> req_len) return(16); |
987 | rc = dixLookupResourceByType((void **) &glyphSet, stuff->glyphset, |
988 | GlyphSetType, client, DixDestroyAccess(1<<2)); |
989 | if (rc != Success0) { |
990 | client->errorValue = stuff->glyphset; |
991 | return rc; |
992 | } |
993 | FreeResource(stuff->glyphset, RT_NONE((RESTYPE)0)); |
994 | return Success0; |
995 | } |
996 | |
997 | typedef struct _GlyphNew { |
998 | Glyph id; |
999 | GlyphPtr glyph; |
1000 | Bool found; |
1001 | unsigned char sha1[20]; |
1002 | } GlyphNewRec, *GlyphNewPtr; |
1003 | |
1004 | #define NeedsComponent(f)((((f) >> 12) & 0x0f) != 0 && (((f) ) & 0xfff) != 0) (PICT_FORMAT_A(f)(((f) >> 12) & 0x0f) != 0 && PICT_FORMAT_RGB(f)(((f) ) & 0xfff) != 0) |
1005 | |
1006 | static int |
1007 | ProcRenderAddGlyphs(ClientPtr client) |
1008 | { |
1009 | GlyphSetPtr glyphSet; |
1010 | |
1011 | REQUEST(xRenderAddGlyphsReq)xRenderAddGlyphsReq *stuff = (xRenderAddGlyphsReq *)client-> requestBuffer; |
1012 | GlyphNewRec glyphsLocal[NLOCALGLYPH256]; |
1013 | GlyphNewPtr glyphsBase, glyphs, glyph_new; |
1014 | int remain, nglyphs; |
1015 | CARD32 *gids; |
1016 | xGlyphInfo *gi; |
1017 | CARD8 *bits; |
1018 | unsigned int size; |
1019 | int err; |
1020 | int i, screen; |
1021 | PicturePtr pSrc = NULL((void*)0), pDst = NULL((void*)0); |
1022 | PixmapPtr pSrcPix = NULL((void*)0), pDstPix = NULL((void*)0); |
1023 | CARD32 component_alpha; |
1024 | |
1025 | REQUEST_AT_LEAST_SIZE(xRenderAddGlyphsReq)if ((sizeof(xRenderAddGlyphsReq) >> 2) > client-> req_len ) return(16); |
1026 | err = |
1027 | dixLookupResourceByType((void **) &glyphSet, stuff->glyphset, |
1028 | GlyphSetType, client, DixAddAccess(1<<12)); |
1029 | if (err != Success0) { |
1030 | client->errorValue = stuff->glyphset; |
1031 | return err; |
1032 | } |
1033 | |
1034 | err = BadAlloc11; |
Value stored to 'err' is never read | |
1035 | nglyphs = stuff->nglyphs; |
1036 | if (nglyphs > UINT32_MAX4294967295U / sizeof(GlyphNewRec)) |
1037 | return BadAlloc11; |
1038 | |
1039 | component_alpha = NeedsComponent(glyphSet->format->format)((((glyphSet->format->format) >> 12) & 0x0f) != 0 && (((glyphSet->format->format) ) & 0xfff ) != 0); |
1040 | |
1041 | if (nglyphs <= NLOCALGLYPH256) { |
1042 | memset(glyphsLocal, 0, sizeof(glyphsLocal))__builtin___memset_chk (glyphsLocal, 0, sizeof(glyphsLocal), __builtin_object_size (glyphsLocal, 0)); |
1043 | glyphsBase = glyphsLocal; |
1044 | } |
1045 | else { |
1046 | glyphsBase = (GlyphNewPtr) calloc(nglyphs, sizeof(GlyphNewRec)); |
1047 | if (!glyphsBase) |
1048 | return BadAlloc11; |
1049 | } |
1050 | |
1051 | remain = (client->req_len << 2) - sizeof(xRenderAddGlyphsReq); |
1052 | |
1053 | glyphs = glyphsBase; |
1054 | |
1055 | gids = (CARD32 *) (stuff + 1); |
1056 | gi = (xGlyphInfo *) (gids + nglyphs); |
1057 | bits = (CARD8 *) (gi + nglyphs); |
1058 | remain -= (sizeof(CARD32) + sizeof(xGlyphInfo)) * nglyphs; |
1059 | |
1060 | /* protect against bad nglyphs */ |
1061 | if (gi < ((xGlyphInfo *) stuff) || |
1062 | gi > ((xGlyphInfo *) ((CARD32 *) stuff + client->req_len)) || |
1063 | bits < ((CARD8 *) stuff) || |
1064 | bits > ((CARD8 *) ((CARD32 *) stuff + client->req_len))) { |
1065 | err = BadLength16; |
1066 | goto bail; |
1067 | } |
1068 | |
1069 | for (i = 0; i < nglyphs; i++) { |
1070 | size_t padded_width; |
1071 | |
1072 | glyph_new = &glyphs[i]; |
1073 | |
1074 | padded_width = PixmapBytePad(gi[i].width, glyphSet->format->depth)((PixmapWidthPaddingInfo[glyphSet->format->depth].notPower2 ? (((int)(gi[i].width) * PixmapWidthPaddingInfo[glyphSet-> format->depth].bytesPerPixel + PixmapWidthPaddingInfo[glyphSet ->format->depth].bytesPerPixel) >> PixmapWidthPaddingInfo [glyphSet->format->depth].padBytesLog2) : ((int)((gi[i] .width) + PixmapWidthPaddingInfo[glyphSet->format->depth ].padRoundUp) >> PixmapWidthPaddingInfo[glyphSet->format ->depth].padPixelsLog2)) << PixmapWidthPaddingInfo[glyphSet ->format->depth].padBytesLog2); |
1075 | |
1076 | if (gi[i].height && |
1077 | padded_width > (UINT32_MAX4294967295U - sizeof(GlyphRec)) / gi[i].height) |
1078 | break; |
1079 | |
1080 | size = gi[i].height * padded_width; |
1081 | if (remain < size) |
1082 | break; |
1083 | |
1084 | err = HashGlyph(&gi[i], bits, size, glyph_new->sha1); |
1085 | if (err) |
1086 | goto bail; |
1087 | |
1088 | glyph_new->glyph = FindGlyphByHash(glyph_new->sha1, glyphSet->fdepth); |
1089 | |
1090 | if (glyph_new->glyph && glyph_new->glyph != DeletedGlyph((GlyphPtr) 1)) { |
1091 | glyph_new->found = TRUE1; |
1092 | } |
1093 | else { |
1094 | GlyphPtr glyph; |
1095 | |
1096 | glyph_new->found = FALSE0; |
1097 | glyph_new->glyph = glyph = AllocateGlyph(&gi[i], glyphSet->fdepth); |
1098 | if (!glyph) { |
1099 | err = BadAlloc11; |
1100 | goto bail; |
1101 | } |
1102 | |
1103 | for (screen = 0; screen < screenInfo.numScreens; screen++) { |
1104 | int width = gi[i].width; |
1105 | int height = gi[i].height; |
1106 | int depth = glyphSet->format->depth; |
1107 | ScreenPtr pScreen; |
1108 | int error; |
1109 | |
1110 | /* Skip work if it's invisibly small anyway */ |
1111 | if (!width || !height) |
1112 | break; |
1113 | |
1114 | pScreen = screenInfo.screens[screen]; |
1115 | pSrcPix = GetScratchPixmapHeader(pScreen, |
1116 | width, height, |
1117 | depth, depth, -1, bits); |
1118 | if (!pSrcPix) { |
1119 | err = BadAlloc11; |
1120 | goto bail; |
1121 | } |
1122 | |
1123 | pSrc = CreatePicture(0, &pSrcPix->drawable, |
1124 | glyphSet->format, 0, NULL((void*)0), |
1125 | serverClient, &error); |
1126 | if (!pSrc) { |
1127 | err = BadAlloc11; |
1128 | goto bail; |
1129 | } |
1130 | |
1131 | pDstPix = (pScreen->CreatePixmap) (pScreen, |
1132 | width, height, depth, |
1133 | CREATE_PIXMAP_USAGE_GLYPH_PICTURE3); |
1134 | |
1135 | if (!pDstPix) { |
1136 | err = BadAlloc11; |
1137 | goto bail; |
1138 | } |
1139 | |
1140 | pDst = CreatePicture(0, &pDstPix->drawable, |
1141 | glyphSet->format, |
1142 | CPComponentAlpha(1 << 12), &component_alpha, |
1143 | serverClient, &error); |
1144 | SetGlyphPicture(glyph, pScreen, pDst); |
1145 | |
1146 | /* The picture takes a reference to the pixmap, so we |
1147 | drop ours. */ |
1148 | (pScreen->DestroyPixmap) (pDstPix); |
1149 | pDstPix = NULL((void*)0); |
1150 | |
1151 | if (!pDst) { |
1152 | err = BadAlloc11; |
1153 | goto bail; |
1154 | } |
1155 | |
1156 | CompositePicture(PictOpSrc1, |
1157 | pSrc, |
1158 | None0L, pDst, 0, 0, 0, 0, 0, 0, width, height); |
1159 | |
1160 | FreePicture((void *) pSrc, 0); |
1161 | pSrc = NULL((void*)0); |
1162 | FreeScratchPixmapHeader(pSrcPix); |
1163 | pSrcPix = NULL((void*)0); |
1164 | } |
1165 | |
1166 | memcpy(glyph_new->glyph->sha1, glyph_new->sha1, 20)__builtin___memcpy_chk (glyph_new->glyph->sha1, glyph_new ->sha1, 20, __builtin_object_size (glyph_new->glyph-> sha1, 0)); |
1167 | } |
1168 | |
1169 | glyph_new->id = gids[i]; |
1170 | |
1171 | if (size & 3) |
1172 | size += 4 - (size & 3); |
1173 | bits += size; |
1174 | remain -= size; |
1175 | } |
1176 | if (remain || i < nglyphs) { |
1177 | err = BadLength16; |
1178 | goto bail; |
1179 | } |
1180 | if (!ResizeGlyphSet(glyphSet, nglyphs)) { |
1181 | err = BadAlloc11; |
1182 | goto bail; |
1183 | } |
1184 | for (i = 0; i < nglyphs; i++) |
1185 | AddGlyph(glyphSet, glyphs[i].glyph, glyphs[i].id); |
1186 | |
1187 | if (glyphsBase != glyphsLocal) |
1188 | free(glyphsBase); |
1189 | return Success0; |
1190 | bail: |
1191 | if (pSrc) |
1192 | FreePicture((void *) pSrc, 0); |
1193 | if (pSrcPix) |
1194 | FreeScratchPixmapHeader(pSrcPix); |
1195 | for (i = 0; i < nglyphs; i++) |
1196 | if (glyphs[i].glyph && !glyphs[i].found) |
1197 | free(glyphs[i].glyph); |
1198 | if (glyphsBase != glyphsLocal) |
1199 | free(glyphsBase); |
1200 | return err; |
1201 | } |
1202 | |
1203 | static int |
1204 | ProcRenderAddGlyphsFromPicture(ClientPtr client) |
1205 | { |
1206 | return BadImplementation17; |
1207 | } |
1208 | |
1209 | static int |
1210 | ProcRenderFreeGlyphs(ClientPtr client) |
1211 | { |
1212 | REQUEST(xRenderFreeGlyphsReq)xRenderFreeGlyphsReq *stuff = (xRenderFreeGlyphsReq *)client-> requestBuffer; |
1213 | GlyphSetPtr glyphSet; |
1214 | int rc, nglyph; |
1215 | CARD32 *gids; |
1216 | CARD32 glyph; |
1217 | |
1218 | REQUEST_AT_LEAST_SIZE(xRenderFreeGlyphsReq)if ((sizeof(xRenderFreeGlyphsReq) >> 2) > client-> req_len ) return(16); |
1219 | rc = dixLookupResourceByType((void **) &glyphSet, stuff->glyphset, |
1220 | GlyphSetType, client, DixRemoveAccess(1<<13)); |
1221 | if (rc != Success0) { |
1222 | client->errorValue = stuff->glyphset; |
1223 | return rc; |
1224 | } |
1225 | nglyph = |
1226 | bytes_to_int32((client->req_len << 2) - sizeof(xRenderFreeGlyphsReq)); |
1227 | gids = (CARD32 *) (stuff + 1); |
1228 | while (nglyph-- > 0) { |
1229 | glyph = *gids++; |
1230 | if (!DeleteGlyph(glyphSet, glyph)) { |
1231 | client->errorValue = glyph; |
1232 | return RenderErrBase + BadGlyph4; |
1233 | } |
1234 | } |
1235 | return Success0; |
1236 | } |
1237 | |
1238 | static int |
1239 | ProcRenderCompositeGlyphs(ClientPtr client) |
1240 | { |
1241 | GlyphSetPtr glyphSet; |
1242 | GlyphSet gs; |
1243 | PicturePtr pSrc, pDst; |
1244 | PictFormatPtr pFormat; |
1245 | GlyphListRec listsLocal[NLOCALDELTA64]; |
1246 | GlyphListPtr lists, listsBase; |
1247 | GlyphPtr glyphsLocal[NLOCALGLYPH256]; |
1248 | Glyph glyph; |
1249 | GlyphPtr *glyphs, *glyphsBase; |
1250 | xGlyphElt *elt; |
1251 | CARD8 *buffer, *end; |
1252 | int nglyph; |
1253 | int nlist; |
1254 | int space; |
1255 | int size; |
1256 | int rc, n; |
1257 | |
1258 | REQUEST(xRenderCompositeGlyphsReq)xRenderCompositeGlyphsReq *stuff = (xRenderCompositeGlyphsReq *)client->requestBuffer; |
1259 | |
1260 | REQUEST_AT_LEAST_SIZE(xRenderCompositeGlyphsReq)if ((sizeof(xRenderCompositeGlyphsReq) >> 2) > client ->req_len ) return(16); |
1261 | |
1262 | switch (stuff->renderReqType) { |
1263 | default: |
1264 | size = 1; |
1265 | break; |
1266 | case X_RenderCompositeGlyphs1624: |
1267 | size = 2; |
1268 | break; |
1269 | case X_RenderCompositeGlyphs3225: |
1270 | size = 4; |
1271 | break; |
1272 | } |
1273 | |
1274 | if (!PictOpValid(stuff->op)) { |
1275 | client->errorValue = stuff->op; |
1276 | return BadValue2; |
1277 | } |
1278 | VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess){ int tmprc = dixLookupResourceByType((void *)&(pSrc), stuff ->src, PictureType, client, (1<<0)); if (tmprc != 0) return tmprc;}; |
1279 | VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess){ int tmprc = dixLookupResourceByType((void *)&(pDst), stuff ->dst, PictureType, client, (1<<1)); if (tmprc != 0) return tmprc;}; |
1280 | if (!pDst->pDrawable) |
1281 | return BadDrawable9; |
1282 | if (pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) |
1283 | return BadMatch8; |
1284 | if (stuff->maskFormat) { |
1285 | rc = dixLookupResourceByType((void **) &pFormat, stuff->maskFormat, |
1286 | PictFormatType, client, DixReadAccess(1<<0)); |
1287 | if (rc != Success0) |
1288 | return rc; |
1289 | } |
1290 | else |
1291 | pFormat = 0; |
1292 | |
1293 | rc = dixLookupResourceByType((void **) &glyphSet, stuff->glyphset, |
1294 | GlyphSetType, client, DixUseAccess(1<<24)); |
1295 | if (rc != Success0) |
1296 | return rc; |
1297 | |
1298 | buffer = (CARD8 *) (stuff + 1); |
1299 | end = (CARD8 *) stuff + (client->req_len << 2); |
1300 | nglyph = 0; |
1301 | nlist = 0; |
1302 | while (buffer + sizeof(xGlyphElt) < end) { |
1303 | elt = (xGlyphElt *) buffer; |
1304 | buffer += sizeof(xGlyphElt); |
1305 | |
1306 | if (elt->len == 0xff) { |
1307 | buffer += 4; |
1308 | } |
1309 | else { |
1310 | nlist++; |
1311 | nglyph += elt->len; |
1312 | space = size * elt->len; |
1313 | if (space & 3) |
1314 | space += 4 - (space & 3); |
1315 | buffer += space; |
1316 | } |
1317 | } |
1318 | if (nglyph <= NLOCALGLYPH256) |
1319 | glyphsBase = glyphsLocal; |
1320 | else { |
1321 | glyphsBase = xallocarray(nglyph, sizeof(GlyphPtr))xreallocarray(((void*)0), (nglyph), (sizeof(GlyphPtr))); |
1322 | if (!glyphsBase) |
1323 | return BadAlloc11; |
1324 | } |
1325 | if (nlist <= NLOCALDELTA64) |
1326 | listsBase = listsLocal; |
1327 | else { |
1328 | listsBase = xallocarray(nlist, sizeof(GlyphListRec))xreallocarray(((void*)0), (nlist), (sizeof(GlyphListRec))); |
1329 | if (!listsBase) { |
1330 | rc = BadAlloc11; |
1331 | goto bail; |
1332 | } |
1333 | } |
1334 | buffer = (CARD8 *) (stuff + 1); |
1335 | glyphs = glyphsBase; |
1336 | lists = listsBase; |
1337 | while (buffer + sizeof(xGlyphElt) < end) { |
1338 | elt = (xGlyphElt *) buffer; |
1339 | buffer += sizeof(xGlyphElt); |
1340 | |
1341 | if (elt->len == 0xff) { |
1342 | if (buffer + sizeof(GlyphSet) < end) { |
1343 | memcpy(&gs, buffer, sizeof(GlyphSet))__builtin___memcpy_chk (&gs, buffer, sizeof(GlyphSet), __builtin_object_size (&gs, 0)); |
1344 | rc = dixLookupResourceByType((void **) &glyphSet, gs, |
1345 | GlyphSetType, client, |
1346 | DixUseAccess(1<<24)); |
1347 | if (rc != Success0) |
1348 | goto bail; |
1349 | } |
1350 | buffer += 4; |
1351 | } |
1352 | else { |
1353 | lists->xOff = elt->deltax; |
1354 | lists->yOff = elt->deltay; |
1355 | lists->format = glyphSet->format; |
1356 | lists->len = 0; |
1357 | n = elt->len; |
1358 | while (n--) { |
1359 | if (buffer + size <= end) { |
1360 | switch (size) { |
1361 | case 1: |
1362 | glyph = *((CARD8 *) buffer); |
1363 | break; |
1364 | case 2: |
1365 | glyph = *((CARD16 *) buffer); |
1366 | break; |
1367 | case 4: |
1368 | default: |
1369 | glyph = *((CARD32 *) buffer); |
1370 | break; |
1371 | } |
1372 | if ((*glyphs = FindGlyph(glyphSet, glyph))) { |
1373 | lists->len++; |
1374 | glyphs++; |
1375 | } |
1376 | } |
1377 | buffer += size; |
1378 | } |
1379 | space = size * elt->len; |
1380 | if (space & 3) |
1381 | buffer += 4 - (space & 3); |
1382 | lists++; |
1383 | } |
1384 | } |
1385 | if (buffer > end) { |
1386 | rc = BadLength16; |
1387 | goto bail; |
1388 | } |
1389 | |
1390 | CompositeGlyphs(stuff->op, |
1391 | pSrc, |
1392 | pDst, |
1393 | pFormat, |
1394 | stuff->xSrc, stuff->ySrc, nlist, listsBase, glyphsBase); |
1395 | rc = Success0; |
1396 | |
1397 | bail: |
1398 | if (glyphsBase != glyphsLocal) |
1399 | free(glyphsBase); |
1400 | if (listsBase != listsLocal) |
1401 | free(listsBase); |
1402 | return rc; |
1403 | } |
1404 | |
1405 | static int |
1406 | ProcRenderFillRectangles(ClientPtr client) |
1407 | { |
1408 | PicturePtr pDst; |
1409 | int things; |
1410 | |
1411 | REQUEST(xRenderFillRectanglesReq)xRenderFillRectanglesReq *stuff = (xRenderFillRectanglesReq * )client->requestBuffer; |
1412 | |
1413 | REQUEST_AT_LEAST_SIZE(xRenderFillRectanglesReq)if ((sizeof(xRenderFillRectanglesReq) >> 2) > client ->req_len ) return(16); |
1414 | if (!PictOpValid(stuff->op)) { |
1415 | client->errorValue = stuff->op; |
1416 | return BadValue2; |
1417 | } |
1418 | VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess){ int tmprc = dixLookupResourceByType((void *)&(pDst), stuff ->dst, PictureType, client, (1<<1)); if (tmprc != 0) return tmprc;}; |
1419 | if (!pDst->pDrawable) |
1420 | return BadDrawable9; |
1421 | |
1422 | things = (client->req_len << 2) - sizeof(xRenderFillRectanglesReq); |
1423 | if (things & 4) |
1424 | return BadLength16; |
1425 | things >>= 3; |
1426 | |
1427 | CompositeRects(stuff->op, |
1428 | pDst, &stuff->color, things, (xRectangle *) &stuff[1]); |
1429 | |
1430 | return Success0; |
1431 | } |
1432 | |
1433 | static void |
1434 | RenderSetBit(unsigned char *line, int x, int bit) |
1435 | { |
1436 | unsigned char mask; |
1437 | |
1438 | if (screenInfo.bitmapBitOrder == LSBFirst0) |
1439 | mask = (1 << (x & 7)); |
1440 | else |
1441 | mask = (0x80 >> (x & 7)); |
1442 | /* XXX assumes byte order is host byte order */ |
1443 | line += (x >> 3); |
1444 | if (bit) |
1445 | *line |= mask; |
1446 | else |
1447 | *line &= ~mask; |
1448 | } |
1449 | |
1450 | #define DITHER_DIM2 2 |
1451 | |
1452 | static CARD32 orderedDither[DITHER_DIM2][DITHER_DIM2] = { |
1453 | {1, 3,}, |
1454 | {4, 2,}, |
1455 | }; |
1456 | |
1457 | #define DITHER_SIZE((sizeof orderedDither / sizeof orderedDither[0][0]) + 1) ((sizeof orderedDither / sizeof orderedDither[0][0]) + 1) |
1458 | |
1459 | static int |
1460 | ProcRenderCreateCursor(ClientPtr client) |
1461 | { |
1462 | REQUEST(xRenderCreateCursorReq)xRenderCreateCursorReq *stuff = (xRenderCreateCursorReq *)client ->requestBuffer; |
1463 | PicturePtr pSrc; |
1464 | ScreenPtr pScreen; |
1465 | unsigned short width, height; |
1466 | CARD32 *argbbits, *argb; |
1467 | unsigned char *srcbits, *srcline; |
1468 | unsigned char *mskbits, *mskline; |
1469 | int stride; |
1470 | int x, y; |
1471 | int nbytes_mono; |
1472 | CursorMetricRec cm; |
1473 | CursorPtr pCursor; |
1474 | CARD32 twocolor[3]; |
1475 | int rc, ncolor; |
1476 | |
1477 | REQUEST_SIZE_MATCH(xRenderCreateCursorReq)if ((sizeof(xRenderCreateCursorReq) >> 2) != client-> req_len) return(16); |
1478 | LEGAL_NEW_RESOURCE(stuff->cid, client)if (!LegalNewID(stuff->cid,client)) { client->errorValue = stuff->cid; return 14; }; |
1479 | |
1480 | VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess){ int tmprc = dixLookupResourceByType((void *)&(pSrc), stuff ->src, PictureType, client, (1<<0)); if (tmprc != 0) return tmprc;}; |
1481 | if (!pSrc->pDrawable) |
1482 | return BadDrawable9; |
1483 | pScreen = pSrc->pDrawable->pScreen; |
1484 | width = pSrc->pDrawable->width; |
1485 | height = pSrc->pDrawable->height; |
1486 | if (height && width > UINT32_MAX4294967295U / (height * sizeof(CARD32))) |
1487 | return BadAlloc11; |
1488 | if (stuff->x > width || stuff->y > height) |
1489 | return BadMatch8; |
1490 | argbbits = malloc(width * height * sizeof(CARD32)); |
1491 | if (!argbbits) |
1492 | return BadAlloc11; |
1493 | |
1494 | stride = BitmapBytePad(width)(((int)((width) + 32 - 1) >> 5) << 2); |
1495 | nbytes_mono = stride * height; |
1496 | srcbits = calloc(1, nbytes_mono); |
1497 | if (!srcbits) { |
1498 | free(argbbits); |
1499 | return BadAlloc11; |
1500 | } |
1501 | mskbits = calloc(1, nbytes_mono); |
1502 | if (!mskbits) { |
1503 | free(argbbits); |
1504 | free(srcbits); |
1505 | return BadAlloc11; |
1506 | } |
1507 | |
1508 | if (pSrc->format == PICT_a8r8g8b8) { |
1509 | (*pScreen->GetImage) (pSrc->pDrawable, |
1510 | 0, 0, width, height, ZPixmap2, |
1511 | 0xffffffff, (void *) argbbits); |
1512 | } |
1513 | else { |
1514 | PixmapPtr pPixmap; |
1515 | PicturePtr pPicture; |
1516 | PictFormatPtr pFormat; |
1517 | int error; |
1518 | |
1519 | pFormat = PictureMatchFormat(pScreen, 32, PICT_a8r8g8b8); |
1520 | if (!pFormat) { |
1521 | free(argbbits); |
1522 | free(srcbits); |
1523 | free(mskbits); |
1524 | return BadImplementation17; |
1525 | } |
1526 | pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, 32, |
1527 | CREATE_PIXMAP_USAGE_SCRATCH1); |
1528 | if (!pPixmap) { |
1529 | free(argbbits); |
1530 | free(srcbits); |
1531 | free(mskbits); |
1532 | return BadAlloc11; |
1533 | } |
1534 | pPicture = CreatePicture(0, &pPixmap->drawable, pFormat, 0, 0, |
1535 | client, &error); |
1536 | if (!pPicture) { |
1537 | free(argbbits); |
1538 | free(srcbits); |
1539 | free(mskbits); |
1540 | return error; |
1541 | } |
1542 | (*pScreen->DestroyPixmap) (pPixmap); |
1543 | CompositePicture(PictOpSrc1, |
1544 | pSrc, 0, pPicture, 0, 0, 0, 0, 0, 0, width, height); |
1545 | (*pScreen->GetImage) (pPicture->pDrawable, |
1546 | 0, 0, width, height, ZPixmap2, |
1547 | 0xffffffff, (void *) argbbits); |
1548 | FreePicture(pPicture, 0); |
1549 | } |
1550 | /* |
1551 | * Check whether the cursor can be directly supported by |
1552 | * the core cursor code |
1553 | */ |
1554 | ncolor = 0; |
1555 | argb = argbbits; |
1556 | for (y = 0; ncolor <= 2 && y < height; y++) { |
1557 | for (x = 0; ncolor <= 2 && x < width; x++) { |
1558 | CARD32 p = *argb++; |
1559 | CARD32 a = (p >> 24); |
1560 | |
1561 | if (a == 0) /* transparent */ |
1562 | continue; |
1563 | if (a == 0xff) { /* opaque */ |
1564 | int n; |
1565 | |
1566 | for (n = 0; n < ncolor; n++) |
1567 | if (p == twocolor[n]) |
1568 | break; |
1569 | if (n == ncolor) |
1570 | twocolor[ncolor++] = p; |
1571 | } |
1572 | else |
1573 | ncolor = 3; |
1574 | } |
1575 | } |
1576 | |
1577 | /* |
1578 | * Convert argb image to two plane cursor |
1579 | */ |
1580 | srcline = srcbits; |
1581 | mskline = mskbits; |
1582 | argb = argbbits; |
1583 | for (y = 0; y < height; y++) { |
1584 | for (x = 0; x < width; x++) { |
1585 | CARD32 p = *argb++; |
1586 | |
1587 | if (ncolor <= 2) { |
1588 | CARD32 a = ((p >> 24)); |
1589 | |
1590 | RenderSetBit(mskline, x, a != 0); |
1591 | RenderSetBit(srcline, x, a != 0 && p == twocolor[0]); |
1592 | } |
1593 | else { |
1594 | CARD32 a = ((p >> 24) * DITHER_SIZE((sizeof orderedDither / sizeof orderedDither[0][0]) + 1) + 127) / 255; |
1595 | CARD32 i = ((CvtR8G8B8toY15(p)(((((p) >> 16) & 0xff) * 153 + (((p) >> 8) & 0xff) * 301 + (((p) ) & 0xff) * 58) >> 2) >> 7) * DITHER_SIZE((sizeof orderedDither / sizeof orderedDither[0][0]) + 1) + 127) / 255; |
1596 | CARD32 d = |
1597 | orderedDither[y & (DITHER_DIM2 - 1)][x & (DITHER_DIM2 - 1)]; |
1598 | /* Set mask from dithered alpha value */ |
1599 | RenderSetBit(mskline, x, a > d); |
1600 | /* Set src from dithered intensity value */ |
1601 | RenderSetBit(srcline, x, a > d && i <= d); |
1602 | } |
1603 | } |
1604 | srcline += stride; |
1605 | mskline += stride; |
1606 | } |
1607 | /* |
1608 | * Dither to white and black if the cursor has more than two colors |
1609 | */ |
1610 | if (ncolor > 2) { |
1611 | twocolor[0] = 0xff000000; |
1612 | twocolor[1] = 0xffffffff; |
1613 | } |
1614 | else { |
1615 | free(argbbits); |
1616 | argbbits = 0; |
1617 | } |
1618 | |
1619 | #define GetByte(p,s)(((p) >> (s)) & 0xff) (((p) >> (s)) & 0xff) |
1620 | #define GetColor(p,s)((((p) >> (s)) & 0xff) | ((((p) >> (s)) & 0xff) << 8)) (GetByte(p,s)(((p) >> (s)) & 0xff) | (GetByte(p,s)(((p) >> (s)) & 0xff) << 8)) |
1621 | |
1622 | cm.width = width; |
1623 | cm.height = height; |
1624 | cm.xhot = stuff->x; |
1625 | cm.yhot = stuff->y; |
1626 | rc = AllocARGBCursor(srcbits, mskbits, argbbits, &cm, |
1627 | GetColor(twocolor[0], 16)((((twocolor[0]) >> (16)) & 0xff) | ((((twocolor[0] ) >> (16)) & 0xff) << 8)), |
1628 | GetColor(twocolor[0], 8)((((twocolor[0]) >> (8)) & 0xff) | ((((twocolor[0]) >> (8)) & 0xff) << 8)), |
1629 | GetColor(twocolor[0], 0)((((twocolor[0]) >> (0)) & 0xff) | ((((twocolor[0]) >> (0)) & 0xff) << 8)), |
1630 | GetColor(twocolor[1], 16)((((twocolor[1]) >> (16)) & 0xff) | ((((twocolor[1] ) >> (16)) & 0xff) << 8)), |
1631 | GetColor(twocolor[1], 8)((((twocolor[1]) >> (8)) & 0xff) | ((((twocolor[1]) >> (8)) & 0xff) << 8)), |
1632 | GetColor(twocolor[1], 0)((((twocolor[1]) >> (0)) & 0xff) | ((((twocolor[1]) >> (0)) & 0xff) << 8)), |
1633 | &pCursor, client, stuff->cid); |
1634 | if (rc != Success0) |
1635 | goto bail; |
1636 | if (!AddResourceDarwin_X_AddResource(stuff->cid, RT_CURSOR((RESTYPE)5), (void *) pCursor)) { |
1637 | rc = BadAlloc11; |
1638 | goto bail; |
1639 | } |
1640 | |
1641 | return Success0; |
1642 | bail: |
1643 | free(srcbits); |
1644 | free(mskbits); |
1645 | return rc; |
1646 | } |
1647 | |
1648 | static int |
1649 | ProcRenderSetPictureTransform(ClientPtr client) |
1650 | { |
1651 | REQUEST(xRenderSetPictureTransformReq)xRenderSetPictureTransformReq *stuff = (xRenderSetPictureTransformReq *)client->requestBuffer; |
1652 | PicturePtr pPicture; |
1653 | |
1654 | REQUEST_SIZE_MATCH(xRenderSetPictureTransformReq)if ((sizeof(xRenderSetPictureTransformReq) >> 2) != client ->req_len) return(16); |
1655 | VERIFY_PICTURE(pPicture, stuff->picture, client, DixSetAttrAccess){ int tmprc = dixLookupResourceByType((void *)&(pPicture) , stuff->picture, PictureType, client, (1<<5)); if ( tmprc != 0) return tmprc;}; |
1656 | return SetPictureTransform(pPicture, (PictTransform *) &stuff->transform); |
1657 | } |
1658 | |
1659 | static int |
1660 | ProcRenderQueryFilters(ClientPtr client) |
1661 | { |
1662 | REQUEST(xRenderQueryFiltersReq)xRenderQueryFiltersReq *stuff = (xRenderQueryFiltersReq *)client ->requestBuffer; |
1663 | DrawablePtr pDrawable; |
1664 | xRenderQueryFiltersReply *reply; |
1665 | int nbytesName; |
1666 | int nnames; |
1667 | ScreenPtr pScreen; |
1668 | PictureScreenPtr ps; |
1669 | int i, j, len, total_bytes, rc; |
1670 | INT16 *aliases; |
1671 | char *names; |
1672 | |
1673 | REQUEST_SIZE_MATCH(xRenderQueryFiltersReq)if ((sizeof(xRenderQueryFiltersReq) >> 2) != client-> req_len) return(16); |
1674 | rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0, |
1675 | DixGetAttrAccess(1<<4)); |
1676 | if (rc != Success0) |
1677 | return rc; |
1678 | |
1679 | pScreen = pDrawable->pScreen; |
1680 | nbytesName = 0; |
1681 | nnames = 0; |
1682 | ps = GetPictureScreenIfSet(pScreen)(dixPrivateKeyRegistered((&PictureScreenPrivateKeyRec)) ? ((PictureScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates , (&PictureScreenPrivateKeyRec))) : ((void*)0)); |
1683 | if (ps) { |
1684 | for (i = 0; i < ps->nfilters; i++) |
1685 | nbytesName += 1 + strlen(ps->filters[i].name); |
1686 | for (i = 0; i < ps->nfilterAliases; i++) |
1687 | nbytesName += 1 + strlen(ps->filterAliases[i].alias); |
1688 | nnames = ps->nfilters + ps->nfilterAliases; |
1689 | } |
1690 | len = ((nnames + 1) >> 1) + bytes_to_int32(nbytesName); |
1691 | total_bytes = sizeof(xRenderQueryFiltersReply) + (len << 2); |
1692 | reply = (xRenderQueryFiltersReply *) calloc(1, total_bytes); |
1693 | if (!reply) |
1694 | return BadAlloc11; |
1695 | aliases = (INT16 *) (reply + 1); |
1696 | names = (char *) (aliases + ((nnames + 1) & ~1)); |
1697 | |
1698 | reply->type = X_Reply1; |
1699 | reply->sequenceNumber = client->sequence; |
1700 | reply->length = len; |
1701 | reply->numAliases = nnames; |
1702 | reply->numFilters = nnames; |
1703 | if (ps) { |
1704 | |
1705 | /* fill in alias values */ |
1706 | for (i = 0; i < ps->nfilters; i++) |
1707 | aliases[i] = FilterAliasNone-1; |
1708 | for (i = 0; i < ps->nfilterAliases; i++) { |
1709 | for (j = 0; j < ps->nfilters; j++) |
1710 | if (ps->filterAliases[i].filter_id == ps->filters[j].id) |
1711 | break; |
1712 | if (j == ps->nfilters) { |
1713 | for (j = 0; j < ps->nfilterAliases; j++) |
1714 | if (ps->filterAliases[i].filter_id == |
1715 | ps->filterAliases[j].alias_id) { |
1716 | break; |
1717 | } |
1718 | if (j == ps->nfilterAliases) |
1719 | j = FilterAliasNone-1; |
1720 | else |
1721 | j = j + ps->nfilters; |
1722 | } |
1723 | aliases[i + ps->nfilters] = j; |
1724 | } |
1725 | |
1726 | /* fill in filter names */ |
1727 | for (i = 0; i < ps->nfilters; i++) { |
1728 | j = strlen(ps->filters[i].name); |
1729 | *names++ = j; |
1730 | memcpy(names, ps->filters[i].name, j)__builtin___memcpy_chk (names, ps->filters[i].name, j, __builtin_object_size (names, 0)); |
1731 | names += j; |
1732 | } |
1733 | |
1734 | /* fill in filter alias names */ |
1735 | for (i = 0; i < ps->nfilterAliases; i++) { |
1736 | j = strlen(ps->filterAliases[i].alias); |
1737 | *names++ = j; |
1738 | memcpy(names, ps->filterAliases[i].alias, j)__builtin___memcpy_chk (names, ps->filterAliases[i].alias, j, __builtin_object_size (names, 0)); |
1739 | names += j; |
1740 | } |
1741 | } |
1742 | |
1743 | if (client->swapped) { |
1744 | for (i = 0; i < reply->numAliases; i++) { |
1745 | swaps(&aliases[i])do { if (sizeof(*(&aliases[i])) != 2) wrong_size(); if (__builtin_constant_p ((uintptr_t)(&aliases[i]) & 1) && ((uintptr_t )(&aliases[i]) & 1) == 0) *(&aliases[i]) = lswaps (*(&aliases[i])); else swap_uint16((uint16_t *)(&aliases [i])); } while (0); |
1746 | } |
1747 | swaps(&reply->sequenceNumber)do { if (sizeof(*(&reply->sequenceNumber)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->sequenceNumber ) & 1) && ((uintptr_t)(&reply->sequenceNumber ) & 1) == 0) *(&reply->sequenceNumber) = lswaps(*( &reply->sequenceNumber)); else swap_uint16((uint16_t * )(&reply->sequenceNumber)); } while (0); |
1748 | swapl(&reply->length)do { if (sizeof(*(&reply->length)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&reply->length) & 3) && ((uintptr_t)(&reply->length) & 3) == 0) *(&reply->length) = lswapl(*(&reply->length )); else swap_uint32((uint32_t *)(&reply->length)); } while (0); |
1749 | swapl(&reply->numAliases)do { if (sizeof(*(&reply->numAliases)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->numAliases ) & 3) && ((uintptr_t)(&reply->numAliases) & 3) == 0) *(&reply->numAliases) = lswapl(*(& reply->numAliases)); else swap_uint32((uint32_t *)(&reply ->numAliases)); } while (0); |
1750 | swapl(&reply->numFilters)do { if (sizeof(*(&reply->numFilters)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->numFilters ) & 3) && ((uintptr_t)(&reply->numFilters) & 3) == 0) *(&reply->numFilters) = lswapl(*(& reply->numFilters)); else swap_uint32((uint32_t *)(&reply ->numFilters)); } while (0); |
1751 | } |
1752 | WriteToClient(client, total_bytes, reply); |
1753 | free(reply); |
1754 | |
1755 | return Success0; |
1756 | } |
1757 | |
1758 | static int |
1759 | ProcRenderSetPictureFilter(ClientPtr client) |
1760 | { |
1761 | REQUEST(xRenderSetPictureFilterReq)xRenderSetPictureFilterReq *stuff = (xRenderSetPictureFilterReq *)client->requestBuffer; |
1762 | PicturePtr pPicture; |
1763 | int result; |
1764 | xFixed *params; |
1765 | int nparams; |
1766 | char *name; |
1767 | |
1768 | REQUEST_AT_LEAST_SIZE(xRenderSetPictureFilterReq)if ((sizeof(xRenderSetPictureFilterReq) >> 2) > client ->req_len ) return(16); |
1769 | VERIFY_PICTURE(pPicture, stuff->picture, client, DixSetAttrAccess){ int tmprc = dixLookupResourceByType((void *)&(pPicture) , stuff->picture, PictureType, client, (1<<5)); if ( tmprc != 0) return tmprc;}; |
1770 | name = (char *) (stuff + 1); |
1771 | params = (xFixed *) (name + pad_to_int32(stuff->nbytes)); |
1772 | nparams = ((xFixed *) stuff + client->req_len) - params; |
1773 | result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams); |
1774 | return result; |
1775 | } |
1776 | |
1777 | static int |
1778 | ProcRenderCreateAnimCursor(ClientPtr client) |
1779 | { |
1780 | REQUEST(xRenderCreateAnimCursorReq)xRenderCreateAnimCursorReq *stuff = (xRenderCreateAnimCursorReq *)client->requestBuffer; |
1781 | CursorPtr *cursors; |
1782 | CARD32 *deltas; |
1783 | CursorPtr pCursor; |
1784 | int ncursor; |
1785 | xAnimCursorElt *elt; |
1786 | int i; |
1787 | int ret; |
1788 | |
1789 | REQUEST_AT_LEAST_SIZE(xRenderCreateAnimCursorReq)if ((sizeof(xRenderCreateAnimCursorReq) >> 2) > client ->req_len ) return(16); |
1790 | LEGAL_NEW_RESOURCE(stuff->cid, client)if (!LegalNewID(stuff->cid,client)) { client->errorValue = stuff->cid; return 14; }; |
1791 | if (client->req_len & 1) |
1792 | return BadLength16; |
1793 | ncursor = |
1794 | (client->req_len - |
1795 | (bytes_to_int32(sizeof(xRenderCreateAnimCursorReq)))) >> 1; |
1796 | cursors = xallocarray(ncursor, sizeof(CursorPtr) + sizeof(CARD32))xreallocarray(((void*)0), (ncursor), (sizeof(CursorPtr) + sizeof (CARD32))); |
1797 | if (!cursors) |
1798 | return BadAlloc11; |
1799 | deltas = (CARD32 *) (cursors + ncursor); |
1800 | elt = (xAnimCursorElt *) (stuff + 1); |
1801 | for (i = 0; i < ncursor; i++) { |
1802 | ret = dixLookupResourceByType((void **) (cursors + i), elt->cursor, |
1803 | RT_CURSOR((RESTYPE)5), client, DixReadAccess(1<<0)); |
1804 | if (ret != Success0) { |
1805 | free(cursors); |
1806 | return ret; |
1807 | } |
1808 | deltas[i] = elt->delay; |
1809 | elt++; |
1810 | } |
1811 | ret = AnimCursorCreate(cursors, deltas, ncursor, &pCursor, client, |
1812 | stuff->cid); |
1813 | free(cursors); |
1814 | if (ret != Success0) |
1815 | return ret; |
1816 | |
1817 | if (AddResourceDarwin_X_AddResource(stuff->cid, RT_CURSOR((RESTYPE)5), (void *) pCursor)) |
1818 | return Success0; |
1819 | return BadAlloc11; |
1820 | } |
1821 | |
1822 | static int |
1823 | ProcRenderAddTraps(ClientPtr client) |
1824 | { |
1825 | int ntraps; |
1826 | PicturePtr pPicture; |
1827 | |
1828 | REQUEST(xRenderAddTrapsReq)xRenderAddTrapsReq *stuff = (xRenderAddTrapsReq *)client-> requestBuffer; |
1829 | |
1830 | REQUEST_AT_LEAST_SIZE(xRenderAddTrapsReq)if ((sizeof(xRenderAddTrapsReq) >> 2) > client->req_len ) return(16); |
1831 | VERIFY_PICTURE(pPicture, stuff->picture, client, DixWriteAccess){ int tmprc = dixLookupResourceByType((void *)&(pPicture) , stuff->picture, PictureType, client, (1<<1)); if ( tmprc != 0) return tmprc;}; |
1832 | if (!pPicture->pDrawable) |
1833 | return BadDrawable9; |
1834 | ntraps = (client->req_len << 2) - sizeof(xRenderAddTrapsReq); |
1835 | if (ntraps % sizeof(xTrap)) |
1836 | return BadLength16; |
1837 | ntraps /= sizeof(xTrap); |
1838 | if (ntraps) |
1839 | AddTraps(pPicture, |
1840 | stuff->xOff, stuff->yOff, ntraps, (xTrap *) &stuff[1]); |
1841 | return Success0; |
1842 | } |
1843 | |
1844 | static int |
1845 | ProcRenderCreateSolidFill(ClientPtr client) |
1846 | { |
1847 | PicturePtr pPicture; |
1848 | int error = 0; |
1849 | |
1850 | REQUEST(xRenderCreateSolidFillReq)xRenderCreateSolidFillReq *stuff = (xRenderCreateSolidFillReq *)client->requestBuffer; |
1851 | |
1852 | REQUEST_AT_LEAST_SIZE(xRenderCreateSolidFillReq)if ((sizeof(xRenderCreateSolidFillReq) >> 2) > client ->req_len ) return(16); |
1853 | |
1854 | LEGAL_NEW_RESOURCE(stuff->pid, client)if (!LegalNewID(stuff->pid,client)) { client->errorValue = stuff->pid; return 14; }; |
1855 | |
1856 | pPicture = CreateSolidPicture(stuff->pid, &stuff->color, &error); |
1857 | if (!pPicture) |
1858 | return error; |
1859 | /* security creation/labeling check */ |
1860 | error = XaceHook(XACE_RESOURCE_ACCESS2, client, stuff->pid, PictureType, |
1861 | pPicture, RT_NONE((RESTYPE)0), NULL((void*)0), DixCreateAccess(1<<3)); |
1862 | if (error != Success0) |
1863 | return error; |
1864 | if (!AddResourceDarwin_X_AddResource(stuff->pid, PictureType, (void *) pPicture)) |
1865 | return BadAlloc11; |
1866 | return Success0; |
1867 | } |
1868 | |
1869 | static int |
1870 | ProcRenderCreateLinearGradient(ClientPtr client) |
1871 | { |
1872 | PicturePtr pPicture; |
1873 | int len; |
1874 | int error = 0; |
1875 | xFixed *stops; |
1876 | xRenderColor *colors; |
1877 | |
1878 | REQUEST(xRenderCreateLinearGradientReq)xRenderCreateLinearGradientReq *stuff = (xRenderCreateLinearGradientReq *)client->requestBuffer; |
1879 | |
1880 | REQUEST_AT_LEAST_SIZE(xRenderCreateLinearGradientReq)if ((sizeof(xRenderCreateLinearGradientReq) >> 2) > client ->req_len ) return(16); |
1881 | |
1882 | LEGAL_NEW_RESOURCE(stuff->pid, client)if (!LegalNewID(stuff->pid,client)) { client->errorValue = stuff->pid; return 14; }; |
1883 | |
1884 | len = (client->req_len << 2) - sizeof(xRenderCreateLinearGradientReq); |
1885 | if (stuff->nStops > UINT32_MAX4294967295U / (sizeof(xFixed) + sizeof(xRenderColor))) |
1886 | return BadLength16; |
1887 | if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor))) |
1888 | return BadLength16; |
1889 | |
1890 | stops = (xFixed *) (stuff + 1); |
1891 | colors = (xRenderColor *) (stops + stuff->nStops); |
1892 | |
1893 | pPicture = CreateLinearGradientPicture(stuff->pid, &stuff->p1, &stuff->p2, |
1894 | stuff->nStops, stops, colors, |
1895 | &error); |
1896 | if (!pPicture) |
1897 | return error; |
1898 | /* security creation/labeling check */ |
1899 | error = XaceHook(XACE_RESOURCE_ACCESS2, client, stuff->pid, PictureType, |
1900 | pPicture, RT_NONE((RESTYPE)0), NULL((void*)0), DixCreateAccess(1<<3)); |
1901 | if (error != Success0) |
1902 | return error; |
1903 | if (!AddResourceDarwin_X_AddResource(stuff->pid, PictureType, (void *) pPicture)) |
1904 | return BadAlloc11; |
1905 | return Success0; |
1906 | } |
1907 | |
1908 | static int |
1909 | ProcRenderCreateRadialGradient(ClientPtr client) |
1910 | { |
1911 | PicturePtr pPicture; |
1912 | int len; |
1913 | int error = 0; |
1914 | xFixed *stops; |
1915 | xRenderColor *colors; |
1916 | |
1917 | REQUEST(xRenderCreateRadialGradientReq)xRenderCreateRadialGradientReq *stuff = (xRenderCreateRadialGradientReq *)client->requestBuffer; |
1918 | |
1919 | REQUEST_AT_LEAST_SIZE(xRenderCreateRadialGradientReq)if ((sizeof(xRenderCreateRadialGradientReq) >> 2) > client ->req_len ) return(16); |
1920 | |
1921 | LEGAL_NEW_RESOURCE(stuff->pid, client)if (!LegalNewID(stuff->pid,client)) { client->errorValue = stuff->pid; return 14; }; |
1922 | |
1923 | len = (client->req_len << 2) - sizeof(xRenderCreateRadialGradientReq); |
1924 | if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor))) |
1925 | return BadLength16; |
1926 | |
1927 | stops = (xFixed *) (stuff + 1); |
1928 | colors = (xRenderColor *) (stops + stuff->nStops); |
1929 | |
1930 | pPicture = |
1931 | CreateRadialGradientPicture(stuff->pid, &stuff->inner, &stuff->outer, |
1932 | stuff->inner_radius, stuff->outer_radius, |
1933 | stuff->nStops, stops, colors, &error); |
1934 | if (!pPicture) |
1935 | return error; |
1936 | /* security creation/labeling check */ |
1937 | error = XaceHook(XACE_RESOURCE_ACCESS2, client, stuff->pid, PictureType, |
1938 | pPicture, RT_NONE((RESTYPE)0), NULL((void*)0), DixCreateAccess(1<<3)); |
1939 | if (error != Success0) |
1940 | return error; |
1941 | if (!AddResourceDarwin_X_AddResource(stuff->pid, PictureType, (void *) pPicture)) |
1942 | return BadAlloc11; |
1943 | return Success0; |
1944 | } |
1945 | |
1946 | static int |
1947 | ProcRenderCreateConicalGradient(ClientPtr client) |
1948 | { |
1949 | PicturePtr pPicture; |
1950 | int len; |
1951 | int error = 0; |
1952 | xFixed *stops; |
1953 | xRenderColor *colors; |
1954 | |
1955 | REQUEST(xRenderCreateConicalGradientReq)xRenderCreateConicalGradientReq *stuff = (xRenderCreateConicalGradientReq *)client->requestBuffer; |
1956 | |
1957 | REQUEST_AT_LEAST_SIZE(xRenderCreateConicalGradientReq)if ((sizeof(xRenderCreateConicalGradientReq) >> 2) > client->req_len ) return(16); |
1958 | |
1959 | LEGAL_NEW_RESOURCE(stuff->pid, client)if (!LegalNewID(stuff->pid,client)) { client->errorValue = stuff->pid; return 14; }; |
1960 | |
1961 | len = (client->req_len << 2) - sizeof(xRenderCreateConicalGradientReq); |
1962 | if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor))) |
1963 | return BadLength16; |
1964 | |
1965 | stops = (xFixed *) (stuff + 1); |
1966 | colors = (xRenderColor *) (stops + stuff->nStops); |
1967 | |
1968 | pPicture = |
1969 | CreateConicalGradientPicture(stuff->pid, &stuff->center, stuff->angle, |
1970 | stuff->nStops, stops, colors, &error); |
1971 | if (!pPicture) |
1972 | return error; |
1973 | /* security creation/labeling check */ |
1974 | error = XaceHook(XACE_RESOURCE_ACCESS2, client, stuff->pid, PictureType, |
1975 | pPicture, RT_NONE((RESTYPE)0), NULL((void*)0), DixCreateAccess(1<<3)); |
1976 | if (error != Success0) |
1977 | return error; |
1978 | if (!AddResourceDarwin_X_AddResource(stuff->pid, PictureType, (void *) pPicture)) |
1979 | return BadAlloc11; |
1980 | return Success0; |
1981 | } |
1982 | |
1983 | static int |
1984 | ProcRenderDispatch(ClientPtr client) |
1985 | { |
1986 | REQUEST(xReq)xReq *stuff = (xReq *)client->requestBuffer; |
1987 | |
1988 | if (stuff->data < RenderNumberRequests(36 +1)) |
1989 | return (*ProcRenderVector[stuff->data]) (client); |
1990 | else |
1991 | return BadRequest1; |
1992 | } |
1993 | |
1994 | static int |
1995 | SProcRenderQueryVersion(ClientPtr client) |
1996 | { |
1997 | REQUEST(xRenderQueryVersionReq)xRenderQueryVersionReq *stuff = (xRenderQueryVersionReq *)client ->requestBuffer; |
1998 | REQUEST_SIZE_MATCH(xRenderQueryVersionReq)if ((sizeof(xRenderQueryVersionReq) >> 2) != client-> req_len) return(16); |
1999 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2000 | swapl(&stuff->majorVersion)do { if (sizeof(*(&stuff->majorVersion)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->majorVersion ) & 3) && ((uintptr_t)(&stuff->majorVersion ) & 3) == 0) *(&stuff->majorVersion) = lswapl(*(& stuff->majorVersion)); else swap_uint32((uint32_t *)(& stuff->majorVersion)); } while (0); |
2001 | swapl(&stuff->minorVersion)do { if (sizeof(*(&stuff->minorVersion)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->minorVersion ) & 3) && ((uintptr_t)(&stuff->minorVersion ) & 3) == 0) *(&stuff->minorVersion) = lswapl(*(& stuff->minorVersion)); else swap_uint32((uint32_t *)(& stuff->minorVersion)); } while (0); |
2002 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2003 | } |
2004 | |
2005 | static int |
2006 | SProcRenderQueryPictFormats(ClientPtr client) |
2007 | { |
2008 | REQUEST(xRenderQueryPictFormatsReq)xRenderQueryPictFormatsReq *stuff = (xRenderQueryPictFormatsReq *)client->requestBuffer; |
2009 | REQUEST_SIZE_MATCH(xRenderQueryPictFormatsReq)if ((sizeof(xRenderQueryPictFormatsReq) >> 2) != client ->req_len) return(16); |
2010 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2011 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2012 | } |
2013 | |
2014 | static int |
2015 | SProcRenderQueryPictIndexValues(ClientPtr client) |
2016 | { |
2017 | REQUEST(xRenderQueryPictIndexValuesReq)xRenderQueryPictIndexValuesReq *stuff = (xRenderQueryPictIndexValuesReq *)client->requestBuffer; |
2018 | REQUEST_AT_LEAST_SIZE(xRenderQueryPictIndexValuesReq)if ((sizeof(xRenderQueryPictIndexValuesReq) >> 2) > client ->req_len ) return(16); |
2019 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2020 | swapl(&stuff->format)do { if (sizeof(*(&stuff->format)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->format) & 3) && ((uintptr_t)(&stuff->format) & 3) == 0) *(&stuff->format) = lswapl(*(&stuff->format )); else swap_uint32((uint32_t *)(&stuff->format)); } while (0); |
2021 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2022 | } |
2023 | |
2024 | static int |
2025 | SProcRenderQueryDithers(ClientPtr client) |
2026 | { |
2027 | return BadImplementation17; |
2028 | } |
2029 | |
2030 | static int |
2031 | SProcRenderCreatePicture(ClientPtr client) |
2032 | { |
2033 | REQUEST(xRenderCreatePictureReq)xRenderCreatePictureReq *stuff = (xRenderCreatePictureReq *)client ->requestBuffer; |
2034 | REQUEST_AT_LEAST_SIZE(xRenderCreatePictureReq)if ((sizeof(xRenderCreatePictureReq) >> 2) > client-> req_len ) return(16); |
2035 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2036 | swapl(&stuff->pid)do { if (sizeof(*(&stuff->pid)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->pid) & 3 ) && ((uintptr_t)(&stuff->pid) & 3) == 0) * (&stuff->pid) = lswapl(*(&stuff->pid)); else swap_uint32 ((uint32_t *)(&stuff->pid)); } while (0); |
2037 | swapl(&stuff->drawable)do { if (sizeof(*(&stuff->drawable)) != 4) wrong_size( ); if (__builtin_constant_p((uintptr_t)(&stuff->drawable ) & 3) && ((uintptr_t)(&stuff->drawable) & 3) == 0) *(&stuff->drawable) = lswapl(*(&stuff-> drawable)); else swap_uint32((uint32_t *)(&stuff->drawable )); } while (0); |
2038 | swapl(&stuff->format)do { if (sizeof(*(&stuff->format)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->format) & 3) && ((uintptr_t)(&stuff->format) & 3) == 0) *(&stuff->format) = lswapl(*(&stuff->format )); else swap_uint32((uint32_t *)(&stuff->format)); } while (0); |
2039 | swapl(&stuff->mask)do { if (sizeof(*(&stuff->mask)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->mask) & 3) && ((uintptr_t)(&stuff->mask) & 3) == 0 ) *(&stuff->mask) = lswapl(*(&stuff->mask)); else swap_uint32((uint32_t *)(&stuff->mask)); } while (0); |
2040 | SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof (*stuff) >> 2))); |
2041 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2042 | } |
2043 | |
2044 | static int |
2045 | SProcRenderChangePicture(ClientPtr client) |
2046 | { |
2047 | REQUEST(xRenderChangePictureReq)xRenderChangePictureReq *stuff = (xRenderChangePictureReq *)client ->requestBuffer; |
2048 | REQUEST_AT_LEAST_SIZE(xRenderChangePictureReq)if ((sizeof(xRenderChangePictureReq) >> 2) > client-> req_len ) return(16); |
2049 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2050 | swapl(&stuff->picture)do { if (sizeof(*(&stuff->picture)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->picture ) & 3) && ((uintptr_t)(&stuff->picture) & 3) == 0) *(&stuff->picture) = lswapl(*(&stuff-> picture)); else swap_uint32((uint32_t *)(&stuff->picture )); } while (0); |
2051 | swapl(&stuff->mask)do { if (sizeof(*(&stuff->mask)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->mask) & 3) && ((uintptr_t)(&stuff->mask) & 3) == 0 ) *(&stuff->mask) = lswapl(*(&stuff->mask)); else swap_uint32((uint32_t *)(&stuff->mask)); } while (0); |
2052 | SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof (*stuff) >> 2))); |
2053 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2054 | } |
2055 | |
2056 | static int |
2057 | SProcRenderSetPictureClipRectangles(ClientPtr client) |
2058 | { |
2059 | REQUEST(xRenderSetPictureClipRectanglesReq)xRenderSetPictureClipRectanglesReq *stuff = (xRenderSetPictureClipRectanglesReq *)client->requestBuffer; |
2060 | REQUEST_AT_LEAST_SIZE(xRenderSetPictureClipRectanglesReq)if ((sizeof(xRenderSetPictureClipRectanglesReq) >> 2) > client->req_len ) return(16); |
2061 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2062 | swapl(&stuff->picture)do { if (sizeof(*(&stuff->picture)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->picture ) & 3) && ((uintptr_t)(&stuff->picture) & 3) == 0) *(&stuff->picture) = lswapl(*(&stuff-> picture)); else swap_uint32((uint32_t *)(&stuff->picture )); } while (0); |
2063 | swaps(&stuff->xOrigin)do { if (sizeof(*(&stuff->xOrigin)) != 2) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->xOrigin ) & 1) && ((uintptr_t)(&stuff->xOrigin) & 1) == 0) *(&stuff->xOrigin) = lswaps(*(&stuff-> xOrigin)); else swap_uint16((uint16_t *)(&stuff->xOrigin )); } while (0); |
2064 | swaps(&stuff->yOrigin)do { if (sizeof(*(&stuff->yOrigin)) != 2) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->yOrigin ) & 1) && ((uintptr_t)(&stuff->yOrigin) & 1) == 0) *(&stuff->yOrigin) = lswaps(*(&stuff-> yOrigin)); else swap_uint16((uint16_t *)(&stuff->yOrigin )); } while (0); |
2065 | SwapRestS(stuff)SwapShorts((short *)(stuff + 1), ((client->req_len << 1) - (sizeof(*stuff) >> 1))); |
2066 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2067 | } |
2068 | |
2069 | static int |
2070 | SProcRenderFreePicture(ClientPtr client) |
2071 | { |
2072 | REQUEST(xRenderFreePictureReq)xRenderFreePictureReq *stuff = (xRenderFreePictureReq *)client ->requestBuffer; |
2073 | REQUEST_SIZE_MATCH(xRenderFreePictureReq)if ((sizeof(xRenderFreePictureReq) >> 2) != client-> req_len) return(16); |
2074 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2075 | swapl(&stuff->picture)do { if (sizeof(*(&stuff->picture)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->picture ) & 3) && ((uintptr_t)(&stuff->picture) & 3) == 0) *(&stuff->picture) = lswapl(*(&stuff-> picture)); else swap_uint32((uint32_t *)(&stuff->picture )); } while (0); |
2076 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2077 | } |
2078 | |
2079 | static int |
2080 | SProcRenderComposite(ClientPtr client) |
2081 | { |
2082 | REQUEST(xRenderCompositeReq)xRenderCompositeReq *stuff = (xRenderCompositeReq *)client-> requestBuffer; |
2083 | REQUEST_SIZE_MATCH(xRenderCompositeReq)if ((sizeof(xRenderCompositeReq) >> 2) != client->req_len ) return(16); |
2084 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2085 | swapl(&stuff->src)do { if (sizeof(*(&stuff->src)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->src) & 3 ) && ((uintptr_t)(&stuff->src) & 3) == 0) * (&stuff->src) = lswapl(*(&stuff->src)); else swap_uint32 ((uint32_t *)(&stuff->src)); } while (0); |
2086 | swapl(&stuff->mask)do { if (sizeof(*(&stuff->mask)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->mask) & 3) && ((uintptr_t)(&stuff->mask) & 3) == 0 ) *(&stuff->mask) = lswapl(*(&stuff->mask)); else swap_uint32((uint32_t *)(&stuff->mask)); } while (0); |
2087 | swapl(&stuff->dst)do { if (sizeof(*(&stuff->dst)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->dst) & 3 ) && ((uintptr_t)(&stuff->dst) & 3) == 0) * (&stuff->dst) = lswapl(*(&stuff->dst)); else swap_uint32 ((uint32_t *)(&stuff->dst)); } while (0); |
2088 | swaps(&stuff->xSrc)do { if (sizeof(*(&stuff->xSrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->xSrc) & 1) && ((uintptr_t)(&stuff->xSrc) & 1) == 0 ) *(&stuff->xSrc) = lswaps(*(&stuff->xSrc)); else swap_uint16((uint16_t *)(&stuff->xSrc)); } while (0); |
2089 | swaps(&stuff->ySrc)do { if (sizeof(*(&stuff->ySrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->ySrc) & 1) && ((uintptr_t)(&stuff->ySrc) & 1) == 0 ) *(&stuff->ySrc) = lswaps(*(&stuff->ySrc)); else swap_uint16((uint16_t *)(&stuff->ySrc)); } while (0); |
2090 | swaps(&stuff->xMask)do { if (sizeof(*(&stuff->xMask)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->xMask) & 1) && ((uintptr_t)(&stuff->xMask) & 1) == 0) *(&stuff->xMask) = lswaps(*(&stuff->xMask)) ; else swap_uint16((uint16_t *)(&stuff->xMask)); } while (0); |
2091 | swaps(&stuff->yMask)do { if (sizeof(*(&stuff->yMask)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->yMask) & 1) && ((uintptr_t)(&stuff->yMask) & 1) == 0) *(&stuff->yMask) = lswaps(*(&stuff->yMask)) ; else swap_uint16((uint16_t *)(&stuff->yMask)); } while (0); |
2092 | swaps(&stuff->xDst)do { if (sizeof(*(&stuff->xDst)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->xDst) & 1) && ((uintptr_t)(&stuff->xDst) & 1) == 0 ) *(&stuff->xDst) = lswaps(*(&stuff->xDst)); else swap_uint16((uint16_t *)(&stuff->xDst)); } while (0); |
2093 | swaps(&stuff->yDst)do { if (sizeof(*(&stuff->yDst)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->yDst) & 1) && ((uintptr_t)(&stuff->yDst) & 1) == 0 ) *(&stuff->yDst) = lswaps(*(&stuff->yDst)); else swap_uint16((uint16_t *)(&stuff->yDst)); } while (0); |
2094 | swaps(&stuff->width)do { if (sizeof(*(&stuff->width)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->width) & 1) && ((uintptr_t)(&stuff->width) & 1) == 0) *(&stuff->width) = lswaps(*(&stuff->width)) ; else swap_uint16((uint16_t *)(&stuff->width)); } while (0); |
2095 | swaps(&stuff->height)do { if (sizeof(*(&stuff->height)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->height) & 1) && ((uintptr_t)(&stuff->height) & 1) == 0) *(&stuff->height) = lswaps(*(&stuff->height )); else swap_uint16((uint16_t *)(&stuff->height)); } while (0); |
2096 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2097 | } |
2098 | |
2099 | static int |
2100 | SProcRenderScale(ClientPtr client) |
2101 | { |
2102 | return BadImplementation17; |
2103 | } |
2104 | |
2105 | static int |
2106 | SProcRenderTrapezoids(ClientPtr client) |
2107 | { |
2108 | REQUEST(xRenderTrapezoidsReq)xRenderTrapezoidsReq *stuff = (xRenderTrapezoidsReq *)client-> requestBuffer; |
2109 | |
2110 | REQUEST_AT_LEAST_SIZE(xRenderTrapezoidsReq)if ((sizeof(xRenderTrapezoidsReq) >> 2) > client-> req_len ) return(16); |
2111 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2112 | swapl(&stuff->src)do { if (sizeof(*(&stuff->src)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->src) & 3 ) && ((uintptr_t)(&stuff->src) & 3) == 0) * (&stuff->src) = lswapl(*(&stuff->src)); else swap_uint32 ((uint32_t *)(&stuff->src)); } while (0); |
2113 | swapl(&stuff->dst)do { if (sizeof(*(&stuff->dst)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->dst) & 3 ) && ((uintptr_t)(&stuff->dst) & 3) == 0) * (&stuff->dst) = lswapl(*(&stuff->dst)); else swap_uint32 ((uint32_t *)(&stuff->dst)); } while (0); |
2114 | swapl(&stuff->maskFormat)do { if (sizeof(*(&stuff->maskFormat)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->maskFormat ) & 3) && ((uintptr_t)(&stuff->maskFormat) & 3) == 0) *(&stuff->maskFormat) = lswapl(*(& stuff->maskFormat)); else swap_uint32((uint32_t *)(&stuff ->maskFormat)); } while (0); |
2115 | swaps(&stuff->xSrc)do { if (sizeof(*(&stuff->xSrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->xSrc) & 1) && ((uintptr_t)(&stuff->xSrc) & 1) == 0 ) *(&stuff->xSrc) = lswaps(*(&stuff->xSrc)); else swap_uint16((uint16_t *)(&stuff->xSrc)); } while (0); |
2116 | swaps(&stuff->ySrc)do { if (sizeof(*(&stuff->ySrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->ySrc) & 1) && ((uintptr_t)(&stuff->ySrc) & 1) == 0 ) *(&stuff->ySrc) = lswaps(*(&stuff->ySrc)); else swap_uint16((uint16_t *)(&stuff->ySrc)); } while (0); |
2117 | SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof (*stuff) >> 2))); |
2118 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2119 | } |
2120 | |
2121 | static int |
2122 | SProcRenderTriangles(ClientPtr client) |
2123 | { |
2124 | REQUEST(xRenderTrianglesReq)xRenderTrianglesReq *stuff = (xRenderTrianglesReq *)client-> requestBuffer; |
2125 | |
2126 | REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq)if ((sizeof(xRenderTrianglesReq) >> 2) > client-> req_len ) return(16); |
2127 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2128 | swapl(&stuff->src)do { if (sizeof(*(&stuff->src)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->src) & 3 ) && ((uintptr_t)(&stuff->src) & 3) == 0) * (&stuff->src) = lswapl(*(&stuff->src)); else swap_uint32 ((uint32_t *)(&stuff->src)); } while (0); |
2129 | swapl(&stuff->dst)do { if (sizeof(*(&stuff->dst)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->dst) & 3 ) && ((uintptr_t)(&stuff->dst) & 3) == 0) * (&stuff->dst) = lswapl(*(&stuff->dst)); else swap_uint32 ((uint32_t *)(&stuff->dst)); } while (0); |
2130 | swapl(&stuff->maskFormat)do { if (sizeof(*(&stuff->maskFormat)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->maskFormat ) & 3) && ((uintptr_t)(&stuff->maskFormat) & 3) == 0) *(&stuff->maskFormat) = lswapl(*(& stuff->maskFormat)); else swap_uint32((uint32_t *)(&stuff ->maskFormat)); } while (0); |
2131 | swaps(&stuff->xSrc)do { if (sizeof(*(&stuff->xSrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->xSrc) & 1) && ((uintptr_t)(&stuff->xSrc) & 1) == 0 ) *(&stuff->xSrc) = lswaps(*(&stuff->xSrc)); else swap_uint16((uint16_t *)(&stuff->xSrc)); } while (0); |
2132 | swaps(&stuff->ySrc)do { if (sizeof(*(&stuff->ySrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->ySrc) & 1) && ((uintptr_t)(&stuff->ySrc) & 1) == 0 ) *(&stuff->ySrc) = lswaps(*(&stuff->ySrc)); else swap_uint16((uint16_t *)(&stuff->ySrc)); } while (0); |
2133 | SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof (*stuff) >> 2))); |
2134 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2135 | } |
2136 | |
2137 | static int |
2138 | SProcRenderTriStrip(ClientPtr client) |
2139 | { |
2140 | REQUEST(xRenderTriStripReq)xRenderTriStripReq *stuff = (xRenderTriStripReq *)client-> requestBuffer; |
2141 | |
2142 | REQUEST_AT_LEAST_SIZE(xRenderTriStripReq)if ((sizeof(xRenderTriStripReq) >> 2) > client->req_len ) return(16); |
2143 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2144 | swapl(&stuff->src)do { if (sizeof(*(&stuff->src)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->src) & 3 ) && ((uintptr_t)(&stuff->src) & 3) == 0) * (&stuff->src) = lswapl(*(&stuff->src)); else swap_uint32 ((uint32_t *)(&stuff->src)); } while (0); |
2145 | swapl(&stuff->dst)do { if (sizeof(*(&stuff->dst)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->dst) & 3 ) && ((uintptr_t)(&stuff->dst) & 3) == 0) * (&stuff->dst) = lswapl(*(&stuff->dst)); else swap_uint32 ((uint32_t *)(&stuff->dst)); } while (0); |
2146 | swapl(&stuff->maskFormat)do { if (sizeof(*(&stuff->maskFormat)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->maskFormat ) & 3) && ((uintptr_t)(&stuff->maskFormat) & 3) == 0) *(&stuff->maskFormat) = lswapl(*(& stuff->maskFormat)); else swap_uint32((uint32_t *)(&stuff ->maskFormat)); } while (0); |
2147 | swaps(&stuff->xSrc)do { if (sizeof(*(&stuff->xSrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->xSrc) & 1) && ((uintptr_t)(&stuff->xSrc) & 1) == 0 ) *(&stuff->xSrc) = lswaps(*(&stuff->xSrc)); else swap_uint16((uint16_t *)(&stuff->xSrc)); } while (0); |
2148 | swaps(&stuff->ySrc)do { if (sizeof(*(&stuff->ySrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->ySrc) & 1) && ((uintptr_t)(&stuff->ySrc) & 1) == 0 ) *(&stuff->ySrc) = lswaps(*(&stuff->ySrc)); else swap_uint16((uint16_t *)(&stuff->ySrc)); } while (0); |
2149 | SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof (*stuff) >> 2))); |
2150 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2151 | } |
2152 | |
2153 | static int |
2154 | SProcRenderTriFan(ClientPtr client) |
2155 | { |
2156 | REQUEST(xRenderTriFanReq)xRenderTriFanReq *stuff = (xRenderTriFanReq *)client->requestBuffer; |
2157 | |
2158 | REQUEST_AT_LEAST_SIZE(xRenderTriFanReq)if ((sizeof(xRenderTriFanReq) >> 2) > client->req_len ) return(16); |
2159 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2160 | swapl(&stuff->src)do { if (sizeof(*(&stuff->src)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->src) & 3 ) && ((uintptr_t)(&stuff->src) & 3) == 0) * (&stuff->src) = lswapl(*(&stuff->src)); else swap_uint32 ((uint32_t *)(&stuff->src)); } while (0); |
2161 | swapl(&stuff->dst)do { if (sizeof(*(&stuff->dst)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->dst) & 3 ) && ((uintptr_t)(&stuff->dst) & 3) == 0) * (&stuff->dst) = lswapl(*(&stuff->dst)); else swap_uint32 ((uint32_t *)(&stuff->dst)); } while (0); |
2162 | swapl(&stuff->maskFormat)do { if (sizeof(*(&stuff->maskFormat)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->maskFormat ) & 3) && ((uintptr_t)(&stuff->maskFormat) & 3) == 0) *(&stuff->maskFormat) = lswapl(*(& stuff->maskFormat)); else swap_uint32((uint32_t *)(&stuff ->maskFormat)); } while (0); |
2163 | swaps(&stuff->xSrc)do { if (sizeof(*(&stuff->xSrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->xSrc) & 1) && ((uintptr_t)(&stuff->xSrc) & 1) == 0 ) *(&stuff->xSrc) = lswaps(*(&stuff->xSrc)); else swap_uint16((uint16_t *)(&stuff->xSrc)); } while (0); |
2164 | swaps(&stuff->ySrc)do { if (sizeof(*(&stuff->ySrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->ySrc) & 1) && ((uintptr_t)(&stuff->ySrc) & 1) == 0 ) *(&stuff->ySrc) = lswaps(*(&stuff->ySrc)); else swap_uint16((uint16_t *)(&stuff->ySrc)); } while (0); |
2165 | SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof (*stuff) >> 2))); |
2166 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2167 | } |
2168 | |
2169 | static int |
2170 | SProcRenderColorTrapezoids(ClientPtr client) |
2171 | { |
2172 | return BadImplementation17; |
2173 | } |
2174 | |
2175 | static int |
2176 | SProcRenderColorTriangles(ClientPtr client) |
2177 | { |
2178 | return BadImplementation17; |
2179 | } |
2180 | |
2181 | static int |
2182 | SProcRenderTransform(ClientPtr client) |
2183 | { |
2184 | return BadImplementation17; |
2185 | } |
2186 | |
2187 | static int |
2188 | SProcRenderCreateGlyphSet(ClientPtr client) |
2189 | { |
2190 | REQUEST(xRenderCreateGlyphSetReq)xRenderCreateGlyphSetReq *stuff = (xRenderCreateGlyphSetReq * )client->requestBuffer; |
2191 | REQUEST_SIZE_MATCH(xRenderCreateGlyphSetReq)if ((sizeof(xRenderCreateGlyphSetReq) >> 2) != client-> req_len) return(16); |
2192 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2193 | swapl(&stuff->gsid)do { if (sizeof(*(&stuff->gsid)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->gsid) & 3) && ((uintptr_t)(&stuff->gsid) & 3) == 0 ) *(&stuff->gsid) = lswapl(*(&stuff->gsid)); else swap_uint32((uint32_t *)(&stuff->gsid)); } while (0); |
2194 | swapl(&stuff->format)do { if (sizeof(*(&stuff->format)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->format) & 3) && ((uintptr_t)(&stuff->format) & 3) == 0) *(&stuff->format) = lswapl(*(&stuff->format )); else swap_uint32((uint32_t *)(&stuff->format)); } while (0); |
2195 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2196 | } |
2197 | |
2198 | static int |
2199 | SProcRenderReferenceGlyphSet(ClientPtr client) |
2200 | { |
2201 | REQUEST(xRenderReferenceGlyphSetReq)xRenderReferenceGlyphSetReq *stuff = (xRenderReferenceGlyphSetReq *)client->requestBuffer; |
2202 | REQUEST_SIZE_MATCH(xRenderReferenceGlyphSetReq)if ((sizeof(xRenderReferenceGlyphSetReq) >> 2) != client ->req_len) return(16); |
2203 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2204 | swapl(&stuff->gsid)do { if (sizeof(*(&stuff->gsid)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->gsid) & 3) && ((uintptr_t)(&stuff->gsid) & 3) == 0 ) *(&stuff->gsid) = lswapl(*(&stuff->gsid)); else swap_uint32((uint32_t *)(&stuff->gsid)); } while (0); |
2205 | swapl(&stuff->existing)do { if (sizeof(*(&stuff->existing)) != 4) wrong_size( ); if (__builtin_constant_p((uintptr_t)(&stuff->existing ) & 3) && ((uintptr_t)(&stuff->existing) & 3) == 0) *(&stuff->existing) = lswapl(*(&stuff-> existing)); else swap_uint32((uint32_t *)(&stuff->existing )); } while (0); |
2206 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2207 | } |
2208 | |
2209 | static int |
2210 | SProcRenderFreeGlyphSet(ClientPtr client) |
2211 | { |
2212 | REQUEST(xRenderFreeGlyphSetReq)xRenderFreeGlyphSetReq *stuff = (xRenderFreeGlyphSetReq *)client ->requestBuffer; |
2213 | REQUEST_SIZE_MATCH(xRenderFreeGlyphSetReq)if ((sizeof(xRenderFreeGlyphSetReq) >> 2) != client-> req_len) return(16); |
2214 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2215 | swapl(&stuff->glyphset)do { if (sizeof(*(&stuff->glyphset)) != 4) wrong_size( ); if (__builtin_constant_p((uintptr_t)(&stuff->glyphset ) & 3) && ((uintptr_t)(&stuff->glyphset) & 3) == 0) *(&stuff->glyphset) = lswapl(*(&stuff-> glyphset)); else swap_uint32((uint32_t *)(&stuff->glyphset )); } while (0); |
2216 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2217 | } |
2218 | |
2219 | static int |
2220 | SProcRenderAddGlyphs(ClientPtr client) |
2221 | { |
2222 | register int i; |
2223 | CARD32 *gids; |
2224 | void *end; |
2225 | xGlyphInfo *gi; |
2226 | |
2227 | REQUEST(xRenderAddGlyphsReq)xRenderAddGlyphsReq *stuff = (xRenderAddGlyphsReq *)client-> requestBuffer; |
2228 | REQUEST_AT_LEAST_SIZE(xRenderAddGlyphsReq)if ((sizeof(xRenderAddGlyphsReq) >> 2) > client-> req_len ) return(16); |
2229 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2230 | swapl(&stuff->glyphset)do { if (sizeof(*(&stuff->glyphset)) != 4) wrong_size( ); if (__builtin_constant_p((uintptr_t)(&stuff->glyphset ) & 3) && ((uintptr_t)(&stuff->glyphset) & 3) == 0) *(&stuff->glyphset) = lswapl(*(&stuff-> glyphset)); else swap_uint32((uint32_t *)(&stuff->glyphset )); } while (0); |
2231 | swapl(&stuff->nglyphs)do { if (sizeof(*(&stuff->nglyphs)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->nglyphs ) & 3) && ((uintptr_t)(&stuff->nglyphs) & 3) == 0) *(&stuff->nglyphs) = lswapl(*(&stuff-> nglyphs)); else swap_uint32((uint32_t *)(&stuff->nglyphs )); } while (0); |
2232 | if (stuff->nglyphs & 0xe0000000) |
2233 | return BadLength16; |
2234 | end = (CARD8 *) stuff + (client->req_len << 2); |
2235 | gids = (CARD32 *) (stuff + 1); |
2236 | gi = (xGlyphInfo *) (gids + stuff->nglyphs); |
2237 | if ((char *) end - (char *) (gids + stuff->nglyphs) < 0) |
2238 | return BadLength16; |
2239 | if ((char *) end - (char *) (gi + stuff->nglyphs) < 0) |
2240 | return BadLength16; |
2241 | for (i = 0; i < stuff->nglyphs; i++) { |
2242 | swapl(&gids[i])do { if (sizeof(*(&gids[i])) != 4) wrong_size(); if (__builtin_constant_p ((uintptr_t)(&gids[i]) & 3) && ((uintptr_t)(& gids[i]) & 3) == 0) *(&gids[i]) = lswapl(*(&gids[ i])); else swap_uint32((uint32_t *)(&gids[i])); } while ( 0); |
2243 | swaps(&gi[i].width)do { if (sizeof(*(&gi[i].width)) != 2) wrong_size(); if ( __builtin_constant_p((uintptr_t)(&gi[i].width) & 1) && ((uintptr_t)(&gi[i].width) & 1) == 0) *(&gi[i].width ) = lswaps(*(&gi[i].width)); else swap_uint16((uint16_t * )(&gi[i].width)); } while (0); |
2244 | swaps(&gi[i].height)do { if (sizeof(*(&gi[i].height)) != 2) wrong_size(); if ( __builtin_constant_p((uintptr_t)(&gi[i].height) & 1) && ((uintptr_t)(&gi[i].height) & 1) == 0) *(&gi[i]. height) = lswaps(*(&gi[i].height)); else swap_uint16((uint16_t *)(&gi[i].height)); } while (0); |
2245 | swaps(&gi[i].x)do { if (sizeof(*(&gi[i].x)) != 2) wrong_size(); if (__builtin_constant_p ((uintptr_t)(&gi[i].x) & 1) && ((uintptr_t)(& gi[i].x) & 1) == 0) *(&gi[i].x) = lswaps(*(&gi[i] .x)); else swap_uint16((uint16_t *)(&gi[i].x)); } while ( 0); |
2246 | swaps(&gi[i].y)do { if (sizeof(*(&gi[i].y)) != 2) wrong_size(); if (__builtin_constant_p ((uintptr_t)(&gi[i].y) & 1) && ((uintptr_t)(& gi[i].y) & 1) == 0) *(&gi[i].y) = lswaps(*(&gi[i] .y)); else swap_uint16((uint16_t *)(&gi[i].y)); } while ( 0); |
2247 | swaps(&gi[i].xOff)do { if (sizeof(*(&gi[i].xOff)) != 2) wrong_size(); if (__builtin_constant_p ((uintptr_t)(&gi[i].xOff) & 1) && ((uintptr_t )(&gi[i].xOff) & 1) == 0) *(&gi[i].xOff) = lswaps (*(&gi[i].xOff)); else swap_uint16((uint16_t *)(&gi[i ].xOff)); } while (0); |
2248 | swaps(&gi[i].yOff)do { if (sizeof(*(&gi[i].yOff)) != 2) wrong_size(); if (__builtin_constant_p ((uintptr_t)(&gi[i].yOff) & 1) && ((uintptr_t )(&gi[i].yOff) & 1) == 0) *(&gi[i].yOff) = lswaps (*(&gi[i].yOff)); else swap_uint16((uint16_t *)(&gi[i ].yOff)); } while (0); |
2249 | } |
2250 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2251 | } |
2252 | |
2253 | static int |
2254 | SProcRenderAddGlyphsFromPicture(ClientPtr client) |
2255 | { |
2256 | return BadImplementation17; |
2257 | } |
2258 | |
2259 | static int |
2260 | SProcRenderFreeGlyphs(ClientPtr client) |
2261 | { |
2262 | REQUEST(xRenderFreeGlyphsReq)xRenderFreeGlyphsReq *stuff = (xRenderFreeGlyphsReq *)client-> requestBuffer; |
2263 | REQUEST_AT_LEAST_SIZE(xRenderFreeGlyphsReq)if ((sizeof(xRenderFreeGlyphsReq) >> 2) > client-> req_len ) return(16); |
2264 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2265 | swapl(&stuff->glyphset)do { if (sizeof(*(&stuff->glyphset)) != 4) wrong_size( ); if (__builtin_constant_p((uintptr_t)(&stuff->glyphset ) & 3) && ((uintptr_t)(&stuff->glyphset) & 3) == 0) *(&stuff->glyphset) = lswapl(*(&stuff-> glyphset)); else swap_uint32((uint32_t *)(&stuff->glyphset )); } while (0); |
2266 | SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof (*stuff) >> 2))); |
2267 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2268 | } |
2269 | |
2270 | static int |
2271 | SProcRenderCompositeGlyphs(ClientPtr client) |
2272 | { |
2273 | xGlyphElt *elt; |
2274 | CARD8 *buffer; |
2275 | CARD8 *end; |
2276 | int space; |
2277 | int i; |
2278 | int size; |
2279 | |
2280 | REQUEST(xRenderCompositeGlyphsReq)xRenderCompositeGlyphsReq *stuff = (xRenderCompositeGlyphsReq *)client->requestBuffer; |
2281 | REQUEST_AT_LEAST_SIZE(xRenderCompositeGlyphsReq)if ((sizeof(xRenderCompositeGlyphsReq) >> 2) > client ->req_len ) return(16); |
2282 | |
2283 | switch (stuff->renderReqType) { |
2284 | default: |
2285 | size = 1; |
2286 | break; |
2287 | case X_RenderCompositeGlyphs1624: |
2288 | size = 2; |
2289 | break; |
2290 | case X_RenderCompositeGlyphs3225: |
2291 | size = 4; |
2292 | break; |
2293 | } |
2294 | |
2295 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2296 | swapl(&stuff->src)do { if (sizeof(*(&stuff->src)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->src) & 3 ) && ((uintptr_t)(&stuff->src) & 3) == 0) * (&stuff->src) = lswapl(*(&stuff->src)); else swap_uint32 ((uint32_t *)(&stuff->src)); } while (0); |
2297 | swapl(&stuff->dst)do { if (sizeof(*(&stuff->dst)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->dst) & 3 ) && ((uintptr_t)(&stuff->dst) & 3) == 0) * (&stuff->dst) = lswapl(*(&stuff->dst)); else swap_uint32 ((uint32_t *)(&stuff->dst)); } while (0); |
2298 | swapl(&stuff->maskFormat)do { if (sizeof(*(&stuff->maskFormat)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->maskFormat ) & 3) && ((uintptr_t)(&stuff->maskFormat) & 3) == 0) *(&stuff->maskFormat) = lswapl(*(& stuff->maskFormat)); else swap_uint32((uint32_t *)(&stuff ->maskFormat)); } while (0); |
2299 | swapl(&stuff->glyphset)do { if (sizeof(*(&stuff->glyphset)) != 4) wrong_size( ); if (__builtin_constant_p((uintptr_t)(&stuff->glyphset ) & 3) && ((uintptr_t)(&stuff->glyphset) & 3) == 0) *(&stuff->glyphset) = lswapl(*(&stuff-> glyphset)); else swap_uint32((uint32_t *)(&stuff->glyphset )); } while (0); |
2300 | swaps(&stuff->xSrc)do { if (sizeof(*(&stuff->xSrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->xSrc) & 1) && ((uintptr_t)(&stuff->xSrc) & 1) == 0 ) *(&stuff->xSrc) = lswaps(*(&stuff->xSrc)); else swap_uint16((uint16_t *)(&stuff->xSrc)); } while (0); |
2301 | swaps(&stuff->ySrc)do { if (sizeof(*(&stuff->ySrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->ySrc) & 1) && ((uintptr_t)(&stuff->ySrc) & 1) == 0 ) *(&stuff->ySrc) = lswaps(*(&stuff->ySrc)); else swap_uint16((uint16_t *)(&stuff->ySrc)); } while (0); |
2302 | buffer = (CARD8 *) (stuff + 1); |
2303 | end = (CARD8 *) stuff + (client->req_len << 2); |
2304 | while (buffer + sizeof(xGlyphElt) < end) { |
2305 | elt = (xGlyphElt *) buffer; |
2306 | buffer += sizeof(xGlyphElt); |
2307 | |
2308 | swaps(&elt->deltax)do { if (sizeof(*(&elt->deltax)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&elt->deltax) & 1) && ((uintptr_t)(&elt->deltax) & 1) == 0 ) *(&elt->deltax) = lswaps(*(&elt->deltax)); else swap_uint16((uint16_t *)(&elt->deltax)); } while (0); |
2309 | swaps(&elt->deltay)do { if (sizeof(*(&elt->deltay)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&elt->deltay) & 1) && ((uintptr_t)(&elt->deltay) & 1) == 0 ) *(&elt->deltay) = lswaps(*(&elt->deltay)); else swap_uint16((uint16_t *)(&elt->deltay)); } while (0); |
2310 | |
2311 | i = elt->len; |
2312 | if (i == 0xff) { |
2313 | swapl((int *) buffer)do { if (sizeof(*((int *) buffer)) != 4) wrong_size(); if (__builtin_constant_p ((uintptr_t)((int *) buffer) & 3) && ((uintptr_t) ((int *) buffer) & 3) == 0) *((int *) buffer) = lswapl(*( (int *) buffer)); else swap_uint32((uint32_t *)((int *) buffer )); } while (0); |
2314 | buffer += 4; |
2315 | } |
2316 | else { |
2317 | space = size * i; |
2318 | switch (size) { |
2319 | case 1: |
2320 | buffer += i; |
2321 | break; |
2322 | case 2: |
2323 | while (i--) { |
2324 | swaps((short *) buffer)do { if (sizeof(*((short *) buffer)) != 2) wrong_size(); if ( __builtin_constant_p((uintptr_t)((short *) buffer) & 1) && ((uintptr_t)((short *) buffer) & 1) == 0) *((short *) buffer ) = lswaps(*((short *) buffer)); else swap_uint16((uint16_t * )((short *) buffer)); } while (0); |
2325 | buffer += 2; |
2326 | } |
2327 | break; |
2328 | case 4: |
2329 | while (i--) { |
2330 | swapl((int *) buffer)do { if (sizeof(*((int *) buffer)) != 4) wrong_size(); if (__builtin_constant_p ((uintptr_t)((int *) buffer) & 3) && ((uintptr_t) ((int *) buffer) & 3) == 0) *((int *) buffer) = lswapl(*( (int *) buffer)); else swap_uint32((uint32_t *)((int *) buffer )); } while (0); |
2331 | buffer += 4; |
2332 | } |
2333 | break; |
2334 | } |
2335 | if (space & 3) |
2336 | buffer += 4 - (space & 3); |
2337 | } |
2338 | } |
2339 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2340 | } |
2341 | |
2342 | static int |
2343 | SProcRenderFillRectangles(ClientPtr client) |
2344 | { |
2345 | REQUEST(xRenderFillRectanglesReq)xRenderFillRectanglesReq *stuff = (xRenderFillRectanglesReq * )client->requestBuffer; |
2346 | |
2347 | REQUEST_AT_LEAST_SIZE(xRenderFillRectanglesReq)if ((sizeof(xRenderFillRectanglesReq) >> 2) > client ->req_len ) return(16); |
2348 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2349 | swapl(&stuff->dst)do { if (sizeof(*(&stuff->dst)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->dst) & 3 ) && ((uintptr_t)(&stuff->dst) & 3) == 0) * (&stuff->dst) = lswapl(*(&stuff->dst)); else swap_uint32 ((uint32_t *)(&stuff->dst)); } while (0); |
2350 | swaps(&stuff->color.red)do { if (sizeof(*(&stuff->color.red)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->color .red) & 1) && ((uintptr_t)(&stuff->color.red ) & 1) == 0) *(&stuff->color.red) = lswaps(*(& stuff->color.red)); else swap_uint16((uint16_t *)(&stuff ->color.red)); } while (0); |
2351 | swaps(&stuff->color.green)do { if (sizeof(*(&stuff->color.green)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->color .green) & 1) && ((uintptr_t)(&stuff->color .green) & 1) == 0) *(&stuff->color.green) = lswaps (*(&stuff->color.green)); else swap_uint16((uint16_t * )(&stuff->color.green)); } while (0); |
2352 | swaps(&stuff->color.blue)do { if (sizeof(*(&stuff->color.blue)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->color .blue) & 1) && ((uintptr_t)(&stuff->color. blue) & 1) == 0) *(&stuff->color.blue) = lswaps(*( &stuff->color.blue)); else swap_uint16((uint16_t *)(& stuff->color.blue)); } while (0); |
2353 | swaps(&stuff->color.alpha)do { if (sizeof(*(&stuff->color.alpha)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->color .alpha) & 1) && ((uintptr_t)(&stuff->color .alpha) & 1) == 0) *(&stuff->color.alpha) = lswaps (*(&stuff->color.alpha)); else swap_uint16((uint16_t * )(&stuff->color.alpha)); } while (0); |
2354 | SwapRestS(stuff)SwapShorts((short *)(stuff + 1), ((client->req_len << 1) - (sizeof(*stuff) >> 1))); |
2355 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2356 | } |
2357 | |
2358 | static int |
2359 | SProcRenderCreateCursor(ClientPtr client) |
2360 | { |
2361 | REQUEST(xRenderCreateCursorReq)xRenderCreateCursorReq *stuff = (xRenderCreateCursorReq *)client ->requestBuffer; |
2362 | REQUEST_SIZE_MATCH(xRenderCreateCursorReq)if ((sizeof(xRenderCreateCursorReq) >> 2) != client-> req_len) return(16); |
2363 | |
2364 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2365 | swapl(&stuff->cid)do { if (sizeof(*(&stuff->cid)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->cid) & 3 ) && ((uintptr_t)(&stuff->cid) & 3) == 0) * (&stuff->cid) = lswapl(*(&stuff->cid)); else swap_uint32 ((uint32_t *)(&stuff->cid)); } while (0); |
2366 | swapl(&stuff->src)do { if (sizeof(*(&stuff->src)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->src) & 3 ) && ((uintptr_t)(&stuff->src) & 3) == 0) * (&stuff->src) = lswapl(*(&stuff->src)); else swap_uint32 ((uint32_t *)(&stuff->src)); } while (0); |
2367 | swaps(&stuff->x)do { if (sizeof(*(&stuff->x)) != 2) wrong_size(); if ( __builtin_constant_p((uintptr_t)(&stuff->x) & 1) && ((uintptr_t)(&stuff->x) & 1) == 0) *(&stuff-> x) = lswaps(*(&stuff->x)); else swap_uint16((uint16_t * )(&stuff->x)); } while (0); |
2368 | swaps(&stuff->y)do { if (sizeof(*(&stuff->y)) != 2) wrong_size(); if ( __builtin_constant_p((uintptr_t)(&stuff->y) & 1) && ((uintptr_t)(&stuff->y) & 1) == 0) *(&stuff-> y) = lswaps(*(&stuff->y)); else swap_uint16((uint16_t * )(&stuff->y)); } while (0); |
2369 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2370 | } |
2371 | |
2372 | static int |
2373 | SProcRenderSetPictureTransform(ClientPtr client) |
2374 | { |
2375 | REQUEST(xRenderSetPictureTransformReq)xRenderSetPictureTransformReq *stuff = (xRenderSetPictureTransformReq *)client->requestBuffer; |
2376 | REQUEST_SIZE_MATCH(xRenderSetPictureTransformReq)if ((sizeof(xRenderSetPictureTransformReq) >> 2) != client ->req_len) return(16); |
2377 | |
2378 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2379 | swapl(&stuff->picture)do { if (sizeof(*(&stuff->picture)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->picture ) & 3) && ((uintptr_t)(&stuff->picture) & 3) == 0) *(&stuff->picture) = lswapl(*(&stuff-> picture)); else swap_uint32((uint32_t *)(&stuff->picture )); } while (0); |
2380 | swapl(&stuff->transform.matrix11)do { if (sizeof(*(&stuff->transform.matrix11)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->transform .matrix11) & 3) && ((uintptr_t)(&stuff->transform .matrix11) & 3) == 0) *(&stuff->transform.matrix11 ) = lswapl(*(&stuff->transform.matrix11)); else swap_uint32 ((uint32_t *)(&stuff->transform.matrix11)); } while (0 ); |
2381 | swapl(&stuff->transform.matrix12)do { if (sizeof(*(&stuff->transform.matrix12)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->transform .matrix12) & 3) && ((uintptr_t)(&stuff->transform .matrix12) & 3) == 0) *(&stuff->transform.matrix12 ) = lswapl(*(&stuff->transform.matrix12)); else swap_uint32 ((uint32_t *)(&stuff->transform.matrix12)); } while (0 ); |
2382 | swapl(&stuff->transform.matrix13)do { if (sizeof(*(&stuff->transform.matrix13)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->transform .matrix13) & 3) && ((uintptr_t)(&stuff->transform .matrix13) & 3) == 0) *(&stuff->transform.matrix13 ) = lswapl(*(&stuff->transform.matrix13)); else swap_uint32 ((uint32_t *)(&stuff->transform.matrix13)); } while (0 ); |
2383 | swapl(&stuff->transform.matrix21)do { if (sizeof(*(&stuff->transform.matrix21)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->transform .matrix21) & 3) && ((uintptr_t)(&stuff->transform .matrix21) & 3) == 0) *(&stuff->transform.matrix21 ) = lswapl(*(&stuff->transform.matrix21)); else swap_uint32 ((uint32_t *)(&stuff->transform.matrix21)); } while (0 ); |
2384 | swapl(&stuff->transform.matrix22)do { if (sizeof(*(&stuff->transform.matrix22)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->transform .matrix22) & 3) && ((uintptr_t)(&stuff->transform .matrix22) & 3) == 0) *(&stuff->transform.matrix22 ) = lswapl(*(&stuff->transform.matrix22)); else swap_uint32 ((uint32_t *)(&stuff->transform.matrix22)); } while (0 ); |
2385 | swapl(&stuff->transform.matrix23)do { if (sizeof(*(&stuff->transform.matrix23)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->transform .matrix23) & 3) && ((uintptr_t)(&stuff->transform .matrix23) & 3) == 0) *(&stuff->transform.matrix23 ) = lswapl(*(&stuff->transform.matrix23)); else swap_uint32 ((uint32_t *)(&stuff->transform.matrix23)); } while (0 ); |
2386 | swapl(&stuff->transform.matrix31)do { if (sizeof(*(&stuff->transform.matrix31)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->transform .matrix31) & 3) && ((uintptr_t)(&stuff->transform .matrix31) & 3) == 0) *(&stuff->transform.matrix31 ) = lswapl(*(&stuff->transform.matrix31)); else swap_uint32 ((uint32_t *)(&stuff->transform.matrix31)); } while (0 ); |
2387 | swapl(&stuff->transform.matrix32)do { if (sizeof(*(&stuff->transform.matrix32)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->transform .matrix32) & 3) && ((uintptr_t)(&stuff->transform .matrix32) & 3) == 0) *(&stuff->transform.matrix32 ) = lswapl(*(&stuff->transform.matrix32)); else swap_uint32 ((uint32_t *)(&stuff->transform.matrix32)); } while (0 ); |
2388 | swapl(&stuff->transform.matrix33)do { if (sizeof(*(&stuff->transform.matrix33)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->transform .matrix33) & 3) && ((uintptr_t)(&stuff->transform .matrix33) & 3) == 0) *(&stuff->transform.matrix33 ) = lswapl(*(&stuff->transform.matrix33)); else swap_uint32 ((uint32_t *)(&stuff->transform.matrix33)); } while (0 ); |
2389 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2390 | } |
2391 | |
2392 | static int |
2393 | SProcRenderQueryFilters(ClientPtr client) |
2394 | { |
2395 | REQUEST(xRenderQueryFiltersReq)xRenderQueryFiltersReq *stuff = (xRenderQueryFiltersReq *)client ->requestBuffer; |
2396 | REQUEST_SIZE_MATCH(xRenderQueryFiltersReq)if ((sizeof(xRenderQueryFiltersReq) >> 2) != client-> req_len) return(16); |
2397 | |
2398 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2399 | swapl(&stuff->drawable)do { if (sizeof(*(&stuff->drawable)) != 4) wrong_size( ); if (__builtin_constant_p((uintptr_t)(&stuff->drawable ) & 3) && ((uintptr_t)(&stuff->drawable) & 3) == 0) *(&stuff->drawable) = lswapl(*(&stuff-> drawable)); else swap_uint32((uint32_t *)(&stuff->drawable )); } while (0); |
2400 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2401 | } |
2402 | |
2403 | static int |
2404 | SProcRenderSetPictureFilter(ClientPtr client) |
2405 | { |
2406 | REQUEST(xRenderSetPictureFilterReq)xRenderSetPictureFilterReq *stuff = (xRenderSetPictureFilterReq *)client->requestBuffer; |
2407 | REQUEST_AT_LEAST_SIZE(xRenderSetPictureFilterReq)if ((sizeof(xRenderSetPictureFilterReq) >> 2) > client ->req_len ) return(16); |
2408 | |
2409 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2410 | swapl(&stuff->picture)do { if (sizeof(*(&stuff->picture)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->picture ) & 3) && ((uintptr_t)(&stuff->picture) & 3) == 0) *(&stuff->picture) = lswapl(*(&stuff-> picture)); else swap_uint32((uint32_t *)(&stuff->picture )); } while (0); |
2411 | swaps(&stuff->nbytes)do { if (sizeof(*(&stuff->nbytes)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->nbytes) & 1) && ((uintptr_t)(&stuff->nbytes) & 1) == 0) *(&stuff->nbytes) = lswaps(*(&stuff->nbytes )); else swap_uint16((uint16_t *)(&stuff->nbytes)); } while (0); |
2412 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2413 | } |
2414 | |
2415 | static int |
2416 | SProcRenderCreateAnimCursor(ClientPtr client) |
2417 | { |
2418 | REQUEST(xRenderCreateAnimCursorReq)xRenderCreateAnimCursorReq *stuff = (xRenderCreateAnimCursorReq *)client->requestBuffer; |
2419 | REQUEST_AT_LEAST_SIZE(xRenderCreateAnimCursorReq)if ((sizeof(xRenderCreateAnimCursorReq) >> 2) > client ->req_len ) return(16); |
2420 | |
2421 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2422 | swapl(&stuff->cid)do { if (sizeof(*(&stuff->cid)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->cid) & 3 ) && ((uintptr_t)(&stuff->cid) & 3) == 0) * (&stuff->cid) = lswapl(*(&stuff->cid)); else swap_uint32 ((uint32_t *)(&stuff->cid)); } while (0); |
2423 | SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof (*stuff) >> 2))); |
2424 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2425 | } |
2426 | |
2427 | static int |
2428 | SProcRenderAddTraps(ClientPtr client) |
2429 | { |
2430 | REQUEST(xRenderAddTrapsReq)xRenderAddTrapsReq *stuff = (xRenderAddTrapsReq *)client-> requestBuffer; |
2431 | REQUEST_AT_LEAST_SIZE(xRenderAddTrapsReq)if ((sizeof(xRenderAddTrapsReq) >> 2) > client->req_len ) return(16); |
2432 | |
2433 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2434 | swapl(&stuff->picture)do { if (sizeof(*(&stuff->picture)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->picture ) & 3) && ((uintptr_t)(&stuff->picture) & 3) == 0) *(&stuff->picture) = lswapl(*(&stuff-> picture)); else swap_uint32((uint32_t *)(&stuff->picture )); } while (0); |
2435 | swaps(&stuff->xOff)do { if (sizeof(*(&stuff->xOff)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->xOff) & 1) && ((uintptr_t)(&stuff->xOff) & 1) == 0 ) *(&stuff->xOff) = lswaps(*(&stuff->xOff)); else swap_uint16((uint16_t *)(&stuff->xOff)); } while (0); |
2436 | swaps(&stuff->yOff)do { if (sizeof(*(&stuff->yOff)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->yOff) & 1) && ((uintptr_t)(&stuff->yOff) & 1) == 0 ) *(&stuff->yOff) = lswaps(*(&stuff->yOff)); else swap_uint16((uint16_t *)(&stuff->yOff)); } while (0); |
2437 | SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof (*stuff) >> 2))); |
2438 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2439 | } |
2440 | |
2441 | static int |
2442 | SProcRenderCreateSolidFill(ClientPtr client) |
2443 | { |
2444 | REQUEST(xRenderCreateSolidFillReq)xRenderCreateSolidFillReq *stuff = (xRenderCreateSolidFillReq *)client->requestBuffer; |
2445 | REQUEST_AT_LEAST_SIZE(xRenderCreateSolidFillReq)if ((sizeof(xRenderCreateSolidFillReq) >> 2) > client ->req_len ) return(16); |
2446 | |
2447 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2448 | swapl(&stuff->pid)do { if (sizeof(*(&stuff->pid)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->pid) & 3 ) && ((uintptr_t)(&stuff->pid) & 3) == 0) * (&stuff->pid) = lswapl(*(&stuff->pid)); else swap_uint32 ((uint32_t *)(&stuff->pid)); } while (0); |
2449 | swaps(&stuff->color.alpha)do { if (sizeof(*(&stuff->color.alpha)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->color .alpha) & 1) && ((uintptr_t)(&stuff->color .alpha) & 1) == 0) *(&stuff->color.alpha) = lswaps (*(&stuff->color.alpha)); else swap_uint16((uint16_t * )(&stuff->color.alpha)); } while (0); |
2450 | swaps(&stuff->color.red)do { if (sizeof(*(&stuff->color.red)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->color .red) & 1) && ((uintptr_t)(&stuff->color.red ) & 1) == 0) *(&stuff->color.red) = lswaps(*(& stuff->color.red)); else swap_uint16((uint16_t *)(&stuff ->color.red)); } while (0); |
2451 | swaps(&stuff->color.green)do { if (sizeof(*(&stuff->color.green)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->color .green) & 1) && ((uintptr_t)(&stuff->color .green) & 1) == 0) *(&stuff->color.green) = lswaps (*(&stuff->color.green)); else swap_uint16((uint16_t * )(&stuff->color.green)); } while (0); |
2452 | swaps(&stuff->color.blue)do { if (sizeof(*(&stuff->color.blue)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->color .blue) & 1) && ((uintptr_t)(&stuff->color. blue) & 1) == 0) *(&stuff->color.blue) = lswaps(*( &stuff->color.blue)); else swap_uint16((uint16_t *)(& stuff->color.blue)); } while (0); |
2453 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2454 | } |
2455 | |
2456 | static void |
2457 | swapStops(void *stuff, int num) |
2458 | { |
2459 | int i; |
2460 | CARD32 *stops; |
2461 | CARD16 *colors; |
2462 | |
2463 | stops = (CARD32 *) (stuff); |
2464 | for (i = 0; i < num; ++i) { |
2465 | swapl(stops)do { if (sizeof(*(stops)) != 4) wrong_size(); if (__builtin_constant_p ((uintptr_t)(stops) & 3) && ((uintptr_t)(stops) & 3) == 0) *(stops) = lswapl(*(stops)); else swap_uint32((uint32_t *)(stops)); } while (0); |
2466 | ++stops; |
2467 | } |
2468 | colors = (CARD16 *) (stops); |
2469 | for (i = 0; i < 4 * num; ++i) { |
2470 | swaps(colors)do { if (sizeof(*(colors)) != 2) wrong_size(); if (__builtin_constant_p ((uintptr_t)(colors) & 1) && ((uintptr_t)(colors) & 1) == 0) *(colors) = lswaps(*(colors)); else swap_uint16 ((uint16_t *)(colors)); } while (0); |
2471 | ++colors; |
2472 | } |
2473 | } |
2474 | |
2475 | static int |
2476 | SProcRenderCreateLinearGradient(ClientPtr client) |
2477 | { |
2478 | int len; |
2479 | |
2480 | REQUEST(xRenderCreateLinearGradientReq)xRenderCreateLinearGradientReq *stuff = (xRenderCreateLinearGradientReq *)client->requestBuffer; |
2481 | REQUEST_AT_LEAST_SIZE(xRenderCreateLinearGradientReq)if ((sizeof(xRenderCreateLinearGradientReq) >> 2) > client ->req_len ) return(16); |
2482 | |
2483 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2484 | swapl(&stuff->pid)do { if (sizeof(*(&stuff->pid)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->pid) & 3 ) && ((uintptr_t)(&stuff->pid) & 3) == 0) * (&stuff->pid) = lswapl(*(&stuff->pid)); else swap_uint32 ((uint32_t *)(&stuff->pid)); } while (0); |
2485 | swapl(&stuff->p1.x)do { if (sizeof(*(&stuff->p1.x)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->p1.x) & 3) && ((uintptr_t)(&stuff->p1.x) & 3) == 0 ) *(&stuff->p1.x) = lswapl(*(&stuff->p1.x)); else swap_uint32((uint32_t *)(&stuff->p1.x)); } while (0); |
2486 | swapl(&stuff->p1.y)do { if (sizeof(*(&stuff->p1.y)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->p1.y) & 3) && ((uintptr_t)(&stuff->p1.y) & 3) == 0 ) *(&stuff->p1.y) = lswapl(*(&stuff->p1.y)); else swap_uint32((uint32_t *)(&stuff->p1.y)); } while (0); |
2487 | swapl(&stuff->p2.x)do { if (sizeof(*(&stuff->p2.x)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->p2.x) & 3) && ((uintptr_t)(&stuff->p2.x) & 3) == 0 ) *(&stuff->p2.x) = lswapl(*(&stuff->p2.x)); else swap_uint32((uint32_t *)(&stuff->p2.x)); } while (0); |
2488 | swapl(&stuff->p2.y)do { if (sizeof(*(&stuff->p2.y)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->p2.y) & 3) && ((uintptr_t)(&stuff->p2.y) & 3) == 0 ) *(&stuff->p2.y) = lswapl(*(&stuff->p2.y)); else swap_uint32((uint32_t *)(&stuff->p2.y)); } while (0); |
2489 | swapl(&stuff->nStops)do { if (sizeof(*(&stuff->nStops)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->nStops) & 3) && ((uintptr_t)(&stuff->nStops) & 3) == 0) *(&stuff->nStops) = lswapl(*(&stuff->nStops )); else swap_uint32((uint32_t *)(&stuff->nStops)); } while (0); |
2490 | |
2491 | len = (client->req_len << 2) - sizeof(xRenderCreateLinearGradientReq); |
2492 | if (stuff->nStops > UINT32_MAX4294967295U / (sizeof(xFixed) + sizeof(xRenderColor))) |
2493 | return BadLength16; |
2494 | if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor))) |
2495 | return BadLength16; |
2496 | |
2497 | swapStops(stuff + 1, stuff->nStops); |
2498 | |
2499 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2500 | } |
2501 | |
2502 | static int |
2503 | SProcRenderCreateRadialGradient(ClientPtr client) |
2504 | { |
2505 | int len; |
2506 | |
2507 | REQUEST(xRenderCreateRadialGradientReq)xRenderCreateRadialGradientReq *stuff = (xRenderCreateRadialGradientReq *)client->requestBuffer; |
2508 | REQUEST_AT_LEAST_SIZE(xRenderCreateRadialGradientReq)if ((sizeof(xRenderCreateRadialGradientReq) >> 2) > client ->req_len ) return(16); |
2509 | |
2510 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2511 | swapl(&stuff->pid)do { if (sizeof(*(&stuff->pid)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->pid) & 3 ) && ((uintptr_t)(&stuff->pid) & 3) == 0) * (&stuff->pid) = lswapl(*(&stuff->pid)); else swap_uint32 ((uint32_t *)(&stuff->pid)); } while (0); |
2512 | swapl(&stuff->inner.x)do { if (sizeof(*(&stuff->inner.x)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->inner.x ) & 3) && ((uintptr_t)(&stuff->inner.x) & 3) == 0) *(&stuff->inner.x) = lswapl(*(&stuff-> inner.x)); else swap_uint32((uint32_t *)(&stuff->inner .x)); } while (0); |
2513 | swapl(&stuff->inner.y)do { if (sizeof(*(&stuff->inner.y)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->inner.y ) & 3) && ((uintptr_t)(&stuff->inner.y) & 3) == 0) *(&stuff->inner.y) = lswapl(*(&stuff-> inner.y)); else swap_uint32((uint32_t *)(&stuff->inner .y)); } while (0); |
2514 | swapl(&stuff->outer.x)do { if (sizeof(*(&stuff->outer.x)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->outer.x ) & 3) && ((uintptr_t)(&stuff->outer.x) & 3) == 0) *(&stuff->outer.x) = lswapl(*(&stuff-> outer.x)); else swap_uint32((uint32_t *)(&stuff->outer .x)); } while (0); |
2515 | swapl(&stuff->outer.y)do { if (sizeof(*(&stuff->outer.y)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->outer.y ) & 3) && ((uintptr_t)(&stuff->outer.y) & 3) == 0) *(&stuff->outer.y) = lswapl(*(&stuff-> outer.y)); else swap_uint32((uint32_t *)(&stuff->outer .y)); } while (0); |
2516 | swapl(&stuff->inner_radius)do { if (sizeof(*(&stuff->inner_radius)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->inner_radius ) & 3) && ((uintptr_t)(&stuff->inner_radius ) & 3) == 0) *(&stuff->inner_radius) = lswapl(*(& stuff->inner_radius)); else swap_uint32((uint32_t *)(& stuff->inner_radius)); } while (0); |
2517 | swapl(&stuff->outer_radius)do { if (sizeof(*(&stuff->outer_radius)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->outer_radius ) & 3) && ((uintptr_t)(&stuff->outer_radius ) & 3) == 0) *(&stuff->outer_radius) = lswapl(*(& stuff->outer_radius)); else swap_uint32((uint32_t *)(& stuff->outer_radius)); } while (0); |
2518 | swapl(&stuff->nStops)do { if (sizeof(*(&stuff->nStops)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->nStops) & 3) && ((uintptr_t)(&stuff->nStops) & 3) == 0) *(&stuff->nStops) = lswapl(*(&stuff->nStops )); else swap_uint32((uint32_t *)(&stuff->nStops)); } while (0); |
2519 | |
2520 | len = (client->req_len << 2) - sizeof(xRenderCreateRadialGradientReq); |
2521 | if (stuff->nStops > UINT32_MAX4294967295U / (sizeof(xFixed) + sizeof(xRenderColor))) |
2522 | return BadLength16; |
2523 | if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor))) |
2524 | return BadLength16; |
2525 | |
2526 | swapStops(stuff + 1, stuff->nStops); |
2527 | |
2528 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2529 | } |
2530 | |
2531 | static int |
2532 | SProcRenderCreateConicalGradient(ClientPtr client) |
2533 | { |
2534 | int len; |
2535 | |
2536 | REQUEST(xRenderCreateConicalGradientReq)xRenderCreateConicalGradientReq *stuff = (xRenderCreateConicalGradientReq *)client->requestBuffer; |
2537 | REQUEST_AT_LEAST_SIZE(xRenderCreateConicalGradientReq)if ((sizeof(xRenderCreateConicalGradientReq) >> 2) > client->req_len ) return(16); |
2538 | |
2539 | swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->length) & 1) && ((uintptr_t)(&stuff->length) & 1) == 0) *(&stuff->length) = lswaps(*(&stuff->length )); else swap_uint16((uint16_t *)(&stuff->length)); } while (0); |
2540 | swapl(&stuff->pid)do { if (sizeof(*(&stuff->pid)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->pid) & 3 ) && ((uintptr_t)(&stuff->pid) & 3) == 0) * (&stuff->pid) = lswapl(*(&stuff->pid)); else swap_uint32 ((uint32_t *)(&stuff->pid)); } while (0); |
2541 | swapl(&stuff->center.x)do { if (sizeof(*(&stuff->center.x)) != 4) wrong_size( ); if (__builtin_constant_p((uintptr_t)(&stuff->center .x) & 3) && ((uintptr_t)(&stuff->center.x) & 3) == 0) *(&stuff->center.x) = lswapl(*(&stuff ->center.x)); else swap_uint32((uint32_t *)(&stuff-> center.x)); } while (0); |
2542 | swapl(&stuff->center.y)do { if (sizeof(*(&stuff->center.y)) != 4) wrong_size( ); if (__builtin_constant_p((uintptr_t)(&stuff->center .y) & 3) && ((uintptr_t)(&stuff->center.y) & 3) == 0) *(&stuff->center.y) = lswapl(*(&stuff ->center.y)); else swap_uint32((uint32_t *)(&stuff-> center.y)); } while (0); |
2543 | swapl(&stuff->angle)do { if (sizeof(*(&stuff->angle)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->angle) & 3) && ((uintptr_t)(&stuff->angle) & 3) == 0) *(&stuff->angle) = lswapl(*(&stuff->angle)) ; else swap_uint32((uint32_t *)(&stuff->angle)); } while (0); |
2544 | swapl(&stuff->nStops)do { if (sizeof(*(&stuff->nStops)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->nStops) & 3) && ((uintptr_t)(&stuff->nStops) & 3) == 0) *(&stuff->nStops) = lswapl(*(&stuff->nStops )); else swap_uint32((uint32_t *)(&stuff->nStops)); } while (0); |
2545 | |
2546 | len = (client->req_len << 2) - sizeof(xRenderCreateConicalGradientReq); |
2547 | if (stuff->nStops > UINT32_MAX4294967295U / (sizeof(xFixed) + sizeof(xRenderColor))) |
2548 | return BadLength16; |
2549 | if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor))) |
2550 | return BadLength16; |
2551 | |
2552 | swapStops(stuff + 1, stuff->nStops); |
2553 | |
2554 | return (*ProcRenderVector[stuff->renderReqType]) (client); |
2555 | } |
2556 | |
2557 | static int |
2558 | SProcRenderDispatch(ClientPtr client) |
2559 | { |
2560 | REQUEST(xReq)xReq *stuff = (xReq *)client->requestBuffer; |
2561 | |
2562 | if (stuff->data < RenderNumberRequests(36 +1)) |
2563 | return (*SProcRenderVector[stuff->data]) (client); |
2564 | else |
2565 | return BadRequest1; |
2566 | } |
2567 | |
2568 | #ifdef PANORAMIX1 |
2569 | #define VERIFY_XIN_PICTURE(pPicture, pid, client, mode){ int rc = dixLookupResourceByType((void **)&(pPicture), pid , XRT_PICTURE, client, mode); if (rc != 0) return rc;} {\ |
2570 | int rc = dixLookupResourceByType((void **)&(pPicture), pid,\ |
2571 | XRT_PICTURE, client, mode);\ |
2572 | if (rc != Success0)\ |
2573 | return rc;\ |
2574 | } |
2575 | |
2576 | #define VERIFY_XIN_ALPHA(pPicture, pid, client, mode){ if (pid == 0L) pPicture = 0; else { { int rc = dixLookupResourceByType ((void **)&(pPicture), pid, XRT_PICTURE, client, mode); if (rc != 0) return rc;}; } } {\ |
2577 | if (pid == None0L) \ |
2578 | pPicture = 0; \ |
2579 | else { \ |
2580 | VERIFY_XIN_PICTURE(pPicture, pid, client, mode){ int rc = dixLookupResourceByType((void **)&(pPicture), pid , XRT_PICTURE, client, mode); if (rc != 0) return rc;}; \ |
2581 | } \ |
2582 | } \ |
2583 | |
2584 | int (*PanoramiXSaveRenderVector[RenderNumberRequests(36 +1)]) (ClientPtr); |
2585 | |
2586 | static int |
2587 | PanoramiXRenderCreatePicture(ClientPtr client) |
2588 | { |
2589 | REQUEST(xRenderCreatePictureReq)xRenderCreatePictureReq *stuff = (xRenderCreatePictureReq *)client ->requestBuffer; |
2590 | PanoramiXRes *refDraw, *newPict; |
2591 | int result, j; |
2592 | |
2593 | REQUEST_AT_LEAST_SIZE(xRenderCreatePictureReq)if ((sizeof(xRenderCreatePictureReq) >> 2) > client-> req_len ) return(16); |
2594 | result = dixLookupResourceByClass((void **) &refDraw, stuff->drawable, |
2595 | XRC_DRAWABLE, client, DixWriteAccess(1<<1)); |
2596 | if (result != Success0) |
2597 | return (result == BadValue2) ? BadDrawable9 : result; |
2598 | if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes)))) |
2599 | return BadAlloc11; |
2600 | newPict->type = XRT_PICTURE; |
2601 | panoramix_setup_ids(newPict, client, stuff->pid); |
2602 | |
2603 | if (refDraw->type == XRT_WINDOW && |
2604 | stuff->drawable == screenInfo.screens[0]->root->drawable.id) { |
2605 | newPict->u.pict.root = TRUE1; |
2606 | } |
2607 | else |
2608 | newPict->u.pict.root = FALSE0; |
2609 | |
2610 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { |
2611 | stuff->pid = newPict->info[j].id; |
2612 | stuff->drawable = refDraw->info[j].id; |
2613 | result = (*PanoramiXSaveRenderVector[X_RenderCreatePicture4]) (client); |
2614 | if (result != Success0) |
2615 | break; |
2616 | } |
2617 | |
2618 | if (result == Success0) |
2619 | AddResourceDarwin_X_AddResource(newPict->info[0].id, XRT_PICTURE, newPict); |
2620 | else |
2621 | free(newPict); |
2622 | |
2623 | return result; |
2624 | } |
2625 | |
2626 | static int |
2627 | PanoramiXRenderChangePicture(ClientPtr client) |
2628 | { |
2629 | PanoramiXRes *pict; |
2630 | int result = Success0, j; |
2631 | |
2632 | REQUEST(xRenderChangePictureReq)xRenderChangePictureReq *stuff = (xRenderChangePictureReq *)client ->requestBuffer; |
2633 | |
2634 | REQUEST_AT_LEAST_SIZE(xRenderChangePictureReq)if ((sizeof(xRenderChangePictureReq) >> 2) > client-> req_len ) return(16); |
2635 | |
2636 | VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(pict), stuff ->picture, XRT_PICTURE, client, (1<<1)); if (rc != 0 ) return rc;}; |
2637 | |
2638 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { |
2639 | stuff->picture = pict->info[j].id; |
2640 | result = (*PanoramiXSaveRenderVector[X_RenderChangePicture5]) (client); |
2641 | if (result != Success0) |
2642 | break; |
2643 | } |
2644 | |
2645 | return result; |
2646 | } |
2647 | |
2648 | static int |
2649 | PanoramiXRenderSetPictureClipRectangles(ClientPtr client) |
2650 | { |
2651 | REQUEST(xRenderSetPictureClipRectanglesReq)xRenderSetPictureClipRectanglesReq *stuff = (xRenderSetPictureClipRectanglesReq *)client->requestBuffer; |
2652 | int result = Success0, j; |
2653 | PanoramiXRes *pict; |
2654 | |
2655 | REQUEST_AT_LEAST_SIZE(xRenderSetPictureClipRectanglesReq)if ((sizeof(xRenderSetPictureClipRectanglesReq) >> 2) > client->req_len ) return(16); |
2656 | |
2657 | VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(pict), stuff ->picture, XRT_PICTURE, client, (1<<1)); if (rc != 0 ) return rc;}; |
2658 | |
2659 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { |
2660 | stuff->picture = pict->info[j].id; |
2661 | result = |
2662 | (*PanoramiXSaveRenderVector[X_RenderSetPictureClipRectangles6]) |
2663 | (client); |
2664 | if (result != Success0) |
2665 | break; |
2666 | } |
2667 | |
2668 | return result; |
2669 | } |
2670 | |
2671 | static int |
2672 | PanoramiXRenderSetPictureTransform(ClientPtr client) |
2673 | { |
2674 | REQUEST(xRenderSetPictureTransformReq)xRenderSetPictureTransformReq *stuff = (xRenderSetPictureTransformReq *)client->requestBuffer; |
2675 | int result = Success0, j; |
2676 | PanoramiXRes *pict; |
2677 | |
2678 | REQUEST_AT_LEAST_SIZE(xRenderSetPictureTransformReq)if ((sizeof(xRenderSetPictureTransformReq) >> 2) > client ->req_len ) return(16); |
2679 | |
2680 | VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(pict), stuff ->picture, XRT_PICTURE, client, (1<<1)); if (rc != 0 ) return rc;}; |
2681 | |
2682 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { |
2683 | stuff->picture = pict->info[j].id; |
2684 | result = |
2685 | (*PanoramiXSaveRenderVector[X_RenderSetPictureTransform28]) (client); |
2686 | if (result != Success0) |
2687 | break; |
2688 | } |
2689 | |
2690 | return result; |
2691 | } |
2692 | |
2693 | static int |
2694 | PanoramiXRenderSetPictureFilter(ClientPtr client) |
2695 | { |
2696 | REQUEST(xRenderSetPictureFilterReq)xRenderSetPictureFilterReq *stuff = (xRenderSetPictureFilterReq *)client->requestBuffer; |
2697 | int result = Success0, j; |
2698 | PanoramiXRes *pict; |
2699 | |
2700 | REQUEST_AT_LEAST_SIZE(xRenderSetPictureFilterReq)if ((sizeof(xRenderSetPictureFilterReq) >> 2) > client ->req_len ) return(16); |
2701 | |
2702 | VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(pict), stuff ->picture, XRT_PICTURE, client, (1<<1)); if (rc != 0 ) return rc;}; |
2703 | |
2704 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { |
2705 | stuff->picture = pict->info[j].id; |
2706 | result = |
2707 | (*PanoramiXSaveRenderVector[X_RenderSetPictureFilter30]) (client); |
2708 | if (result != Success0) |
2709 | break; |
2710 | } |
2711 | |
2712 | return result; |
2713 | } |
2714 | |
2715 | static int |
2716 | PanoramiXRenderFreePicture(ClientPtr client) |
2717 | { |
2718 | PanoramiXRes *pict; |
2719 | int result = Success0, j; |
2720 | |
2721 | REQUEST(xRenderFreePictureReq)xRenderFreePictureReq *stuff = (xRenderFreePictureReq *)client ->requestBuffer; |
2722 | |
2723 | REQUEST_SIZE_MATCH(xRenderFreePictureReq)if ((sizeof(xRenderFreePictureReq) >> 2) != client-> req_len) return(16); |
2724 | |
2725 | client->errorValue = stuff->picture; |
2726 | |
2727 | VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixDestroyAccess){ int rc = dixLookupResourceByType((void **)&(pict), stuff ->picture, XRT_PICTURE, client, (1<<2)); if (rc != 0 ) return rc;}; |
2728 | |
2729 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { |
2730 | stuff->picture = pict->info[j].id; |
2731 | result = (*PanoramiXSaveRenderVector[X_RenderFreePicture7]) (client); |
2732 | if (result != Success0) |
2733 | break; |
2734 | } |
2735 | |
2736 | /* Since ProcRenderFreePicture is using FreeResource, it will free |
2737 | our resource for us on the last pass through the loop above */ |
2738 | |
2739 | return result; |
2740 | } |
2741 | |
2742 | static int |
2743 | PanoramiXRenderComposite(ClientPtr client) |
2744 | { |
2745 | PanoramiXRes *src, *msk, *dst; |
2746 | int result = Success0, j; |
2747 | xRenderCompositeReq orig; |
2748 | |
2749 | REQUEST(xRenderCompositeReq)xRenderCompositeReq *stuff = (xRenderCompositeReq *)client-> requestBuffer; |
2750 | |
2751 | REQUEST_SIZE_MATCH(xRenderCompositeReq)if ((sizeof(xRenderCompositeReq) >> 2) != client->req_len ) return(16); |
2752 | |
2753 | VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess){ int rc = dixLookupResourceByType((void **)&(src), stuff ->src, XRT_PICTURE, client, (1<<0)); if (rc != 0) return rc;}; |
2754 | VERIFY_XIN_ALPHA(msk, stuff->mask, client, DixReadAccess){ if (stuff->mask == 0L) msk = 0; else { { int rc = dixLookupResourceByType ((void **)&(msk), stuff->mask, XRT_PICTURE, client, (1 <<0)); if (rc != 0) return rc;}; } }; |
2755 | VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(dst), stuff ->dst, XRT_PICTURE, client, (1<<1)); if (rc != 0) return rc;}; |
2756 | |
2757 | orig = *stuff; |
2758 | |
2759 | FOR_NSCREENS_FORWARD(j)for(j = 0; j < PanoramiXNumScreens; j++) { |
2760 | stuff->src = src->info[j].id; |
2761 | if (src->u.pict.root) { |
2762 | stuff->xSrc = orig.xSrc - screenInfo.screens[j]->x; |
2763 | stuff->ySrc = orig.ySrc - screenInfo.screens[j]->y; |
2764 | } |
2765 | stuff->dst = dst->info[j].id; |
2766 | if (dst->u.pict.root) { |
2767 | stuff->xDst = orig.xDst - screenInfo.screens[j]->x; |
2768 | stuff->yDst = orig.yDst - screenInfo.screens[j]->y; |
2769 | } |
2770 | if (msk) { |
2771 | stuff->mask = msk->info[j].id; |
2772 | if (msk->u.pict.root) { |
2773 | stuff->xMask = orig.xMask - screenInfo.screens[j]->x; |
2774 | stuff->yMask = orig.yMask - screenInfo.screens[j]->y; |
2775 | } |
2776 | } |
2777 | result = (*PanoramiXSaveRenderVector[X_RenderComposite8]) (client); |
2778 | if (result != Success0) |
2779 | break; |
2780 | } |
2781 | |
2782 | return result; |
2783 | } |
2784 | |
2785 | static int |
2786 | PanoramiXRenderCompositeGlyphs(ClientPtr client) |
2787 | { |
2788 | PanoramiXRes *src, *dst; |
2789 | int result = Success0, j; |
2790 | |
2791 | REQUEST(xRenderCompositeGlyphsReq)xRenderCompositeGlyphsReq *stuff = (xRenderCompositeGlyphsReq *)client->requestBuffer; |
2792 | xGlyphElt origElt, *elt; |
2793 | INT16 xSrc, ySrc; |
2794 | |
2795 | REQUEST_AT_LEAST_SIZE(xRenderCompositeGlyphsReq)if ((sizeof(xRenderCompositeGlyphsReq) >> 2) > client ->req_len ) return(16); |
2796 | VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess){ int rc = dixLookupResourceByType((void **)&(src), stuff ->src, XRT_PICTURE, client, (1<<0)); if (rc != 0) return rc;}; |
2797 | VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(dst), stuff ->dst, XRT_PICTURE, client, (1<<1)); if (rc != 0) return rc;}; |
2798 | |
2799 | if (client->req_len << 2 >= (sizeof(xRenderCompositeGlyphsReq) + |
2800 | sizeof(xGlyphElt))) { |
2801 | elt = (xGlyphElt *) (stuff + 1); |
2802 | origElt = *elt; |
2803 | xSrc = stuff->xSrc; |
2804 | ySrc = stuff->ySrc; |
2805 | FOR_NSCREENS_FORWARD(j)for(j = 0; j < PanoramiXNumScreens; j++) { |
2806 | stuff->src = src->info[j].id; |
2807 | if (src->u.pict.root) { |
2808 | stuff->xSrc = xSrc - screenInfo.screens[j]->x; |
2809 | stuff->ySrc = ySrc - screenInfo.screens[j]->y; |
2810 | } |
2811 | stuff->dst = dst->info[j].id; |
2812 | if (dst->u.pict.root) { |
2813 | elt->deltax = origElt.deltax - screenInfo.screens[j]->x; |
2814 | elt->deltay = origElt.deltay - screenInfo.screens[j]->y; |
2815 | } |
2816 | result = |
2817 | (*PanoramiXSaveRenderVector[stuff->renderReqType]) (client); |
2818 | if (result != Success0) |
2819 | break; |
2820 | } |
2821 | } |
2822 | |
2823 | return result; |
2824 | } |
2825 | |
2826 | static int |
2827 | PanoramiXRenderFillRectangles(ClientPtr client) |
2828 | { |
2829 | PanoramiXRes *dst; |
2830 | int result = Success0, j; |
2831 | |
2832 | REQUEST(xRenderFillRectanglesReq)xRenderFillRectanglesReq *stuff = (xRenderFillRectanglesReq * )client->requestBuffer; |
2833 | char *extra; |
2834 | int extra_len; |
2835 | |
2836 | REQUEST_AT_LEAST_SIZE(xRenderFillRectanglesReq)if ((sizeof(xRenderFillRectanglesReq) >> 2) > client ->req_len ) return(16); |
2837 | VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(dst), stuff ->dst, XRT_PICTURE, client, (1<<1)); if (rc != 0) return rc;}; |
2838 | extra_len = (client->req_len << 2) - sizeof(xRenderFillRectanglesReq); |
2839 | if (extra_len && (extra = (char *) malloc(extra_len))) { |
2840 | memcpy(extra, stuff + 1, extra_len)__builtin___memcpy_chk (extra, stuff + 1, extra_len, __builtin_object_size (extra, 0)); |
2841 | FOR_NSCREENS_FORWARD(j)for(j = 0; j < PanoramiXNumScreens; j++) { |
2842 | if (j) |
2843 | memcpy(stuff + 1, extra, extra_len)__builtin___memcpy_chk (stuff + 1, extra, extra_len, __builtin_object_size (stuff + 1, 0)); |
2844 | if (dst->u.pict.root) { |
2845 | int x_off = screenInfo.screens[j]->x; |
2846 | int y_off = screenInfo.screens[j]->y; |
2847 | |
2848 | if (x_off || y_off) { |
2849 | xRectangle *rects = (xRectangle *) (stuff + 1); |
2850 | int i = extra_len / sizeof(xRectangle); |
2851 | |
2852 | while (i--) { |
2853 | rects->x -= x_off; |
2854 | rects->y -= y_off; |
2855 | rects++; |
2856 | } |
2857 | } |
2858 | } |
2859 | stuff->dst = dst->info[j].id; |
2860 | result = |
2861 | (*PanoramiXSaveRenderVector[X_RenderFillRectangles26]) (client); |
2862 | if (result != Success0) |
2863 | break; |
2864 | } |
2865 | free(extra); |
2866 | } |
2867 | |
2868 | return result; |
2869 | } |
2870 | |
2871 | static int |
2872 | PanoramiXRenderTrapezoids(ClientPtr client) |
2873 | { |
2874 | PanoramiXRes *src, *dst; |
2875 | int result = Success0, j; |
2876 | |
2877 | REQUEST(xRenderTrapezoidsReq)xRenderTrapezoidsReq *stuff = (xRenderTrapezoidsReq *)client-> requestBuffer; |
2878 | char *extra; |
2879 | int extra_len; |
2880 | |
2881 | REQUEST_AT_LEAST_SIZE(xRenderTrapezoidsReq)if ((sizeof(xRenderTrapezoidsReq) >> 2) > client-> req_len ) return(16); |
2882 | |
2883 | VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess){ int rc = dixLookupResourceByType((void **)&(src), stuff ->src, XRT_PICTURE, client, (1<<0)); if (rc != 0) return rc;}; |
2884 | VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(dst), stuff ->dst, XRT_PICTURE, client, (1<<1)); if (rc != 0) return rc;}; |
2885 | |
2886 | extra_len = (client->req_len << 2) - sizeof(xRenderTrapezoidsReq); |
2887 | |
2888 | if (extra_len && (extra = (char *) malloc(extra_len))) { |
2889 | memcpy(extra, stuff + 1, extra_len)__builtin___memcpy_chk (extra, stuff + 1, extra_len, __builtin_object_size (extra, 0)); |
2890 | |
2891 | FOR_NSCREENS_FORWARD(j)for(j = 0; j < PanoramiXNumScreens; j++) { |
2892 | if (j) |
2893 | memcpy(stuff + 1, extra, extra_len)__builtin___memcpy_chk (stuff + 1, extra, extra_len, __builtin_object_size (stuff + 1, 0)); |
2894 | if (dst->u.pict.root) { |
2895 | int x_off = screenInfo.screens[j]->x; |
2896 | int y_off = screenInfo.screens[j]->y; |
2897 | |
2898 | if (x_off || y_off) { |
2899 | xTrapezoid *trap = (xTrapezoid *) (stuff + 1); |
2900 | int i = extra_len / sizeof(xTrapezoid); |
2901 | |
2902 | while (i--) { |
2903 | trap->top -= y_off; |
2904 | trap->bottom -= y_off; |
2905 | trap->left.p1.x -= x_off; |
2906 | trap->left.p1.y -= y_off; |
2907 | trap->left.p2.x -= x_off; |
2908 | trap->left.p2.y -= y_off; |
2909 | trap->right.p1.x -= x_off; |
2910 | trap->right.p1.y -= y_off; |
2911 | trap->right.p2.x -= x_off; |
2912 | trap->right.p2.y -= y_off; |
2913 | trap++; |
2914 | } |
2915 | } |
2916 | } |
2917 | |
2918 | stuff->src = src->info[j].id; |
2919 | stuff->dst = dst->info[j].id; |
2920 | result = (*PanoramiXSaveRenderVector[X_RenderTrapezoids10]) (client); |
2921 | |
2922 | if (result != Success0) |
2923 | break; |
2924 | } |
2925 | |
2926 | free(extra); |
2927 | } |
2928 | |
2929 | return result; |
2930 | } |
2931 | |
2932 | static int |
2933 | PanoramiXRenderTriangles(ClientPtr client) |
2934 | { |
2935 | PanoramiXRes *src, *dst; |
2936 | int result = Success0, j; |
2937 | |
2938 | REQUEST(xRenderTrianglesReq)xRenderTrianglesReq *stuff = (xRenderTrianglesReq *)client-> requestBuffer; |
2939 | char *extra; |
2940 | int extra_len; |
2941 | |
2942 | REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq)if ((sizeof(xRenderTrianglesReq) >> 2) > client-> req_len ) return(16); |
2943 | |
2944 | VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess){ int rc = dixLookupResourceByType((void **)&(src), stuff ->src, XRT_PICTURE, client, (1<<0)); if (rc != 0) return rc;}; |
2945 | VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(dst), stuff ->dst, XRT_PICTURE, client, (1<<1)); if (rc != 0) return rc;}; |
2946 | |
2947 | extra_len = (client->req_len << 2) - sizeof(xRenderTrianglesReq); |
2948 | |
2949 | if (extra_len && (extra = (char *) malloc(extra_len))) { |
2950 | memcpy(extra, stuff + 1, extra_len)__builtin___memcpy_chk (extra, stuff + 1, extra_len, __builtin_object_size (extra, 0)); |
2951 | |
2952 | FOR_NSCREENS_FORWARD(j)for(j = 0; j < PanoramiXNumScreens; j++) { |
2953 | if (j) |
2954 | memcpy(stuff + 1, extra, extra_len)__builtin___memcpy_chk (stuff + 1, extra, extra_len, __builtin_object_size (stuff + 1, 0)); |
2955 | if (dst->u.pict.root) { |
2956 | int x_off = screenInfo.screens[j]->x; |
2957 | int y_off = screenInfo.screens[j]->y; |
2958 | |
2959 | if (x_off || y_off) { |
2960 | xTriangle *tri = (xTriangle *) (stuff + 1); |
2961 | int i = extra_len / sizeof(xTriangle); |
2962 | |
2963 | while (i--) { |
2964 | tri->p1.x -= x_off; |
2965 | tri->p1.y -= y_off; |
2966 | tri->p2.x -= x_off; |
2967 | tri->p2.y -= y_off; |
2968 | tri->p3.x -= x_off; |
2969 | tri->p3.y -= y_off; |
2970 | tri++; |
2971 | } |
2972 | } |
2973 | } |
2974 | |
2975 | stuff->src = src->info[j].id; |
2976 | stuff->dst = dst->info[j].id; |
2977 | result = (*PanoramiXSaveRenderVector[X_RenderTriangles11]) (client); |
2978 | |
2979 | if (result != Success0) |
2980 | break; |
2981 | } |
2982 | |
2983 | free(extra); |
2984 | } |
2985 | |
2986 | return result; |
2987 | } |
2988 | |
2989 | static int |
2990 | PanoramiXRenderTriStrip(ClientPtr client) |
2991 | { |
2992 | PanoramiXRes *src, *dst; |
2993 | int result = Success0, j; |
2994 | |
2995 | REQUEST(xRenderTriStripReq)xRenderTriStripReq *stuff = (xRenderTriStripReq *)client-> requestBuffer; |
2996 | char *extra; |
2997 | int extra_len; |
2998 | |
2999 | REQUEST_AT_LEAST_SIZE(xRenderTriStripReq)if ((sizeof(xRenderTriStripReq) >> 2) > client->req_len ) return(16); |
3000 | |
3001 | VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess){ int rc = dixLookupResourceByType((void **)&(src), stuff ->src, XRT_PICTURE, client, (1<<0)); if (rc != 0) return rc;}; |
3002 | VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(dst), stuff ->dst, XRT_PICTURE, client, (1<<1)); if (rc != 0) return rc;}; |
3003 | |
3004 | extra_len = (client->req_len << 2) - sizeof(xRenderTriStripReq); |
3005 | |
3006 | if (extra_len && (extra = (char *) malloc(extra_len))) { |
3007 | memcpy(extra, stuff + 1, extra_len)__builtin___memcpy_chk (extra, stuff + 1, extra_len, __builtin_object_size (extra, 0)); |
3008 | |
3009 | FOR_NSCREENS_FORWARD(j)for(j = 0; j < PanoramiXNumScreens; j++) { |
3010 | if (j) |
3011 | memcpy(stuff + 1, extra, extra_len)__builtin___memcpy_chk (stuff + 1, extra, extra_len, __builtin_object_size (stuff + 1, 0)); |
3012 | if (dst->u.pict.root) { |
3013 | int x_off = screenInfo.screens[j]->x; |
3014 | int y_off = screenInfo.screens[j]->y; |
3015 | |
3016 | if (x_off || y_off) { |
3017 | xPointFixed *fixed = (xPointFixed *) (stuff + 1); |
3018 | int i = extra_len / sizeof(xPointFixed); |
3019 | |
3020 | while (i--) { |
3021 | fixed->x -= x_off; |
3022 | fixed->y -= y_off; |
3023 | fixed++; |
3024 | } |
3025 | } |
3026 | } |
3027 | |
3028 | stuff->src = src->info[j].id; |
3029 | stuff->dst = dst->info[j].id; |
3030 | result = (*PanoramiXSaveRenderVector[X_RenderTriStrip12]) (client); |
3031 | |
3032 | if (result != Success0) |
3033 | break; |
3034 | } |
3035 | |
3036 | free(extra); |
3037 | } |
3038 | |
3039 | return result; |
3040 | } |
3041 | |
3042 | static int |
3043 | PanoramiXRenderTriFan(ClientPtr client) |
3044 | { |
3045 | PanoramiXRes *src, *dst; |
3046 | int result = Success0, j; |
3047 | |
3048 | REQUEST(xRenderTriFanReq)xRenderTriFanReq *stuff = (xRenderTriFanReq *)client->requestBuffer; |
3049 | char *extra; |
3050 | int extra_len; |
3051 | |
3052 | REQUEST_AT_LEAST_SIZE(xRenderTriFanReq)if ((sizeof(xRenderTriFanReq) >> 2) > client->req_len ) return(16); |
3053 | |
3054 | VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess){ int rc = dixLookupResourceByType((void **)&(src), stuff ->src, XRT_PICTURE, client, (1<<0)); if (rc != 0) return rc;}; |
3055 | VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(dst), stuff ->dst, XRT_PICTURE, client, (1<<1)); if (rc != 0) return rc;}; |
3056 | |
3057 | extra_len = (client->req_len << 2) - sizeof(xRenderTriFanReq); |
3058 | |
3059 | if (extra_len && (extra = (char *) malloc(extra_len))) { |
3060 | memcpy(extra, stuff + 1, extra_len)__builtin___memcpy_chk (extra, stuff + 1, extra_len, __builtin_object_size (extra, 0)); |
3061 | |
3062 | FOR_NSCREENS_FORWARD(j)for(j = 0; j < PanoramiXNumScreens; j++) { |
3063 | if (j) |
3064 | memcpy(stuff + 1, extra, extra_len)__builtin___memcpy_chk (stuff + 1, extra, extra_len, __builtin_object_size (stuff + 1, 0)); |
3065 | if (dst->u.pict.root) { |
3066 | int x_off = screenInfo.screens[j]->x; |
3067 | int y_off = screenInfo.screens[j]->y; |
3068 | |
3069 | if (x_off || y_off) { |
3070 | xPointFixed *fixed = (xPointFixed *) (stuff + 1); |
3071 | int i = extra_len / sizeof(xPointFixed); |
3072 | |
3073 | while (i--) { |
3074 | fixed->x -= x_off; |
3075 | fixed->y -= y_off; |
3076 | fixed++; |
3077 | } |
3078 | } |
3079 | } |
3080 | |
3081 | stuff->src = src->info[j].id; |
3082 | stuff->dst = dst->info[j].id; |
3083 | result = (*PanoramiXSaveRenderVector[X_RenderTriFan13]) (client); |
3084 | |
3085 | if (result != Success0) |
3086 | break; |
3087 | } |
3088 | |
3089 | free(extra); |
3090 | } |
3091 | |
3092 | return result; |
3093 | } |
3094 | |
3095 | static int |
3096 | PanoramiXRenderAddTraps(ClientPtr client) |
3097 | { |
3098 | PanoramiXRes *picture; |
3099 | int result = Success0, j; |
3100 | |
3101 | REQUEST(xRenderAddTrapsReq)xRenderAddTrapsReq *stuff = (xRenderAddTrapsReq *)client-> requestBuffer; |
3102 | char *extra; |
3103 | int extra_len; |
3104 | INT16 x_off, y_off; |
3105 | |
3106 | REQUEST_AT_LEAST_SIZE(xRenderAddTrapsReq)if ((sizeof(xRenderAddTrapsReq) >> 2) > client->req_len ) return(16); |
3107 | VERIFY_XIN_PICTURE(picture, stuff->picture, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(picture), stuff ->picture, XRT_PICTURE, client, (1<<1)); if (rc != 0 ) return rc;}; |
3108 | extra_len = (client->req_len << 2) - sizeof(xRenderAddTrapsReq); |
3109 | if (extra_len && (extra = (char *) malloc(extra_len))) { |
3110 | memcpy(extra, stuff + 1, extra_len)__builtin___memcpy_chk (extra, stuff + 1, extra_len, __builtin_object_size (extra, 0)); |
3111 | x_off = stuff->xOff; |
3112 | y_off = stuff->yOff; |
3113 | FOR_NSCREENS_FORWARD(j)for(j = 0; j < PanoramiXNumScreens; j++) { |
3114 | if (j) |
3115 | memcpy(stuff + 1, extra, extra_len)__builtin___memcpy_chk (stuff + 1, extra, extra_len, __builtin_object_size (stuff + 1, 0)); |
3116 | stuff->picture = picture->info[j].id; |
3117 | |
3118 | if (picture->u.pict.root) { |
3119 | stuff->xOff = x_off + screenInfo.screens[j]->x; |
3120 | stuff->yOff = y_off + screenInfo.screens[j]->y; |
3121 | } |
3122 | result = (*PanoramiXSaveRenderVector[X_RenderAddTraps32]) (client); |
3123 | if (result != Success0) |
3124 | break; |
3125 | } |
3126 | free(extra); |
3127 | } |
3128 | |
3129 | return result; |
3130 | } |
3131 | |
3132 | static int |
3133 | PanoramiXRenderCreateSolidFill(ClientPtr client) |
3134 | { |
3135 | REQUEST(xRenderCreateSolidFillReq)xRenderCreateSolidFillReq *stuff = (xRenderCreateSolidFillReq *)client->requestBuffer; |
3136 | PanoramiXRes *newPict; |
3137 | int result = Success0, j; |
3138 | |
3139 | REQUEST_AT_LEAST_SIZE(xRenderCreateSolidFillReq)if ((sizeof(xRenderCreateSolidFillReq) >> 2) > client ->req_len ) return(16); |
3140 | |
3141 | if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes)))) |
3142 | return BadAlloc11; |
3143 | |
3144 | newPict->type = XRT_PICTURE; |
3145 | panoramix_setup_ids(newPict, client, stuff->pid); |
3146 | newPict->u.pict.root = FALSE0; |
3147 | |
3148 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { |
3149 | stuff->pid = newPict->info[j].id; |
3150 | result = (*PanoramiXSaveRenderVector[X_RenderCreateSolidFill33]) (client); |
3151 | if (result != Success0) |
3152 | break; |
3153 | } |
3154 | |
3155 | if (result == Success0) |
3156 | AddResourceDarwin_X_AddResource(newPict->info[0].id, XRT_PICTURE, newPict); |
3157 | else |
3158 | free(newPict); |
3159 | |
3160 | return result; |
3161 | } |
3162 | |
3163 | static int |
3164 | PanoramiXRenderCreateLinearGradient(ClientPtr client) |
3165 | { |
3166 | REQUEST(xRenderCreateLinearGradientReq)xRenderCreateLinearGradientReq *stuff = (xRenderCreateLinearGradientReq *)client->requestBuffer; |
3167 | PanoramiXRes *newPict; |
3168 | int result = Success0, j; |
3169 | |
3170 | REQUEST_AT_LEAST_SIZE(xRenderCreateLinearGradientReq)if ((sizeof(xRenderCreateLinearGradientReq) >> 2) > client ->req_len ) return(16); |
3171 | |
3172 | if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes)))) |
3173 | return BadAlloc11; |
3174 | |
3175 | newPict->type = XRT_PICTURE; |
3176 | panoramix_setup_ids(newPict, client, stuff->pid); |
3177 | newPict->u.pict.root = FALSE0; |
3178 | |
3179 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { |
3180 | stuff->pid = newPict->info[j].id; |
3181 | result = |
3182 | (*PanoramiXSaveRenderVector[X_RenderCreateLinearGradient34]) (client); |
3183 | if (result != Success0) |
3184 | break; |
3185 | } |
3186 | |
3187 | if (result == Success0) |
3188 | AddResourceDarwin_X_AddResource(newPict->info[0].id, XRT_PICTURE, newPict); |
3189 | else |
3190 | free(newPict); |
3191 | |
3192 | return result; |
3193 | } |
3194 | |
3195 | static int |
3196 | PanoramiXRenderCreateRadialGradient(ClientPtr client) |
3197 | { |
3198 | REQUEST(xRenderCreateRadialGradientReq)xRenderCreateRadialGradientReq *stuff = (xRenderCreateRadialGradientReq *)client->requestBuffer; |
3199 | PanoramiXRes *newPict; |
3200 | int result = Success0, j; |
3201 | |
3202 | REQUEST_AT_LEAST_SIZE(xRenderCreateRadialGradientReq)if ((sizeof(xRenderCreateRadialGradientReq) >> 2) > client ->req_len ) return(16); |
3203 | |
3204 | if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes)))) |
3205 | return BadAlloc11; |
3206 | |
3207 | newPict->type = XRT_PICTURE; |
3208 | panoramix_setup_ids(newPict, client, stuff->pid); |
3209 | newPict->u.pict.root = FALSE0; |
3210 | |
3211 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { |
3212 | stuff->pid = newPict->info[j].id; |
3213 | result = |
3214 | (*PanoramiXSaveRenderVector[X_RenderCreateRadialGradient35]) (client); |
3215 | if (result != Success0) |
3216 | break; |
3217 | } |
3218 | |
3219 | if (result == Success0) |
3220 | AddResourceDarwin_X_AddResource(newPict->info[0].id, XRT_PICTURE, newPict); |
3221 | else |
3222 | free(newPict); |
3223 | |
3224 | return result; |
3225 | } |
3226 | |
3227 | static int |
3228 | PanoramiXRenderCreateConicalGradient(ClientPtr client) |
3229 | { |
3230 | REQUEST(xRenderCreateConicalGradientReq)xRenderCreateConicalGradientReq *stuff = (xRenderCreateConicalGradientReq *)client->requestBuffer; |
3231 | PanoramiXRes *newPict; |
3232 | int result = Success0, j; |
3233 | |
3234 | REQUEST_AT_LEAST_SIZE(xRenderCreateConicalGradientReq)if ((sizeof(xRenderCreateConicalGradientReq) >> 2) > client->req_len ) return(16); |
3235 | |
3236 | if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes)))) |
3237 | return BadAlloc11; |
3238 | |
3239 | newPict->type = XRT_PICTURE; |
3240 | panoramix_setup_ids(newPict, client, stuff->pid); |
3241 | newPict->u.pict.root = FALSE0; |
3242 | |
3243 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { |
3244 | stuff->pid = newPict->info[j].id; |
3245 | result = |
3246 | (*PanoramiXSaveRenderVector[X_RenderCreateConicalGradient36]) |
3247 | (client); |
3248 | if (result != Success0) |
3249 | break; |
3250 | } |
3251 | |
3252 | if (result == Success0) |
3253 | AddResourceDarwin_X_AddResource(newPict->info[0].id, XRT_PICTURE, newPict); |
3254 | else |
3255 | free(newPict); |
3256 | |
3257 | return result; |
3258 | } |
3259 | |
3260 | void |
3261 | PanoramiXRenderInit(void) |
3262 | { |
3263 | int i; |
3264 | |
3265 | XRT_PICTURE = CreateNewResourceType(XineramaDeleteResource, |
3266 | "XineramaPicture"); |
3267 | if (RenderErrBase) |
3268 | SetResourceTypeErrorValue(XRT_PICTURE, RenderErrBase + BadPicture1); |
3269 | for (i = 0; i < RenderNumberRequests(36 +1); i++) |
3270 | PanoramiXSaveRenderVector[i] = ProcRenderVector[i]; |
3271 | /* |
3272 | * Stuff in Xinerama aware request processing hooks |
3273 | */ |
3274 | ProcRenderVector[X_RenderCreatePicture4] = PanoramiXRenderCreatePicture; |
3275 | ProcRenderVector[X_RenderChangePicture5] = PanoramiXRenderChangePicture; |
3276 | ProcRenderVector[X_RenderSetPictureTransform28] = |
3277 | PanoramiXRenderSetPictureTransform; |
3278 | ProcRenderVector[X_RenderSetPictureFilter30] = |
3279 | PanoramiXRenderSetPictureFilter; |
3280 | ProcRenderVector[X_RenderSetPictureClipRectangles6] = |
3281 | PanoramiXRenderSetPictureClipRectangles; |
3282 | ProcRenderVector[X_RenderFreePicture7] = PanoramiXRenderFreePicture; |
3283 | ProcRenderVector[X_RenderComposite8] = PanoramiXRenderComposite; |
3284 | ProcRenderVector[X_RenderCompositeGlyphs823] = PanoramiXRenderCompositeGlyphs; |
3285 | ProcRenderVector[X_RenderCompositeGlyphs1624] = |
3286 | PanoramiXRenderCompositeGlyphs; |
3287 | ProcRenderVector[X_RenderCompositeGlyphs3225] = |
3288 | PanoramiXRenderCompositeGlyphs; |
3289 | ProcRenderVector[X_RenderFillRectangles26] = PanoramiXRenderFillRectangles; |
3290 | |
3291 | ProcRenderVector[X_RenderTrapezoids10] = PanoramiXRenderTrapezoids; |
3292 | ProcRenderVector[X_RenderTriangles11] = PanoramiXRenderTriangles; |
3293 | ProcRenderVector[X_RenderTriStrip12] = PanoramiXRenderTriStrip; |
3294 | ProcRenderVector[X_RenderTriFan13] = PanoramiXRenderTriFan; |
3295 | ProcRenderVector[X_RenderAddTraps32] = PanoramiXRenderAddTraps; |
3296 | |
3297 | ProcRenderVector[X_RenderCreateSolidFill33] = PanoramiXRenderCreateSolidFill; |
3298 | ProcRenderVector[X_RenderCreateLinearGradient34] = |
3299 | PanoramiXRenderCreateLinearGradient; |
3300 | ProcRenderVector[X_RenderCreateRadialGradient35] = |
3301 | PanoramiXRenderCreateRadialGradient; |
3302 | ProcRenderVector[X_RenderCreateConicalGradient36] = |
3303 | PanoramiXRenderCreateConicalGradient; |
3304 | } |
3305 | |
3306 | void |
3307 | PanoramiXRenderReset(void) |
3308 | { |
3309 | int i; |
3310 | |
3311 | for (i = 0; i < RenderNumberRequests(36 +1); i++) |
3312 | ProcRenderVector[i] = PanoramiXSaveRenderVector[i]; |
3313 | RenderErrBase = 0; |
3314 | } |
3315 | |
3316 | #endif /* PANORAMIX */ |