1 /* 2 * This file generated automatically from xvmc.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 "xvmc.h" 15 16 #define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) 17 #include "xv.h" 18 19 xcb_extension_t xcb_xvmc_id = { "XVideo-MotionCompensation", 0 }; 20 21 void 22 xcb_xvmc_context_next (xcb_xvmc_context_iterator_t *i) 23 { 24 --i->rem; 25 ++i->data; 26 i->index += sizeof(xcb_xvmc_context_t); 27 } 28 29 xcb_generic_iterator_t 30 xcb_xvmc_context_end (xcb_xvmc_context_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 39 void 40 xcb_xvmc_surface_next (xcb_xvmc_surface_iterator_t *i) 41 { 42 --i->rem; 43 ++i->data; 44 i->index += sizeof(xcb_xvmc_surface_t); 45 } 46 47 xcb_generic_iterator_t 48 xcb_xvmc_surface_end (xcb_xvmc_surface_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 57 void 58 xcb_xvmc_subpicture_next (xcb_xvmc_subpicture_iterator_t *i) 59 { 60 --i->rem; 61 ++i->data; 62 i->index += sizeof(xcb_xvmc_subpicture_t); 63 } 64 65 xcb_generic_iterator_t 66 xcb_xvmc_subpicture_end (xcb_xvmc_subpicture_iterator_t i) 67 { 68 xcb_generic_iterator_t ret; 69 ret.data = i.data + i.rem; 70 ret.index = i.index + ((char *) ret.data - (char *) i.data); 71 ret.rem = 0; 72 return ret; 73 } 74 75 void 76 xcb_xvmc_surface_info_next (xcb_xvmc_surface_info_iterator_t *i) 77 { 78 --i->rem; 79 ++i->data; 80 i->index += sizeof(xcb_xvmc_surface_info_t); 81 } 82 83 xcb_generic_iterator_t 84 xcb_xvmc_surface_info_end (xcb_xvmc_surface_info_iterator_t i) 85 { 86 xcb_generic_iterator_t ret; 87 ret.data = i.data + i.rem; 88 ret.index = i.index + ((char *) ret.data - (char *) i.data); 89 ret.rem = 0; 90 return ret; 91 } 92 93 xcb_xvmc_query_version_cookie_t 94 xcb_xvmc_query_version (xcb_connection_t *c) 95 { 96 static const xcb_protocol_request_t xcb_req = { 97 .count = 2, 98 .ext = &xcb_xvmc_id, 99 .opcode = XCB_XVMC_QUERY_VERSION, 100 .isvoid = 0 101 }; 102 103 struct iovec xcb_parts[4]; 104 xcb_xvmc_query_version_cookie_t xcb_ret; 105 xcb_xvmc_query_version_request_t xcb_out; 106 107 108 xcb_parts[2].iov_base = (char *) &xcb_out; 109 xcb_parts[2].iov_len = sizeof(xcb_out); 110 xcb_parts[3].iov_base = 0; 111 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 112 113 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 114 return xcb_ret; 115 } 116 117 xcb_xvmc_query_version_cookie_t 118 xcb_xvmc_query_version_unchecked (xcb_connection_t *c) 119 { 120 static const xcb_protocol_request_t xcb_req = { 121 .count = 2, 122 .ext = &xcb_xvmc_id, 123 .opcode = XCB_XVMC_QUERY_VERSION, 124 .isvoid = 0 125 }; 126 127 struct iovec xcb_parts[4]; 128 xcb_xvmc_query_version_cookie_t xcb_ret; 129 xcb_xvmc_query_version_request_t xcb_out; 130 131 132 xcb_parts[2].iov_base = (char *) &xcb_out; 133 xcb_parts[2].iov_len = sizeof(xcb_out); 134 xcb_parts[3].iov_base = 0; 135 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 136 137 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 138 return xcb_ret; 139 } 140 141 xcb_xvmc_query_version_reply_t * 142 xcb_xvmc_query_version_reply (xcb_connection_t *c, 143 xcb_xvmc_query_version_cookie_t cookie /**< */, 144 xcb_generic_error_t **e) 145 { 146 return (xcb_xvmc_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 147 } 148 149 int 150 xcb_xvmc_list_surface_types_sizeof (const void *_buffer) 151 { 152 char *xcb_tmp = (char *)_buffer; 153 const xcb_xvmc_list_surface_types_reply_t *_aux = (xcb_xvmc_list_surface_types_reply_t *)_buffer; 154 unsigned int xcb_buffer_len = 0; 155 unsigned int xcb_block_len = 0; 156 unsigned int xcb_pad = 0; 157 unsigned int xcb_align_to = 0; 158 159 160 xcb_block_len += sizeof(xcb_xvmc_list_surface_types_reply_t); 161 xcb_tmp += xcb_block_len; 162 xcb_buffer_len += xcb_block_len; 163 xcb_block_len = 0; 164 /* surfaces */ 165 xcb_block_len += _aux->num * sizeof(xcb_xvmc_surface_info_t); 166 xcb_tmp += xcb_block_len; 167 xcb_align_to = ALIGNOF(xcb_xvmc_surface_info_t); 168 /* insert padding */ 169 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 170 xcb_buffer_len += xcb_block_len + xcb_pad; 171 if (0 != xcb_pad) { 172 xcb_tmp += xcb_pad; 173 xcb_pad = 0; 174 } 175 xcb_block_len = 0; 176 177 return xcb_buffer_len; 178 } 179 180 xcb_xvmc_list_surface_types_cookie_t 181 xcb_xvmc_list_surface_types (xcb_connection_t *c, 182 xcb_xv_port_t port_id) 183 { 184 static const xcb_protocol_request_t xcb_req = { 185 .count = 2, 186 .ext = &xcb_xvmc_id, 187 .opcode = XCB_XVMC_LIST_SURFACE_TYPES, 188 .isvoid = 0 189 }; 190 191 struct iovec xcb_parts[4]; 192 xcb_xvmc_list_surface_types_cookie_t xcb_ret; 193 xcb_xvmc_list_surface_types_request_t xcb_out; 194 195 xcb_out.port_id = port_id; 196 197 xcb_parts[2].iov_base = (char *) &xcb_out; 198 xcb_parts[2].iov_len = sizeof(xcb_out); 199 xcb_parts[3].iov_base = 0; 200 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 201 202 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 203 return xcb_ret; 204 } 205 206 xcb_xvmc_list_surface_types_cookie_t 207 xcb_xvmc_list_surface_types_unchecked (xcb_connection_t *c, 208 xcb_xv_port_t port_id) 209 { 210 static const xcb_protocol_request_t xcb_req = { 211 .count = 2, 212 .ext = &xcb_xvmc_id, 213 .opcode = XCB_XVMC_LIST_SURFACE_TYPES, 214 .isvoid = 0 215 }; 216 217 struct iovec xcb_parts[4]; 218 xcb_xvmc_list_surface_types_cookie_t xcb_ret; 219 xcb_xvmc_list_surface_types_request_t xcb_out; 220 221 xcb_out.port_id = port_id; 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 232 xcb_xvmc_surface_info_t * 233 xcb_xvmc_list_surface_types_surfaces (const xcb_xvmc_list_surface_types_reply_t *R) 234 { 235 return (xcb_xvmc_surface_info_t *) (R + 1); 236 } 237 238 int 239 xcb_xvmc_list_surface_types_surfaces_length (const xcb_xvmc_list_surface_types_reply_t *R) 240 { 241 return R->num; 242 } 243 244 xcb_xvmc_surface_info_iterator_t 245 xcb_xvmc_list_surface_types_surfaces_iterator (const xcb_xvmc_list_surface_types_reply_t *R) 246 { 247 xcb_xvmc_surface_info_iterator_t i; 248 i.data = (xcb_xvmc_surface_info_t *) (R + 1); 249 i.rem = R->num; 250 i.index = (char *) i.data - (char *) R; 251 return i; 252 } 253 254 xcb_xvmc_list_surface_types_reply_t * 255 xcb_xvmc_list_surface_types_reply (xcb_connection_t *c, 256 xcb_xvmc_list_surface_types_cookie_t cookie /**< */, 257 xcb_generic_error_t **e) 258 { 259 return (xcb_xvmc_list_surface_types_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 260 } 261 262 int 263 xcb_xvmc_create_context_sizeof (const void *_buffer) 264 { 265 char *xcb_tmp = (char *)_buffer; 266 const xcb_xvmc_create_context_reply_t *_aux = (xcb_xvmc_create_context_reply_t *)_buffer; 267 unsigned int xcb_buffer_len = 0; 268 unsigned int xcb_block_len = 0; 269 unsigned int xcb_pad = 0; 270 unsigned int xcb_align_to = 0; 271 272 273 xcb_block_len += sizeof(xcb_xvmc_create_context_reply_t); 274 xcb_tmp += xcb_block_len; 275 xcb_buffer_len += xcb_block_len; 276 xcb_block_len = 0; 277 /* priv_data */ 278 xcb_block_len += _aux->length * sizeof(uint32_t); 279 xcb_tmp += xcb_block_len; 280 xcb_align_to = ALIGNOF(uint32_t); 281 /* insert padding */ 282 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 283 xcb_buffer_len += xcb_block_len + xcb_pad; 284 if (0 != xcb_pad) { 285 xcb_tmp += xcb_pad; 286 xcb_pad = 0; 287 } 288 xcb_block_len = 0; 289 290 return xcb_buffer_len; 291 } 292 293 xcb_xvmc_create_context_cookie_t 294 xcb_xvmc_create_context (xcb_connection_t *c, 295 xcb_xvmc_context_t context_id, 296 xcb_xv_port_t port_id, 297 xcb_xvmc_surface_t surface_id, 298 uint16_t width, 299 uint16_t height, 300 uint32_t flags) 301 { 302 static const xcb_protocol_request_t xcb_req = { 303 .count = 2, 304 .ext = &xcb_xvmc_id, 305 .opcode = XCB_XVMC_CREATE_CONTEXT, 306 .isvoid = 0 307 }; 308 309 struct iovec xcb_parts[4]; 310 xcb_xvmc_create_context_cookie_t xcb_ret; 311 xcb_xvmc_create_context_request_t xcb_out; 312 313 xcb_out.context_id = context_id; 314 xcb_out.port_id = port_id; 315 xcb_out.surface_id = surface_id; 316 xcb_out.width = width; 317 xcb_out.height = height; 318 xcb_out.flags = flags; 319 320 xcb_parts[2].iov_base = (char *) &xcb_out; 321 xcb_parts[2].iov_len = sizeof(xcb_out); 322 xcb_parts[3].iov_base = 0; 323 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 324 325 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 326 return xcb_ret; 327 } 328 329 xcb_xvmc_create_context_cookie_t 330 xcb_xvmc_create_context_unchecked (xcb_connection_t *c, 331 xcb_xvmc_context_t context_id, 332 xcb_xv_port_t port_id, 333 xcb_xvmc_surface_t surface_id, 334 uint16_t width, 335 uint16_t height, 336 uint32_t flags) 337 { 338 static const xcb_protocol_request_t xcb_req = { 339 .count = 2, 340 .ext = &xcb_xvmc_id, 341 .opcode = XCB_XVMC_CREATE_CONTEXT, 342 .isvoid = 0 343 }; 344 345 struct iovec xcb_parts[4]; 346 xcb_xvmc_create_context_cookie_t xcb_ret; 347 xcb_xvmc_create_context_request_t xcb_out; 348 349 xcb_out.context_id = context_id; 350 xcb_out.port_id = port_id; 351 xcb_out.surface_id = surface_id; 352 xcb_out.width = width; 353 xcb_out.height = height; 354 xcb_out.flags = flags; 355 356 xcb_parts[2].iov_base = (char *) &xcb_out; 357 xcb_parts[2].iov_len = sizeof(xcb_out); 358 xcb_parts[3].iov_base = 0; 359 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 360 361 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 362 return xcb_ret; 363 } 364 365 uint32_t * 366 xcb_xvmc_create_context_priv_data (const xcb_xvmc_create_context_reply_t *R) 367 { 368 return (uint32_t *) (R + 1); 369 } 370 371 int 372 xcb_xvmc_create_context_priv_data_length (const xcb_xvmc_create_context_reply_t *R) 373 { 374 return R->length; 375 } 376 377 xcb_generic_iterator_t 378 xcb_xvmc_create_context_priv_data_end (const xcb_xvmc_create_context_reply_t *R) 379 { 380 xcb_generic_iterator_t i; 381 i.data = ((uint32_t *) (R + 1)) + (R->length); 382 i.rem = 0; 383 i.index = (char *) i.data - (char *) R; 384 return i; 385 } 386 387 xcb_xvmc_create_context_reply_t * 388 xcb_xvmc_create_context_reply (xcb_connection_t *c, 389 xcb_xvmc_create_context_cookie_t cookie /**< */, 390 xcb_generic_error_t **e) 391 { 392 return (xcb_xvmc_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 393 } 394 395 xcb_void_cookie_t 396 xcb_xvmc_destroy_context_checked (xcb_connection_t *c, 397 xcb_xvmc_context_t context_id) 398 { 399 static const xcb_protocol_request_t xcb_req = { 400 .count = 2, 401 .ext = &xcb_xvmc_id, 402 .opcode = XCB_XVMC_DESTROY_CONTEXT, 403 .isvoid = 1 404 }; 405 406 struct iovec xcb_parts[4]; 407 xcb_void_cookie_t xcb_ret; 408 xcb_xvmc_destroy_context_request_t xcb_out; 409 410 xcb_out.context_id = context_id; 411 412 xcb_parts[2].iov_base = (char *) &xcb_out; 413 xcb_parts[2].iov_len = sizeof(xcb_out); 414 xcb_parts[3].iov_base = 0; 415 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 416 417 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 418 return xcb_ret; 419 } 420 421 xcb_void_cookie_t 422 xcb_xvmc_destroy_context (xcb_connection_t *c, 423 xcb_xvmc_context_t context_id) 424 { 425 static const xcb_protocol_request_t xcb_req = { 426 .count = 2, 427 .ext = &xcb_xvmc_id, 428 .opcode = XCB_XVMC_DESTROY_CONTEXT, 429 .isvoid = 1 430 }; 431 432 struct iovec xcb_parts[4]; 433 xcb_void_cookie_t xcb_ret; 434 xcb_xvmc_destroy_context_request_t xcb_out; 435 436 xcb_out.context_id = context_id; 437 438 xcb_parts[2].iov_base = (char *) &xcb_out; 439 xcb_parts[2].iov_len = sizeof(xcb_out); 440 xcb_parts[3].iov_base = 0; 441 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 442 443 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 444 return xcb_ret; 445 } 446 447 int 448 xcb_xvmc_create_surface_sizeof (const void *_buffer) 449 { 450 char *xcb_tmp = (char *)_buffer; 451 const xcb_xvmc_create_surface_reply_t *_aux = (xcb_xvmc_create_surface_reply_t *)_buffer; 452 unsigned int xcb_buffer_len = 0; 453 unsigned int xcb_block_len = 0; 454 unsigned int xcb_pad = 0; 455 unsigned int xcb_align_to = 0; 456 457 458 xcb_block_len += sizeof(xcb_xvmc_create_surface_reply_t); 459 xcb_tmp += xcb_block_len; 460 xcb_buffer_len += xcb_block_len; 461 xcb_block_len = 0; 462 /* priv_data */ 463 xcb_block_len += _aux->length * sizeof(uint32_t); 464 xcb_tmp += xcb_block_len; 465 xcb_align_to = ALIGNOF(uint32_t); 466 /* insert padding */ 467 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 468 xcb_buffer_len += xcb_block_len + xcb_pad; 469 if (0 != xcb_pad) { 470 xcb_tmp += xcb_pad; 471 xcb_pad = 0; 472 } 473 xcb_block_len = 0; 474 475 return xcb_buffer_len; 476 } 477 478 xcb_xvmc_create_surface_cookie_t 479 xcb_xvmc_create_surface (xcb_connection_t *c, 480 xcb_xvmc_surface_t surface_id, 481 xcb_xvmc_context_t context_id) 482 { 483 static const xcb_protocol_request_t xcb_req = { 484 .count = 2, 485 .ext = &xcb_xvmc_id, 486 .opcode = XCB_XVMC_CREATE_SURFACE, 487 .isvoid = 0 488 }; 489 490 struct iovec xcb_parts[4]; 491 xcb_xvmc_create_surface_cookie_t xcb_ret; 492 xcb_xvmc_create_surface_request_t xcb_out; 493 494 xcb_out.surface_id = surface_id; 495 xcb_out.context_id = context_id; 496 497 xcb_parts[2].iov_base = (char *) &xcb_out; 498 xcb_parts[2].iov_len = sizeof(xcb_out); 499 xcb_parts[3].iov_base = 0; 500 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 501 502 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 503 return xcb_ret; 504 } 505 506 xcb_xvmc_create_surface_cookie_t 507 xcb_xvmc_create_surface_unchecked (xcb_connection_t *c, 508 xcb_xvmc_surface_t surface_id, 509 xcb_xvmc_context_t context_id) 510 { 511 static const xcb_protocol_request_t xcb_req = { 512 .count = 2, 513 .ext = &xcb_xvmc_id, 514 .opcode = XCB_XVMC_CREATE_SURFACE, 515 .isvoid = 0 516 }; 517 518 struct iovec xcb_parts[4]; 519 xcb_xvmc_create_surface_cookie_t xcb_ret; 520 xcb_xvmc_create_surface_request_t xcb_out; 521 522 xcb_out.surface_id = surface_id; 523 xcb_out.context_id = context_id; 524 525 xcb_parts[2].iov_base = (char *) &xcb_out; 526 xcb_parts[2].iov_len = sizeof(xcb_out); 527 xcb_parts[3].iov_base = 0; 528 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 529 530 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 531 return xcb_ret; 532 } 533 534 uint32_t * 535 xcb_xvmc_create_surface_priv_data (const xcb_xvmc_create_surface_reply_t *R) 536 { 537 return (uint32_t *) (R + 1); 538 } 539 540 int 541 xcb_xvmc_create_surface_priv_data_length (const xcb_xvmc_create_surface_reply_t *R) 542 { 543 return R->length; 544 } 545 546 xcb_generic_iterator_t 547 xcb_xvmc_create_surface_priv_data_end (const xcb_xvmc_create_surface_reply_t *R) 548 { 549 xcb_generic_iterator_t i; 550 i.data = ((uint32_t *) (R + 1)) + (R->length); 551 i.rem = 0; 552 i.index = (char *) i.data - (char *) R; 553 return i; 554 } 555 556 xcb_xvmc_create_surface_reply_t * 557 xcb_xvmc_create_surface_reply (xcb_connection_t *c, 558 xcb_xvmc_create_surface_cookie_t cookie /**< */, 559 xcb_generic_error_t **e) 560 { 561 return (xcb_xvmc_create_surface_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 562 } 563 564 xcb_void_cookie_t 565 xcb_xvmc_destroy_surface_checked (xcb_connection_t *c, 566 xcb_xvmc_surface_t surface_id) 567 { 568 static const xcb_protocol_request_t xcb_req = { 569 .count = 2, 570 .ext = &xcb_xvmc_id, 571 .opcode = XCB_XVMC_DESTROY_SURFACE, 572 .isvoid = 1 573 }; 574 575 struct iovec xcb_parts[4]; 576 xcb_void_cookie_t xcb_ret; 577 xcb_xvmc_destroy_surface_request_t xcb_out; 578 579 xcb_out.surface_id = surface_id; 580 581 xcb_parts[2].iov_base = (char *) &xcb_out; 582 xcb_parts[2].iov_len = sizeof(xcb_out); 583 xcb_parts[3].iov_base = 0; 584 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 585 586 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 587 return xcb_ret; 588 } 589 590 xcb_void_cookie_t 591 xcb_xvmc_destroy_surface (xcb_connection_t *c, 592 xcb_xvmc_surface_t surface_id) 593 { 594 static const xcb_protocol_request_t xcb_req = { 595 .count = 2, 596 .ext = &xcb_xvmc_id, 597 .opcode = XCB_XVMC_DESTROY_SURFACE, 598 .isvoid = 1 599 }; 600 601 struct iovec xcb_parts[4]; 602 xcb_void_cookie_t xcb_ret; 603 xcb_xvmc_destroy_surface_request_t xcb_out; 604 605 xcb_out.surface_id = surface_id; 606 607 xcb_parts[2].iov_base = (char *) &xcb_out; 608 xcb_parts[2].iov_len = sizeof(xcb_out); 609 xcb_parts[3].iov_base = 0; 610 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 611 612 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 613 return xcb_ret; 614 } 615 616 int 617 xcb_xvmc_create_subpicture_sizeof (const void *_buffer) 618 { 619 char *xcb_tmp = (char *)_buffer; 620 const xcb_xvmc_create_subpicture_reply_t *_aux = (xcb_xvmc_create_subpicture_reply_t *)_buffer; 621 unsigned int xcb_buffer_len = 0; 622 unsigned int xcb_block_len = 0; 623 unsigned int xcb_pad = 0; 624 unsigned int xcb_align_to = 0; 625 626 627 xcb_block_len += sizeof(xcb_xvmc_create_subpicture_reply_t); 628 xcb_tmp += xcb_block_len; 629 xcb_buffer_len += xcb_block_len; 630 xcb_block_len = 0; 631 /* priv_data */ 632 xcb_block_len += _aux->length * sizeof(uint32_t); 633 xcb_tmp += xcb_block_len; 634 xcb_align_to = ALIGNOF(uint32_t); 635 /* insert padding */ 636 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 637 xcb_buffer_len += xcb_block_len + xcb_pad; 638 if (0 != xcb_pad) { 639 xcb_tmp += xcb_pad; 640 xcb_pad = 0; 641 } 642 xcb_block_len = 0; 643 644 return xcb_buffer_len; 645 } 646 647 xcb_xvmc_create_subpicture_cookie_t 648 xcb_xvmc_create_subpicture (xcb_connection_t *c, 649 xcb_xvmc_subpicture_t subpicture_id, 650 xcb_xvmc_context_t context, 651 uint32_t xvimage_id, 652 uint16_t width, 653 uint16_t height) 654 { 655 static const xcb_protocol_request_t xcb_req = { 656 .count = 2, 657 .ext = &xcb_xvmc_id, 658 .opcode = XCB_XVMC_CREATE_SUBPICTURE, 659 .isvoid = 0 660 }; 661 662 struct iovec xcb_parts[4]; 663 xcb_xvmc_create_subpicture_cookie_t xcb_ret; 664 xcb_xvmc_create_subpicture_request_t xcb_out; 665 666 xcb_out.subpicture_id = subpicture_id; 667 xcb_out.context = context; 668 xcb_out.xvimage_id = xvimage_id; 669 xcb_out.width = width; 670 xcb_out.height = height; 671 672 xcb_parts[2].iov_base = (char *) &xcb_out; 673 xcb_parts[2].iov_len = sizeof(xcb_out); 674 xcb_parts[3].iov_base = 0; 675 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 676 677 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 678 return xcb_ret; 679 } 680 681 xcb_xvmc_create_subpicture_cookie_t 682 xcb_xvmc_create_subpicture_unchecked (xcb_connection_t *c, 683 xcb_xvmc_subpicture_t subpicture_id, 684 xcb_xvmc_context_t context, 685 uint32_t xvimage_id, 686 uint16_t width, 687 uint16_t height) 688 { 689 static const xcb_protocol_request_t xcb_req = { 690 .count = 2, 691 .ext = &xcb_xvmc_id, 692 .opcode = XCB_XVMC_CREATE_SUBPICTURE, 693 .isvoid = 0 694 }; 695 696 struct iovec xcb_parts[4]; 697 xcb_xvmc_create_subpicture_cookie_t xcb_ret; 698 xcb_xvmc_create_subpicture_request_t xcb_out; 699 700 xcb_out.subpicture_id = subpicture_id; 701 xcb_out.context = context; 702 xcb_out.xvimage_id = xvimage_id; 703 xcb_out.width = width; 704 xcb_out.height = height; 705 706 xcb_parts[2].iov_base = (char *) &xcb_out; 707 xcb_parts[2].iov_len = sizeof(xcb_out); 708 xcb_parts[3].iov_base = 0; 709 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 710 711 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 712 return xcb_ret; 713 } 714 715 uint32_t * 716 xcb_xvmc_create_subpicture_priv_data (const xcb_xvmc_create_subpicture_reply_t *R) 717 { 718 return (uint32_t *) (R + 1); 719 } 720 721 int 722 xcb_xvmc_create_subpicture_priv_data_length (const xcb_xvmc_create_subpicture_reply_t *R) 723 { 724 return R->length; 725 } 726 727 xcb_generic_iterator_t 728 xcb_xvmc_create_subpicture_priv_data_end (const xcb_xvmc_create_subpicture_reply_t *R) 729 { 730 xcb_generic_iterator_t i; 731 i.data = ((uint32_t *) (R + 1)) + (R->length); 732 i.rem = 0; 733 i.index = (char *) i.data - (char *) R; 734 return i; 735 } 736 737 xcb_xvmc_create_subpicture_reply_t * 738 xcb_xvmc_create_subpicture_reply (xcb_connection_t *c, 739 xcb_xvmc_create_subpicture_cookie_t cookie /**< */, 740 xcb_generic_error_t **e) 741 { 742 return (xcb_xvmc_create_subpicture_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 743 } 744 745 xcb_void_cookie_t 746 xcb_xvmc_destroy_subpicture_checked (xcb_connection_t *c, 747 xcb_xvmc_subpicture_t subpicture_id) 748 { 749 static const xcb_protocol_request_t xcb_req = { 750 .count = 2, 751 .ext = &xcb_xvmc_id, 752 .opcode = XCB_XVMC_DESTROY_SUBPICTURE, 753 .isvoid = 1 754 }; 755 756 struct iovec xcb_parts[4]; 757 xcb_void_cookie_t xcb_ret; 758 xcb_xvmc_destroy_subpicture_request_t xcb_out; 759 760 xcb_out.subpicture_id = subpicture_id; 761 762 xcb_parts[2].iov_base = (char *) &xcb_out; 763 xcb_parts[2].iov_len = sizeof(xcb_out); 764 xcb_parts[3].iov_base = 0; 765 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 766 767 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 768 return xcb_ret; 769 } 770 771 xcb_void_cookie_t 772 xcb_xvmc_destroy_subpicture (xcb_connection_t *c, 773 xcb_xvmc_subpicture_t subpicture_id) 774 { 775 static const xcb_protocol_request_t xcb_req = { 776 .count = 2, 777 .ext = &xcb_xvmc_id, 778 .opcode = XCB_XVMC_DESTROY_SUBPICTURE, 779 .isvoid = 1 780 }; 781 782 struct iovec xcb_parts[4]; 783 xcb_void_cookie_t xcb_ret; 784 xcb_xvmc_destroy_subpicture_request_t xcb_out; 785 786 xcb_out.subpicture_id = subpicture_id; 787 788 xcb_parts[2].iov_base = (char *) &xcb_out; 789 xcb_parts[2].iov_len = sizeof(xcb_out); 790 xcb_parts[3].iov_base = 0; 791 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 792 793 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 794 return xcb_ret; 795 } 796 797 int 798 xcb_xvmc_list_subpicture_types_sizeof (const void *_buffer) 799 { 800 char *xcb_tmp = (char *)_buffer; 801 const xcb_xvmc_list_subpicture_types_reply_t *_aux = (xcb_xvmc_list_subpicture_types_reply_t *)_buffer; 802 unsigned int xcb_buffer_len = 0; 803 unsigned int xcb_block_len = 0; 804 unsigned int xcb_pad = 0; 805 unsigned int xcb_align_to = 0; 806 807 808 xcb_block_len += sizeof(xcb_xvmc_list_subpicture_types_reply_t); 809 xcb_tmp += xcb_block_len; 810 xcb_buffer_len += xcb_block_len; 811 xcb_block_len = 0; 812 /* types */ 813 xcb_block_len += _aux->num * sizeof(xcb_xv_image_format_info_t); 814 xcb_tmp += xcb_block_len; 815 xcb_align_to = ALIGNOF(xcb_xv_image_format_info_t); 816 /* insert padding */ 817 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 818 xcb_buffer_len += xcb_block_len + xcb_pad; 819 if (0 != xcb_pad) { 820 xcb_tmp += xcb_pad; 821 xcb_pad = 0; 822 } 823 xcb_block_len = 0; 824 825 return xcb_buffer_len; 826 } 827 828 xcb_xvmc_list_subpicture_types_cookie_t 829 xcb_xvmc_list_subpicture_types (xcb_connection_t *c, 830 xcb_xv_port_t port_id, 831 xcb_xvmc_surface_t surface_id) 832 { 833 static const xcb_protocol_request_t xcb_req = { 834 .count = 2, 835 .ext = &xcb_xvmc_id, 836 .opcode = XCB_XVMC_LIST_SUBPICTURE_TYPES, 837 .isvoid = 0 838 }; 839 840 struct iovec xcb_parts[4]; 841 xcb_xvmc_list_subpicture_types_cookie_t xcb_ret; 842 xcb_xvmc_list_subpicture_types_request_t xcb_out; 843 844 xcb_out.port_id = port_id; 845 xcb_out.surface_id = surface_id; 846 847 xcb_parts[2].iov_base = (char *) &xcb_out; 848 xcb_parts[2].iov_len = sizeof(xcb_out); 849 xcb_parts[3].iov_base = 0; 850 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 851 852 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 853 return xcb_ret; 854 } 855 856 xcb_xvmc_list_subpicture_types_cookie_t 857 xcb_xvmc_list_subpicture_types_unchecked (xcb_connection_t *c, 858 xcb_xv_port_t port_id, 859 xcb_xvmc_surface_t surface_id) 860 { 861 static const xcb_protocol_request_t xcb_req = { 862 .count = 2, 863 .ext = &xcb_xvmc_id, 864 .opcode = XCB_XVMC_LIST_SUBPICTURE_TYPES, 865 .isvoid = 0 866 }; 867 868 struct iovec xcb_parts[4]; 869 xcb_xvmc_list_subpicture_types_cookie_t xcb_ret; 870 xcb_xvmc_list_subpicture_types_request_t xcb_out; 871 872 xcb_out.port_id = port_id; 873 xcb_out.surface_id = surface_id; 874 875 xcb_parts[2].iov_base = (char *) &xcb_out; 876 xcb_parts[2].iov_len = sizeof(xcb_out); 877 xcb_parts[3].iov_base = 0; 878 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 879 880 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 881 return xcb_ret; 882 } 883 884 xcb_xv_image_format_info_t * 885 xcb_xvmc_list_subpicture_types_types (const xcb_xvmc_list_subpicture_types_reply_t *R) 886 { 887 return (xcb_xv_image_format_info_t *) (R + 1); 888 } 889 890 int 891 xcb_xvmc_list_subpicture_types_types_length (const xcb_xvmc_list_subpicture_types_reply_t *R) 892 { 893 return R->num; 894 } 895 896 xcb_xv_image_format_info_iterator_t 897 xcb_xvmc_list_subpicture_types_types_iterator (const xcb_xvmc_list_subpicture_types_reply_t *R) 898 { 899 xcb_xv_image_format_info_iterator_t i; 900 i.data = (xcb_xv_image_format_info_t *) (R + 1); 901 i.rem = R->num; 902 i.index = (char *) i.data - (char *) R; 903 return i; 904 } 905 906 xcb_xvmc_list_subpicture_types_reply_t * 907 xcb_xvmc_list_subpicture_types_reply (xcb_connection_t *c, 908 xcb_xvmc_list_subpicture_types_cookie_t cookie /**< */, 909 xcb_generic_error_t **e) 910 { 911 return (xcb_xvmc_list_subpicture_types_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 912 } 913 914
Indexes created Mon Jul 13 00:28:05 UTC 2026