suwako / ShaderPlayground

master
ブランチ master
ShaderPlayground / deps / xlibre / include / X11 / extensions / syncproto.h
10.7 KB、474行 生 Blame 履歴
1/*
2
3Copyright 1991, 1993, 1994, 1998 The Open Group
4
5Permission to use, copy, modify, distribute, and sell this software and its
6documentation for any purpose is hereby granted without fee, provided that
7the above copyright notice appear in all copies and that both that
8copyright notice and this permission notice appear in supporting
9documentation.
10
11The above copyright notice and this permission notice shall be included in
12all copies or substantial portions of the Software.
13
14THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
18AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
20
21Except as contained in this notice, the name of The Open Group shall not be
22used in advertising or otherwise to promote the sale, use or other dealings
23in this Software without prior written authorization from The Open Group.
24
25*/
26
27/***********************************************************
28Copyright 1991,1993 by Digital Equipment Corporation, Maynard, Massachusetts,
29and Olivetti Research Limited, Cambridge, England.
30
31 All Rights Reserved
32
33Permission to use, copy, modify, and distribute this software and its
34documentation for any purpose and without fee is hereby granted,
35provided that the above copyright notice appear in all copies and that
36both that copyright notice and this permission notice appear in
37supporting documentation, and that the names of Digital or Olivetti
38not be used in advertising or publicity pertaining to distribution of the
39software without specific, written prior permission.
40
41DIGITAL AND OLIVETTI DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
42SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
43FITNESS, IN NO EVENT SHALL THEY BE LIABLE FOR ANY SPECIAL, INDIRECT OR
44CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
45USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
46OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
47PERFORMANCE OF THIS SOFTWARE.
48
49******************************************************************/
50
51#ifndef _SYNCPROTO_H_
52#define _SYNCPROTO_H_
53
54#include <X11/extensions/syncconst.h>
55
56#define X_SyncInitialize 0
57#define X_SyncListSystemCounters 1
58#define X_SyncCreateCounter 2
59#define X_SyncSetCounter 3
60#define X_SyncChangeCounter 4
61#define X_SyncQueryCounter 5
62#define X_SyncDestroyCounter 6
63#define X_SyncAwait 7
64#define X_SyncCreateAlarm 8
65#define X_SyncChangeAlarm 9
66#define X_SyncQueryAlarm 10
67#define X_SyncDestroyAlarm 11
68#define X_SyncSetPriority 12
69#define X_SyncGetPriority 13
70#define X_SyncCreateFence 14
71#define X_SyncTriggerFence 15
72#define X_SyncResetFence 16
73#define X_SyncDestroyFence 17
74#define X_SyncQueryFence 18
75#define X_SyncAwaitFence 19
76
77/* cover up types from sync.h to make sure they're the right size for
78 * protocol packaging. These will be undef'ed after all the protocol
79 * structures are defined.
80 */
81#define XSyncCounter CARD32
82#define XSyncAlarm CARD32
83#define XSyncFence CARD32
84#define Drawable CARD32
85
86/*
87 * Initialize
88 */
89typedef struct _xSyncInitialize {
90 CARD8 reqType;
91 CARD8 syncReqType;
92 CARD16 length;
93 CARD8 majorVersion;
94 CARD8 minorVersion;
95 CARD16 pad;
96} xSyncInitializeReq;
97#define sz_xSyncInitializeReq 8
98
99typedef struct {
100 BYTE type;
101 CARD8 unused;
102 CARD16 sequenceNumber;
103 CARD32 length;
104 CARD8 majorVersion;
105 CARD8 minorVersion;
106 CARD16 pad;
107 CARD32 pad0;
108 CARD32 pad1;
109 CARD32 pad2;
110 CARD32 pad3;
111 CARD32 pad4;
112} xSyncInitializeReply;
113#define sz_xSyncInitializeReply 32
114
115/*
116 * ListSystemCounters
117 */
118typedef struct _xSyncListSystemCounters
119{
120 CARD8 reqType;
121 CARD8 syncReqType;
122 CARD16 length;
123} xSyncListSystemCountersReq;
124#define sz_xSyncListSystemCountersReq 4
125
126typedef struct {
127 BYTE type;
128 CARD8 unused;
129 CARD16 sequenceNumber;
130 CARD32 length;
131 INT32 nCounters;
132 CARD32 pad0;
133 CARD32 pad1;
134 CARD32 pad2;
135 CARD32 pad3;
136 CARD32 pad4;
137} xSyncListSystemCountersReply;
138#define sz_xSyncListSystemCountersReply 32
139
140typedef struct {
141 XSyncCounter counter;
142 INT32 resolution_hi;
143 CARD32 resolution_lo;
144 CARD16 name_length;
145} xSyncSystemCounter;
146#define sz_xSyncSystemCounter 14
147
148/*
149 * Create Counter
150 */
151typedef struct _xSyncCreateCounterReq {
152 CARD8 reqType;
153 CARD8 syncReqType;
154 CARD16 length;
155 XSyncCounter cid;
156 INT32 initial_value_hi;
157 CARD32 initial_value_lo;
158} xSyncCreateCounterReq;
159#define sz_xSyncCreateCounterReq 16
160
161/*
162 * Change Counter
163 */
164typedef struct _xSyncChangeCounterReq {
165 CARD8 reqType;
166 CARD8 syncReqType;
167 CARD16 length;
168 XSyncCounter cid;
169 INT32 value_hi;
170 CARD32 value_lo;
171} xSyncChangeCounterReq;
172#define sz_xSyncChangeCounterReq 16
173
174/*
175 * Set Counter
176 */
177typedef struct _xSyncSetCounterReq {
178 CARD8 reqType;
179 CARD8 syncReqType;
180 CARD16 length;
181 XSyncCounter cid;
182 INT32 value_hi;
183 CARD32 value_lo;
184} xSyncSetCounterReq;
185#define sz_xSyncSetCounterReq 16
186
187/*
188 * Destroy Counter
189 */
190typedef struct _xSyncDestroyCounterReq {
191 CARD8 reqType;
192 CARD8 syncReqType;
193 CARD16 length;
194 XSyncCounter counter;
195} xSyncDestroyCounterReq;
196#define sz_xSyncDestroyCounterReq 8
197
198/*
199 * Query Counter
200 */
201typedef struct _xSyncQueryCounterReq {
202 CARD8 reqType;
203 CARD8 syncReqType;
204 CARD16 length;
205 XSyncCounter counter;
206} xSyncQueryCounterReq;
207#define sz_xSyncQueryCounterReq 8
208
209
210typedef struct {
211 BYTE type;
212 CARD8 unused;
213 CARD16 sequenceNumber;
214 CARD32 length;
215 INT32 value_hi;
216 CARD32 value_lo;
217 CARD32 pad0;
218 CARD32 pad1;
219 CARD32 pad2;
220 CARD32 pad3;
221} xSyncQueryCounterReply;
222#define sz_xSyncQueryCounterReply 32
223
224/*
225 * Await
226 */
227typedef struct _xSyncAwaitReq {
228 CARD8 reqType;
229 CARD8 syncReqType;
230 CARD16 length;
231} xSyncAwaitReq;
232#define sz_xSyncAwaitReq 4
233
234typedef struct _xSyncWaitCondition {
235 XSyncCounter counter;
236 CARD32 value_type;
237 INT32 wait_value_hi;
238 CARD32 wait_value_lo;
239 CARD32 test_type;
240 INT32 event_threshold_hi;
241 CARD32 event_threshold_lo;
242} xSyncWaitCondition;
243#define sz_xSyncWaitCondition 28
244
245/*
246 * Create Alarm
247 */
248typedef struct _xSyncCreateAlarmReq {
249 CARD8 reqType;
250 CARD8 syncReqType;
251 CARD16 length;
252 XSyncAlarm id;
253 CARD32 valueMask;
254} xSyncCreateAlarmReq;
255#define sz_xSyncCreateAlarmReq 12
256
257/*
258 * Destroy Alarm
259 */
260typedef struct _xSyncDestroyAlarmReq {
261 CARD8 reqType;
262 CARD8 syncReqType;
263 CARD16 length;
264 XSyncAlarm alarm;
265} xSyncDestroyAlarmReq;
266#define sz_xSyncDestroyAlarmReq 8
267
268/*
269 * Query Alarm
270 */
271typedef struct _xSyncQueryAlarmReq {
272 CARD8 reqType;
273 CARD8 syncReqType;
274 CARD16 length;
275 XSyncAlarm alarm;
276} xSyncQueryAlarmReq;
277#define sz_xSyncQueryAlarmReq 8
278
279typedef struct {
280 BYTE type;
281 CARD8 unused;
282 CARD16 sequenceNumber;
283 CARD32 length;
284 XSyncCounter counter;
285 CARD32 value_type;
286 INT32 wait_value_hi;
287 CARD32 wait_value_lo;
288 CARD32 test_type;
289 INT32 delta_hi;
290 CARD32 delta_lo;
291 BOOL events;
292 BYTE state;
293 BYTE pad0;
294 BYTE pad1;
295} xSyncQueryAlarmReply;
296#define sz_xSyncQueryAlarmReply 40
297
298/*
299 * Change Alarm
300 */
301typedef struct _xSyncChangeAlarmReq {
302 CARD8 reqType;
303 CARD8 syncReqType;
304 CARD16 length;
305 XSyncAlarm alarm;
306 CARD32 valueMask;
307} xSyncChangeAlarmReq;
308#define sz_xSyncChangeAlarmReq 12
309
310/*
311 * SetPriority
312 */
313typedef struct _xSyncSetPriority{
314 CARD8 reqType;
315 CARD8 syncReqType;
316 CARD16 length;
317 CARD32 id;
318 INT32 priority;
319} xSyncSetPriorityReq;
320#define sz_xSyncSetPriorityReq 12
321
322/*
323 * Get Priority
324 */
325typedef struct _xSyncGetPriority{
326 CARD8 reqType;
327 CARD8 syncReqType;
328 CARD16 length;
329 CARD32 id; /*XXX XID? */
330} xSyncGetPriorityReq;
331#define sz_xSyncGetPriorityReq 8
332
333typedef struct {
334 BYTE type;
335 CARD8 unused;
336 CARD16 sequenceNumber;
337 CARD32 length;
338 INT32 priority;
339 CARD32 pad0;
340 CARD32 pad1;
341 CARD32 pad2;
342 CARD32 pad3;
343 CARD32 pad4;
344} xSyncGetPriorityReply;
345#define sz_xSyncGetPriorityReply 32
346
347/*
348 * Create Fence
349 */
350typedef struct _xSyncCreateFenceReq {
351 CARD8 reqType;
352 CARD8 syncReqType;
353 CARD16 length;
354 Drawable d;
355 XSyncFence fid;
356 BOOL initially_triggered;
357 CARD8 pad0;
358 CARD16 pad1;
359} xSyncCreateFenceReq;
360#define sz_xSyncCreateFenceReq 16
361
362/*
363 * Put a fence object in the "triggered" state.
364 */
365typedef struct _xSyncTriggerFenceReq {
366 CARD8 reqType;
367 CARD8 syncReqType;
368 CARD16 length;
369 XSyncFence fid;
370} xSyncTriggerFenceReq;
371#define sz_xSyncTriggerFenceReq 8
372
373/*
374 * Put a fence in the "untriggered" state.
375 */
376typedef struct _xSyncResetFenceReq {
377 CARD8 reqType;
378 CARD8 syncReqType;
379 CARD16 length;
380 XSyncFence fid;
381} xSyncResetFenceReq;
382#define sz_xSyncResetFenceReq 8
383
384/*
385 * Destroy a fence object
386 */
387typedef struct _xSyncDestroyFenceReq {
388 CARD8 reqType;
389 CARD8 syncReqType;
390 CARD16 length;
391 XSyncFence fid;
392} xSyncDestroyFenceReq;
393#define sz_xSyncDestroyFenceReq 8
394
395/*
396 * Query a fence object
397 */
398typedef struct _xSyncQueryFenceReq {
399 CARD8 reqType;
400 CARD8 syncReqType;
401 CARD16 length;
402 XSyncFence fid;
403} xSyncQueryFenceReq;
404#define sz_xSyncQueryFenceReq 8
405
406/*
407 * Wait for any of a list of fence sync objects
408 * to reach the "triggered" state.
409 */
410typedef struct _xSyncAwaitFenceReq {
411 CARD8 reqType;
412 CARD8 syncReqType;
413 CARD16 length;
414} xSyncAwaitFenceReq;
415#define sz_xSyncAwaitFenceReq 4
416
417typedef struct {
418 BYTE type;
419 CARD8 unused;
420 CARD16 sequenceNumber;
421 CARD32 length;
422 BOOL triggered;
423 BYTE pad0;
424 CARD16 pad1;
425 CARD32 pad2;
426 CARD32 pad3;
427 CARD32 pad4;
428 CARD32 pad5;
429 CARD32 pad6;
430} xSyncQueryFenceReply;
431#define sz_xSyncQueryFenceReply 32
432
433/*
434 * Events
435 */
436
437typedef struct _xSyncCounterNotifyEvent {
438 BYTE type;
439 BYTE kind;
440 CARD16 sequenceNumber;
441 XSyncCounter counter;
442 INT32 wait_value_hi;
443 CARD32 wait_value_lo;
444 INT32 counter_value_hi;
445 CARD32 counter_value_lo;
446 CARD32 time;
447 CARD16 count;
448 BOOL destroyed;
449 BYTE pad0;
450} xSyncCounterNotifyEvent;
451
452typedef struct _xSyncAlarmNotifyEvent {
453 BYTE type;
454 BYTE kind;
455 CARD16 sequenceNumber;
456 XSyncAlarm alarm;
457 INT32 counter_value_hi;
458 CARD32 counter_value_lo;
459 INT32 alarm_value_hi;
460 CARD32 alarm_value_lo;
461 CARD32 time;
462 CARD8 state;
463 BYTE pad0;
464 BYTE pad1;
465 BYTE pad2;
466} xSyncAlarmNotifyEvent;
467
468#undef XSyncCounter
469#undef XSyncAlarm
470#undef XSyncFence
471#undef Drawable
472
473
474#endif /* _SYNCPROTO_H_ */