1 /*********************************************************** 2 Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts, 3 and the Massachusetts Institute of Technology, Cambridge, Massachusetts. 4 5 All Rights Reserved 6 7 Permission to use, copy, modify, and distribute this software and its 8 documentation for any purpose and without fee is hereby granted, 9 provided that the above copyright notice appear in all copies and that 10 both that copyright notice and this permission notice appear in 11 supporting documentation, and that the names of Digital or MIT not be 12 used in advertising or publicity pertaining to distribution of the 13 software without specific, written prior permission. 14 15 DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING 16 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL 17 DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR 18 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, 19 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, 20 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS 21 SOFTWARE. 22 23 ******************************************************************/ 24 /* $XFree86: xc/lib/Xv/Xv.c,v 1.15 2001/05/11 08:23:22 alanh Exp $ */ 25 /* 26 ** File: 27 ** 28 ** Xv.c --- Xv library extension module. 29 ** 30 ** Author: 31 ** 32 ** David Carver (Digital Workstation Engineering/Project Athena) 33 ** 34 ** Revisions: 35 ** 36 ** 26.06.91 Carver 37 ** - changed XvFreeAdaptors to XvFreeAdaptorInfo 38 ** - changed XvFreeEncodings to XvFreeEncodingInfo 39 ** 40 ** 11.06.91 Carver 41 ** - changed SetPortControl to SetPortAttribute 42 ** - changed GetPortControl to GetPortAttribute 43 ** - changed QueryBestSize 44 ** 45 ** 15.05.91 Carver 46 ** - version 2.0 upgrade 47 ** 48 ** 240.01.91 Carver 49 ** - version 1.4 upgrade 50 ** 51 */ 52 53 #include <stdio.h> 54 #include "Xvlibint.h" 55 #include "../extensions/Xext.h" 56 #include <X11/extensions/XShm.h> 57 #include "../extensions/extutil.h" 58 59 static XExtensionInfo _xv_info_data; 60 static XExtensionInfo *xv_info = &_xv_info_data; 61 static char *xv_extension_name = XvName; 62 63 #define XvCheckExtension(dpy, i, val) \ 64 XextCheckExtension(dpy, i, xv_extension_name, val) 65 66 static char *xv_error_string(); 67 static int xv_close_display(); 68 static Bool xv_wire_to_event(); 69 70 static XExtensionHooks xv_extension_hooks = { 71 NULL, /* create_gc */ 72 NULL, /* copy_gc */ 73 NULL, /* flush_gc */ 74 NULL, /* free_gc */ 75 NULL, /* create_font */ 76 NULL, /* free_font */ 77 xv_close_display, /* close_display */ 78 xv_wire_to_event, /* wire_to_event */ 79 NULL, /* event_to_wire */ 80 NULL, /* error */ 81 xv_error_string /* error_string */ 82 }; 83 84 85 static char *xv_error_list[] = 86 { 87 "BadPort", /* XvBadPort */ 88 "BadEncoding", /* XvBadEncoding */ 89 "BadControl" /* XvBadControl */ 90 }; 91 92 static XEXT_GENERATE_CLOSE_DISPLAY (xv_close_display, xv_info) 93 94 95 static XEXT_GENERATE_FIND_DISPLAY (xv_find_display, xv_info, 96 xv_extension_name, 97 &xv_extension_hooks, 98 XvNumEvents, NULL) 99 100 101 static XEXT_GENERATE_ERROR_STRING (xv_error_string, xv_extension_name, 102 XvNumErrors, xv_error_list) 103 104 105 int 106 SDL_NAME(XvQueryExtension)( 107 Display *dpy, 108 unsigned int *p_version, 109 unsigned int *p_revision, 110 unsigned int *p_requestBase, 111 unsigned int *p_eventBase, 112 unsigned int *p_errorBase 113 ){ 114 XExtDisplayInfo *info = xv_find_display(dpy); 115 xvQueryExtensionReq *req; 116 xvQueryExtensionReply rep; 117 118 XvCheckExtension(dpy, info, XvBadExtension); 119 120 LockDisplay(dpy); 121 122 XvGetReq(QueryExtension, req); 123 124 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { 125 UnlockDisplay(dpy); 126 SyncHandle(); 127 return XvBadExtension; 128 } 129 130 *p_version = rep.version; 131 *p_revision = rep.revision; 132 *p_requestBase = info->codes->major_opcode; 133 *p_eventBase = info->codes->first_event; 134 *p_errorBase = info->codes->first_error; 135 136 UnlockDisplay(dpy); 137 SyncHandle(); 138 139 return Success; 140 } 141 142 int 143 SDL_NAME(XvQueryAdaptors)( 144 Display *dpy, 145 Window window, 146 unsigned int *p_nAdaptors, 147 SDL_NAME(XvAdaptorInfo) **p_pAdaptors 148 ){ 149 XExtDisplayInfo *info = xv_find_display(dpy); 150 xvQueryAdaptorsReq *req; 151 xvQueryAdaptorsReply rep; 152 int size,ii,jj; 153 char *name; 154 SDL_NAME(XvAdaptorInfo) *pas, *pa; 155 SDL_NAME(XvFormat) *pfs, *pf; 156 char *buffer; 157 union 158 { 159 char *buffer; 160 char *string; 161 xvAdaptorInfo *pa; 162 xvFormat *pf; 163 } u; 164 165 XvCheckExtension(dpy, info, XvBadExtension); 166 167 LockDisplay(dpy); 168 169 XvGetReq(QueryAdaptors, req); 170 req->window = window; 171 172 /* READ THE REPLY */ 173 174 if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) { 175 UnlockDisplay(dpy); 176 SyncHandle(); 177 return(XvBadReply); 178 } 179 180 size = rep.length << 2; 181 if ( (buffer = (char *)Xmalloc ((unsigned) size)) == NULL) { 182 UnlockDisplay(dpy); 183 SyncHandle(); 184 return(XvBadAlloc); 185 } 186 _XRead (dpy, buffer, size); 187 188 u.buffer = buffer; 189 190 /* GET INPUT ADAPTORS */ 191 192 if (rep.num_adaptors == 0) { 193 pas = NULL; 194 } else { 195 size = rep.num_adaptors*sizeof(SDL_NAME(XvAdaptorInfo)); 196 if ((pas=(SDL_NAME(XvAdaptorInfo) *)Xmalloc(size))==NULL) { 197 Xfree(buffer); 198 UnlockDisplay(dpy); 199 SyncHandle(); 200 return(XvBadAlloc); 201 } 202 } 203 204 /* INIT ADAPTOR FIELDS */ 205 206 pa = pas; 207 for (ii=0; ii<rep.num_adaptors; ii++) { 208 pa->num_adaptors = 0; 209 pa->name = (char *)NULL; 210 pa->formats = (SDL_NAME(XvFormat) *)NULL; 211 pa++; 212 } 213 214 pa = pas; 215 for (ii=0; ii<rep.num_adaptors; ii++) { 216 pa->type = u.pa->type; 217 pa->base_id = u.pa->base_id; 218 pa->num_ports = u.pa->num_ports; 219 pa->num_formats = u.pa->num_formats; 220 pa->num_adaptors = rep.num_adaptors - ii; 221 222 /* GET ADAPTOR NAME */ 223 224 size = u.pa->name_size; 225 u.buffer += (sz_xvAdaptorInfo + 3) & ~3; 226 227 if ( (name = (char *)Xmalloc(size+1)) == NULL) 228 { 229 SDL_NAME(XvFreeAdaptorInfo)(pas); 230 Xfree(buffer); 231 UnlockDisplay(dpy); 232 SyncHandle(); 233 return(XvBadAlloc); 234 } 235 SDL_strlcpy(name, u.string, size); 236 pa->name = name; 237 238 u.buffer += (size + 3) & ~3; 239 240 /* GET FORMATS */ 241 242 size = pa->num_formats*sizeof(SDL_NAME(XvFormat)); 243 if ((pfs=(SDL_NAME(XvFormat) *)Xmalloc(size))==NULL) { 244 SDL_NAME(XvFreeAdaptorInfo)(pas); 245 Xfree(buffer); 246 UnlockDisplay(dpy); 247 SyncHandle(); 248 return(XvBadAlloc); 249 } 250 251 pf = pfs; 252 for (jj=0; jj<pa->num_formats; jj++) { 253 pf->depth = u.pf->depth; 254 pf->visual_id = u.pf->visual; 255 pf++; 256 257 u.buffer += (sz_xvFormat + 3) & ~3; 258 } 259 260 pa->formats = pfs; 261 262 pa++; 263 264 } 265 266 *p_nAdaptors = rep.num_adaptors; 267 *p_pAdaptors = pas; 268 269 Xfree(buffer); 270 UnlockDisplay(dpy); 271 SyncHandle(); 272 273 return (Success); 274 } 275 276 277 void 278 SDL_NAME(XvFreeAdaptorInfo)(SDL_NAME(XvAdaptorInfo) *pAdaptors) 279 { 280 281 SDL_NAME(XvAdaptorInfo) *pa; 282 int ii; 283 284 if (!pAdaptors) return; 285 286 pa = pAdaptors; 287 288 for (ii=0; ii<pAdaptors->num_adaptors; ii++, pa++) 289 { 290 if (pa->name) 291 { 292 Xfree(pa->name); 293 } 294 if (pa->formats) 295 { 296 Xfree(pa->formats); 297 } 298 } 299 300 Xfree(pAdaptors); 301 } 302 303 int 304 SDL_NAME(XvQueryEncodings)( 305 Display *dpy, 306 XvPortID port, 307 unsigned int *p_nEncodings, 308 SDL_NAME(XvEncodingInfo) **p_pEncodings 309 ){ 310 XExtDisplayInfo *info = xv_find_display(dpy); 311 xvQueryEncodingsReq *req; 312 xvQueryEncodingsReply rep; 313 int size, jj; 314 char *name; 315 SDL_NAME(XvEncodingInfo) *pes, *pe; 316 char *buffer; 317 union 318 { 319 char *buffer; 320 char *string; 321 xvEncodingInfo *pe; 322 } u; 323 324 XvCheckExtension(dpy, info, XvBadExtension); 325 326 LockDisplay(dpy); 327 328 XvGetReq(QueryEncodings, req); 329 req->port = port; 330 331 /* READ THE REPLY */ 332 333 if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) { 334 UnlockDisplay(dpy); 335 SyncHandle(); 336 return(XvBadReply); 337 } 338 339 size = rep.length << 2; 340 if ( (buffer = (char *)Xmalloc ((unsigned) size)) == NULL) { 341 UnlockDisplay(dpy); 342 SyncHandle(); 343 return(XvBadAlloc); 344 } 345 _XRead (dpy, buffer, size); 346 347 u.buffer = buffer; 348 349 /* GET ENCODINGS */ 350 351 size = rep.num_encodings*sizeof(SDL_NAME(XvEncodingInfo)); 352 if ( (pes = (SDL_NAME(XvEncodingInfo) *)Xmalloc(size)) == NULL) { 353 Xfree(buffer); 354 UnlockDisplay(dpy); 355 SyncHandle(); 356 return(XvBadAlloc); 357 } 358 359 /* INITIALIZE THE ENCODING POINTER */ 360 361 pe = pes; 362 for (jj=0; jj<rep.num_encodings; jj++) { 363 pe->name = (char *)NULL; 364 pe->num_encodings = 0; 365 pe++; 366 } 367 368 pe = pes; 369 for (jj=0; jj<rep.num_encodings; jj++) { 370 pe->encoding_id = u.pe->encoding; 371 pe->width = u.pe->width; 372 pe->height = u.pe->height; 373 pe->rate.numerator = u.pe->rate.numerator; 374 pe->rate.denominator = u.pe->rate.denominator; 375 pe->num_encodings = rep.num_encodings - jj; 376 377 size = u.pe->name_size; 378 u.buffer += (sz_xvEncodingInfo + 3) & ~3; 379 380 if ( (name = (char *)Xmalloc(size+1)) == NULL) { 381 Xfree(buffer); 382 UnlockDisplay(dpy); 383 SyncHandle(); 384 return(XvBadAlloc); 385 } 386 SDL_strlcpy(name, u.string, size); 387 pe->name = name; 388 pe++; 389 390 u.buffer += (size + 3) & ~3; 391 } 392 393 *p_nEncodings = rep.num_encodings; 394 *p_pEncodings = pes; 395 396 Xfree(buffer); 397 UnlockDisplay(dpy); 398 SyncHandle(); 399 400 return (Success); 401 } 402 403 void 404 SDL_NAME(XvFreeEncodingInfo)(SDL_NAME(XvEncodingInfo) *pEncodings) 405 { 406 407 SDL_NAME(XvEncodingInfo) *pe; 408 int ii; 409 410 if (!pEncodings) return; 411 412 pe = pEncodings; 413 414 for (ii=0; ii<pEncodings->num_encodings; ii++, pe++) { 415 if (pe->name) Xfree(pe->name); 416 } 417 418 Xfree(pEncodings); 419 } 420 421 int 422 SDL_NAME(XvPutVideo)( 423 Display *dpy, 424 XvPortID port, 425 Drawable d, 426 GC gc, 427 int vx, int vy, 428 unsigned int vw, unsigned int vh, 429 int dx, int dy, 430 unsigned int dw, unsigned int dh 431 ){ 432 XExtDisplayInfo *info = xv_find_display(dpy); 433 xvPutVideoReq *req; 434 435 XvCheckExtension(dpy, info, XvBadExtension); 436 437 LockDisplay(dpy); 438 439 FlushGC(dpy, gc); 440 441 XvGetReq(PutVideo, req); 442 443 req->port = port; 444 req->drawable = d; 445 req->gc = gc->gid; 446 req->vid_x = vx; 447 req->vid_y = vy; 448 req->vid_w = vw; 449 req->vid_h = vh; 450 req->drw_x = dx; 451 req->drw_y = dy; 452 req->drw_w = dw; 453 req->drw_h = dh; 454 455 UnlockDisplay(dpy); 456 SyncHandle(); 457 458 return Success; 459 } 460 461 int 462 SDL_NAME(XvPutStill)( 463 Display *dpy, 464 XvPortID port, 465 Drawable d, 466 GC gc, 467 int vx, int vy, 468 unsigned int vw, unsigned int vh, 469 int dx, int dy, 470 unsigned int dw, unsigned int dh 471 ){ 472 XExtDisplayInfo *info = xv_find_display(dpy); 473 xvPutStillReq *req; 474 475 XvCheckExtension(dpy, info, XvBadExtension); 476 477 LockDisplay(dpy); 478 479 FlushGC(dpy, gc); 480 481 XvGetReq(PutStill, req); 482 req->port = port; 483 req->drawable = d; 484 req->gc = gc->gid; 485 req->vid_x = vx; 486 req->vid_y = vy; 487 req->vid_w = vw; 488 req->vid_h = vh; 489 req->drw_x = dx; 490 req->drw_y = dy; 491 req->drw_w = dw; 492 req->drw_h = dh; 493 494 UnlockDisplay(dpy); 495 SyncHandle(); 496 497 return Success; 498 } 499 500 int 501 SDL_NAME(XvGetVideo)( 502 Display *dpy, 503 XvPortID port, 504 Drawable d, 505 GC gc, 506 int vx, int vy, 507 unsigned int vw, unsigned int vh, 508 int dx, int dy, 509 unsigned int dw, unsigned int dh 510 ){ 511 XExtDisplayInfo *info = xv_find_display(dpy); 512 xvGetVideoReq *req; 513 514 XvCheckExtension(dpy, info, XvBadExtension); 515 516 LockDisplay(dpy); 517 518 FlushGC(dpy, gc); 519 520 XvGetReq(GetVideo, req); 521 req->port = port; 522 req->drawable = d; 523 req->gc = gc->gid; 524 req->vid_x = vx; 525 req->vid_y = vy; 526 req->vid_w = vw; 527 req->vid_h = vh; 528 req->drw_x = dx; 529 req->drw_y = dy; 530 req->drw_w = dw; 531 req->drw_h = dh; 532 533 UnlockDisplay(dpy); 534 SyncHandle(); 535 536 return Success; 537 } 538 539 int 540 SDL_NAME(XvGetStill)( 541 Display *dpy, 542 XvPortID port, 543 Drawable d, 544 GC gc, 545 int vx, int vy, 546 unsigned int vw, unsigned int vh, 547 int dx, int dy, 548 unsigned int dw, unsigned int dh 549 ){ 550 XExtDisplayInfo *info = xv_find_display(dpy); 551 xvGetStillReq *req; 552 553 XvCheckExtension(dpy, info, XvBadExtension); 554 555 LockDisplay(dpy); 556 557 FlushGC(dpy, gc); 558 559 XvGetReq(GetStill, req); 560 req->port = port; 561 req->drawable = d; 562 req->gc = gc->gid; 563 req->vid_x = vx; 564 req->vid_y = vy; 565 req->vid_w = vw; 566 req->vid_h = vh; 567 req->drw_x = dx; 568 req->drw_y = dy; 569 req->drw_w = dw; 570 req->drw_h = dh; 571 572 UnlockDisplay(dpy); 573 SyncHandle(); 574 575 return Success; 576 } 577 578 int 579 SDL_NAME(XvStopVideo)( 580 Display *dpy, 581 XvPortID port, 582 Drawable draw 583 ){ 584 XExtDisplayInfo *info = xv_find_display(dpy); 585 xvStopVideoReq *req; 586 587 XvCheckExtension(dpy, info, XvBadExtension); 588 589 LockDisplay(dpy); 590 591 XvGetReq(StopVideo, req); 592 req->port = port; 593 req->drawable = draw; 594 595 UnlockDisplay(dpy); 596 SyncHandle(); 597 598 return Success; 599 } 600 601 int 602 SDL_NAME(XvGrabPort)( 603 Display *dpy, 604 XvPortID port, 605 Time time 606 ){ 607 XExtDisplayInfo *info = xv_find_display(dpy); 608 int result; 609 xvGrabPortReply rep; 610 xvGrabPortReq *req; 611 612 XvCheckExtension(dpy, info, XvBadExtension); 613 614 LockDisplay(dpy); 615 616 XvGetReq(GrabPort, req); 617 req->port = port; 618 req->time = time; 619 620 if (_XReply (dpy, (xReply *) &rep, 0, xTrue) == 0) 621 rep.result = GrabSuccess; 622 623 result = rep.result; 624 625 UnlockDisplay(dpy); 626 SyncHandle(); 627 628 return result; 629 } 630 631 int 632 SDL_NAME(XvUngrabPort)( 633 Display *dpy, 634 XvPortID port, 635 Time time 636 ){ 637 XExtDisplayInfo *info = xv_find_display(dpy); 638 xvUngrabPortReq *req; 639 640 XvCheckExtension(dpy, info, XvBadExtension); 641 642 LockDisplay(dpy); 643 644 XvGetReq(UngrabPort, req); 645 req->port = port; 646 req->time = time; 647 648 UnlockDisplay(dpy); 649 SyncHandle(); 650 651 return Success; 652 } 653 654 int 655 SDL_NAME(XvSelectVideoNotify)( 656 Display *dpy, 657 Drawable drawable, 658 Bool onoff 659 ){ 660 XExtDisplayInfo *info = xv_find_display(dpy); 661 xvSelectVideoNotifyReq *req; 662 663 XvCheckExtension(dpy, info, XvBadExtension); 664 665 LockDisplay(dpy); 666 667 XvGetReq(SelectVideoNotify, req); 668 req->drawable = drawable; 669 req->onoff = onoff; 670 671 UnlockDisplay(dpy); 672 SyncHandle(); 673 674 return Success; 675 } 676 677 int 678 SDL_NAME(XvSelectPortNotify)( 679 Display *dpy, 680 XvPortID port, 681 Bool onoff 682 ){ 683 XExtDisplayInfo *info = xv_find_display(dpy); 684 xvSelectPortNotifyReq *req; 685 686 XvCheckExtension(dpy, info, XvBadExtension); 687 688 LockDisplay(dpy); 689 690 XvGetReq(SelectPortNotify, req); 691 req->port = port; 692 req->onoff = onoff; 693 694 UnlockDisplay(dpy); 695 SyncHandle(); 696 697 return Success; 698 } 699 700 int 701 SDL_NAME(XvSetPortAttribute) ( 702 Display *dpy, 703 XvPortID port, 704 Atom attribute, 705 int value 706 ) 707 { 708 XExtDisplayInfo *info = xv_find_display(dpy); 709 xvSetPortAttributeReq *req; 710 711 XvCheckExtension(dpy, info, XvBadExtension); 712 713 LockDisplay(dpy); 714 715 XvGetReq(SetPortAttribute, req); 716 req->port = port; 717 req->attribute = attribute; 718 req->value = value; 719 720 UnlockDisplay(dpy); 721 SyncHandle(); 722 723 return (Success); 724 } 725 726 int 727 SDL_NAME(XvGetPortAttribute) ( 728 Display *dpy, 729 XvPortID port, 730 Atom attribute, 731 int *p_value 732 ) 733 { 734 XExtDisplayInfo *info = xv_find_display(dpy); 735 xvGetPortAttributeReq *req; 736 xvGetPortAttributeReply rep; 737 738 XvCheckExtension(dpy, info, XvBadExtension); 739 740 LockDisplay(dpy); 741 742 XvGetReq(GetPortAttribute, req); 743 req->port = port; 744 req->attribute = attribute; 745 746 /* READ THE REPLY */ 747 748 if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) { 749 UnlockDisplay(dpy); 750 SyncHandle(); 751 return(XvBadReply); 752 } 753 754 *p_value = rep.value; 755 756 UnlockDisplay(dpy); 757 SyncHandle(); 758 759 return (Success); 760 } 761 762 int 763 SDL_NAME(XvQueryBestSize)( 764 Display *dpy, 765 XvPortID port, 766 Bool motion, 767 unsigned int vid_w, 768 unsigned int vid_h, 769 unsigned int drw_w, 770 unsigned int drw_h, 771 unsigned int *p_actual_width, 772 unsigned int *p_actual_height 773 ) 774 { 775 XExtDisplayInfo *info = xv_find_display(dpy); 776 xvQueryBestSizeReq *req; 777 xvQueryBestSizeReply rep; 778 779 XvCheckExtension(dpy, info, XvBadExtension); 780 781 LockDisplay(dpy); 782 783 XvGetReq(QueryBestSize, req); 784 req->port = port; 785 req->motion = motion; 786 req->vid_w = vid_w; 787 req->vid_h = vid_h; 788 req->drw_w = drw_w; 789 req->drw_h = drw_h; 790 791 /* READ THE REPLY */ 792 793 if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) { 794 UnlockDisplay(dpy); 795 SyncHandle(); 796 return(XvBadReply); 797 } 798 799 *p_actual_width = rep.actual_width; 800 *p_actual_height = rep.actual_height; 801 802 UnlockDisplay(dpy); 803 SyncHandle(); 804 805 return (Success); 806 } 807 808 809 SDL_NAME(XvAttribute)* 810 SDL_NAME(XvQueryPortAttributes)(Display *dpy, XvPortID port, int *num) 811 { 812 XExtDisplayInfo *info = xv_find_display(dpy); 813 xvQueryPortAttributesReq *req; 814 xvQueryPortAttributesReply rep; 815 SDL_NAME(XvAttribute) *ret = NULL; 816 817 *num = 0; 818 819 XvCheckExtension(dpy, info, NULL); 820 821 LockDisplay(dpy); 822 823 XvGetReq(QueryPortAttributes, req); 824 req->port = port; 825 826 /* READ THE REPLY */ 827 828 if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) { 829 UnlockDisplay(dpy); 830 SyncHandle(); 831 return ret; 832 } 833 834 if(rep.num_attributes) { 835 int size = (rep.num_attributes * sizeof(SDL_NAME(XvAttribute))) + rep.text_size; 836 837 if((ret = Xmalloc(size))) { 838 char* marker = (char*)(&ret[rep.num_attributes]); 839 xvAttributeInfo Info; 840 int i; 841 842 for(i = 0; i < rep.num_attributes; i++) { 843 _XRead(dpy, (char*)(&Info), sz_xvAttributeInfo); 844 ret[i].flags = (int)Info.flags; 845 ret[i].min_value = Info.min; 846 ret[i].max_value = Info.max; 847 ret[i].name = marker; 848 _XRead(dpy, marker, Info.size); 849 marker += Info.size; 850 (*num)++; 851 } 852 } else 853 _XEatData(dpy, rep.length << 2); 854 } 855 856 UnlockDisplay(dpy); 857 SyncHandle(); 858 859 return ret; 860 } 861 862 SDL_NAME(XvImageFormatValues) * SDL_NAME(XvListImageFormats) ( 863 Display *dpy, 864 XvPortID port, 865 int *num 866 ){ 867 XExtDisplayInfo *info = xv_find_display(dpy); 868 xvListImageFormatsReq *req; 869 xvListImageFormatsReply rep; 870 SDL_NAME(XvImageFormatValues) *ret = NULL; 871 872 *num = 0; 873 874 XvCheckExtension(dpy, info, NULL); 875 876 LockDisplay(dpy); 877 878 XvGetReq(ListImageFormats, req); 879 req->port = port; 880 881 /* READ THE REPLY */ 882 883 if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) { 884 UnlockDisplay(dpy); 885 SyncHandle(); 886 return NULL; 887 } 888 889 if(rep.num_formats) { 890 int size = (rep.num_formats * sizeof(SDL_NAME(XvImageFormatValues))); 891 892 if((ret = Xmalloc(size))) { 893 xvImageFormatInfo Info; 894 int i; 895 896 for(i = 0; i < rep.num_formats; i++) { 897 _XRead(dpy, (char*)(&Info), sz_xvImageFormatInfo); 898 ret[i].id = Info.id; 899 ret[i].type = Info.type; 900 ret[i].byte_order = Info.byte_order; 901 memcpy(&(ret[i].guid[0]), &(Info.guid[0]), 16); 902 ret[i].bits_per_pixel = Info.bpp; 903 ret[i].format = Info.format; 904 ret[i].num_planes = Info.num_planes; 905 ret[i].depth = Info.depth; 906 ret[i].red_mask = Info.red_mask; 907 ret[i].green_mask = Info.green_mask; 908 ret[i].blue_mask = Info.blue_mask; 909 ret[i].y_sample_bits = Info.y_sample_bits; 910 ret[i].u_sample_bits = Info.u_sample_bits; 911 ret[i].v_sample_bits = Info.v_sample_bits; 912 ret[i].horz_y_period = Info.horz_y_period; 913 ret[i].horz_u_period = Info.horz_u_period; 914 ret[i].horz_v_period = Info.horz_v_period; 915 ret[i].vert_y_period = Info.vert_y_period; 916 ret[i].vert_u_period = Info.vert_u_period; 917 ret[i].vert_v_period = Info.vert_v_period; 918 memcpy(&(ret[i].component_order[0]), &(Info.comp_order[0]), 32); 919 ret[i].scanline_order = Info.scanline_order; 920 (*num)++; 921 } 922 } else 923 _XEatData(dpy, rep.length << 2); 924 } 925 926 UnlockDisplay(dpy); 927 SyncHandle(); 928 929 return ret; 930 } 931 932 SDL_NAME(XvImage) * SDL_NAME(XvCreateImage) ( 933 Display *dpy, 934 XvPortID port, 935 int id, 936 char *data, 937 int width, 938 int height 939 ) { 940 XExtDisplayInfo *info = xv_find_display(dpy); 941 xvQueryImageAttributesReq *req; 942 xvQueryImageAttributesReply rep; 943 SDL_NAME(XvImage) *ret = NULL; 944 945 XvCheckExtension(dpy, info, NULL); 946 947 LockDisplay(dpy); 948 949 XvGetReq(QueryImageAttributes, req); 950 req->id = id; 951 req->port = port; 952 req->width = width; 953 req->height = height; 954 955 /* READ THE REPLY */ 956 957 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { 958 UnlockDisplay(dpy); 959 SyncHandle(); 960 return NULL; 961 } 962 963 if((ret = (SDL_NAME(XvImage)*)Xmalloc(sizeof(SDL_NAME(XvImage)) + (rep.num_planes << 3)))) { 964 ret->id = id; 965 ret->width = rep.width; 966 ret->height = rep.height; 967 ret->data_size = rep.data_size; 968 ret->num_planes = rep.num_planes; 969 ret->pitches = (int*)(&ret[1]); 970 ret->offsets = ret->pitches + rep.num_planes; 971 ret->data = data; 972 ret->obdata = NULL; 973 _XRead(dpy, (char*)(ret->pitches), rep.num_planes << 2); 974 _XRead(dpy, (char*)(ret->offsets), rep.num_planes << 2); 975 } else 976 _XEatData(dpy, rep.length << 2); 977 978 UnlockDisplay(dpy); 979 SyncHandle(); 980 return ret; 981 } 982 983 SDL_NAME(XvImage) * SDL_NAME(XvShmCreateImage) ( 984 Display *dpy, 985 XvPortID port, 986 int id, 987 char *data, 988 int width, 989 int height, 990 XShmSegmentInfo *shminfo 991 ){ 992 SDL_NAME(XvImage) *ret; 993 994 ret = SDL_NAME(XvCreateImage)(dpy, port, id, data, width, height); 995 996 if(ret) ret->obdata = (XPointer)shminfo; 997 998 return ret; 999 } 1000 1001 int SDL_NAME(XvPutImage) ( 1002 Display *dpy, 1003 XvPortID port, 1004 Drawable d, 1005 GC gc, 1006 SDL_NAME(XvImage) *image, 1007 int src_x, 1008 int src_y, 1009 unsigned int src_w, 1010 unsigned int src_h, 1011 int dest_x, 1012 int dest_y, 1013 unsigned int dest_w, 1014 unsigned int dest_h 1015 ){ 1016 XExtDisplayInfo *info = xv_find_display(dpy); 1017 xvPutImageReq *req; 1018 int len; 1019 1020 XvCheckExtension(dpy, info, XvBadExtension); 1021 1022 LockDisplay(dpy); 1023 1024 FlushGC(dpy, gc); 1025 1026 XvGetReq(PutImage, req); 1027 1028 req->port = port; 1029 req->drawable = d; 1030 req->gc = gc->gid; 1031 req->id = image->id; 1032 req->src_x = src_x; 1033 req->src_y = src_y; 1034 req->src_w = src_w; 1035 req->src_h = src_h; 1036 req->drw_x = dest_x; 1037 req->drw_y = dest_y; 1038 req->drw_w = dest_w; 1039 req->drw_h = dest_h; 1040 req->width = image->width; 1041 req->height = image->height; 1042 1043 len = (image->data_size + 3) >> 2; 1044 SetReqLen(req, len, len); 1045 1046 /* Yes it's kindof lame that we are sending the whole thing, 1047 but for video all of it may be needed even if displaying 1048 only a subsection, and I don't want to go through the 1049 trouble of creating subregions to send */ 1050 Data(dpy, (char *)image->data, image->data_size); 1051 1052 UnlockDisplay(dpy); 1053 SyncHandle(); 1054 1055 return Success; 1056 } 1057 1058 int SDL_NAME(XvShmPutImage) ( 1059 Display *dpy, 1060 XvPortID port, 1061 Drawable d, 1062 GC gc, 1063 SDL_NAME(XvImage) *image, 1064 int src_x, 1065 int src_y, 1066 unsigned int src_w, 1067 unsigned int src_h, 1068 int dest_x, 1069 int dest_y, 1070 unsigned int dest_w, 1071 unsigned int dest_h, 1072 Bool send_event 1073 ){ 1074 XExtDisplayInfo *info = xv_find_display(dpy); 1075 XShmSegmentInfo *shminfo = (XShmSegmentInfo *)image->obdata; 1076 xvShmPutImageReq *req; 1077 1078 XvCheckExtension(dpy, info, XvBadExtension); 1079 1080 LockDisplay(dpy); 1081 1082 FlushGC(dpy, gc); 1083 1084 XvGetReq(ShmPutImage, req); 1085 1086 req->port = port; 1087 req->drawable = d; 1088 req->gc = gc->gid; 1089 req->shmseg = shminfo->shmseg; 1090 req->id = image->id; 1091 req->src_x = src_x; 1092 req->src_y = src_y; 1093 req->src_w = src_w; 1094 req->src_h = src_h; 1095 req->drw_x = dest_x; 1096 req->drw_y = dest_y; 1097 req->drw_w = dest_w; 1098 req->drw_h = dest_h; 1099 req->offset = image->data - shminfo->shmaddr; 1100 req->width = image->width; 1101 req->height = image->height; 1102 req->send_event = send_event; 1103 1104 UnlockDisplay(dpy); 1105 SyncHandle(); 1106 1107 return Success; 1108 } 1109 1110 1111 static Bool 1112 xv_wire_to_event(Display *dpy, XEvent *host, xEvent *wire) 1113 { 1114 XExtDisplayInfo *info = xv_find_display(dpy); 1115 SDL_NAME(XvEvent) *re = (SDL_NAME(XvEvent) *)host; 1116 xvEvent *event = (xvEvent *)wire; 1117 1118 XvCheckExtension(dpy, info, False); 1119 1120 switch((event->u.u.type & 0x7F) - info->codes->first_event) 1121 { 1122 case XvVideoNotify: 1123 re->xvvideo.type = event->u.u.type & 0x7f; 1124 re->xvvideo.serial = 1125 _XSetLastRequestRead(dpy, (xGenericReply *)event); 1126 re->xvvideo.send_event = ((event->u.u.type & 0x80) != 0); 1127 re->xvvideo.display = dpy; 1128 re->xvvideo.time = event->u.videoNotify.time; 1129 re->xvvideo.reason = event->u.videoNotify.reason; 1130 re->xvvideo.drawable = event->u.videoNotify.drawable; 1131 re->xvvideo.port_id = event->u.videoNotify.port; 1132 break; 1133 case XvPortNotify: 1134 re->xvport.type = event->u.u.type & 0x7f; 1135 re->xvport.serial = 1136 _XSetLastRequestRead(dpy, (xGenericReply *)event); 1137 re->xvport.send_event = ((event->u.u.type & 0x80) != 0); 1138 re->xvport.display = dpy; 1139 re->xvport.time = event->u.portNotify.time; 1140 re->xvport.port_id = event->u.portNotify.port; 1141 re->xvport.attribute = event->u.portNotify.attribute; 1142 re->xvport.value = event->u.portNotify.value; 1143 break; 1144 default: 1145 return False; 1146 } 1147 1148 return (True); 1149 } 1150 1151 1152
