1/* 2 * This file generated automatically from dri2.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 "dri2.h" 15 16#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) 17#include "xproto.h" 18 19xcb_extension_t xcb_dri2_id = { "DRI2", 0 }; 20 21void 22xcb_dri2_dri2_buffer_next (xcb_dri2_dri2_buffer_iterator_t *i) 23{ 24 --i->rem; 25 ++i->data; 26 i->index += sizeof(xcb_dri2_dri2_buffer_t); 27} 28 29xcb_generic_iterator_t 30xcb_dri2_dri2_buffer_end (xcb_dri2_dri2_buffer_iterator_t i) 31{ 32 xcb_generic_iterator_t ret; 33 ret.data = i.data + i.rem; 34 ret.index = i.index + ((char *) ret.data - (char *) i.data); 35 ret.rem = 0; 36 return ret; 37} 38 39void 40xcb_dri2_attach_format_next (xcb_dri2_attach_format_iterator_t *i) 41{ 42 --i->rem; 43 ++i->data; 44 i->index += sizeof(xcb_dri2_attach_format_t); 45} 46 47xcb_generic_iterator_t 48xcb_dri2_attach_format_end (xcb_dri2_attach_format_iterator_t i) 49{ 50 xcb_generic_iterator_t ret; 51 ret.data = i.data + i.rem; 52 ret.index = i.index + ((char *) ret.data - (char *) i.data); 53 ret.rem = 0; 54 return ret; 55} 56 57xcb_dri2_query_version_cookie_t 58xcb_dri2_query_version (xcb_connection_t *c, 59 uint32_t major_version, 60 uint32_t minor_version) 61{ 62 static const xcb_protocol_request_t xcb_req = { 63 .count = 2, 64 .ext = &xcb_dri2_id, 65 .opcode = XCB_DRI2_QUERY_VERSION, 66 .isvoid = 0 67 }; 68 69 struct iovec xcb_parts[4]; 70 xcb_dri2_query_version_cookie_t xcb_ret; 71 xcb_dri2_query_version_request_t xcb_out; 72 73 xcb_out.major_version = major_version; 74 xcb_out.minor_version = minor_version; 75 76 xcb_parts[2].iov_base = (char *) &xcb_out; 77 xcb_parts[2].iov_len = sizeof(xcb_out); 78 xcb_parts[3].iov_base = 0; 79 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 80 81 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 82 return xcb_ret; 83} 84 85xcb_dri2_query_version_cookie_t 86xcb_dri2_query_version_unchecked (xcb_connection_t *c, 87 uint32_t major_version, 88 uint32_t minor_version) 89{ 90 static const xcb_protocol_request_t xcb_req = { 91 .count = 2, 92 .ext = &xcb_dri2_id, 93 .opcode = XCB_DRI2_QUERY_VERSION, 94 .isvoid = 0 95 }; 96 97 struct iovec xcb_parts[4]; 98 xcb_dri2_query_version_cookie_t xcb_ret; 99 xcb_dri2_query_version_request_t xcb_out; 100 101 xcb_out.major_version = major_version; 102 xcb_out.minor_version = minor_version; 103 104 xcb_parts[2].iov_base = (char *) &xcb_out; 105 xcb_parts[2].iov_len = sizeof(xcb_out); 106 xcb_parts[3].iov_base = 0; 107 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 108 109 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 110 return xcb_ret; 111} 112 113xcb_dri2_query_version_reply_t * 114xcb_dri2_query_version_reply (xcb_connection_t *c, 115 xcb_dri2_query_version_cookie_t cookie /**< */, 116 xcb_generic_error_t **e) 117{ 118 return (xcb_dri2_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 119} 120 121int 122xcb_dri2_connect_sizeof (const void *_buffer) 123{ 124 char *xcb_tmp = (char *)_buffer; 125 const xcb_dri2_connect_reply_t *_aux = (xcb_dri2_connect_reply_t *)_buffer; 126 unsigned int xcb_buffer_len = 0; 127 unsigned int xcb_block_len = 0; 128 unsigned int xcb_pad = 0; 129 unsigned int xcb_align_to = 0; 130 131 132 xcb_block_len += sizeof(xcb_dri2_connect_reply_t); 133 xcb_tmp += xcb_block_len; 134 xcb_buffer_len += xcb_block_len; 135 xcb_block_len = 0; 136 /* driver_name */ 137 xcb_block_len += _aux->driver_name_length * sizeof(char); 138 xcb_tmp += xcb_block_len; 139 xcb_align_to = ALIGNOF(char); 140 /* insert padding */ 141 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 142 xcb_buffer_len += xcb_block_len + xcb_pad; 143 if (0 != xcb_pad) { 144 xcb_tmp += xcb_pad; 145 xcb_pad = 0; 146 } 147 xcb_block_len = 0; 148 /* alignment_pad */ 149 xcb_block_len += (((_aux->driver_name_length + 3) & (~3)) - _aux->driver_name_length) * sizeof(char); 150 xcb_tmp += xcb_block_len; 151 xcb_align_to = ALIGNOF(char); 152 /* insert padding */ 153 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 154 xcb_buffer_len += xcb_block_len + xcb_pad; 155 if (0 != xcb_pad) { 156 xcb_tmp += xcb_pad; 157 xcb_pad = 0; 158 } 159 xcb_block_len = 0; 160 /* device_name */ 161 xcb_block_len += _aux->device_name_length * sizeof(char); 162 xcb_tmp += xcb_block_len; 163 xcb_align_to = ALIGNOF(char); 164 /* insert padding */ 165 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 166 xcb_buffer_len += xcb_block_len + xcb_pad; 167 if (0 != xcb_pad) { 168 xcb_tmp += xcb_pad; 169 xcb_pad = 0; 170 } 171 xcb_block_len = 0; 172 173 return xcb_buffer_len; 174} 175 176xcb_dri2_connect_cookie_t 177xcb_dri2_connect (xcb_connection_t *c, 178 xcb_window_t window, 179 uint32_t driver_type) 180{ 181 static const xcb_protocol_request_t xcb_req = { 182 .count = 2, 183 .ext = &xcb_dri2_id, 184 .opcode = XCB_DRI2_CONNECT, 185 .isvoid = 0 186 }; 187 188 struct iovec xcb_parts[4]; 189 xcb_dri2_connect_cookie_t xcb_ret; 190 xcb_dri2_connect_request_t xcb_out; 191 192 xcb_out.window = window; 193 xcb_out.driver_type = driver_type; 194 195 xcb_parts[2].iov_base = (char *) &xcb_out; 196 xcb_parts[2].iov_len = sizeof(xcb_out); 197 xcb_parts[3].iov_base = 0; 198 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 199 200 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 201 return xcb_ret; 202} 203 204xcb_dri2_connect_cookie_t 205xcb_dri2_connect_unchecked (xcb_connection_t *c, 206 xcb_window_t window, 207 uint32_t driver_type) 208{ 209 static const xcb_protocol_request_t xcb_req = { 210 .count = 2, 211 .ext = &xcb_dri2_id, 212 .opcode = XCB_DRI2_CONNECT, 213 .isvoid = 0 214 }; 215 216 struct iovec xcb_parts[4]; 217 xcb_dri2_connect_cookie_t xcb_ret; 218 xcb_dri2_connect_request_t xcb_out; 219 220 xcb_out.window = window; 221 xcb_out.driver_type = driver_type; 222 223 xcb_parts[2].iov_base = (char *) &xcb_out; 224 xcb_parts[2].iov_len = sizeof(xcb_out); 225 xcb_parts[3].iov_base = 0; 226 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 227 228 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 229 return xcb_ret; 230} 231 232char * 233xcb_dri2_connect_driver_name (const xcb_dri2_connect_reply_t *R) 234{ 235 return (char *) (R + 1); 236} 237 238int 239xcb_dri2_connect_driver_name_length (const xcb_dri2_connect_reply_t *R) 240{ 241 return R->driver_name_length; 242} 243 244xcb_generic_iterator_t 245xcb_dri2_connect_driver_name_end (const xcb_dri2_connect_reply_t *R) 246{ 247 xcb_generic_iterator_t i; 248 i.data = ((char *) (R + 1)) + (R->driver_name_length); 249 i.rem = 0; 250 i.index = (char *) i.data - (char *) R; 251 return i; 252} 253 254void * 255xcb_dri2_connect_alignment_pad (const xcb_dri2_connect_reply_t *R) 256{ 257 xcb_generic_iterator_t prev = xcb_dri2_connect_driver_name_end(R); 258 return (void *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); 259} 260 261int 262xcb_dri2_connect_alignment_pad_length (const xcb_dri2_connect_reply_t *R) 263{ 264 return (((R->driver_name_length + 3) & (~3)) - R->driver_name_length); 265} 266 267xcb_generic_iterator_t 268xcb_dri2_connect_alignment_pad_end (const xcb_dri2_connect_reply_t *R) 269{ 270 xcb_generic_iterator_t i; 271 xcb_generic_iterator_t prev = xcb_dri2_connect_driver_name_end(R); 272 i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + ((((R->driver_name_length + 3) & (~3)) - R->driver_name_length)); 273 i.rem = 0; 274 i.index = (char *) i.data - (char *) R; 275 return i; 276} 277 278char * 279xcb_dri2_connect_device_name (const xcb_dri2_connect_reply_t *R) 280{ 281 xcb_generic_iterator_t prev = xcb_dri2_connect_alignment_pad_end(R); 282 return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); 283} 284 285int 286xcb_dri2_connect_device_name_length (const xcb_dri2_connect_reply_t *R) 287{ 288 return R->device_name_length; 289} 290 291xcb_generic_iterator_t 292xcb_dri2_connect_device_name_end (const xcb_dri2_connect_reply_t *R) 293{ 294 xcb_generic_iterator_t i; 295 xcb_generic_iterator_t prev = xcb_dri2_connect_alignment_pad_end(R); 296 i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->device_name_length); 297 i.rem = 0; 298 i.index = (char *) i.data - (char *) R; 299 return i; 300} 301 302xcb_dri2_connect_reply_t * 303xcb_dri2_connect_reply (xcb_connection_t *c, 304 xcb_dri2_connect_cookie_t cookie /**< */, 305 xcb_generic_error_t **e) 306{ 307 return (xcb_dri2_connect_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 308} 309 310xcb_dri2_authenticate_cookie_t 311xcb_dri2_authenticate (xcb_connection_t *c, 312 xcb_window_t window, 313 uint32_t magic) 314{ 315 static const xcb_protocol_request_t xcb_req = { 316 .count = 2, 317 .ext = &xcb_dri2_id, 318 .opcode = XCB_DRI2_AUTHENTICATE, 319 .isvoid = 0 320 }; 321 322 struct iovec xcb_parts[4]; 323 xcb_dri2_authenticate_cookie_t xcb_ret; 324 xcb_dri2_authenticate_request_t xcb_out; 325 326 xcb_out.window = window; 327 xcb_out.magic = magic; 328 329 xcb_parts[2].iov_base = (char *) &xcb_out; 330 xcb_parts[2].iov_len = sizeof(xcb_out); 331 xcb_parts[3].iov_base = 0; 332 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 333 334 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 335 return xcb_ret; 336} 337 338xcb_dri2_authenticate_cookie_t 339xcb_dri2_authenticate_unchecked (xcb_connection_t *c, 340 xcb_window_t window, 341 uint32_t magic) 342{ 343 static const xcb_protocol_request_t xcb_req = { 344 .count = 2, 345 .ext = &xcb_dri2_id, 346 .opcode = XCB_DRI2_AUTHENTICATE, 347 .isvoid = 0 348 }; 349 350 struct iovec xcb_parts[4]; 351 xcb_dri2_authenticate_cookie_t xcb_ret; 352 xcb_dri2_authenticate_request_t xcb_out; 353 354 xcb_out.window = window; 355 xcb_out.magic = magic; 356 357 xcb_parts[2].iov_base = (char *) &xcb_out; 358 xcb_parts[2].iov_len = sizeof(xcb_out); 359 xcb_parts[3].iov_base = 0; 360 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 361 362 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 363 return xcb_ret; 364} 365 366xcb_dri2_authenticate_reply_t * 367xcb_dri2_authenticate_reply (xcb_connection_t *c, 368 xcb_dri2_authenticate_cookie_t cookie /**< */, 369 xcb_generic_error_t **e) 370{ 371 return (xcb_dri2_authenticate_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 372} 373 374xcb_void_cookie_t 375xcb_dri2_create_drawable_checked (xcb_connection_t *c, 376 xcb_drawable_t drawable) 377{ 378 static const xcb_protocol_request_t xcb_req = { 379 .count = 2, 380 .ext = &xcb_dri2_id, 381 .opcode = XCB_DRI2_CREATE_DRAWABLE, 382 .isvoid = 1 383 }; 384 385 struct iovec xcb_parts[4]; 386 xcb_void_cookie_t xcb_ret; 387 xcb_dri2_create_drawable_request_t xcb_out; 388 389 xcb_out.drawable = drawable; 390 391 xcb_parts[2].iov_base = (char *) &xcb_out; 392 xcb_parts[2].iov_len = sizeof(xcb_out); 393 xcb_parts[3].iov_base = 0; 394 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 395 396 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 397 return xcb_ret; 398} 399 400xcb_void_cookie_t 401xcb_dri2_create_drawable (xcb_connection_t *c, 402 xcb_drawable_t drawable) 403{ 404 static const xcb_protocol_request_t xcb_req = { 405 .count = 2, 406 .ext = &xcb_dri2_id, 407 .opcode = XCB_DRI2_CREATE_DRAWABLE, 408 .isvoid = 1 409 }; 410 411 struct iovec xcb_parts[4]; 412 xcb_void_cookie_t xcb_ret; 413 xcb_dri2_create_drawable_request_t xcb_out; 414 415 xcb_out.drawable = drawable; 416 417 xcb_parts[2].iov_base = (char *) &xcb_out; 418 xcb_parts[2].iov_len = sizeof(xcb_out); 419 xcb_parts[3].iov_base = 0; 420 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 421 422 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 423 return xcb_ret; 424} 425 426xcb_void_cookie_t 427xcb_dri2_destroy_drawable_checked (xcb_connection_t *c, 428 xcb_drawable_t drawable) 429{ 430 static const xcb_protocol_request_t xcb_req = { 431 .count = 2, 432 .ext = &xcb_dri2_id, 433 .opcode = XCB_DRI2_DESTROY_DRAWABLE, 434 .isvoid = 1 435 }; 436 437 struct iovec xcb_parts[4]; 438 xcb_void_cookie_t xcb_ret; 439 xcb_dri2_destroy_drawable_request_t xcb_out; 440 441 xcb_out.drawable = drawable; 442 443 xcb_parts[2].iov_base = (char *) &xcb_out; 444 xcb_parts[2].iov_len = sizeof(xcb_out); 445 xcb_parts[3].iov_base = 0; 446 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 447 448 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 449 return xcb_ret; 450} 451 452xcb_void_cookie_t 453xcb_dri2_destroy_drawable (xcb_connection_t *c, 454 xcb_drawable_t drawable) 455{ 456 static const xcb_protocol_request_t xcb_req = { 457 .count = 2, 458 .ext = &xcb_dri2_id, 459 .opcode = XCB_DRI2_DESTROY_DRAWABLE, 460 .isvoid = 1 461 }; 462 463 struct iovec xcb_parts[4]; 464 xcb_void_cookie_t xcb_ret; 465 xcb_dri2_destroy_drawable_request_t xcb_out; 466 467 xcb_out.drawable = drawable; 468 469 xcb_parts[2].iov_base = (char *) &xcb_out; 470 xcb_parts[2].iov_len = sizeof(xcb_out); 471 xcb_parts[3].iov_base = 0; 472 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 473 474 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 475 return xcb_ret; 476} 477 478int 479xcb_dri2_get_buffers_sizeof (const void *_buffer, 480 uint32_t attachments_len) 481{ 482 char *xcb_tmp = (char *)_buffer; 483 unsigned int xcb_buffer_len = 0; 484 unsigned int xcb_block_len = 0; 485 unsigned int xcb_pad = 0; 486 unsigned int xcb_align_to = 0; 487 488 489 xcb_block_len += sizeof(xcb_dri2_get_buffers_request_t); 490 xcb_tmp += xcb_block_len; 491 xcb_buffer_len += xcb_block_len; 492 xcb_block_len = 0; 493 /* attachments */ 494 xcb_block_len += attachments_len * sizeof(uint32_t); 495 xcb_tmp += xcb_block_len; 496 xcb_align_to = ALIGNOF(uint32_t); 497 /* insert padding */ 498 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 499 xcb_buffer_len += xcb_block_len + xcb_pad; 500 if (0 != xcb_pad) { 501 xcb_tmp += xcb_pad; 502 xcb_pad = 0; 503 } 504 xcb_block_len = 0; 505 506 return xcb_buffer_len; 507} 508 509xcb_dri2_get_buffers_cookie_t 510xcb_dri2_get_buffers (xcb_connection_t *c, 511 xcb_drawable_t drawable, 512 uint32_t count, 513 uint32_t attachments_len, 514 const uint32_t *attachments) 515{ 516 static const xcb_protocol_request_t xcb_req = { 517 .count = 4, 518 .ext = &xcb_dri2_id, 519 .opcode = XCB_DRI2_GET_BUFFERS, 520 .isvoid = 0 521 }; 522 523 struct iovec xcb_parts[6]; 524 xcb_dri2_get_buffers_cookie_t xcb_ret; 525 xcb_dri2_get_buffers_request_t xcb_out; 526 527 xcb_out.drawable = drawable; 528 xcb_out.count = count; 529 530 xcb_parts[2].iov_base = (char *) &xcb_out; 531 xcb_parts[2].iov_len = sizeof(xcb_out); 532 xcb_parts[3].iov_base = 0; 533 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 534 /* uint32_t attachments */ 535 xcb_parts[4].iov_base = (char *) attachments; 536 xcb_parts[4].iov_len = attachments_len * sizeof(uint32_t); 537 xcb_parts[5].iov_base = 0; 538 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 539 540 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 541 return xcb_ret; 542} 543 544xcb_dri2_get_buffers_cookie_t 545xcb_dri2_get_buffers_unchecked (xcb_connection_t *c, 546 xcb_drawable_t drawable, 547 uint32_t count, 548 uint32_t attachments_len, 549 const uint32_t *attachments) 550{ 551 static const xcb_protocol_request_t xcb_req = { 552 .count = 4, 553 .ext = &xcb_dri2_id, 554 .opcode = XCB_DRI2_GET_BUFFERS, 555 .isvoid = 0 556 }; 557 558 struct iovec xcb_parts[6]; 559 xcb_dri2_get_buffers_cookie_t xcb_ret; 560 xcb_dri2_get_buffers_request_t xcb_out; 561 562 xcb_out.drawable = drawable; 563 xcb_out.count = count; 564 565 xcb_parts[2].iov_base = (char *) &xcb_out; 566 xcb_parts[2].iov_len = sizeof(xcb_out); 567 xcb_parts[3].iov_base = 0; 568 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 569 /* uint32_t attachments */ 570 xcb_parts[4].iov_base = (char *) attachments; 571 xcb_parts[4].iov_len = attachments_len * sizeof(uint32_t); 572 xcb_parts[5].iov_base = 0; 573 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 574 575 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 576 return xcb_ret; 577} 578 579xcb_dri2_dri2_buffer_t * 580xcb_dri2_get_buffers_buffers (const xcb_dri2_get_buffers_reply_t *R) 581{ 582 return (xcb_dri2_dri2_buffer_t *) (R + 1); 583} 584 585int 586xcb_dri2_get_buffers_buffers_length (const xcb_dri2_get_buffers_reply_t *R) 587{ 588 return R->count; 589} 590 591xcb_dri2_dri2_buffer_iterator_t 592xcb_dri2_get_buffers_buffers_iterator (const xcb_dri2_get_buffers_reply_t *R) 593{ 594 xcb_dri2_dri2_buffer_iterator_t i; 595 i.data = (xcb_dri2_dri2_buffer_t *) (R + 1); 596 i.rem = R->count; 597 i.index = (char *) i.data - (char *) R; 598 return i; 599} 600 601xcb_dri2_get_buffers_reply_t * 602xcb_dri2_get_buffers_reply (xcb_connection_t *c, 603 xcb_dri2_get_buffers_cookie_t cookie /**< */, 604 xcb_generic_error_t **e) 605{ 606 return (xcb_dri2_get_buffers_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 607} 608 609xcb_dri2_copy_region_cookie_t 610xcb_dri2_copy_region (xcb_connection_t *c, 611 xcb_drawable_t drawable, 612 uint32_t region, 613 uint32_t dest, 614 uint32_t src) 615{ 616 static const xcb_protocol_request_t xcb_req = { 617 .count = 2, 618 .ext = &xcb_dri2_id, 619 .opcode = XCB_DRI2_COPY_REGION, 620 .isvoid = 0 621 }; 622 623 struct iovec xcb_parts[4]; 624 xcb_dri2_copy_region_cookie_t xcb_ret; 625 xcb_dri2_copy_region_request_t xcb_out; 626 627 xcb_out.drawable = drawable; 628 xcb_out.region = region; 629 xcb_out.dest = dest; 630 xcb_out.src = src; 631 632 xcb_parts[2].iov_base = (char *) &xcb_out; 633 xcb_parts[2].iov_len = sizeof(xcb_out); 634 xcb_parts[3].iov_base = 0; 635 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 636 637 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 638 return xcb_ret; 639} 640 641xcb_dri2_copy_region_cookie_t 642xcb_dri2_copy_region_unchecked (xcb_connection_t *c, 643 xcb_drawable_t drawable, 644 uint32_t region, 645 uint32_t dest, 646 uint32_t src) 647{ 648 static const xcb_protocol_request_t xcb_req = { 649 .count = 2, 650 .ext = &xcb_dri2_id, 651 .opcode = XCB_DRI2_COPY_REGION, 652 .isvoid = 0 653 }; 654 655 struct iovec xcb_parts[4]; 656 xcb_dri2_copy_region_cookie_t xcb_ret; 657 xcb_dri2_copy_region_request_t xcb_out; 658 659 xcb_out.drawable = drawable; 660 xcb_out.region = region; 661 xcb_out.dest = dest; 662 xcb_out.src = src; 663 664 xcb_parts[2].iov_base = (char *) &xcb_out; 665 xcb_parts[2].iov_len = sizeof(xcb_out); 666 xcb_parts[3].iov_base = 0; 667 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 668 669 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 670 return xcb_ret; 671} 672 673xcb_dri2_copy_region_reply_t * 674xcb_dri2_copy_region_reply (xcb_connection_t *c, 675 xcb_dri2_copy_region_cookie_t cookie /**< */, 676 xcb_generic_error_t **e) 677{ 678 return (xcb_dri2_copy_region_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 679} 680 681int 682xcb_dri2_get_buffers_with_format_sizeof (const void *_buffer, 683 uint32_t attachments_len) 684{ 685 char *xcb_tmp = (char *)_buffer; 686 unsigned int xcb_buffer_len = 0; 687 unsigned int xcb_block_len = 0; 688 unsigned int xcb_pad = 0; 689 unsigned int xcb_align_to = 0; 690 691 692 xcb_block_len += sizeof(xcb_dri2_get_buffers_with_format_request_t); 693 xcb_tmp += xcb_block_len; 694 xcb_buffer_len += xcb_block_len; 695 xcb_block_len = 0; 696 /* attachments */ 697 xcb_block_len += attachments_len * sizeof(xcb_dri2_attach_format_t); 698 xcb_tmp += xcb_block_len; 699 xcb_align_to = ALIGNOF(xcb_dri2_attach_format_t); 700 /* insert padding */ 701 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 702 xcb_buffer_len += xcb_block_len + xcb_pad; 703 if (0 != xcb_pad) { 704 xcb_tmp += xcb_pad; 705 xcb_pad = 0; 706 } 707 xcb_block_len = 0; 708 709 return xcb_buffer_len; 710} 711 712xcb_dri2_get_buffers_with_format_cookie_t 713xcb_dri2_get_buffers_with_format (xcb_connection_t *c, 714 xcb_drawable_t drawable, 715 uint32_t count, 716 uint32_t attachments_len, 717 const xcb_dri2_attach_format_t *attachments) 718{ 719 static const xcb_protocol_request_t xcb_req = { 720 .count = 4, 721 .ext = &xcb_dri2_id, 722 .opcode = XCB_DRI2_GET_BUFFERS_WITH_FORMAT, 723 .isvoid = 0 724 }; 725 726 struct iovec xcb_parts[6]; 727 xcb_dri2_get_buffers_with_format_cookie_t xcb_ret; 728 xcb_dri2_get_buffers_with_format_request_t xcb_out; 729 730 xcb_out.drawable = drawable; 731 xcb_out.count = count; 732 733 xcb_parts[2].iov_base = (char *) &xcb_out; 734 xcb_parts[2].iov_len = sizeof(xcb_out); 735 xcb_parts[3].iov_base = 0; 736 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 737 /* xcb_dri2_attach_format_t attachments */ 738 xcb_parts[4].iov_base = (char *) attachments; 739 xcb_parts[4].iov_len = attachments_len * sizeof(xcb_dri2_attach_format_t); 740 xcb_parts[5].iov_base = 0; 741 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 742 743 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 744 return xcb_ret; 745} 746 747xcb_dri2_get_buffers_with_format_cookie_t 748xcb_dri2_get_buffers_with_format_unchecked (xcb_connection_t *c, 749 xcb_drawable_t drawable, 750 uint32_t count, 751 uint32_t attachments_len, 752 const xcb_dri2_attach_format_t *attachments) 753{ 754 static const xcb_protocol_request_t xcb_req = { 755 .count = 4, 756 .ext = &xcb_dri2_id, 757 .opcode = XCB_DRI2_GET_BUFFERS_WITH_FORMAT, 758 .isvoid = 0 759 }; 760 761 struct iovec xcb_parts[6]; 762 xcb_dri2_get_buffers_with_format_cookie_t xcb_ret; 763 xcb_dri2_get_buffers_with_format_request_t xcb_out; 764 765 xcb_out.drawable = drawable; 766 xcb_out.count = count; 767 768 xcb_parts[2].iov_base = (char *) &xcb_out; 769 xcb_parts[2].iov_len = sizeof(xcb_out); 770 xcb_parts[3].iov_base = 0; 771 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 772 /* xcb_dri2_attach_format_t attachments */ 773 xcb_parts[4].iov_base = (char *) attachments; 774 xcb_parts[4].iov_len = attachments_len * sizeof(xcb_dri2_attach_format_t); 775 xcb_parts[5].iov_base = 0; 776 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 777 778 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 779 return xcb_ret; 780} 781 782xcb_dri2_dri2_buffer_t * 783xcb_dri2_get_buffers_with_format_buffers (const xcb_dri2_get_buffers_with_format_reply_t *R) 784{ 785 return (xcb_dri2_dri2_buffer_t *) (R + 1); 786} 787 788int 789xcb_dri2_get_buffers_with_format_buffers_length (const xcb_dri2_get_buffers_with_format_reply_t *R) 790{ 791 return R->count; 792} 793 794xcb_dri2_dri2_buffer_iterator_t 795xcb_dri2_get_buffers_with_format_buffers_iterator (const xcb_dri2_get_buffers_with_format_reply_t *R) 796{ 797 xcb_dri2_dri2_buffer_iterator_t i; 798 i.data = (xcb_dri2_dri2_buffer_t *) (R + 1); 799 i.rem = R->count; 800 i.index = (char *) i.data - (char *) R; 801 return i; 802} 803 804xcb_dri2_get_buffers_with_format_reply_t * 805xcb_dri2_get_buffers_with_format_reply (xcb_connection_t *c, 806 xcb_dri2_get_buffers_with_format_cookie_t cookie /**< */, 807 xcb_generic_error_t **e) 808{ 809 return (xcb_dri2_get_buffers_with_format_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 810} 811 812xcb_dri2_swap_buffers_cookie_t 813xcb_dri2_swap_buffers (xcb_connection_t *c, 814 xcb_drawable_t drawable, 815 uint32_t target_msc_hi, 816 uint32_t target_msc_lo, 817 uint32_t divisor_hi, 818 uint32_t divisor_lo, 819 uint32_t remainder_hi, 820 uint32_t remainder_lo) 821{ 822 static const xcb_protocol_request_t xcb_req = { 823 .count = 2, 824 .ext = &xcb_dri2_id, 825 .opcode = XCB_DRI2_SWAP_BUFFERS, 826 .isvoid = 0 827 }; 828 829 struct iovec xcb_parts[4]; 830 xcb_dri2_swap_buffers_cookie_t xcb_ret; 831 xcb_dri2_swap_buffers_request_t xcb_out; 832 833 xcb_out.drawable = drawable; 834 xcb_out.target_msc_hi = target_msc_hi; 835 xcb_out.target_msc_lo = target_msc_lo; 836 xcb_out.divisor_hi = divisor_hi; 837 xcb_out.divisor_lo = divisor_lo; 838 xcb_out.remainder_hi = remainder_hi; 839 xcb_out.remainder_lo = remainder_lo; 840 841 xcb_parts[2].iov_base = (char *) &xcb_out; 842 xcb_parts[2].iov_len = sizeof(xcb_out); 843 xcb_parts[3].iov_base = 0; 844 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 845 846 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 847 return xcb_ret; 848} 849 850xcb_dri2_swap_buffers_cookie_t 851xcb_dri2_swap_buffers_unchecked (xcb_connection_t *c, 852 xcb_drawable_t drawable, 853 uint32_t target_msc_hi, 854 uint32_t target_msc_lo, 855 uint32_t divisor_hi, 856 uint32_t divisor_lo, 857 uint32_t remainder_hi, 858 uint32_t remainder_lo) 859{ 860 static const xcb_protocol_request_t xcb_req = { 861 .count = 2, 862 .ext = &xcb_dri2_id, 863 .opcode = XCB_DRI2_SWAP_BUFFERS, 864 .isvoid = 0 865 }; 866 867 struct iovec xcb_parts[4]; 868 xcb_dri2_swap_buffers_cookie_t xcb_ret; 869 xcb_dri2_swap_buffers_request_t xcb_out; 870 871 xcb_out.drawable = drawable; 872 xcb_out.target_msc_hi = target_msc_hi; 873 xcb_out.target_msc_lo = target_msc_lo; 874 xcb_out.divisor_hi = divisor_hi; 875 xcb_out.divisor_lo = divisor_lo; 876 xcb_out.remainder_hi = remainder_hi; 877 xcb_out.remainder_lo = remainder_lo; 878 879 xcb_parts[2].iov_base = (char *) &xcb_out; 880 xcb_parts[2].iov_len = sizeof(xcb_out); 881 xcb_parts[3].iov_base = 0; 882 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 883 884 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 885 return xcb_ret; 886} 887 888xcb_dri2_swap_buffers_reply_t * 889xcb_dri2_swap_buffers_reply (xcb_connection_t *c, 890 xcb_dri2_swap_buffers_cookie_t cookie /**< */, 891 xcb_generic_error_t **e) 892{ 893 return (xcb_dri2_swap_buffers_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 894} 895 896xcb_dri2_get_msc_cookie_t 897xcb_dri2_get_msc (xcb_connection_t *c, 898 xcb_drawable_t drawable) 899{ 900 static const xcb_protocol_request_t xcb_req = { 901 .count = 2, 902 .ext = &xcb_dri2_id, 903 .opcode = XCB_DRI2_GET_MSC, 904 .isvoid = 0 905 }; 906 907 struct iovec xcb_parts[4]; 908 xcb_dri2_get_msc_cookie_t xcb_ret; 909 xcb_dri2_get_msc_request_t xcb_out; 910 911 xcb_out.drawable = drawable; 912 913 xcb_parts[2].iov_base = (char *) &xcb_out; 914 xcb_parts[2].iov_len = sizeof(xcb_out); 915 xcb_parts[3].iov_base = 0; 916 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 917 918 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 919 return xcb_ret; 920} 921 922xcb_dri2_get_msc_cookie_t 923xcb_dri2_get_msc_unchecked (xcb_connection_t *c, 924 xcb_drawable_t drawable) 925{ 926 static const xcb_protocol_request_t xcb_req = { 927 .count = 2, 928 .ext = &xcb_dri2_id, 929 .opcode = XCB_DRI2_GET_MSC, 930 .isvoid = 0 931 }; 932 933 struct iovec xcb_parts[4]; 934 xcb_dri2_get_msc_cookie_t xcb_ret; 935 xcb_dri2_get_msc_request_t xcb_out; 936 937 xcb_out.drawable = drawable; 938 939 xcb_parts[2].iov_base = (char *) &xcb_out; 940 xcb_parts[2].iov_len = sizeof(xcb_out); 941 xcb_parts[3].iov_base = 0; 942 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 943 944 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 945 return xcb_ret; 946} 947 948xcb_dri2_get_msc_reply_t * 949xcb_dri2_get_msc_reply (xcb_connection_t *c, 950 xcb_dri2_get_msc_cookie_t cookie /**< */, 951 xcb_generic_error_t **e) 952{ 953 return (xcb_dri2_get_msc_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 954} 955 956xcb_dri2_wait_msc_cookie_t 957xcb_dri2_wait_msc (xcb_connection_t *c, 958 xcb_drawable_t drawable, 959 uint32_t target_msc_hi, 960 uint32_t target_msc_lo, 961 uint32_t divisor_hi, 962 uint32_t divisor_lo, 963 uint32_t remainder_hi, 964 uint32_t remainder_lo) 965{ 966 static const xcb_protocol_request_t xcb_req = { 967 .count = 2, 968 .ext = &xcb_dri2_id, 969 .opcode = XCB_DRI2_WAIT_MSC, 970 .isvoid = 0 971 }; 972 973 struct iovec xcb_parts[4]; 974 xcb_dri2_wait_msc_cookie_t xcb_ret; 975 xcb_dri2_wait_msc_request_t xcb_out; 976 977 xcb_out.drawable = drawable; 978 xcb_out.target_msc_hi = target_msc_hi; 979 xcb_out.target_msc_lo = target_msc_lo; 980 xcb_out.divisor_hi = divisor_hi; 981 xcb_out.divisor_lo = divisor_lo; 982 xcb_out.remainder_hi = remainder_hi; 983 xcb_out.remainder_lo = remainder_lo; 984 985 xcb_parts[2].iov_base = (char *) &xcb_out; 986 xcb_parts[2].iov_len = sizeof(xcb_out); 987 xcb_parts[3].iov_base = 0; 988 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 989 990 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 991 return xcb_ret; 992} 993 994xcb_dri2_wait_msc_cookie_t 995xcb_dri2_wait_msc_unchecked (xcb_connection_t *c, 996 xcb_drawable_t drawable, 997 uint32_t target_msc_hi, 998 uint32_t target_msc_lo, 999 uint32_t divisor_hi, 1000 uint32_t divisor_lo, 1001 uint32_t remainder_hi, 1002 uint32_t remainder_lo) 1003{ 1004 static const xcb_protocol_request_t xcb_req = { 1005 .count = 2, 1006 .ext = &xcb_dri2_id, 1007 .opcode = XCB_DRI2_WAIT_MSC, 1008 .isvoid = 0 1009 }; 1010 1011 struct iovec xcb_parts[4]; 1012 xcb_dri2_wait_msc_cookie_t xcb_ret; 1013 xcb_dri2_wait_msc_request_t xcb_out; 1014 1015 xcb_out.drawable = drawable; 1016 xcb_out.target_msc_hi = target_msc_hi; 1017 xcb_out.target_msc_lo = target_msc_lo; 1018 xcb_out.divisor_hi = divisor_hi; 1019 xcb_out.divisor_lo = divisor_lo; 1020 xcb_out.remainder_hi = remainder_hi; 1021 xcb_out.remainder_lo = remainder_lo; 1022 1023 xcb_parts[2].iov_base = (char *) &xcb_out; 1024 xcb_parts[2].iov_len = sizeof(xcb_out); 1025 xcb_parts[3].iov_base = 0; 1026 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1027 1028 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1029 return xcb_ret; 1030} 1031 1032xcb_dri2_wait_msc_reply_t * 1033xcb_dri2_wait_msc_reply (xcb_connection_t *c, 1034 xcb_dri2_wait_msc_cookie_t cookie /**< */, 1035 xcb_generic_error_t **e) 1036{ 1037 return (xcb_dri2_wait_msc_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1038} 1039 1040xcb_dri2_wait_sbc_cookie_t 1041xcb_dri2_wait_sbc (xcb_connection_t *c, 1042 xcb_drawable_t drawable, 1043 uint32_t target_sbc_hi, 1044 uint32_t target_sbc_lo) 1045{ 1046 static const xcb_protocol_request_t xcb_req = { 1047 .count = 2, 1048 .ext = &xcb_dri2_id, 1049 .opcode = XCB_DRI2_WAIT_SBC, 1050 .isvoid = 0 1051 }; 1052 1053 struct iovec xcb_parts[4]; 1054 xcb_dri2_wait_sbc_cookie_t xcb_ret; 1055 xcb_dri2_wait_sbc_request_t xcb_out; 1056 1057 xcb_out.drawable = drawable; 1058 xcb_out.target_sbc_hi = target_sbc_hi; 1059 xcb_out.target_sbc_lo = target_sbc_lo; 1060 1061 xcb_parts[2].iov_base = (char *) &xcb_out; 1062 xcb_parts[2].iov_len = sizeof(xcb_out); 1063 xcb_parts[3].iov_base = 0; 1064 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1065 1066 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1067 return xcb_ret; 1068} 1069 1070xcb_dri2_wait_sbc_cookie_t 1071xcb_dri2_wait_sbc_unchecked (xcb_connection_t *c, 1072 xcb_drawable_t drawable, 1073 uint32_t target_sbc_hi, 1074 uint32_t target_sbc_lo) 1075{ 1076 static const xcb_protocol_request_t xcb_req = { 1077 .count = 2, 1078 .ext = &xcb_dri2_id, 1079 .opcode = XCB_DRI2_WAIT_SBC, 1080 .isvoid = 0 1081 }; 1082 1083 struct iovec xcb_parts[4]; 1084 xcb_dri2_wait_sbc_cookie_t xcb_ret; 1085 xcb_dri2_wait_sbc_request_t xcb_out; 1086 1087 xcb_out.drawable = drawable; 1088 xcb_out.target_sbc_hi = target_sbc_hi; 1089 xcb_out.target_sbc_lo = target_sbc_lo; 1090 1091 xcb_parts[2].iov_base = (char *) &xcb_out; 1092 xcb_parts[2].iov_len = sizeof(xcb_out); 1093 xcb_parts[3].iov_base = 0; 1094 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1095 1096 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1097 return xcb_ret; 1098} 1099 1100xcb_dri2_wait_sbc_reply_t * 1101xcb_dri2_wait_sbc_reply (xcb_connection_t *c, 1102 xcb_dri2_wait_sbc_cookie_t cookie /**< */, 1103 xcb_generic_error_t **e) 1104{ 1105 return (xcb_dri2_wait_sbc_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1106} 1107 1108xcb_void_cookie_t 1109xcb_dri2_swap_interval_checked (xcb_connection_t *c, 1110 xcb_drawable_t drawable, 1111 uint32_t interval) 1112{ 1113 static const xcb_protocol_request_t xcb_req = { 1114 .count = 2, 1115 .ext = &xcb_dri2_id, 1116 .opcode = XCB_DRI2_SWAP_INTERVAL, 1117 .isvoid = 1 1118 }; 1119 1120 struct iovec xcb_parts[4]; 1121 xcb_void_cookie_t xcb_ret; 1122 xcb_dri2_swap_interval_request_t xcb_out; 1123 1124 xcb_out.drawable = drawable; 1125 xcb_out.interval = interval; 1126 1127 xcb_parts[2].iov_base = (char *) &xcb_out; 1128 xcb_parts[2].iov_len = sizeof(xcb_out); 1129 xcb_parts[3].iov_base = 0; 1130 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1131 1132 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1133 return xcb_ret; 1134} 1135 1136xcb_void_cookie_t 1137xcb_dri2_swap_interval (xcb_connection_t *c, 1138 xcb_drawable_t drawable, 1139 uint32_t interval) 1140{ 1141 static const xcb_protocol_request_t xcb_req = { 1142 .count = 2, 1143 .ext = &xcb_dri2_id, 1144 .opcode = XCB_DRI2_SWAP_INTERVAL, 1145 .isvoid = 1 1146 }; 1147 1148 struct iovec xcb_parts[4]; 1149 xcb_void_cookie_t xcb_ret; 1150 xcb_dri2_swap_interval_request_t xcb_out; 1151 1152 xcb_out.drawable = drawable; 1153 xcb_out.interval = interval; 1154 1155 xcb_parts[2].iov_base = (char *) &xcb_out; 1156 xcb_parts[2].iov_len = sizeof(xcb_out); 1157 xcb_parts[3].iov_base = 0; 1158 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1159 1160 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1161 return xcb_ret; 1162} 1163 1164xcb_dri2_get_param_cookie_t 1165xcb_dri2_get_param (xcb_connection_t *c, 1166 xcb_drawable_t drawable, 1167 uint32_t param) 1168{ 1169 static const xcb_protocol_request_t xcb_req = { 1170 .count = 2, 1171 .ext = &xcb_dri2_id, 1172 .opcode = XCB_DRI2_GET_PARAM, 1173 .isvoid = 0 1174 }; 1175 1176 struct iovec xcb_parts[4]; 1177 xcb_dri2_get_param_cookie_t xcb_ret; 1178 xcb_dri2_get_param_request_t xcb_out; 1179 1180 xcb_out.drawable = drawable; 1181 xcb_out.param = param; 1182 1183 xcb_parts[2].iov_base = (char *) &xcb_out; 1184 xcb_parts[2].iov_len = sizeof(xcb_out); 1185 xcb_parts[3].iov_base = 0; 1186 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1187 1188 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1189 return xcb_ret; 1190} 1191 1192xcb_dri2_get_param_cookie_t 1193xcb_dri2_get_param_unchecked (xcb_connection_t *c, 1194 xcb_drawable_t drawable, 1195 uint32_t param) 1196{ 1197 static const xcb_protocol_request_t xcb_req = { 1198 .count = 2, 1199 .ext = &xcb_dri2_id, 1200 .opcode = XCB_DRI2_GET_PARAM, 1201 .isvoid = 0 1202 }; 1203 1204 struct iovec xcb_parts[4]; 1205 xcb_dri2_get_param_cookie_t xcb_ret; 1206 xcb_dri2_get_param_request_t xcb_out; 1207 1208 xcb_out.drawable = drawable; 1209 xcb_out.param = param; 1210 1211 xcb_parts[2].iov_base = (char *) &xcb_out; 1212 xcb_parts[2].iov_len = sizeof(xcb_out); 1213 xcb_parts[3].iov_base = 0; 1214 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1215 1216 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1217 return xcb_ret; 1218} 1219 1220xcb_dri2_get_param_reply_t * 1221xcb_dri2_get_param_reply (xcb_connection_t *c, 1222 xcb_dri2_get_param_cookie_t cookie /**< */, 1223 xcb_generic_error_t **e) 1224{ 1225 return (xcb_dri2_get_param_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1226} 1227 1228