src/video/Xext/Xv/Xv.c

   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