1 /*
2 * This file generated automatically from xv.xml by c_client.py.
3 * Edit at your peril.
4 */
5
6 #ifdef HAVE_CONFIG_H
7 #include "config.h"
8 #endif
9 #include <stdlib.h>
10 #include <string.h>
11 #include <assert.h>
12 #include <stddef.h> /* for offsetof() */
13 #include "xcbext.h"
14 #include "xv.h"
15
16 #define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
17 #include "xproto.h"
18 #include "shm.h"
19
20 xcb_extension_t xcb_xv_id = { "XVideo", 0 };
21
22 void
xcb_xv_port_next(xcb_xv_port_iterator_t * i)23 xcb_xv_port_next (xcb_xv_port_iterator_t *i)
24 {
25 --i->rem;
26 ++i->data;
27 i->index += sizeof(xcb_xv_port_t);
28 }
29
30 xcb_generic_iterator_t
xcb_xv_port_end(xcb_xv_port_iterator_t i)31 xcb_xv_port_end (xcb_xv_port_iterator_t i)
32 {
33 xcb_generic_iterator_t ret;
34 ret.data = i.data + i.rem;
35 ret.index = i.index + ((char *) ret.data - (char *) i.data);
36 ret.rem = 0;
37 return ret;
38 }
39
40 void
xcb_xv_encoding_next(xcb_xv_encoding_iterator_t * i)41 xcb_xv_encoding_next (xcb_xv_encoding_iterator_t *i)
42 {
43 --i->rem;
44 ++i->data;
45 i->index += sizeof(xcb_xv_encoding_t);
46 }
47
48 xcb_generic_iterator_t
xcb_xv_encoding_end(xcb_xv_encoding_iterator_t i)49 xcb_xv_encoding_end (xcb_xv_encoding_iterator_t i)
50 {
51 xcb_generic_iterator_t ret;
52 ret.data = i.data + i.rem;
53 ret.index = i.index + ((char *) ret.data - (char *) i.data);
54 ret.rem = 0;
55 return ret;
56 }
57
58 void
xcb_xv_rational_next(xcb_xv_rational_iterator_t * i)59 xcb_xv_rational_next (xcb_xv_rational_iterator_t *i)
60 {
61 --i->rem;
62 ++i->data;
63 i->index += sizeof(xcb_xv_rational_t);
64 }
65
66 xcb_generic_iterator_t
xcb_xv_rational_end(xcb_xv_rational_iterator_t i)67 xcb_xv_rational_end (xcb_xv_rational_iterator_t i)
68 {
69 xcb_generic_iterator_t ret;
70 ret.data = i.data + i.rem;
71 ret.index = i.index + ((char *) ret.data - (char *) i.data);
72 ret.rem = 0;
73 return ret;
74 }
75
76 void
xcb_xv_format_next(xcb_xv_format_iterator_t * i)77 xcb_xv_format_next (xcb_xv_format_iterator_t *i)
78 {
79 --i->rem;
80 ++i->data;
81 i->index += sizeof(xcb_xv_format_t);
82 }
83
84 xcb_generic_iterator_t
xcb_xv_format_end(xcb_xv_format_iterator_t i)85 xcb_xv_format_end (xcb_xv_format_iterator_t i)
86 {
87 xcb_generic_iterator_t ret;
88 ret.data = i.data + i.rem;
89 ret.index = i.index + ((char *) ret.data - (char *) i.data);
90 ret.rem = 0;
91 return ret;
92 }
93
94 int
xcb_xv_adaptor_info_sizeof(const void * _buffer)95 xcb_xv_adaptor_info_sizeof (const void *_buffer)
96 {
97 char *xcb_tmp = (char *)_buffer;
98 const xcb_xv_adaptor_info_t *_aux = (xcb_xv_adaptor_info_t *)_buffer;
99 unsigned int xcb_buffer_len = 0;
100 unsigned int xcb_block_len = 0;
101 unsigned int xcb_pad = 0;
102 unsigned int xcb_align_to = 0;
103
104
105 xcb_block_len += sizeof(xcb_xv_adaptor_info_t);
106 xcb_tmp += xcb_block_len;
107 xcb_buffer_len += xcb_block_len;
108 xcb_block_len = 0;
109 /* name */
110 xcb_block_len += _aux->name_size * sizeof(char);
111 xcb_tmp += xcb_block_len;
112 xcb_align_to = ALIGNOF(char);
113 xcb_align_to = 4;
114 /* insert padding */
115 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
116 xcb_buffer_len += xcb_block_len + xcb_pad;
117 if (0 != xcb_pad) {
118 xcb_tmp += xcb_pad;
119 xcb_pad = 0;
120 }
121 xcb_block_len = 0;
122 /* insert padding */
123 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
124 xcb_buffer_len += xcb_block_len + xcb_pad;
125 if (0 != xcb_pad) {
126 xcb_tmp += xcb_pad;
127 xcb_pad = 0;
128 }
129 xcb_block_len = 0;
130 /* formats */
131 xcb_block_len += _aux->num_formats * sizeof(xcb_xv_format_t);
132 xcb_tmp += xcb_block_len;
133 xcb_align_to = ALIGNOF(xcb_xv_format_t);
134 /* insert padding */
135 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
136 xcb_buffer_len += xcb_block_len + xcb_pad;
137 if (0 != xcb_pad) {
138 xcb_tmp += xcb_pad;
139 xcb_pad = 0;
140 }
141 xcb_block_len = 0;
142
143 return xcb_buffer_len;
144 }
145
146 char *
xcb_xv_adaptor_info_name(const xcb_xv_adaptor_info_t * R)147 xcb_xv_adaptor_info_name (const xcb_xv_adaptor_info_t *R)
148 {
149 return (char *) (R + 1);
150 }
151
152 int
xcb_xv_adaptor_info_name_length(const xcb_xv_adaptor_info_t * R)153 xcb_xv_adaptor_info_name_length (const xcb_xv_adaptor_info_t *R)
154 {
155 return R->name_size;
156 }
157
158 xcb_generic_iterator_t
xcb_xv_adaptor_info_name_end(const xcb_xv_adaptor_info_t * R)159 xcb_xv_adaptor_info_name_end (const xcb_xv_adaptor_info_t *R)
160 {
161 xcb_generic_iterator_t i;
162 i.data = ((char *) (R + 1)) + (R->name_size);
163 i.rem = 0;
164 i.index = (char *) i.data - (char *) R;
165 return i;
166 }
167
168 xcb_xv_format_t *
xcb_xv_adaptor_info_formats(const xcb_xv_adaptor_info_t * R)169 xcb_xv_adaptor_info_formats (const xcb_xv_adaptor_info_t *R)
170 {
171 xcb_generic_iterator_t prev = xcb_xv_adaptor_info_name_end(R);
172 return (xcb_xv_format_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0);
173 }
174
175 int
xcb_xv_adaptor_info_formats_length(const xcb_xv_adaptor_info_t * R)176 xcb_xv_adaptor_info_formats_length (const xcb_xv_adaptor_info_t *R)
177 {
178 return R->num_formats;
179 }
180
181 xcb_xv_format_iterator_t
xcb_xv_adaptor_info_formats_iterator(const xcb_xv_adaptor_info_t * R)182 xcb_xv_adaptor_info_formats_iterator (const xcb_xv_adaptor_info_t *R)
183 {
184 xcb_xv_format_iterator_t i;
185 xcb_generic_iterator_t prev = xcb_xv_adaptor_info_name_end(R);
186 i.data = (xcb_xv_format_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)));
187 i.rem = R->num_formats;
188 i.index = (char *) i.data - (char *) R;
189 return i;
190 }
191
192 void
xcb_xv_adaptor_info_next(xcb_xv_adaptor_info_iterator_t * i)193 xcb_xv_adaptor_info_next (xcb_xv_adaptor_info_iterator_t *i)
194 {
195 xcb_xv_adaptor_info_t *R = i->data;
196 xcb_generic_iterator_t child;
197 child.data = (xcb_xv_adaptor_info_t *)(((char *)R) + xcb_xv_adaptor_info_sizeof(R));
198 i->index = (char *) child.data - (char *) i->data;
199 --i->rem;
200 i->data = (xcb_xv_adaptor_info_t *) child.data;
201 }
202
203 xcb_generic_iterator_t
xcb_xv_adaptor_info_end(xcb_xv_adaptor_info_iterator_t i)204 xcb_xv_adaptor_info_end (xcb_xv_adaptor_info_iterator_t i)
205 {
206 xcb_generic_iterator_t ret;
207 while(i.rem > 0)
208 xcb_xv_adaptor_info_next(&i);
209 ret.data = i.data;
210 ret.rem = i.rem;
211 ret.index = i.index;
212 return ret;
213 }
214
215 int
xcb_xv_encoding_info_sizeof(const void * _buffer)216 xcb_xv_encoding_info_sizeof (const void *_buffer)
217 {
218 char *xcb_tmp = (char *)_buffer;
219 const xcb_xv_encoding_info_t *_aux = (xcb_xv_encoding_info_t *)_buffer;
220 unsigned int xcb_buffer_len = 0;
221 unsigned int xcb_block_len = 0;
222 unsigned int xcb_pad = 0;
223 unsigned int xcb_align_to = 0;
224
225
226 xcb_block_len += sizeof(xcb_xv_encoding_info_t);
227 xcb_tmp += xcb_block_len;
228 xcb_buffer_len += xcb_block_len;
229 xcb_block_len = 0;
230 /* name */
231 xcb_block_len += _aux->name_size * sizeof(char);
232 xcb_tmp += xcb_block_len;
233 xcb_align_to = ALIGNOF(char);
234 xcb_align_to = 4;
235 /* insert padding */
236 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
237 xcb_buffer_len += xcb_block_len + xcb_pad;
238 if (0 != xcb_pad) {
239 xcb_tmp += xcb_pad;
240 xcb_pad = 0;
241 }
242 xcb_block_len = 0;
243 /* insert padding */
244 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
245 xcb_buffer_len += xcb_block_len + xcb_pad;
246 if (0 != xcb_pad) {
247 xcb_tmp += xcb_pad;
248 xcb_pad = 0;
249 }
250 xcb_block_len = 0;
251
252 return xcb_buffer_len;
253 }
254
255 char *
xcb_xv_encoding_info_name(const xcb_xv_encoding_info_t * R)256 xcb_xv_encoding_info_name (const xcb_xv_encoding_info_t *R)
257 {
258 return (char *) (R + 1);
259 }
260
261 int
xcb_xv_encoding_info_name_length(const xcb_xv_encoding_info_t * R)262 xcb_xv_encoding_info_name_length (const xcb_xv_encoding_info_t *R)
263 {
264 return R->name_size;
265 }
266
267 xcb_generic_iterator_t
xcb_xv_encoding_info_name_end(const xcb_xv_encoding_info_t * R)268 xcb_xv_encoding_info_name_end (const xcb_xv_encoding_info_t *R)
269 {
270 xcb_generic_iterator_t i;
271 i.data = ((char *) (R + 1)) + (R->name_size);
272 i.rem = 0;
273 i.index = (char *) i.data - (char *) R;
274 return i;
275 }
276
277 void
xcb_xv_encoding_info_next(xcb_xv_encoding_info_iterator_t * i)278 xcb_xv_encoding_info_next (xcb_xv_encoding_info_iterator_t *i)
279 {
280 xcb_xv_encoding_info_t *R = i->data;
281 xcb_generic_iterator_t child;
282 child.data = (xcb_xv_encoding_info_t *)(((char *)R) + xcb_xv_encoding_info_sizeof(R));
283 i->index = (char *) child.data - (char *) i->data;
284 --i->rem;
285 i->data = (xcb_xv_encoding_info_t *) child.data;
286 }
287
288 xcb_generic_iterator_t
xcb_xv_encoding_info_end(xcb_xv_encoding_info_iterator_t i)289 xcb_xv_encoding_info_end (xcb_xv_encoding_info_iterator_t i)
290 {
291 xcb_generic_iterator_t ret;
292 while(i.rem > 0)
293 xcb_xv_encoding_info_next(&i);
294 ret.data = i.data;
295 ret.rem = i.rem;
296 ret.index = i.index;
297 return ret;
298 }
299
300 int
xcb_xv_image_sizeof(const void * _buffer)301 xcb_xv_image_sizeof (const void *_buffer)
302 {
303 char *xcb_tmp = (char *)_buffer;
304 const xcb_xv_image_t *_aux = (xcb_xv_image_t *)_buffer;
305 unsigned int xcb_buffer_len = 0;
306 unsigned int xcb_block_len = 0;
307 unsigned int xcb_pad = 0;
308 unsigned int xcb_align_to = 0;
309
310
311 xcb_block_len += sizeof(xcb_xv_image_t);
312 xcb_tmp += xcb_block_len;
313 xcb_buffer_len += xcb_block_len;
314 xcb_block_len = 0;
315 /* pitches */
316 xcb_block_len += _aux->num_planes * sizeof(uint32_t);
317 xcb_tmp += xcb_block_len;
318 xcb_align_to = ALIGNOF(uint32_t);
319 /* insert padding */
320 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
321 xcb_buffer_len += xcb_block_len + xcb_pad;
322 if (0 != xcb_pad) {
323 xcb_tmp += xcb_pad;
324 xcb_pad = 0;
325 }
326 xcb_block_len = 0;
327 /* offsets */
328 xcb_block_len += _aux->num_planes * sizeof(uint32_t);
329 xcb_tmp += xcb_block_len;
330 xcb_align_to = ALIGNOF(uint32_t);
331 /* insert padding */
332 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
333 xcb_buffer_len += xcb_block_len + xcb_pad;
334 if (0 != xcb_pad) {
335 xcb_tmp += xcb_pad;
336 xcb_pad = 0;
337 }
338 xcb_block_len = 0;
339 /* data */
340 xcb_block_len += _aux->data_size * sizeof(uint8_t);
341 xcb_tmp += xcb_block_len;
342 xcb_align_to = ALIGNOF(uint8_t);
343 /* insert padding */
344 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
345 xcb_buffer_len += xcb_block_len + xcb_pad;
346 if (0 != xcb_pad) {
347 xcb_tmp += xcb_pad;
348 xcb_pad = 0;
349 }
350 xcb_block_len = 0;
351
352 return xcb_buffer_len;
353 }
354
355 uint32_t *
xcb_xv_image_pitches(const xcb_xv_image_t * R)356 xcb_xv_image_pitches (const xcb_xv_image_t *R)
357 {
358 return (uint32_t *) (R + 1);
359 }
360
361 int
xcb_xv_image_pitches_length(const xcb_xv_image_t * R)362 xcb_xv_image_pitches_length (const xcb_xv_image_t *R)
363 {
364 return R->num_planes;
365 }
366
367 xcb_generic_iterator_t
xcb_xv_image_pitches_end(const xcb_xv_image_t * R)368 xcb_xv_image_pitches_end (const xcb_xv_image_t *R)
369 {
370 xcb_generic_iterator_t i;
371 i.data = ((uint32_t *) (R + 1)) + (R->num_planes);
372 i.rem = 0;
373 i.index = (char *) i.data - (char *) R;
374 return i;
375 }
376
377 uint32_t *
xcb_xv_image_offsets(const xcb_xv_image_t * R)378 xcb_xv_image_offsets (const xcb_xv_image_t *R)
379 {
380 xcb_generic_iterator_t prev = xcb_xv_image_pitches_end(R);
381 return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
382 }
383
384 int
xcb_xv_image_offsets_length(const xcb_xv_image_t * R)385 xcb_xv_image_offsets_length (const xcb_xv_image_t *R)
386 {
387 return R->num_planes;
388 }
389
390 xcb_generic_iterator_t
xcb_xv_image_offsets_end(const xcb_xv_image_t * R)391 xcb_xv_image_offsets_end (const xcb_xv_image_t *R)
392 {
393 xcb_generic_iterator_t i;
394 xcb_generic_iterator_t prev = xcb_xv_image_pitches_end(R);
395 i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->num_planes);
396 i.rem = 0;
397 i.index = (char *) i.data - (char *) R;
398 return i;
399 }
400
401 uint8_t *
xcb_xv_image_data(const xcb_xv_image_t * R)402 xcb_xv_image_data (const xcb_xv_image_t *R)
403 {
404 xcb_generic_iterator_t prev = xcb_xv_image_offsets_end(R);
405 return (uint8_t *) ((char *) prev.data + XCB_TYPE_PAD(uint8_t, prev.index) + 0);
406 }
407
408 int
xcb_xv_image_data_length(const xcb_xv_image_t * R)409 xcb_xv_image_data_length (const xcb_xv_image_t *R)
410 {
411 return R->data_size;
412 }
413
414 xcb_generic_iterator_t
xcb_xv_image_data_end(const xcb_xv_image_t * R)415 xcb_xv_image_data_end (const xcb_xv_image_t *R)
416 {
417 xcb_generic_iterator_t i;
418 xcb_generic_iterator_t prev = xcb_xv_image_offsets_end(R);
419 i.data = ((uint8_t *) ((char*) prev.data + XCB_TYPE_PAD(uint8_t, prev.index))) + (R->data_size);
420 i.rem = 0;
421 i.index = (char *) i.data - (char *) R;
422 return i;
423 }
424
425 void
xcb_xv_image_next(xcb_xv_image_iterator_t * i)426 xcb_xv_image_next (xcb_xv_image_iterator_t *i)
427 {
428 xcb_xv_image_t *R = i->data;
429 xcb_generic_iterator_t child;
430 child.data = (xcb_xv_image_t *)(((char *)R) + xcb_xv_image_sizeof(R));
431 i->index = (char *) child.data - (char *) i->data;
432 --i->rem;
433 i->data = (xcb_xv_image_t *) child.data;
434 }
435
436 xcb_generic_iterator_t
xcb_xv_image_end(xcb_xv_image_iterator_t i)437 xcb_xv_image_end (xcb_xv_image_iterator_t i)
438 {
439 xcb_generic_iterator_t ret;
440 while(i.rem > 0)
441 xcb_xv_image_next(&i);
442 ret.data = i.data;
443 ret.rem = i.rem;
444 ret.index = i.index;
445 return ret;
446 }
447
448 int
xcb_xv_attribute_info_sizeof(const void * _buffer)449 xcb_xv_attribute_info_sizeof (const void *_buffer)
450 {
451 char *xcb_tmp = (char *)_buffer;
452 const xcb_xv_attribute_info_t *_aux = (xcb_xv_attribute_info_t *)_buffer;
453 unsigned int xcb_buffer_len = 0;
454 unsigned int xcb_block_len = 0;
455 unsigned int xcb_pad = 0;
456 unsigned int xcb_align_to = 0;
457
458
459 xcb_block_len += sizeof(xcb_xv_attribute_info_t);
460 xcb_tmp += xcb_block_len;
461 xcb_buffer_len += xcb_block_len;
462 xcb_block_len = 0;
463 /* name */
464 xcb_block_len += _aux->size * sizeof(char);
465 xcb_tmp += xcb_block_len;
466 xcb_align_to = ALIGNOF(char);
467 xcb_align_to = 4;
468 /* insert padding */
469 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
470 xcb_buffer_len += xcb_block_len + xcb_pad;
471 if (0 != xcb_pad) {
472 xcb_tmp += xcb_pad;
473 xcb_pad = 0;
474 }
475 xcb_block_len = 0;
476 /* insert padding */
477 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
478 xcb_buffer_len += xcb_block_len + xcb_pad;
479 if (0 != xcb_pad) {
480 xcb_tmp += xcb_pad;
481 xcb_pad = 0;
482 }
483 xcb_block_len = 0;
484
485 return xcb_buffer_len;
486 }
487
488 char *
xcb_xv_attribute_info_name(const xcb_xv_attribute_info_t * R)489 xcb_xv_attribute_info_name (const xcb_xv_attribute_info_t *R)
490 {
491 return (char *) (R + 1);
492 }
493
494 int
xcb_xv_attribute_info_name_length(const xcb_xv_attribute_info_t * R)495 xcb_xv_attribute_info_name_length (const xcb_xv_attribute_info_t *R)
496 {
497 return R->size;
498 }
499
500 xcb_generic_iterator_t
xcb_xv_attribute_info_name_end(const xcb_xv_attribute_info_t * R)501 xcb_xv_attribute_info_name_end (const xcb_xv_attribute_info_t *R)
502 {
503 xcb_generic_iterator_t i;
504 i.data = ((char *) (R + 1)) + (R->size);
505 i.rem = 0;
506 i.index = (char *) i.data - (char *) R;
507 return i;
508 }
509
510 void
xcb_xv_attribute_info_next(xcb_xv_attribute_info_iterator_t * i)511 xcb_xv_attribute_info_next (xcb_xv_attribute_info_iterator_t *i)
512 {
513 xcb_xv_attribute_info_t *R = i->data;
514 xcb_generic_iterator_t child;
515 child.data = (xcb_xv_attribute_info_t *)(((char *)R) + xcb_xv_attribute_info_sizeof(R));
516 i->index = (char *) child.data - (char *) i->data;
517 --i->rem;
518 i->data = (xcb_xv_attribute_info_t *) child.data;
519 }
520
521 xcb_generic_iterator_t
xcb_xv_attribute_info_end(xcb_xv_attribute_info_iterator_t i)522 xcb_xv_attribute_info_end (xcb_xv_attribute_info_iterator_t i)
523 {
524 xcb_generic_iterator_t ret;
525 while(i.rem > 0)
526 xcb_xv_attribute_info_next(&i);
527 ret.data = i.data;
528 ret.rem = i.rem;
529 ret.index = i.index;
530 return ret;
531 }
532
533 void
xcb_xv_image_format_info_next(xcb_xv_image_format_info_iterator_t * i)534 xcb_xv_image_format_info_next (xcb_xv_image_format_info_iterator_t *i)
535 {
536 --i->rem;
537 ++i->data;
538 i->index += sizeof(xcb_xv_image_format_info_t);
539 }
540
541 xcb_generic_iterator_t
xcb_xv_image_format_info_end(xcb_xv_image_format_info_iterator_t i)542 xcb_xv_image_format_info_end (xcb_xv_image_format_info_iterator_t i)
543 {
544 xcb_generic_iterator_t ret;
545 ret.data = i.data + i.rem;
546 ret.index = i.index + ((char *) ret.data - (char *) i.data);
547 ret.rem = 0;
548 return ret;
549 }
550
551 xcb_xv_query_extension_cookie_t
xcb_xv_query_extension(xcb_connection_t * c)552 xcb_xv_query_extension (xcb_connection_t *c)
553 {
554 static const xcb_protocol_request_t xcb_req = {
555 .count = 2,
556 .ext = &xcb_xv_id,
557 .opcode = XCB_XV_QUERY_EXTENSION,
558 .isvoid = 0
559 };
560
561 struct iovec xcb_parts[4];
562 xcb_xv_query_extension_cookie_t xcb_ret;
563 xcb_xv_query_extension_request_t xcb_out;
564
565
566 xcb_parts[2].iov_base = (char *) &xcb_out;
567 xcb_parts[2].iov_len = sizeof(xcb_out);
568 xcb_parts[3].iov_base = 0;
569 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
570
571 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
572 return xcb_ret;
573 }
574
575 xcb_xv_query_extension_cookie_t
xcb_xv_query_extension_unchecked(xcb_connection_t * c)576 xcb_xv_query_extension_unchecked (xcb_connection_t *c)
577 {
578 static const xcb_protocol_request_t xcb_req = {
579 .count = 2,
580 .ext = &xcb_xv_id,
581 .opcode = XCB_XV_QUERY_EXTENSION,
582 .isvoid = 0
583 };
584
585 struct iovec xcb_parts[4];
586 xcb_xv_query_extension_cookie_t xcb_ret;
587 xcb_xv_query_extension_request_t xcb_out;
588
589
590 xcb_parts[2].iov_base = (char *) &xcb_out;
591 xcb_parts[2].iov_len = sizeof(xcb_out);
592 xcb_parts[3].iov_base = 0;
593 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
594
595 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
596 return xcb_ret;
597 }
598
599 xcb_xv_query_extension_reply_t *
xcb_xv_query_extension_reply(xcb_connection_t * c,xcb_xv_query_extension_cookie_t cookie,xcb_generic_error_t ** e)600 xcb_xv_query_extension_reply (xcb_connection_t *c,
601 xcb_xv_query_extension_cookie_t cookie /**< */,
602 xcb_generic_error_t **e)
603 {
604 return (xcb_xv_query_extension_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
605 }
606
607 int
xcb_xv_query_adaptors_sizeof(const void * _buffer)608 xcb_xv_query_adaptors_sizeof (const void *_buffer)
609 {
610 char *xcb_tmp = (char *)_buffer;
611 const xcb_xv_query_adaptors_reply_t *_aux = (xcb_xv_query_adaptors_reply_t *)_buffer;
612 unsigned int xcb_buffer_len = 0;
613 unsigned int xcb_block_len = 0;
614 unsigned int xcb_pad = 0;
615 unsigned int xcb_align_to = 0;
616
617 unsigned int i;
618 unsigned int xcb_tmp_len;
619
620 xcb_block_len += sizeof(xcb_xv_query_adaptors_reply_t);
621 xcb_tmp += xcb_block_len;
622 xcb_buffer_len += xcb_block_len;
623 xcb_block_len = 0;
624 /* info */
625 for(i=0; i<_aux->num_adaptors; i++) {
626 xcb_tmp_len = xcb_xv_adaptor_info_sizeof(xcb_tmp);
627 xcb_block_len += xcb_tmp_len;
628 xcb_tmp += xcb_tmp_len;
629 }
630 xcb_align_to = ALIGNOF(xcb_xv_adaptor_info_t);
631 /* insert padding */
632 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
633 xcb_buffer_len += xcb_block_len + xcb_pad;
634 if (0 != xcb_pad) {
635 xcb_tmp += xcb_pad;
636 xcb_pad = 0;
637 }
638 xcb_block_len = 0;
639
640 return xcb_buffer_len;
641 }
642
643 xcb_xv_query_adaptors_cookie_t
xcb_xv_query_adaptors(xcb_connection_t * c,xcb_window_t window)644 xcb_xv_query_adaptors (xcb_connection_t *c,
645 xcb_window_t window)
646 {
647 static const xcb_protocol_request_t xcb_req = {
648 .count = 2,
649 .ext = &xcb_xv_id,
650 .opcode = XCB_XV_QUERY_ADAPTORS,
651 .isvoid = 0
652 };
653
654 struct iovec xcb_parts[4];
655 xcb_xv_query_adaptors_cookie_t xcb_ret;
656 xcb_xv_query_adaptors_request_t xcb_out;
657
658 xcb_out.window = window;
659
660 xcb_parts[2].iov_base = (char *) &xcb_out;
661 xcb_parts[2].iov_len = sizeof(xcb_out);
662 xcb_parts[3].iov_base = 0;
663 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
664
665 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
666 return xcb_ret;
667 }
668
669 xcb_xv_query_adaptors_cookie_t
xcb_xv_query_adaptors_unchecked(xcb_connection_t * c,xcb_window_t window)670 xcb_xv_query_adaptors_unchecked (xcb_connection_t *c,
671 xcb_window_t window)
672 {
673 static const xcb_protocol_request_t xcb_req = {
674 .count = 2,
675 .ext = &xcb_xv_id,
676 .opcode = XCB_XV_QUERY_ADAPTORS,
677 .isvoid = 0
678 };
679
680 struct iovec xcb_parts[4];
681 xcb_xv_query_adaptors_cookie_t xcb_ret;
682 xcb_xv_query_adaptors_request_t xcb_out;
683
684 xcb_out.window = window;
685
686 xcb_parts[2].iov_base = (char *) &xcb_out;
687 xcb_parts[2].iov_len = sizeof(xcb_out);
688 xcb_parts[3].iov_base = 0;
689 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
690
691 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
692 return xcb_ret;
693 }
694
695 int
xcb_xv_query_adaptors_info_length(const xcb_xv_query_adaptors_reply_t * R)696 xcb_xv_query_adaptors_info_length (const xcb_xv_query_adaptors_reply_t *R)
697 {
698 return R->num_adaptors;
699 }
700
701 xcb_xv_adaptor_info_iterator_t
xcb_xv_query_adaptors_info_iterator(const xcb_xv_query_adaptors_reply_t * R)702 xcb_xv_query_adaptors_info_iterator (const xcb_xv_query_adaptors_reply_t *R)
703 {
704 xcb_xv_adaptor_info_iterator_t i;
705 i.data = (xcb_xv_adaptor_info_t *) (R + 1);
706 i.rem = R->num_adaptors;
707 i.index = (char *) i.data - (char *) R;
708 return i;
709 }
710
711 xcb_xv_query_adaptors_reply_t *
xcb_xv_query_adaptors_reply(xcb_connection_t * c,xcb_xv_query_adaptors_cookie_t cookie,xcb_generic_error_t ** e)712 xcb_xv_query_adaptors_reply (xcb_connection_t *c,
713 xcb_xv_query_adaptors_cookie_t cookie /**< */,
714 xcb_generic_error_t **e)
715 {
716 return (xcb_xv_query_adaptors_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
717 }
718
719 int
xcb_xv_query_encodings_sizeof(const void * _buffer)720 xcb_xv_query_encodings_sizeof (const void *_buffer)
721 {
722 char *xcb_tmp = (char *)_buffer;
723 const xcb_xv_query_encodings_reply_t *_aux = (xcb_xv_query_encodings_reply_t *)_buffer;
724 unsigned int xcb_buffer_len = 0;
725 unsigned int xcb_block_len = 0;
726 unsigned int xcb_pad = 0;
727 unsigned int xcb_align_to = 0;
728
729 unsigned int i;
730 unsigned int xcb_tmp_len;
731
732 xcb_block_len += sizeof(xcb_xv_query_encodings_reply_t);
733 xcb_tmp += xcb_block_len;
734 xcb_buffer_len += xcb_block_len;
735 xcb_block_len = 0;
736 /* info */
737 for(i=0; i<_aux->num_encodings; i++) {
738 xcb_tmp_len = xcb_xv_encoding_info_sizeof(xcb_tmp);
739 xcb_block_len += xcb_tmp_len;
740 xcb_tmp += xcb_tmp_len;
741 }
742 xcb_align_to = ALIGNOF(xcb_xv_encoding_info_t);
743 /* insert padding */
744 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
745 xcb_buffer_len += xcb_block_len + xcb_pad;
746 if (0 != xcb_pad) {
747 xcb_tmp += xcb_pad;
748 xcb_pad = 0;
749 }
750 xcb_block_len = 0;
751
752 return xcb_buffer_len;
753 }
754
755 xcb_xv_query_encodings_cookie_t
xcb_xv_query_encodings(xcb_connection_t * c,xcb_xv_port_t port)756 xcb_xv_query_encodings (xcb_connection_t *c,
757 xcb_xv_port_t port)
758 {
759 static const xcb_protocol_request_t xcb_req = {
760 .count = 2,
761 .ext = &xcb_xv_id,
762 .opcode = XCB_XV_QUERY_ENCODINGS,
763 .isvoid = 0
764 };
765
766 struct iovec xcb_parts[4];
767 xcb_xv_query_encodings_cookie_t xcb_ret;
768 xcb_xv_query_encodings_request_t xcb_out;
769
770 xcb_out.port = port;
771
772 xcb_parts[2].iov_base = (char *) &xcb_out;
773 xcb_parts[2].iov_len = sizeof(xcb_out);
774 xcb_parts[3].iov_base = 0;
775 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
776
777 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
778 return xcb_ret;
779 }
780
781 xcb_xv_query_encodings_cookie_t
xcb_xv_query_encodings_unchecked(xcb_connection_t * c,xcb_xv_port_t port)782 xcb_xv_query_encodings_unchecked (xcb_connection_t *c,
783 xcb_xv_port_t port)
784 {
785 static const xcb_protocol_request_t xcb_req = {
786 .count = 2,
787 .ext = &xcb_xv_id,
788 .opcode = XCB_XV_QUERY_ENCODINGS,
789 .isvoid = 0
790 };
791
792 struct iovec xcb_parts[4];
793 xcb_xv_query_encodings_cookie_t xcb_ret;
794 xcb_xv_query_encodings_request_t xcb_out;
795
796 xcb_out.port = port;
797
798 xcb_parts[2].iov_base = (char *) &xcb_out;
799 xcb_parts[2].iov_len = sizeof(xcb_out);
800 xcb_parts[3].iov_base = 0;
801 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
802
803 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
804 return xcb_ret;
805 }
806
807 int
xcb_xv_query_encodings_info_length(const xcb_xv_query_encodings_reply_t * R)808 xcb_xv_query_encodings_info_length (const xcb_xv_query_encodings_reply_t *R)
809 {
810 return R->num_encodings;
811 }
812
813 xcb_xv_encoding_info_iterator_t
xcb_xv_query_encodings_info_iterator(const xcb_xv_query_encodings_reply_t * R)814 xcb_xv_query_encodings_info_iterator (const xcb_xv_query_encodings_reply_t *R)
815 {
816 xcb_xv_encoding_info_iterator_t i;
817 i.data = (xcb_xv_encoding_info_t *) (R + 1);
818 i.rem = R->num_encodings;
819 i.index = (char *) i.data - (char *) R;
820 return i;
821 }
822
823 xcb_xv_query_encodings_reply_t *
xcb_xv_query_encodings_reply(xcb_connection_t * c,xcb_xv_query_encodings_cookie_t cookie,xcb_generic_error_t ** e)824 xcb_xv_query_encodings_reply (xcb_connection_t *c,
825 xcb_xv_query_encodings_cookie_t cookie /**< */,
826 xcb_generic_error_t **e)
827 {
828 return (xcb_xv_query_encodings_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
829 }
830
831 xcb_xv_grab_port_cookie_t
xcb_xv_grab_port(xcb_connection_t * c,xcb_xv_port_t port,xcb_timestamp_t time)832 xcb_xv_grab_port (xcb_connection_t *c,
833 xcb_xv_port_t port,
834 xcb_timestamp_t time)
835 {
836 static const xcb_protocol_request_t xcb_req = {
837 .count = 2,
838 .ext = &xcb_xv_id,
839 .opcode = XCB_XV_GRAB_PORT,
840 .isvoid = 0
841 };
842
843 struct iovec xcb_parts[4];
844 xcb_xv_grab_port_cookie_t xcb_ret;
845 xcb_xv_grab_port_request_t xcb_out;
846
847 xcb_out.port = port;
848 xcb_out.time = time;
849
850 xcb_parts[2].iov_base = (char *) &xcb_out;
851 xcb_parts[2].iov_len = sizeof(xcb_out);
852 xcb_parts[3].iov_base = 0;
853 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
854
855 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
856 return xcb_ret;
857 }
858
859 xcb_xv_grab_port_cookie_t
xcb_xv_grab_port_unchecked(xcb_connection_t * c,xcb_xv_port_t port,xcb_timestamp_t time)860 xcb_xv_grab_port_unchecked (xcb_connection_t *c,
861 xcb_xv_port_t port,
862 xcb_timestamp_t time)
863 {
864 static const xcb_protocol_request_t xcb_req = {
865 .count = 2,
866 .ext = &xcb_xv_id,
867 .opcode = XCB_XV_GRAB_PORT,
868 .isvoid = 0
869 };
870
871 struct iovec xcb_parts[4];
872 xcb_xv_grab_port_cookie_t xcb_ret;
873 xcb_xv_grab_port_request_t xcb_out;
874
875 xcb_out.port = port;
876 xcb_out.time = time;
877
878 xcb_parts[2].iov_base = (char *) &xcb_out;
879 xcb_parts[2].iov_len = sizeof(xcb_out);
880 xcb_parts[3].iov_base = 0;
881 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
882
883 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
884 return xcb_ret;
885 }
886
887 xcb_xv_grab_port_reply_t *
xcb_xv_grab_port_reply(xcb_connection_t * c,xcb_xv_grab_port_cookie_t cookie,xcb_generic_error_t ** e)888 xcb_xv_grab_port_reply (xcb_connection_t *c,
889 xcb_xv_grab_port_cookie_t cookie /**< */,
890 xcb_generic_error_t **e)
891 {
892 return (xcb_xv_grab_port_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
893 }
894
895 xcb_void_cookie_t
xcb_xv_ungrab_port_checked(xcb_connection_t * c,xcb_xv_port_t port,xcb_timestamp_t time)896 xcb_xv_ungrab_port_checked (xcb_connection_t *c,
897 xcb_xv_port_t port,
898 xcb_timestamp_t time)
899 {
900 static const xcb_protocol_request_t xcb_req = {
901 .count = 2,
902 .ext = &xcb_xv_id,
903 .opcode = XCB_XV_UNGRAB_PORT,
904 .isvoid = 1
905 };
906
907 struct iovec xcb_parts[4];
908 xcb_void_cookie_t xcb_ret;
909 xcb_xv_ungrab_port_request_t xcb_out;
910
911 xcb_out.port = port;
912 xcb_out.time = time;
913
914 xcb_parts[2].iov_base = (char *) &xcb_out;
915 xcb_parts[2].iov_len = sizeof(xcb_out);
916 xcb_parts[3].iov_base = 0;
917 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
918
919 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
920 return xcb_ret;
921 }
922
923 xcb_void_cookie_t
xcb_xv_ungrab_port(xcb_connection_t * c,xcb_xv_port_t port,xcb_timestamp_t time)924 xcb_xv_ungrab_port (xcb_connection_t *c,
925 xcb_xv_port_t port,
926 xcb_timestamp_t time)
927 {
928 static const xcb_protocol_request_t xcb_req = {
929 .count = 2,
930 .ext = &xcb_xv_id,
931 .opcode = XCB_XV_UNGRAB_PORT,
932 .isvoid = 1
933 };
934
935 struct iovec xcb_parts[4];
936 xcb_void_cookie_t xcb_ret;
937 xcb_xv_ungrab_port_request_t xcb_out;
938
939 xcb_out.port = port;
940 xcb_out.time = time;
941
942 xcb_parts[2].iov_base = (char *) &xcb_out;
943 xcb_parts[2].iov_len = sizeof(xcb_out);
944 xcb_parts[3].iov_base = 0;
945 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
946
947 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
948 return xcb_ret;
949 }
950
951 xcb_void_cookie_t
xcb_xv_put_video_checked(xcb_connection_t * c,xcb_xv_port_t port,xcb_drawable_t drawable,xcb_gcontext_t gc,int16_t vid_x,int16_t vid_y,uint16_t vid_w,uint16_t vid_h,int16_t drw_x,int16_t drw_y,uint16_t drw_w,uint16_t drw_h)952 xcb_xv_put_video_checked (xcb_connection_t *c,
953 xcb_xv_port_t port,
954 xcb_drawable_t drawable,
955 xcb_gcontext_t gc,
956 int16_t vid_x,
957 int16_t vid_y,
958 uint16_t vid_w,
959 uint16_t vid_h,
960 int16_t drw_x,
961 int16_t drw_y,
962 uint16_t drw_w,
963 uint16_t drw_h)
964 {
965 static const xcb_protocol_request_t xcb_req = {
966 .count = 2,
967 .ext = &xcb_xv_id,
968 .opcode = XCB_XV_PUT_VIDEO,
969 .isvoid = 1
970 };
971
972 struct iovec xcb_parts[4];
973 xcb_void_cookie_t xcb_ret;
974 xcb_xv_put_video_request_t xcb_out;
975
976 xcb_out.port = port;
977 xcb_out.drawable = drawable;
978 xcb_out.gc = gc;
979 xcb_out.vid_x = vid_x;
980 xcb_out.vid_y = vid_y;
981 xcb_out.vid_w = vid_w;
982 xcb_out.vid_h = vid_h;
983 xcb_out.drw_x = drw_x;
984 xcb_out.drw_y = drw_y;
985 xcb_out.drw_w = drw_w;
986 xcb_out.drw_h = drw_h;
987
988 xcb_parts[2].iov_base = (char *) &xcb_out;
989 xcb_parts[2].iov_len = sizeof(xcb_out);
990 xcb_parts[3].iov_base = 0;
991 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
992
993 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
994 return xcb_ret;
995 }
996
997 xcb_void_cookie_t
xcb_xv_put_video(xcb_connection_t * c,xcb_xv_port_t port,xcb_drawable_t drawable,xcb_gcontext_t gc,int16_t vid_x,int16_t vid_y,uint16_t vid_w,uint16_t vid_h,int16_t drw_x,int16_t drw_y,uint16_t drw_w,uint16_t drw_h)998 xcb_xv_put_video (xcb_connection_t *c,
999 xcb_xv_port_t port,
1000 xcb_drawable_t drawable,
1001 xcb_gcontext_t gc,
1002 int16_t vid_x,
1003 int16_t vid_y,
1004 uint16_t vid_w,
1005 uint16_t vid_h,
1006 int16_t drw_x,
1007 int16_t drw_y,
1008 uint16_t drw_w,
1009 uint16_t drw_h)
1010 {
1011 static const xcb_protocol_request_t xcb_req = {
1012 .count = 2,
1013 .ext = &xcb_xv_id,
1014 .opcode = XCB_XV_PUT_VIDEO,
1015 .isvoid = 1
1016 };
1017
1018 struct iovec xcb_parts[4];
1019 xcb_void_cookie_t xcb_ret;
1020 xcb_xv_put_video_request_t xcb_out;
1021
1022 xcb_out.port = port;
1023 xcb_out.drawable = drawable;
1024 xcb_out.gc = gc;
1025 xcb_out.vid_x = vid_x;
1026 xcb_out.vid_y = vid_y;
1027 xcb_out.vid_w = vid_w;
1028 xcb_out.vid_h = vid_h;
1029 xcb_out.drw_x = drw_x;
1030 xcb_out.drw_y = drw_y;
1031 xcb_out.drw_w = drw_w;
1032 xcb_out.drw_h = drw_h;
1033
1034 xcb_parts[2].iov_base = (char *) &xcb_out;
1035 xcb_parts[2].iov_len = sizeof(xcb_out);
1036 xcb_parts[3].iov_base = 0;
1037 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1038
1039 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1040 return xcb_ret;
1041 }
1042
1043 xcb_void_cookie_t
xcb_xv_put_still_checked(xcb_connection_t * c,xcb_xv_port_t port,xcb_drawable_t drawable,xcb_gcontext_t gc,int16_t vid_x,int16_t vid_y,uint16_t vid_w,uint16_t vid_h,int16_t drw_x,int16_t drw_y,uint16_t drw_w,uint16_t drw_h)1044 xcb_xv_put_still_checked (xcb_connection_t *c,
1045 xcb_xv_port_t port,
1046 xcb_drawable_t drawable,
1047 xcb_gcontext_t gc,
1048 int16_t vid_x,
1049 int16_t vid_y,
1050 uint16_t vid_w,
1051 uint16_t vid_h,
1052 int16_t drw_x,
1053 int16_t drw_y,
1054 uint16_t drw_w,
1055 uint16_t drw_h)
1056 {
1057 static const xcb_protocol_request_t xcb_req = {
1058 .count = 2,
1059 .ext = &xcb_xv_id,
1060 .opcode = XCB_XV_PUT_STILL,
1061 .isvoid = 1
1062 };
1063
1064 struct iovec xcb_parts[4];
1065 xcb_void_cookie_t xcb_ret;
1066 xcb_xv_put_still_request_t xcb_out;
1067
1068 xcb_out.port = port;
1069 xcb_out.drawable = drawable;
1070 xcb_out.gc = gc;
1071 xcb_out.vid_x = vid_x;
1072 xcb_out.vid_y = vid_y;
1073 xcb_out.vid_w = vid_w;
1074 xcb_out.vid_h = vid_h;
1075 xcb_out.drw_x = drw_x;
1076 xcb_out.drw_y = drw_y;
1077 xcb_out.drw_w = drw_w;
1078 xcb_out.drw_h = drw_h;
1079
1080 xcb_parts[2].iov_base = (char *) &xcb_out;
1081 xcb_parts[2].iov_len = sizeof(xcb_out);
1082 xcb_parts[3].iov_base = 0;
1083 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1084
1085 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1086 return xcb_ret;
1087 }
1088
1089 xcb_void_cookie_t
xcb_xv_put_still(xcb_connection_t * c,xcb_xv_port_t port,xcb_drawable_t drawable,xcb_gcontext_t gc,int16_t vid_x,int16_t vid_y,uint16_t vid_w,uint16_t vid_h,int16_t drw_x,int16_t drw_y,uint16_t drw_w,uint16_t drw_h)1090 xcb_xv_put_still (xcb_connection_t *c,
1091 xcb_xv_port_t port,
1092 xcb_drawable_t drawable,
1093 xcb_gcontext_t gc,
1094 int16_t vid_x,
1095 int16_t vid_y,
1096 uint16_t vid_w,
1097 uint16_t vid_h,
1098 int16_t drw_x,
1099 int16_t drw_y,
1100 uint16_t drw_w,
1101 uint16_t drw_h)
1102 {
1103 static const xcb_protocol_request_t xcb_req = {
1104 .count = 2,
1105 .ext = &xcb_xv_id,
1106 .opcode = XCB_XV_PUT_STILL,
1107 .isvoid = 1
1108 };
1109
1110 struct iovec xcb_parts[4];
1111 xcb_void_cookie_t xcb_ret;
1112 xcb_xv_put_still_request_t xcb_out;
1113
1114 xcb_out.port = port;
1115 xcb_out.drawable = drawable;
1116 xcb_out.gc = gc;
1117 xcb_out.vid_x = vid_x;
1118 xcb_out.vid_y = vid_y;
1119 xcb_out.vid_w = vid_w;
1120 xcb_out.vid_h = vid_h;
1121 xcb_out.drw_x = drw_x;
1122 xcb_out.drw_y = drw_y;
1123 xcb_out.drw_w = drw_w;
1124 xcb_out.drw_h = drw_h;
1125
1126 xcb_parts[2].iov_base = (char *) &xcb_out;
1127 xcb_parts[2].iov_len = sizeof(xcb_out);
1128 xcb_parts[3].iov_base = 0;
1129 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1130
1131 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1132 return xcb_ret;
1133 }
1134
1135 xcb_void_cookie_t
xcb_xv_get_video_checked(xcb_connection_t * c,xcb_xv_port_t port,xcb_drawable_t drawable,xcb_gcontext_t gc,int16_t vid_x,int16_t vid_y,uint16_t vid_w,uint16_t vid_h,int16_t drw_x,int16_t drw_y,uint16_t drw_w,uint16_t drw_h)1136 xcb_xv_get_video_checked (xcb_connection_t *c,
1137 xcb_xv_port_t port,
1138 xcb_drawable_t drawable,
1139 xcb_gcontext_t gc,
1140 int16_t vid_x,
1141 int16_t vid_y,
1142 uint16_t vid_w,
1143 uint16_t vid_h,
1144 int16_t drw_x,
1145 int16_t drw_y,
1146 uint16_t drw_w,
1147 uint16_t drw_h)
1148 {
1149 static const xcb_protocol_request_t xcb_req = {
1150 .count = 2,
1151 .ext = &xcb_xv_id,
1152 .opcode = XCB_XV_GET_VIDEO,
1153 .isvoid = 1
1154 };
1155
1156 struct iovec xcb_parts[4];
1157 xcb_void_cookie_t xcb_ret;
1158 xcb_xv_get_video_request_t xcb_out;
1159
1160 xcb_out.port = port;
1161 xcb_out.drawable = drawable;
1162 xcb_out.gc = gc;
1163 xcb_out.vid_x = vid_x;
1164 xcb_out.vid_y = vid_y;
1165 xcb_out.vid_w = vid_w;
1166 xcb_out.vid_h = vid_h;
1167 xcb_out.drw_x = drw_x;
1168 xcb_out.drw_y = drw_y;
1169 xcb_out.drw_w = drw_w;
1170 xcb_out.drw_h = drw_h;
1171
1172 xcb_parts[2].iov_base = (char *) &xcb_out;
1173 xcb_parts[2].iov_len = sizeof(xcb_out);
1174 xcb_parts[3].iov_base = 0;
1175 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1176
1177 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1178 return xcb_ret;
1179 }
1180
1181 xcb_void_cookie_t
xcb_xv_get_video(xcb_connection_t * c,xcb_xv_port_t port,xcb_drawable_t drawable,xcb_gcontext_t gc,int16_t vid_x,int16_t vid_y,uint16_t vid_w,uint16_t vid_h,int16_t drw_x,int16_t drw_y,uint16_t drw_w,uint16_t drw_h)1182 xcb_xv_get_video (xcb_connection_t *c,
1183 xcb_xv_port_t port,
1184 xcb_drawable_t drawable,
1185 xcb_gcontext_t gc,
1186 int16_t vid_x,
1187 int16_t vid_y,
1188 uint16_t vid_w,
1189 uint16_t vid_h,
1190 int16_t drw_x,
1191 int16_t drw_y,
1192 uint16_t drw_w,
1193 uint16_t drw_h)
1194 {
1195 static const xcb_protocol_request_t xcb_req = {
1196 .count = 2,
1197 .ext = &xcb_xv_id,
1198 .opcode = XCB_XV_GET_VIDEO,
1199 .isvoid = 1
1200 };
1201
1202 struct iovec xcb_parts[4];
1203 xcb_void_cookie_t xcb_ret;
1204 xcb_xv_get_video_request_t xcb_out;
1205
1206 xcb_out.port = port;
1207 xcb_out.drawable = drawable;
1208 xcb_out.gc = gc;
1209 xcb_out.vid_x = vid_x;
1210 xcb_out.vid_y = vid_y;
1211 xcb_out.vid_w = vid_w;
1212 xcb_out.vid_h = vid_h;
1213 xcb_out.drw_x = drw_x;
1214 xcb_out.drw_y = drw_y;
1215 xcb_out.drw_w = drw_w;
1216 xcb_out.drw_h = drw_h;
1217
1218 xcb_parts[2].iov_base = (char *) &xcb_out;
1219 xcb_parts[2].iov_len = sizeof(xcb_out);
1220 xcb_parts[3].iov_base = 0;
1221 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1222
1223 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1224 return xcb_ret;
1225 }
1226
1227 xcb_void_cookie_t
xcb_xv_get_still_checked(xcb_connection_t * c,xcb_xv_port_t port,xcb_drawable_t drawable,xcb_gcontext_t gc,int16_t vid_x,int16_t vid_y,uint16_t vid_w,uint16_t vid_h,int16_t drw_x,int16_t drw_y,uint16_t drw_w,uint16_t drw_h)1228 xcb_xv_get_still_checked (xcb_connection_t *c,
1229 xcb_xv_port_t port,
1230 xcb_drawable_t drawable,
1231 xcb_gcontext_t gc,
1232 int16_t vid_x,
1233 int16_t vid_y,
1234 uint16_t vid_w,
1235 uint16_t vid_h,
1236 int16_t drw_x,
1237 int16_t drw_y,
1238 uint16_t drw_w,
1239 uint16_t drw_h)
1240 {
1241 static const xcb_protocol_request_t xcb_req = {
1242 .count = 2,
1243 .ext = &xcb_xv_id,
1244 .opcode = XCB_XV_GET_STILL,
1245 .isvoid = 1
1246 };
1247
1248 struct iovec xcb_parts[4];
1249 xcb_void_cookie_t xcb_ret;
1250 xcb_xv_get_still_request_t xcb_out;
1251
1252 xcb_out.port = port;
1253 xcb_out.drawable = drawable;
1254 xcb_out.gc = gc;
1255 xcb_out.vid_x = vid_x;
1256 xcb_out.vid_y = vid_y;
1257 xcb_out.vid_w = vid_w;
1258 xcb_out.vid_h = vid_h;
1259 xcb_out.drw_x = drw_x;
1260 xcb_out.drw_y = drw_y;
1261 xcb_out.drw_w = drw_w;
1262 xcb_out.drw_h = drw_h;
1263
1264 xcb_parts[2].iov_base = (char *) &xcb_out;
1265 xcb_parts[2].iov_len = sizeof(xcb_out);
1266 xcb_parts[3].iov_base = 0;
1267 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1268
1269 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1270 return xcb_ret;
1271 }
1272
1273 xcb_void_cookie_t
xcb_xv_get_still(xcb_connection_t * c,xcb_xv_port_t port,xcb_drawable_t drawable,xcb_gcontext_t gc,int16_t vid_x,int16_t vid_y,uint16_t vid_w,uint16_t vid_h,int16_t drw_x,int16_t drw_y,uint16_t drw_w,uint16_t drw_h)1274 xcb_xv_get_still (xcb_connection_t *c,
1275 xcb_xv_port_t port,
1276 xcb_drawable_t drawable,
1277 xcb_gcontext_t gc,
1278 int16_t vid_x,
1279 int16_t vid_y,
1280 uint16_t vid_w,
1281 uint16_t vid_h,
1282 int16_t drw_x,
1283 int16_t drw_y,
1284 uint16_t drw_w,
1285 uint16_t drw_h)
1286 {
1287 static const xcb_protocol_request_t xcb_req = {
1288 .count = 2,
1289 .ext = &xcb_xv_id,
1290 .opcode = XCB_XV_GET_STILL,
1291 .isvoid = 1
1292 };
1293
1294 struct iovec xcb_parts[4];
1295 xcb_void_cookie_t xcb_ret;
1296 xcb_xv_get_still_request_t xcb_out;
1297
1298 xcb_out.port = port;
1299 xcb_out.drawable = drawable;
1300 xcb_out.gc = gc;
1301 xcb_out.vid_x = vid_x;
1302 xcb_out.vid_y = vid_y;
1303 xcb_out.vid_w = vid_w;
1304 xcb_out.vid_h = vid_h;
1305 xcb_out.drw_x = drw_x;
1306 xcb_out.drw_y = drw_y;
1307 xcb_out.drw_w = drw_w;
1308 xcb_out.drw_h = drw_h;
1309
1310 xcb_parts[2].iov_base = (char *) &xcb_out;
1311 xcb_parts[2].iov_len = sizeof(xcb_out);
1312 xcb_parts[3].iov_base = 0;
1313 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1314
1315 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1316 return xcb_ret;
1317 }
1318
1319 xcb_void_cookie_t
xcb_xv_stop_video_checked(xcb_connection_t * c,xcb_xv_port_t port,xcb_drawable_t drawable)1320 xcb_xv_stop_video_checked (xcb_connection_t *c,
1321 xcb_xv_port_t port,
1322 xcb_drawable_t drawable)
1323 {
1324 static const xcb_protocol_request_t xcb_req = {
1325 .count = 2,
1326 .ext = &xcb_xv_id,
1327 .opcode = XCB_XV_STOP_VIDEO,
1328 .isvoid = 1
1329 };
1330
1331 struct iovec xcb_parts[4];
1332 xcb_void_cookie_t xcb_ret;
1333 xcb_xv_stop_video_request_t xcb_out;
1334
1335 xcb_out.port = port;
1336 xcb_out.drawable = drawable;
1337
1338 xcb_parts[2].iov_base = (char *) &xcb_out;
1339 xcb_parts[2].iov_len = sizeof(xcb_out);
1340 xcb_parts[3].iov_base = 0;
1341 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1342
1343 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1344 return xcb_ret;
1345 }
1346
1347 xcb_void_cookie_t
xcb_xv_stop_video(xcb_connection_t * c,xcb_xv_port_t port,xcb_drawable_t drawable)1348 xcb_xv_stop_video (xcb_connection_t *c,
1349 xcb_xv_port_t port,
1350 xcb_drawable_t drawable)
1351 {
1352 static const xcb_protocol_request_t xcb_req = {
1353 .count = 2,
1354 .ext = &xcb_xv_id,
1355 .opcode = XCB_XV_STOP_VIDEO,
1356 .isvoid = 1
1357 };
1358
1359 struct iovec xcb_parts[4];
1360 xcb_void_cookie_t xcb_ret;
1361 xcb_xv_stop_video_request_t xcb_out;
1362
1363 xcb_out.port = port;
1364 xcb_out.drawable = drawable;
1365
1366 xcb_parts[2].iov_base = (char *) &xcb_out;
1367 xcb_parts[2].iov_len = sizeof(xcb_out);
1368 xcb_parts[3].iov_base = 0;
1369 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1370
1371 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1372 return xcb_ret;
1373 }
1374
1375 xcb_void_cookie_t
xcb_xv_select_video_notify_checked(xcb_connection_t * c,xcb_drawable_t drawable,uint8_t onoff)1376 xcb_xv_select_video_notify_checked (xcb_connection_t *c,
1377 xcb_drawable_t drawable,
1378 uint8_t onoff)
1379 {
1380 static const xcb_protocol_request_t xcb_req = {
1381 .count = 2,
1382 .ext = &xcb_xv_id,
1383 .opcode = XCB_XV_SELECT_VIDEO_NOTIFY,
1384 .isvoid = 1
1385 };
1386
1387 struct iovec xcb_parts[4];
1388 xcb_void_cookie_t xcb_ret;
1389 xcb_xv_select_video_notify_request_t xcb_out;
1390
1391 xcb_out.drawable = drawable;
1392 xcb_out.onoff = onoff;
1393 memset(xcb_out.pad0, 0, 3);
1394
1395 xcb_parts[2].iov_base = (char *) &xcb_out;
1396 xcb_parts[2].iov_len = sizeof(xcb_out);
1397 xcb_parts[3].iov_base = 0;
1398 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1399
1400 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1401 return xcb_ret;
1402 }
1403
1404 xcb_void_cookie_t
xcb_xv_select_video_notify(xcb_connection_t * c,xcb_drawable_t drawable,uint8_t onoff)1405 xcb_xv_select_video_notify (xcb_connection_t *c,
1406 xcb_drawable_t drawable,
1407 uint8_t onoff)
1408 {
1409 static const xcb_protocol_request_t xcb_req = {
1410 .count = 2,
1411 .ext = &xcb_xv_id,
1412 .opcode = XCB_XV_SELECT_VIDEO_NOTIFY,
1413 .isvoid = 1
1414 };
1415
1416 struct iovec xcb_parts[4];
1417 xcb_void_cookie_t xcb_ret;
1418 xcb_xv_select_video_notify_request_t xcb_out;
1419
1420 xcb_out.drawable = drawable;
1421 xcb_out.onoff = onoff;
1422 memset(xcb_out.pad0, 0, 3);
1423
1424 xcb_parts[2].iov_base = (char *) &xcb_out;
1425 xcb_parts[2].iov_len = sizeof(xcb_out);
1426 xcb_parts[3].iov_base = 0;
1427 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1428
1429 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1430 return xcb_ret;
1431 }
1432
1433 xcb_void_cookie_t
xcb_xv_select_port_notify_checked(xcb_connection_t * c,xcb_xv_port_t port,uint8_t onoff)1434 xcb_xv_select_port_notify_checked (xcb_connection_t *c,
1435 xcb_xv_port_t port,
1436 uint8_t onoff)
1437 {
1438 static const xcb_protocol_request_t xcb_req = {
1439 .count = 2,
1440 .ext = &xcb_xv_id,
1441 .opcode = XCB_XV_SELECT_PORT_NOTIFY,
1442 .isvoid = 1
1443 };
1444
1445 struct iovec xcb_parts[4];
1446 xcb_void_cookie_t xcb_ret;
1447 xcb_xv_select_port_notify_request_t xcb_out;
1448
1449 xcb_out.port = port;
1450 xcb_out.onoff = onoff;
1451 memset(xcb_out.pad0, 0, 3);
1452
1453 xcb_parts[2].iov_base = (char *) &xcb_out;
1454 xcb_parts[2].iov_len = sizeof(xcb_out);
1455 xcb_parts[3].iov_base = 0;
1456 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1457
1458 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1459 return xcb_ret;
1460 }
1461
1462 xcb_void_cookie_t
xcb_xv_select_port_notify(xcb_connection_t * c,xcb_xv_port_t port,uint8_t onoff)1463 xcb_xv_select_port_notify (xcb_connection_t *c,
1464 xcb_xv_port_t port,
1465 uint8_t onoff)
1466 {
1467 static const xcb_protocol_request_t xcb_req = {
1468 .count = 2,
1469 .ext = &xcb_xv_id,
1470 .opcode = XCB_XV_SELECT_PORT_NOTIFY,
1471 .isvoid = 1
1472 };
1473
1474 struct iovec xcb_parts[4];
1475 xcb_void_cookie_t xcb_ret;
1476 xcb_xv_select_port_notify_request_t xcb_out;
1477
1478 xcb_out.port = port;
1479 xcb_out.onoff = onoff;
1480 memset(xcb_out.pad0, 0, 3);
1481
1482 xcb_parts[2].iov_base = (char *) &xcb_out;
1483 xcb_parts[2].iov_len = sizeof(xcb_out);
1484 xcb_parts[3].iov_base = 0;
1485 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1486
1487 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1488 return xcb_ret;
1489 }
1490
1491 xcb_xv_query_best_size_cookie_t
xcb_xv_query_best_size(xcb_connection_t * c,xcb_xv_port_t port,uint16_t vid_w,uint16_t vid_h,uint16_t drw_w,uint16_t drw_h,uint8_t motion)1492 xcb_xv_query_best_size (xcb_connection_t *c,
1493 xcb_xv_port_t port,
1494 uint16_t vid_w,
1495 uint16_t vid_h,
1496 uint16_t drw_w,
1497 uint16_t drw_h,
1498 uint8_t motion)
1499 {
1500 static const xcb_protocol_request_t xcb_req = {
1501 .count = 2,
1502 .ext = &xcb_xv_id,
1503 .opcode = XCB_XV_QUERY_BEST_SIZE,
1504 .isvoid = 0
1505 };
1506
1507 struct iovec xcb_parts[4];
1508 xcb_xv_query_best_size_cookie_t xcb_ret;
1509 xcb_xv_query_best_size_request_t xcb_out;
1510
1511 xcb_out.port = port;
1512 xcb_out.vid_w = vid_w;
1513 xcb_out.vid_h = vid_h;
1514 xcb_out.drw_w = drw_w;
1515 xcb_out.drw_h = drw_h;
1516 xcb_out.motion = motion;
1517 memset(xcb_out.pad0, 0, 3);
1518
1519 xcb_parts[2].iov_base = (char *) &xcb_out;
1520 xcb_parts[2].iov_len = sizeof(xcb_out);
1521 xcb_parts[3].iov_base = 0;
1522 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1523
1524 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1525 return xcb_ret;
1526 }
1527
1528 xcb_xv_query_best_size_cookie_t
xcb_xv_query_best_size_unchecked(xcb_connection_t * c,xcb_xv_port_t port,uint16_t vid_w,uint16_t vid_h,uint16_t drw_w,uint16_t drw_h,uint8_t motion)1529 xcb_xv_query_best_size_unchecked (xcb_connection_t *c,
1530 xcb_xv_port_t port,
1531 uint16_t vid_w,
1532 uint16_t vid_h,
1533 uint16_t drw_w,
1534 uint16_t drw_h,
1535 uint8_t motion)
1536 {
1537 static const xcb_protocol_request_t xcb_req = {
1538 .count = 2,
1539 .ext = &xcb_xv_id,
1540 .opcode = XCB_XV_QUERY_BEST_SIZE,
1541 .isvoid = 0
1542 };
1543
1544 struct iovec xcb_parts[4];
1545 xcb_xv_query_best_size_cookie_t xcb_ret;
1546 xcb_xv_query_best_size_request_t xcb_out;
1547
1548 xcb_out.port = port;
1549 xcb_out.vid_w = vid_w;
1550 xcb_out.vid_h = vid_h;
1551 xcb_out.drw_w = drw_w;
1552 xcb_out.drw_h = drw_h;
1553 xcb_out.motion = motion;
1554 memset(xcb_out.pad0, 0, 3);
1555
1556 xcb_parts[2].iov_base = (char *) &xcb_out;
1557 xcb_parts[2].iov_len = sizeof(xcb_out);
1558 xcb_parts[3].iov_base = 0;
1559 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1560
1561 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1562 return xcb_ret;
1563 }
1564
1565 xcb_xv_query_best_size_reply_t *
xcb_xv_query_best_size_reply(xcb_connection_t * c,xcb_xv_query_best_size_cookie_t cookie,xcb_generic_error_t ** e)1566 xcb_xv_query_best_size_reply (xcb_connection_t *c,
1567 xcb_xv_query_best_size_cookie_t cookie /**< */,
1568 xcb_generic_error_t **e)
1569 {
1570 return (xcb_xv_query_best_size_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
1571 }
1572
1573 xcb_void_cookie_t
xcb_xv_set_port_attribute_checked(xcb_connection_t * c,xcb_xv_port_t port,xcb_atom_t attribute,int32_t value)1574 xcb_xv_set_port_attribute_checked (xcb_connection_t *c,
1575 xcb_xv_port_t port,
1576 xcb_atom_t attribute,
1577 int32_t value)
1578 {
1579 static const xcb_protocol_request_t xcb_req = {
1580 .count = 2,
1581 .ext = &xcb_xv_id,
1582 .opcode = XCB_XV_SET_PORT_ATTRIBUTE,
1583 .isvoid = 1
1584 };
1585
1586 struct iovec xcb_parts[4];
1587 xcb_void_cookie_t xcb_ret;
1588 xcb_xv_set_port_attribute_request_t xcb_out;
1589
1590 xcb_out.port = port;
1591 xcb_out.attribute = attribute;
1592 xcb_out.value = value;
1593
1594 xcb_parts[2].iov_base = (char *) &xcb_out;
1595 xcb_parts[2].iov_len = sizeof(xcb_out);
1596 xcb_parts[3].iov_base = 0;
1597 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1598
1599 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1600 return xcb_ret;
1601 }
1602
1603 xcb_void_cookie_t
xcb_xv_set_port_attribute(xcb_connection_t * c,xcb_xv_port_t port,xcb_atom_t attribute,int32_t value)1604 xcb_xv_set_port_attribute (xcb_connection_t *c,
1605 xcb_xv_port_t port,
1606 xcb_atom_t attribute,
1607 int32_t value)
1608 {
1609 static const xcb_protocol_request_t xcb_req = {
1610 .count = 2,
1611 .ext = &xcb_xv_id,
1612 .opcode = XCB_XV_SET_PORT_ATTRIBUTE,
1613 .isvoid = 1
1614 };
1615
1616 struct iovec xcb_parts[4];
1617 xcb_void_cookie_t xcb_ret;
1618 xcb_xv_set_port_attribute_request_t xcb_out;
1619
1620 xcb_out.port = port;
1621 xcb_out.attribute = attribute;
1622 xcb_out.value = value;
1623
1624 xcb_parts[2].iov_base = (char *) &xcb_out;
1625 xcb_parts[2].iov_len = sizeof(xcb_out);
1626 xcb_parts[3].iov_base = 0;
1627 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1628
1629 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1630 return xcb_ret;
1631 }
1632
1633 xcb_xv_get_port_attribute_cookie_t
xcb_xv_get_port_attribute(xcb_connection_t * c,xcb_xv_port_t port,xcb_atom_t attribute)1634 xcb_xv_get_port_attribute (xcb_connection_t *c,
1635 xcb_xv_port_t port,
1636 xcb_atom_t attribute)
1637 {
1638 static const xcb_protocol_request_t xcb_req = {
1639 .count = 2,
1640 .ext = &xcb_xv_id,
1641 .opcode = XCB_XV_GET_PORT_ATTRIBUTE,
1642 .isvoid = 0
1643 };
1644
1645 struct iovec xcb_parts[4];
1646 xcb_xv_get_port_attribute_cookie_t xcb_ret;
1647 xcb_xv_get_port_attribute_request_t xcb_out;
1648
1649 xcb_out.port = port;
1650 xcb_out.attribute = attribute;
1651
1652 xcb_parts[2].iov_base = (char *) &xcb_out;
1653 xcb_parts[2].iov_len = sizeof(xcb_out);
1654 xcb_parts[3].iov_base = 0;
1655 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1656
1657 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1658 return xcb_ret;
1659 }
1660
1661 xcb_xv_get_port_attribute_cookie_t
xcb_xv_get_port_attribute_unchecked(xcb_connection_t * c,xcb_xv_port_t port,xcb_atom_t attribute)1662 xcb_xv_get_port_attribute_unchecked (xcb_connection_t *c,
1663 xcb_xv_port_t port,
1664 xcb_atom_t attribute)
1665 {
1666 static const xcb_protocol_request_t xcb_req = {
1667 .count = 2,
1668 .ext = &xcb_xv_id,
1669 .opcode = XCB_XV_GET_PORT_ATTRIBUTE,
1670 .isvoid = 0
1671 };
1672
1673 struct iovec xcb_parts[4];
1674 xcb_xv_get_port_attribute_cookie_t xcb_ret;
1675 xcb_xv_get_port_attribute_request_t xcb_out;
1676
1677 xcb_out.port = port;
1678 xcb_out.attribute = attribute;
1679
1680 xcb_parts[2].iov_base = (char *) &xcb_out;
1681 xcb_parts[2].iov_len = sizeof(xcb_out);
1682 xcb_parts[3].iov_base = 0;
1683 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1684
1685 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1686 return xcb_ret;
1687 }
1688
1689 xcb_xv_get_port_attribute_reply_t *
xcb_xv_get_port_attribute_reply(xcb_connection_t * c,xcb_xv_get_port_attribute_cookie_t cookie,xcb_generic_error_t ** e)1690 xcb_xv_get_port_attribute_reply (xcb_connection_t *c,
1691 xcb_xv_get_port_attribute_cookie_t cookie /**< */,
1692 xcb_generic_error_t **e)
1693 {
1694 return (xcb_xv_get_port_attribute_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
1695 }
1696
1697 int
xcb_xv_query_port_attributes_sizeof(const void * _buffer)1698 xcb_xv_query_port_attributes_sizeof (const void *_buffer)
1699 {
1700 char *xcb_tmp = (char *)_buffer;
1701 const xcb_xv_query_port_attributes_reply_t *_aux = (xcb_xv_query_port_attributes_reply_t *)_buffer;
1702 unsigned int xcb_buffer_len = 0;
1703 unsigned int xcb_block_len = 0;
1704 unsigned int xcb_pad = 0;
1705 unsigned int xcb_align_to = 0;
1706
1707 unsigned int i;
1708 unsigned int xcb_tmp_len;
1709
1710 xcb_block_len += sizeof(xcb_xv_query_port_attributes_reply_t);
1711 xcb_tmp += xcb_block_len;
1712 xcb_buffer_len += xcb_block_len;
1713 xcb_block_len = 0;
1714 /* attributes */
1715 for(i=0; i<_aux->num_attributes; i++) {
1716 xcb_tmp_len = xcb_xv_attribute_info_sizeof(xcb_tmp);
1717 xcb_block_len += xcb_tmp_len;
1718 xcb_tmp += xcb_tmp_len;
1719 }
1720 xcb_align_to = ALIGNOF(xcb_xv_attribute_info_t);
1721 /* insert padding */
1722 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1723 xcb_buffer_len += xcb_block_len + xcb_pad;
1724 if (0 != xcb_pad) {
1725 xcb_tmp += xcb_pad;
1726 xcb_pad = 0;
1727 }
1728 xcb_block_len = 0;
1729
1730 return xcb_buffer_len;
1731 }
1732
1733 xcb_xv_query_port_attributes_cookie_t
xcb_xv_query_port_attributes(xcb_connection_t * c,xcb_xv_port_t port)1734 xcb_xv_query_port_attributes (xcb_connection_t *c,
1735 xcb_xv_port_t port)
1736 {
1737 static const xcb_protocol_request_t xcb_req = {
1738 .count = 2,
1739 .ext = &xcb_xv_id,
1740 .opcode = XCB_XV_QUERY_PORT_ATTRIBUTES,
1741 .isvoid = 0
1742 };
1743
1744 struct iovec xcb_parts[4];
1745 xcb_xv_query_port_attributes_cookie_t xcb_ret;
1746 xcb_xv_query_port_attributes_request_t xcb_out;
1747
1748 xcb_out.port = port;
1749
1750 xcb_parts[2].iov_base = (char *) &xcb_out;
1751 xcb_parts[2].iov_len = sizeof(xcb_out);
1752 xcb_parts[3].iov_base = 0;
1753 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1754
1755 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1756 return xcb_ret;
1757 }
1758
1759 xcb_xv_query_port_attributes_cookie_t
xcb_xv_query_port_attributes_unchecked(xcb_connection_t * c,xcb_xv_port_t port)1760 xcb_xv_query_port_attributes_unchecked (xcb_connection_t *c,
1761 xcb_xv_port_t port)
1762 {
1763 static const xcb_protocol_request_t xcb_req = {
1764 .count = 2,
1765 .ext = &xcb_xv_id,
1766 .opcode = XCB_XV_QUERY_PORT_ATTRIBUTES,
1767 .isvoid = 0
1768 };
1769
1770 struct iovec xcb_parts[4];
1771 xcb_xv_query_port_attributes_cookie_t xcb_ret;
1772 xcb_xv_query_port_attributes_request_t xcb_out;
1773
1774 xcb_out.port = port;
1775
1776 xcb_parts[2].iov_base = (char *) &xcb_out;
1777 xcb_parts[2].iov_len = sizeof(xcb_out);
1778 xcb_parts[3].iov_base = 0;
1779 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1780
1781 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1782 return xcb_ret;
1783 }
1784
1785 int
xcb_xv_query_port_attributes_attributes_length(const xcb_xv_query_port_attributes_reply_t * R)1786 xcb_xv_query_port_attributes_attributes_length (const xcb_xv_query_port_attributes_reply_t *R)
1787 {
1788 return R->num_attributes;
1789 }
1790
1791 xcb_xv_attribute_info_iterator_t
xcb_xv_query_port_attributes_attributes_iterator(const xcb_xv_query_port_attributes_reply_t * R)1792 xcb_xv_query_port_attributes_attributes_iterator (const xcb_xv_query_port_attributes_reply_t *R)
1793 {
1794 xcb_xv_attribute_info_iterator_t i;
1795 i.data = (xcb_xv_attribute_info_t *) (R + 1);
1796 i.rem = R->num_attributes;
1797 i.index = (char *) i.data - (char *) R;
1798 return i;
1799 }
1800
1801 xcb_xv_query_port_attributes_reply_t *
xcb_xv_query_port_attributes_reply(xcb_connection_t * c,xcb_xv_query_port_attributes_cookie_t cookie,xcb_generic_error_t ** e)1802 xcb_xv_query_port_attributes_reply (xcb_connection_t *c,
1803 xcb_xv_query_port_attributes_cookie_t cookie /**< */,
1804 xcb_generic_error_t **e)
1805 {
1806 return (xcb_xv_query_port_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
1807 }
1808
1809 int
xcb_xv_list_image_formats_sizeof(const void * _buffer)1810 xcb_xv_list_image_formats_sizeof (const void *_buffer)
1811 {
1812 char *xcb_tmp = (char *)_buffer;
1813 const xcb_xv_list_image_formats_reply_t *_aux = (xcb_xv_list_image_formats_reply_t *)_buffer;
1814 unsigned int xcb_buffer_len = 0;
1815 unsigned int xcb_block_len = 0;
1816 unsigned int xcb_pad = 0;
1817 unsigned int xcb_align_to = 0;
1818
1819
1820 xcb_block_len += sizeof(xcb_xv_list_image_formats_reply_t);
1821 xcb_tmp += xcb_block_len;
1822 xcb_buffer_len += xcb_block_len;
1823 xcb_block_len = 0;
1824 /* format */
1825 xcb_block_len += _aux->num_formats * sizeof(xcb_xv_image_format_info_t);
1826 xcb_tmp += xcb_block_len;
1827 xcb_align_to = ALIGNOF(xcb_xv_image_format_info_t);
1828 /* insert padding */
1829 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1830 xcb_buffer_len += xcb_block_len + xcb_pad;
1831 if (0 != xcb_pad) {
1832 xcb_tmp += xcb_pad;
1833 xcb_pad = 0;
1834 }
1835 xcb_block_len = 0;
1836
1837 return xcb_buffer_len;
1838 }
1839
1840 xcb_xv_list_image_formats_cookie_t
xcb_xv_list_image_formats(xcb_connection_t * c,xcb_xv_port_t port)1841 xcb_xv_list_image_formats (xcb_connection_t *c,
1842 xcb_xv_port_t port)
1843 {
1844 static const xcb_protocol_request_t xcb_req = {
1845 .count = 2,
1846 .ext = &xcb_xv_id,
1847 .opcode = XCB_XV_LIST_IMAGE_FORMATS,
1848 .isvoid = 0
1849 };
1850
1851 struct iovec xcb_parts[4];
1852 xcb_xv_list_image_formats_cookie_t xcb_ret;
1853 xcb_xv_list_image_formats_request_t xcb_out;
1854
1855 xcb_out.port = port;
1856
1857 xcb_parts[2].iov_base = (char *) &xcb_out;
1858 xcb_parts[2].iov_len = sizeof(xcb_out);
1859 xcb_parts[3].iov_base = 0;
1860 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1861
1862 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1863 return xcb_ret;
1864 }
1865
1866 xcb_xv_list_image_formats_cookie_t
xcb_xv_list_image_formats_unchecked(xcb_connection_t * c,xcb_xv_port_t port)1867 xcb_xv_list_image_formats_unchecked (xcb_connection_t *c,
1868 xcb_xv_port_t port)
1869 {
1870 static const xcb_protocol_request_t xcb_req = {
1871 .count = 2,
1872 .ext = &xcb_xv_id,
1873 .opcode = XCB_XV_LIST_IMAGE_FORMATS,
1874 .isvoid = 0
1875 };
1876
1877 struct iovec xcb_parts[4];
1878 xcb_xv_list_image_formats_cookie_t xcb_ret;
1879 xcb_xv_list_image_formats_request_t xcb_out;
1880
1881 xcb_out.port = port;
1882
1883 xcb_parts[2].iov_base = (char *) &xcb_out;
1884 xcb_parts[2].iov_len = sizeof(xcb_out);
1885 xcb_parts[3].iov_base = 0;
1886 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1887
1888 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
1889 return xcb_ret;
1890 }
1891
1892 xcb_xv_image_format_info_t *
xcb_xv_list_image_formats_format(const xcb_xv_list_image_formats_reply_t * R)1893 xcb_xv_list_image_formats_format (const xcb_xv_list_image_formats_reply_t *R)
1894 {
1895 return (xcb_xv_image_format_info_t *) (R + 1);
1896 }
1897
1898 int
xcb_xv_list_image_formats_format_length(const xcb_xv_list_image_formats_reply_t * R)1899 xcb_xv_list_image_formats_format_length (const xcb_xv_list_image_formats_reply_t *R)
1900 {
1901 return R->num_formats;
1902 }
1903
1904 xcb_xv_image_format_info_iterator_t
xcb_xv_list_image_formats_format_iterator(const xcb_xv_list_image_formats_reply_t * R)1905 xcb_xv_list_image_formats_format_iterator (const xcb_xv_list_image_formats_reply_t *R)
1906 {
1907 xcb_xv_image_format_info_iterator_t i;
1908 i.data = (xcb_xv_image_format_info_t *) (R + 1);
1909 i.rem = R->num_formats;
1910 i.index = (char *) i.data - (char *) R;
1911 return i;
1912 }
1913
1914 xcb_xv_list_image_formats_reply_t *
xcb_xv_list_image_formats_reply(xcb_connection_t * c,xcb_xv_list_image_formats_cookie_t cookie,xcb_generic_error_t ** e)1915 xcb_xv_list_image_formats_reply (xcb_connection_t *c,
1916 xcb_xv_list_image_formats_cookie_t cookie /**< */,
1917 xcb_generic_error_t **e)
1918 {
1919 return (xcb_xv_list_image_formats_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
1920 }
1921
1922 int
xcb_xv_query_image_attributes_sizeof(const void * _buffer)1923 xcb_xv_query_image_attributes_sizeof (const void *_buffer)
1924 {
1925 char *xcb_tmp = (char *)_buffer;
1926 const xcb_xv_query_image_attributes_reply_t *_aux = (xcb_xv_query_image_attributes_reply_t *)_buffer;
1927 unsigned int xcb_buffer_len = 0;
1928 unsigned int xcb_block_len = 0;
1929 unsigned int xcb_pad = 0;
1930 unsigned int xcb_align_to = 0;
1931
1932
1933 xcb_block_len += sizeof(xcb_xv_query_image_attributes_reply_t);
1934 xcb_tmp += xcb_block_len;
1935 xcb_buffer_len += xcb_block_len;
1936 xcb_block_len = 0;
1937 /* pitches */
1938 xcb_block_len += _aux->num_planes * sizeof(uint32_t);
1939 xcb_tmp += xcb_block_len;
1940 xcb_align_to = ALIGNOF(uint32_t);
1941 /* insert padding */
1942 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1943 xcb_buffer_len += xcb_block_len + xcb_pad;
1944 if (0 != xcb_pad) {
1945 xcb_tmp += xcb_pad;
1946 xcb_pad = 0;
1947 }
1948 xcb_block_len = 0;
1949 /* offsets */
1950 xcb_block_len += _aux->num_planes * sizeof(uint32_t);
1951 xcb_tmp += xcb_block_len;
1952 xcb_align_to = ALIGNOF(uint32_t);
1953 /* insert padding */
1954 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
1955 xcb_buffer_len += xcb_block_len + xcb_pad;
1956 if (0 != xcb_pad) {
1957 xcb_tmp += xcb_pad;
1958 xcb_pad = 0;
1959 }
1960 xcb_block_len = 0;
1961
1962 return xcb_buffer_len;
1963 }
1964
1965 xcb_xv_query_image_attributes_cookie_t
xcb_xv_query_image_attributes(xcb_connection_t * c,xcb_xv_port_t port,uint32_t id,uint16_t width,uint16_t height)1966 xcb_xv_query_image_attributes (xcb_connection_t *c,
1967 xcb_xv_port_t port,
1968 uint32_t id,
1969 uint16_t width,
1970 uint16_t height)
1971 {
1972 static const xcb_protocol_request_t xcb_req = {
1973 .count = 2,
1974 .ext = &xcb_xv_id,
1975 .opcode = XCB_XV_QUERY_IMAGE_ATTRIBUTES,
1976 .isvoid = 0
1977 };
1978
1979 struct iovec xcb_parts[4];
1980 xcb_xv_query_image_attributes_cookie_t xcb_ret;
1981 xcb_xv_query_image_attributes_request_t xcb_out;
1982
1983 xcb_out.port = port;
1984 xcb_out.id = id;
1985 xcb_out.width = width;
1986 xcb_out.height = height;
1987
1988 xcb_parts[2].iov_base = (char *) &xcb_out;
1989 xcb_parts[2].iov_len = sizeof(xcb_out);
1990 xcb_parts[3].iov_base = 0;
1991 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
1992
1993 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
1994 return xcb_ret;
1995 }
1996
1997 xcb_xv_query_image_attributes_cookie_t
xcb_xv_query_image_attributes_unchecked(xcb_connection_t * c,xcb_xv_port_t port,uint32_t id,uint16_t width,uint16_t height)1998 xcb_xv_query_image_attributes_unchecked (xcb_connection_t *c,
1999 xcb_xv_port_t port,
2000 uint32_t id,
2001 uint16_t width,
2002 uint16_t height)
2003 {
2004 static const xcb_protocol_request_t xcb_req = {
2005 .count = 2,
2006 .ext = &xcb_xv_id,
2007 .opcode = XCB_XV_QUERY_IMAGE_ATTRIBUTES,
2008 .isvoid = 0
2009 };
2010
2011 struct iovec xcb_parts[4];
2012 xcb_xv_query_image_attributes_cookie_t xcb_ret;
2013 xcb_xv_query_image_attributes_request_t xcb_out;
2014
2015 xcb_out.port = port;
2016 xcb_out.id = id;
2017 xcb_out.width = width;
2018 xcb_out.height = height;
2019
2020 xcb_parts[2].iov_base = (char *) &xcb_out;
2021 xcb_parts[2].iov_len = sizeof(xcb_out);
2022 xcb_parts[3].iov_base = 0;
2023 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2024
2025 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2026 return xcb_ret;
2027 }
2028
2029 uint32_t *
xcb_xv_query_image_attributes_pitches(const xcb_xv_query_image_attributes_reply_t * R)2030 xcb_xv_query_image_attributes_pitches (const xcb_xv_query_image_attributes_reply_t *R)
2031 {
2032 return (uint32_t *) (R + 1);
2033 }
2034
2035 int
xcb_xv_query_image_attributes_pitches_length(const xcb_xv_query_image_attributes_reply_t * R)2036 xcb_xv_query_image_attributes_pitches_length (const xcb_xv_query_image_attributes_reply_t *R)
2037 {
2038 return R->num_planes;
2039 }
2040
2041 xcb_generic_iterator_t
xcb_xv_query_image_attributes_pitches_end(const xcb_xv_query_image_attributes_reply_t * R)2042 xcb_xv_query_image_attributes_pitches_end (const xcb_xv_query_image_attributes_reply_t *R)
2043 {
2044 xcb_generic_iterator_t i;
2045 i.data = ((uint32_t *) (R + 1)) + (R->num_planes);
2046 i.rem = 0;
2047 i.index = (char *) i.data - (char *) R;
2048 return i;
2049 }
2050
2051 uint32_t *
xcb_xv_query_image_attributes_offsets(const xcb_xv_query_image_attributes_reply_t * R)2052 xcb_xv_query_image_attributes_offsets (const xcb_xv_query_image_attributes_reply_t *R)
2053 {
2054 xcb_generic_iterator_t prev = xcb_xv_query_image_attributes_pitches_end(R);
2055 return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
2056 }
2057
2058 int
xcb_xv_query_image_attributes_offsets_length(const xcb_xv_query_image_attributes_reply_t * R)2059 xcb_xv_query_image_attributes_offsets_length (const xcb_xv_query_image_attributes_reply_t *R)
2060 {
2061 return R->num_planes;
2062 }
2063
2064 xcb_generic_iterator_t
xcb_xv_query_image_attributes_offsets_end(const xcb_xv_query_image_attributes_reply_t * R)2065 xcb_xv_query_image_attributes_offsets_end (const xcb_xv_query_image_attributes_reply_t *R)
2066 {
2067 xcb_generic_iterator_t i;
2068 xcb_generic_iterator_t prev = xcb_xv_query_image_attributes_pitches_end(R);
2069 i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->num_planes);
2070 i.rem = 0;
2071 i.index = (char *) i.data - (char *) R;
2072 return i;
2073 }
2074
2075 xcb_xv_query_image_attributes_reply_t *
xcb_xv_query_image_attributes_reply(xcb_connection_t * c,xcb_xv_query_image_attributes_cookie_t cookie,xcb_generic_error_t ** e)2076 xcb_xv_query_image_attributes_reply (xcb_connection_t *c,
2077 xcb_xv_query_image_attributes_cookie_t cookie /**< */,
2078 xcb_generic_error_t **e)
2079 {
2080 return (xcb_xv_query_image_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
2081 }
2082
2083 int
xcb_xv_put_image_sizeof(const void * _buffer,uint32_t data_len)2084 xcb_xv_put_image_sizeof (const void *_buffer,
2085 uint32_t data_len)
2086 {
2087 char *xcb_tmp = (char *)_buffer;
2088 unsigned int xcb_buffer_len = 0;
2089 unsigned int xcb_block_len = 0;
2090 unsigned int xcb_pad = 0;
2091 unsigned int xcb_align_to = 0;
2092
2093
2094 xcb_block_len += sizeof(xcb_xv_put_image_request_t);
2095 xcb_tmp += xcb_block_len;
2096 xcb_buffer_len += xcb_block_len;
2097 xcb_block_len = 0;
2098 /* data */
2099 xcb_block_len += data_len * sizeof(uint8_t);
2100 xcb_tmp += xcb_block_len;
2101 xcb_align_to = ALIGNOF(uint8_t);
2102 /* insert padding */
2103 xcb_pad = -xcb_block_len & (xcb_align_to - 1);
2104 xcb_buffer_len += xcb_block_len + xcb_pad;
2105 if (0 != xcb_pad) {
2106 xcb_tmp += xcb_pad;
2107 xcb_pad = 0;
2108 }
2109 xcb_block_len = 0;
2110
2111 return xcb_buffer_len;
2112 }
2113
2114 xcb_void_cookie_t
xcb_xv_put_image_checked(xcb_connection_t * c,xcb_xv_port_t port,xcb_drawable_t drawable,xcb_gcontext_t gc,uint32_t id,int16_t src_x,int16_t src_y,uint16_t src_w,uint16_t src_h,int16_t drw_x,int16_t drw_y,uint16_t drw_w,uint16_t drw_h,uint16_t width,uint16_t height,uint32_t data_len,const uint8_t * data)2115 xcb_xv_put_image_checked (xcb_connection_t *c,
2116 xcb_xv_port_t port,
2117 xcb_drawable_t drawable,
2118 xcb_gcontext_t gc,
2119 uint32_t id,
2120 int16_t src_x,
2121 int16_t src_y,
2122 uint16_t src_w,
2123 uint16_t src_h,
2124 int16_t drw_x,
2125 int16_t drw_y,
2126 uint16_t drw_w,
2127 uint16_t drw_h,
2128 uint16_t width,
2129 uint16_t height,
2130 uint32_t data_len,
2131 const uint8_t *data)
2132 {
2133 static const xcb_protocol_request_t xcb_req = {
2134 .count = 4,
2135 .ext = &xcb_xv_id,
2136 .opcode = XCB_XV_PUT_IMAGE,
2137 .isvoid = 1
2138 };
2139
2140 struct iovec xcb_parts[6];
2141 xcb_void_cookie_t xcb_ret;
2142 xcb_xv_put_image_request_t xcb_out;
2143
2144 xcb_out.port = port;
2145 xcb_out.drawable = drawable;
2146 xcb_out.gc = gc;
2147 xcb_out.id = id;
2148 xcb_out.src_x = src_x;
2149 xcb_out.src_y = src_y;
2150 xcb_out.src_w = src_w;
2151 xcb_out.src_h = src_h;
2152 xcb_out.drw_x = drw_x;
2153 xcb_out.drw_y = drw_y;
2154 xcb_out.drw_w = drw_w;
2155 xcb_out.drw_h = drw_h;
2156 xcb_out.width = width;
2157 xcb_out.height = height;
2158
2159 xcb_parts[2].iov_base = (char *) &xcb_out;
2160 xcb_parts[2].iov_len = sizeof(xcb_out);
2161 xcb_parts[3].iov_base = 0;
2162 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2163 /* uint8_t data */
2164 xcb_parts[4].iov_base = (char *) data;
2165 xcb_parts[4].iov_len = data_len * sizeof(uint8_t);
2166 xcb_parts[5].iov_base = 0;
2167 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2168
2169 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2170 return xcb_ret;
2171 }
2172
2173 xcb_void_cookie_t
xcb_xv_put_image(xcb_connection_t * c,xcb_xv_port_t port,xcb_drawable_t drawable,xcb_gcontext_t gc,uint32_t id,int16_t src_x,int16_t src_y,uint16_t src_w,uint16_t src_h,int16_t drw_x,int16_t drw_y,uint16_t drw_w,uint16_t drw_h,uint16_t width,uint16_t height,uint32_t data_len,const uint8_t * data)2174 xcb_xv_put_image (xcb_connection_t *c,
2175 xcb_xv_port_t port,
2176 xcb_drawable_t drawable,
2177 xcb_gcontext_t gc,
2178 uint32_t id,
2179 int16_t src_x,
2180 int16_t src_y,
2181 uint16_t src_w,
2182 uint16_t src_h,
2183 int16_t drw_x,
2184 int16_t drw_y,
2185 uint16_t drw_w,
2186 uint16_t drw_h,
2187 uint16_t width,
2188 uint16_t height,
2189 uint32_t data_len,
2190 const uint8_t *data)
2191 {
2192 static const xcb_protocol_request_t xcb_req = {
2193 .count = 4,
2194 .ext = &xcb_xv_id,
2195 .opcode = XCB_XV_PUT_IMAGE,
2196 .isvoid = 1
2197 };
2198
2199 struct iovec xcb_parts[6];
2200 xcb_void_cookie_t xcb_ret;
2201 xcb_xv_put_image_request_t xcb_out;
2202
2203 xcb_out.port = port;
2204 xcb_out.drawable = drawable;
2205 xcb_out.gc = gc;
2206 xcb_out.id = id;
2207 xcb_out.src_x = src_x;
2208 xcb_out.src_y = src_y;
2209 xcb_out.src_w = src_w;
2210 xcb_out.src_h = src_h;
2211 xcb_out.drw_x = drw_x;
2212 xcb_out.drw_y = drw_y;
2213 xcb_out.drw_w = drw_w;
2214 xcb_out.drw_h = drw_h;
2215 xcb_out.width = width;
2216 xcb_out.height = height;
2217
2218 xcb_parts[2].iov_base = (char *) &xcb_out;
2219 xcb_parts[2].iov_len = sizeof(xcb_out);
2220 xcb_parts[3].iov_base = 0;
2221 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2222 /* uint8_t data */
2223 xcb_parts[4].iov_base = (char *) data;
2224 xcb_parts[4].iov_len = data_len * sizeof(uint8_t);
2225 xcb_parts[5].iov_base = 0;
2226 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
2227
2228 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2229 return xcb_ret;
2230 }
2231
2232 uint8_t *
xcb_xv_put_image_data(const xcb_xv_put_image_request_t * R)2233 xcb_xv_put_image_data (const xcb_xv_put_image_request_t *R)
2234 {
2235 return (uint8_t *) (R + 1);
2236 }
2237
2238 int
xcb_xv_put_image_data_length(const xcb_xv_put_image_request_t * R)2239 xcb_xv_put_image_data_length (const xcb_xv_put_image_request_t *R)
2240 {
2241 return (((R->length * 4) - sizeof(xcb_xv_put_image_request_t))/sizeof(uint8_t));
2242 }
2243
2244 xcb_generic_iterator_t
xcb_xv_put_image_data_end(const xcb_xv_put_image_request_t * R)2245 xcb_xv_put_image_data_end (const xcb_xv_put_image_request_t *R)
2246 {
2247 xcb_generic_iterator_t i;
2248 i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_xv_put_image_request_t))/sizeof(uint8_t)));
2249 i.rem = 0;
2250 i.index = (char *) i.data - (char *) R;
2251 return i;
2252 }
2253
2254 xcb_void_cookie_t
xcb_xv_shm_put_image_checked(xcb_connection_t * c,xcb_xv_port_t port,xcb_drawable_t drawable,xcb_gcontext_t gc,xcb_shm_seg_t shmseg,uint32_t id,uint32_t offset,int16_t src_x,int16_t src_y,uint16_t src_w,uint16_t src_h,int16_t drw_x,int16_t drw_y,uint16_t drw_w,uint16_t drw_h,uint16_t width,uint16_t height,uint8_t send_event)2255 xcb_xv_shm_put_image_checked (xcb_connection_t *c,
2256 xcb_xv_port_t port,
2257 xcb_drawable_t drawable,
2258 xcb_gcontext_t gc,
2259 xcb_shm_seg_t shmseg,
2260 uint32_t id,
2261 uint32_t offset,
2262 int16_t src_x,
2263 int16_t src_y,
2264 uint16_t src_w,
2265 uint16_t src_h,
2266 int16_t drw_x,
2267 int16_t drw_y,
2268 uint16_t drw_w,
2269 uint16_t drw_h,
2270 uint16_t width,
2271 uint16_t height,
2272 uint8_t send_event)
2273 {
2274 static const xcb_protocol_request_t xcb_req = {
2275 .count = 2,
2276 .ext = &xcb_xv_id,
2277 .opcode = XCB_XV_SHM_PUT_IMAGE,
2278 .isvoid = 1
2279 };
2280
2281 struct iovec xcb_parts[4];
2282 xcb_void_cookie_t xcb_ret;
2283 xcb_xv_shm_put_image_request_t xcb_out;
2284
2285 xcb_out.port = port;
2286 xcb_out.drawable = drawable;
2287 xcb_out.gc = gc;
2288 xcb_out.shmseg = shmseg;
2289 xcb_out.id = id;
2290 xcb_out.offset = offset;
2291 xcb_out.src_x = src_x;
2292 xcb_out.src_y = src_y;
2293 xcb_out.src_w = src_w;
2294 xcb_out.src_h = src_h;
2295 xcb_out.drw_x = drw_x;
2296 xcb_out.drw_y = drw_y;
2297 xcb_out.drw_w = drw_w;
2298 xcb_out.drw_h = drw_h;
2299 xcb_out.width = width;
2300 xcb_out.height = height;
2301 xcb_out.send_event = send_event;
2302 memset(xcb_out.pad0, 0, 3);
2303
2304 xcb_parts[2].iov_base = (char *) &xcb_out;
2305 xcb_parts[2].iov_len = sizeof(xcb_out);
2306 xcb_parts[3].iov_base = 0;
2307 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2308
2309 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
2310 return xcb_ret;
2311 }
2312
2313 xcb_void_cookie_t
xcb_xv_shm_put_image(xcb_connection_t * c,xcb_xv_port_t port,xcb_drawable_t drawable,xcb_gcontext_t gc,xcb_shm_seg_t shmseg,uint32_t id,uint32_t offset,int16_t src_x,int16_t src_y,uint16_t src_w,uint16_t src_h,int16_t drw_x,int16_t drw_y,uint16_t drw_w,uint16_t drw_h,uint16_t width,uint16_t height,uint8_t send_event)2314 xcb_xv_shm_put_image (xcb_connection_t *c,
2315 xcb_xv_port_t port,
2316 xcb_drawable_t drawable,
2317 xcb_gcontext_t gc,
2318 xcb_shm_seg_t shmseg,
2319 uint32_t id,
2320 uint32_t offset,
2321 int16_t src_x,
2322 int16_t src_y,
2323 uint16_t src_w,
2324 uint16_t src_h,
2325 int16_t drw_x,
2326 int16_t drw_y,
2327 uint16_t drw_w,
2328 uint16_t drw_h,
2329 uint16_t width,
2330 uint16_t height,
2331 uint8_t send_event)
2332 {
2333 static const xcb_protocol_request_t xcb_req = {
2334 .count = 2,
2335 .ext = &xcb_xv_id,
2336 .opcode = XCB_XV_SHM_PUT_IMAGE,
2337 .isvoid = 1
2338 };
2339
2340 struct iovec xcb_parts[4];
2341 xcb_void_cookie_t xcb_ret;
2342 xcb_xv_shm_put_image_request_t xcb_out;
2343
2344 xcb_out.port = port;
2345 xcb_out.drawable = drawable;
2346 xcb_out.gc = gc;
2347 xcb_out.shmseg = shmseg;
2348 xcb_out.id = id;
2349 xcb_out.offset = offset;
2350 xcb_out.src_x = src_x;
2351 xcb_out.src_y = src_y;
2352 xcb_out.src_w = src_w;
2353 xcb_out.src_h = src_h;
2354 xcb_out.drw_x = drw_x;
2355 xcb_out.drw_y = drw_y;
2356 xcb_out.drw_w = drw_w;
2357 xcb_out.drw_h = drw_h;
2358 xcb_out.width = width;
2359 xcb_out.height = height;
2360 xcb_out.send_event = send_event;
2361 memset(xcb_out.pad0, 0, 3);
2362
2363 xcb_parts[2].iov_base = (char *) &xcb_out;
2364 xcb_parts[2].iov_len = sizeof(xcb_out);
2365 xcb_parts[3].iov_base = 0;
2366 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
2367
2368 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
2369 return xcb_ret;
2370 }
2371
2372