开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
Xv.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：26k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

Xv.c：源码内容
  1. /***********************************************************
  2. Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts,
  3. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  5.                         All Rights Reserved
  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.  
  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.
  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. */
  53. #include <stdio.h>
  54. #include "Xvlibint.h"
  55. #include <X11/extensions/Xext.h>
  56. #include <X11/extensions/XShm.h>
  57. #include "extutil.h"
  59. static XExtensionInfo _xv_info_data;
  60. static XExtensionInfo *xv_info = &_xv_info_data;
  61. static char *xv_extension_name = XvName;
  63. #define XvCheckExtension(dpy, i, val) 
  64.   XextCheckExtension(dpy, i, xv_extension_name, val)
  66. static char *xv_error_string();
  67. static int xv_close_display();
  68. static Bool xv_wire_to_event();
  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. };
  85. static char *xv_error_list[] = 
  86. {
  87.    "BadPort",     /* XvBadPort     */
  88.    "BadEncoding",   /* XvBadEncoding */
  89.    "BadControl"     /* XvBadControl  */
  90. };
  92. static XEXT_GENERATE_CLOSE_DISPLAY (xv_close_display, xv_info)
  95. static XEXT_GENERATE_FIND_DISPLAY (xv_find_display, xv_info, 
  96.                                    xv_extension_name, 
  97.                                    &xv_extension_hooks,
  98.    XvNumEvents, NULL)
  99.      
  101. static XEXT_GENERATE_ERROR_STRING (xv_error_string, xv_extension_name,
  102.                                    XvNumErrors, xv_error_list)
  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;
  118.   XvCheckExtension(dpy, info, XvBadExtension);
  120.   LockDisplay(dpy);
  122.   XvGetReq(QueryExtension, req);
  124.   if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  125.      UnlockDisplay(dpy);
  126.      SyncHandle();
  127.      return XvBadExtension;
  128.   }
  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;
  136.   UnlockDisplay(dpy);
  137.   SyncHandle();
  139.   return Success;
  140. }
  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);
  167.   LockDisplay(dpy);
  169.   XvGetReq(QueryAdaptors, req);
  170.   req->window = window;
  172.   /* READ THE REPLY */
  174.   if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) {
  175.       UnlockDisplay(dpy);
  176.       SyncHandle();
  177.       return(XvBadReply);
  178.   }
  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);
  188.   u.buffer = buffer;
  190.   /* GET INPUT ADAPTORS */
  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.   }
  204.   /* INIT ADAPTOR FIELDS */
  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.   }
  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;
  222.       /* GET ADAPTOR NAME */
  224.       size = u.pa->name_size;
  225.       u.buffer += (sz_xvAdaptorInfo + 3) & ~3;
  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.       (void)strncpy(name, u.string, size);
  236.       name[size] = '';
  237.       pa->name = name;
  239.       u.buffer += (size + 3) & ~3;
  241.       /* GET FORMATS */
  243.       size = pa->num_formats*sizeof(SDL_NAME(XvFormat));
  244.       if ((pfs=(SDL_NAME(XvFormat) *)Xmalloc(size))==NULL) {
  245.   SDL_NAME(XvFreeAdaptorInfo)(pas);
  246.   Xfree(buffer);
  247.           UnlockDisplay(dpy);
  248.           SyncHandle();
  249.   return(XvBadAlloc);
  250.       }
  252.       pf = pfs;
  253.       for (jj=0; jj<pa->num_formats; jj++) {
  254.   pf->depth = u.pf->depth;
  255.   pf->visual_id = u.pf->visual;
  256.   pf++;
  257.   
  258.   u.buffer += (sz_xvFormat + 3) & ~3;
  259.       }
  261.       pa->formats = pfs;
  263.       pa++;
  265.   }
  267.   *p_nAdaptors = rep.num_adaptors;
  268.   *p_pAdaptors = pas;
  270.   UnlockDisplay(dpy);
  271.   SyncHandle();
  273.   return (Success);
  274. }
  277. void
  278. SDL_NAME(XvFreeAdaptorInfo)(SDL_NAME(XvAdaptorInfo) *pAdaptors)
  279. {
  281.   SDL_NAME(XvAdaptorInfo) *pa;
  282.   int ii;
  284.   if (!pAdaptors) return;
  286.   pa = pAdaptors;
  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.     } 
  300.   Xfree(pAdaptors);
  301. }
  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);
  326.   LockDisplay(dpy);
  328.   XvGetReq(QueryEncodings, req);
  329.   req->port = port;
  331.   /* READ THE REPLY */
  333.   if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) {
  334.       UnlockDisplay(dpy);
  335.       SyncHandle();
  336.       return(XvBadReply);
  337.   }
  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);
  347.   u.buffer = buffer;
  349.   /* GET ENCODINGS */
  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.   }
  359.   /* INITIALIZE THE ENCODING POINTER */
  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.   }
  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;
  377.       size = u.pe->name_size;
  378.       u.buffer += (sz_xvEncodingInfo + 3) & ~3;
  380.       if ( (name = (char *)Xmalloc(size+1)) == NULL) {
  381.   Xfree(buffer);
  382.           UnlockDisplay(dpy);
  383.           SyncHandle();
  384.   return(XvBadAlloc);
  385.       }
  386.       strncpy(name, u.string, size);
  387.       name[size] = '';
  388.       pe->name = name;
  389.       pe++;
  391.       u.buffer += (size + 3) & ~3;
  392.   }
  394.   *p_nEncodings = rep.num_encodings;
  395.   *p_pEncodings = pes;
  397.   UnlockDisplay(dpy);
  398.   SyncHandle();
  400.   return (Success);
  401. }
  403. void
  404. SDL_NAME(XvFreeEncodingInfo)(SDL_NAME(XvEncodingInfo) *pEncodings)
  405. {
  407.   SDL_NAME(XvEncodingInfo) *pe;
  408.   int ii;
  410.   if (!pEncodings) return;
  412.   pe = pEncodings;
  414.   for (ii=0; ii<pEncodings->num_encodings; ii++, pe++) {
  415.       if (pe->name) Xfree(pe->name);
  416.   }
  418.   Xfree(pEncodings);
  419. }
  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;
  435.   XvCheckExtension(dpy, info, XvBadExtension);
  437.   LockDisplay(dpy);
  438.   
  439.   FlushGC(dpy, gc);
  441.   XvGetReq(PutVideo, req);
  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;
  455.   UnlockDisplay(dpy);
  456.   SyncHandle();
  458.   return Success;
  459. }
  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;
  475.   XvCheckExtension(dpy, info, XvBadExtension);
  477.   LockDisplay(dpy);
  479.   FlushGC(dpy, gc);
  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;
  494.   UnlockDisplay(dpy);
  495.   SyncHandle();
  497.   return Success;
  498. }
  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;
  514.   XvCheckExtension(dpy, info, XvBadExtension);
  516.   LockDisplay(dpy);
  518.   FlushGC(dpy, gc);
  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;
  533.   UnlockDisplay(dpy);
  534.   SyncHandle();
  536.   return Success;
  537. }
  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;
  553.   XvCheckExtension(dpy, info, XvBadExtension);
  555.   LockDisplay(dpy);
  557.   FlushGC(dpy, gc);
  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;
  572.   UnlockDisplay(dpy);
  573.   SyncHandle();
  575.   return Success;
  576. }
  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;
  587.   XvCheckExtension(dpy, info, XvBadExtension);
  589.   LockDisplay(dpy);
  591.   XvGetReq(StopVideo, req);
  592.   req->port = port;
  593.   req->drawable = draw;
  595.   UnlockDisplay(dpy);
  596.   SyncHandle();
  598.   return Success;
  599. }
  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;
  612.   XvCheckExtension(dpy, info, XvBadExtension);
  614.   LockDisplay(dpy);
  616.   XvGetReq(GrabPort, req);
  617.   req->port = port;
  618.   req->time = time;
  620.   if (_XReply (dpy, (xReply *) &rep, 0, xTrue) == 0) 
  621.     rep.result = GrabSuccess;
  623.   result = rep.result;
  625.   UnlockDisplay(dpy);
  626.   SyncHandle();
  628.   return result;
  629. }
  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;
  640.   XvCheckExtension(dpy, info, XvBadExtension);
  642.   LockDisplay(dpy);
  644.   XvGetReq(UngrabPort, req);
  645.   req->port = port;
  646.   req->time = time;
  648.   UnlockDisplay(dpy);
  649.   SyncHandle();
  651.   return Success;
  652. }
  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;
  663.   XvCheckExtension(dpy, info, XvBadExtension);
  665.   LockDisplay(dpy);
  667.   XvGetReq(SelectVideoNotify, req);
  668.   req->drawable = drawable;
  669.   req->onoff = onoff;
  671.   UnlockDisplay(dpy);
  672.   SyncHandle();
  674.   return Success;
  675. }
  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;
  686.   XvCheckExtension(dpy, info, XvBadExtension);
  688.   LockDisplay(dpy);
  690.   XvGetReq(SelectPortNotify, req);
  691.   req->port = port;
  692.   req->onoff = onoff;
  694.   UnlockDisplay(dpy);
  695.   SyncHandle();
  697.   return Success;
  698. }
  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;
  711.   XvCheckExtension(dpy, info, XvBadExtension);
  713.   LockDisplay(dpy);
  715.   XvGetReq(SetPortAttribute, req);
  716.   req->port = port;
  717.   req->attribute = attribute;
  718.   req->value = value;
  720.   UnlockDisplay(dpy);
  721.   SyncHandle();
  723.   return (Success);
  724. }
  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;
  738.   XvCheckExtension(dpy, info, XvBadExtension);
  740.   LockDisplay(dpy);
  742.   XvGetReq(GetPortAttribute, req);
  743.   req->port = port;
  744.   req->attribute = attribute;
  746.   /* READ THE REPLY */
  748.   if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) {
  749.       UnlockDisplay(dpy);
  750.       SyncHandle();
  751.       return(XvBadReply);
  752.   }
  754.   *p_value = rep.value;
  755.   
  756.   UnlockDisplay(dpy);
  757.   SyncHandle();
  759.   return (Success);
  760. }
  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;
  779.   XvCheckExtension(dpy, info, XvBadExtension);
  781.   LockDisplay(dpy);
  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;
  791.   /* READ THE REPLY */
  793.   if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) {
  794.       UnlockDisplay(dpy);
  795.       SyncHandle();
  796.       return(XvBadReply);
  797.   }
  799.   *p_actual_width = rep.actual_width;
  800.   *p_actual_height = rep.actual_height;
  802.   UnlockDisplay(dpy);
  803.   SyncHandle();
  805.   return (Success);
  806. }
  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;
  817.   *num = 0;
  819.   XvCheckExtension(dpy, info, NULL);
  821.   LockDisplay(dpy);
  823.   XvGetReq(QueryPortAttributes, req);
  824.   req->port = port;
  826.   /* READ THE REPLY */
  828.   if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) {
  829.       UnlockDisplay(dpy);
  830.       SyncHandle();
  831.       return ret;
  832.   }
  834.   if(rep.num_attributes) {
  835.       int size = (rep.num_attributes * sizeof(SDL_NAME(XvAttribute))) + rep.text_size;
  837.       if((ret = Xmalloc(size))) {
  838.   char* marker = (char*)(&ret[rep.num_attributes]);
  839.   xvAttributeInfo Info;
  840.   int i;
  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.   }
  856.   UnlockDisplay(dpy);
  857.   SyncHandle();
  859.   return ret;
  860. }
  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;
  872.   *num = 0;
  874.   XvCheckExtension(dpy, info, NULL);
  876.   LockDisplay(dpy);
  878.   XvGetReq(ListImageFormats, req);
  879.   req->port = port;
  881.   /* READ THE REPLY */
  883.   if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) {
  884.       UnlockDisplay(dpy);
  885.       SyncHandle();
  886.       return NULL;
  887.   }
  889.   if(rep.num_formats) {
  890.       int size = (rep.num_formats * sizeof(SDL_NAME(XvImageFormatValues)));
  892.       if((ret = Xmalloc(size))) {
  893.   xvImageFormatInfo Info;
  894.   int i;
  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.   }
  926.   UnlockDisplay(dpy);
  927.   SyncHandle();
  929.   return ret;
  930. }
  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;
  945.    XvCheckExtension(dpy, info, NULL);
  947.    LockDisplay(dpy);
  949.    XvGetReq(QueryImageAttributes, req);
  950.    req->id = id;
  951.    req->port = port;
  952.    req->width = width;
  953.    req->height = height;
  955.    /* READ THE REPLY */
  957.    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  958.        UnlockDisplay(dpy);
  959.        SyncHandle();
  960.       return NULL;
  961.    }
  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);
  978.    UnlockDisplay(dpy);
  979.    SyncHandle();
  981.    return ret;
  982. }
  984. SDL_NAME(XvImage) * SDL_NAME(XvShmCreateImage) (
  985.    Display *dpy,
  986.    XvPortID port,
  987.    int id,
  988.    char *data,
  989.    int width, 
  990.    int height,
  991.    XShmSegmentInfo *shminfo
  992. ){
  993.    SDL_NAME(XvImage) *ret;
  995.    ret = SDL_NAME(XvCreateImage)(dpy, port, id, data, width, height);
  997.    if(ret) ret->obdata = (XPointer)shminfo;
  999.    return ret;
  1000. }
  1002. int SDL_NAME(XvPutImage) (
  1003.    Display *dpy,
  1004.    XvPortID port,
  1005.    Drawable d,
  1006.    GC gc,
  1007.    SDL_NAME(XvImage) *image,
  1008.    int src_x,
  1009.    int src_y,
  1010.    unsigned int src_w,
  1011.    unsigned int src_h,
  1012.    int dest_x, 
  1013.    int dest_y,
  1014.    unsigned int dest_w,
  1015.    unsigned int dest_h
  1016. ){
  1017.   XExtDisplayInfo *info = xv_find_display(dpy);
  1018.   xvPutImageReq *req;
  1019.   int len;
  1021.   XvCheckExtension(dpy, info, XvBadExtension);
  1023.   LockDisplay(dpy);
  1025.   FlushGC(dpy, gc);
  1027.   XvGetReq(PutImage, req);
  1029.   req->port = port;
  1030.   req->drawable = d;
  1031.   req->gc = gc->gid;
  1032.   req->id = image->id;
  1033.   req->src_x = src_x;
  1034.   req->src_y = src_y;
  1035.   req->src_w = src_w;
  1036.   req->src_h = src_h;
  1037.   req->drw_x = dest_x;
  1038.   req->drw_y = dest_y;
  1039.   req->drw_w = dest_w;
  1040.   req->drw_h = dest_h;
  1041.   req->width = image->width;
  1042.   req->height = image->height;
  1044.   len = (image->data_size + 3) >> 2;
  1045.   SetReqLen(req, len, len);
  1047.   /* Yes it's kindof lame that we are sending the whole thing,
  1048.      but for video all of it may be needed even if displaying
  1049.      only a subsection, and I don't want to go through the 
  1050.      trouble of creating subregions to send */
  1051.   Data(dpy, (char *)image->data, image->data_size);
  1053.   UnlockDisplay(dpy);
  1054.   SyncHandle();
  1056.   return Success;
  1057. }
  1059. int SDL_NAME(XvShmPutImage) (
  1060.    Display *dpy,
  1061.    XvPortID port,
  1062.    Drawable d,
  1063.    GC gc,
  1064.    SDL_NAME(XvImage) *image,
  1065.    int src_x,
  1066.    int src_y,
  1067.    unsigned int src_w,
  1068.    unsigned int src_h,
  1069.    int dest_x, 
  1070.    int dest_y,
  1071.    unsigned int dest_w,
  1072.    unsigned int dest_h,
  1073.    Bool send_event
  1074. ){
  1075.   XExtDisplayInfo *info = xv_find_display(dpy);
  1076.   XShmSegmentInfo *shminfo = (XShmSegmentInfo *)image->obdata;
  1077.   xvShmPutImageReq *req;
  1079.   XvCheckExtension(dpy, info, XvBadExtension);
  1081.   LockDisplay(dpy);
  1082.   
  1083.   FlushGC(dpy, gc);
  1085.   XvGetReq(ShmPutImage, req);
  1087.   req->port = port;
  1088.   req->drawable = d;
  1089.   req->gc = gc->gid;
  1090.   req->shmseg = shminfo->shmseg;
  1091.   req->id = image->id;
  1092.   req->src_x = src_x;
  1093.   req->src_y = src_y;
  1094.   req->src_w = src_w;
  1095.   req->src_h = src_h;
  1096.   req->drw_x = dest_x;
  1097.   req->drw_y = dest_y;
  1098.   req->drw_w = dest_w;
  1099.   req->drw_h = dest_h;
  1100.   req->offset = image->data - shminfo->shmaddr;
  1101.   req->width = image->width;
  1102.   req->height = image->height;
  1103.   req->send_event = send_event;
  1105.   UnlockDisplay(dpy);
  1106.   SyncHandle();
  1108.   return Success;
  1109. }
  1112. static Bool
  1113. xv_wire_to_event(Display *dpy, XEvent *host, xEvent *wire)
  1114. {
  1115.   XExtDisplayInfo *info = xv_find_display(dpy);
  1116.   SDL_NAME(XvEvent) *re    = (SDL_NAME(XvEvent) *)host;
  1117.   xvEvent *event = (xvEvent *)wire;
  1119.   XvCheckExtension(dpy, info, False);
  1121.   switch((event->u.u.type & 0x7F) - info->codes->first_event)
  1122.   {
  1123.     case XvVideoNotify:
  1124.       re->xvvideo.type = event->u.u.type & 0x7f;
  1125.       re->xvvideo.serial = 
  1126. _XSetLastRequestRead(dpy, (xGenericReply *)event);
  1127.       re->xvvideo.send_event = ((event->u.u.type & 0x80) != 0);
  1128.       re->xvvideo.display = dpy;
  1129.       re->xvvideo.time = event->u.videoNotify.time;
  1130.       re->xvvideo.reason = event->u.videoNotify.reason;
  1131.       re->xvvideo.drawable = event->u.videoNotify.drawable;
  1132.       re->xvvideo.port_id = event->u.videoNotify.port;
  1133.       break;
  1134.     case XvPortNotify:
  1135.       re->xvport.type = event->u.u.type & 0x7f;
  1136.       re->xvport.serial = 
  1137. _XSetLastRequestRead(dpy, (xGenericReply *)event);
  1138.       re->xvport.send_event = ((event->u.u.type & 0x80) != 0);
  1139.       re->xvport.display = dpy;
  1140.       re->xvport.time = event->u.portNotify.time;
  1141.       re->xvport.port_id = event->u.portNotify.port;
  1142.       re->xvport.attribute = event->u.portNotify.attribute;
  1143.       re->xvport.value = event->u.portNotify.value;
  1144.       break;
  1145.     default:
  1146.       return False; 
  1147.   }
  1149.   return (True);
  1150. }