Added SDL_LockRect() and SDL_UnlockRect()
Incorporated XFree86 extension libraries into the source
--- a/Makefile.am Sat Mar 02 16:50:35 2002 +0000
+++ b/Makefile.am Tue Mar 05 19:55:32 2002 +0000
@@ -45,7 +45,7 @@
EpocBuildFiles.zip \
WhatsNew \
docs.html \
- sdl.m4 \
+ sdl.m4 \
SDL.spec \
autogen.sh \
strip_fPIC.sh
--- a/WhatsNew Sat Mar 02 16:50:35 2002 +0000
+++ b/WhatsNew Tue Mar 05 19:55:32 2002 +0000
@@ -3,6 +3,12 @@
Version 1.0:
+1.2.4:
+ Added SDL_LockRect() and SDL_UnlockRect() to lock a portion of a
+ surface. This may be more efficient than a full lock if you are
+ using a hardware surface and plan to make a few changes to small
+ areas in the surface.
+
1.2.0:
Added SDL_VIDEOEXPOSE event to signal that the screen needs to
be redrawn. This is currently only delivered to OpenGL windows
--- a/configure.in Sat Mar 02 16:50:35 2002 +0000
+++ b/configure.in Tue Mar 05 19:55:32 2002 +0000
@@ -372,7 +372,7 @@
CheckNAS()
{
AC_ARG_ENABLE(nas,
-[ --enable-nas support the NAS audio API [default=yes]],
+[ --enable-nas support the NAS audio API [default=yes]],
, enable_nas=yes)
if test x$enable_audio = xyes -a x$enable_nas = xyes; then
AC_MSG_CHECKING(for NAS audio support)
@@ -394,7 +394,7 @@
CheckDiskAudio()
{
AC_ARG_ENABLE(diskaudio,
-[ --enable-diskaudio support the disk writer audio driver [default=yes]],
+[ --enable-diskaudio support the disk writer audio driver [default=yes]],
, enable_diskaudio=yes)
if test x$enable_audio = xyes -a x$enable_diskaudio = xyes; then
CFLAGS="$CFLAGS -DDISKAUD_SUPPORT"
@@ -445,44 +445,44 @@
dnl Find the nanox include and library directories
CheckNANOX()
{
- AC_ARG_ENABLE(video-nanox,
- [ --enable-video-nanox use nanox video driver [default=no]],
- , enable_video_nanox=no)
- AC_ARG_ENABLE(nanox-debug,
- [ --enable-nanox-debug print debug messages [default=no]],
- , enable_nanox_debug=no)
- AC_ARG_ENABLE(nanox-share-memory,
- [ --enable-nanox-share-memory use share memory [default=no]],
- , enable_nanox_share_memory=no)
+ AC_ARG_ENABLE(video-nanox,
+ [ --enable-video-nanox use nanox video driver [default=no]],
+ , enable_video_nanox=no)
+ AC_ARG_ENABLE(nanox-debug,
+ [ --enable-nanox-debug print debug messages [default=no]],
+ , enable_nanox_debug=no)
+ AC_ARG_ENABLE(nanox-share-memory,
+ [ --enable-nanox-share-memory use share memory [default=no]],
+ , enable_nanox_share_memory=no)
- AC_ARG_WITH(nanox_pixel_type,
- [ --with-nanox-pixel-type=[rgb/0888/888/565/555/332/pal]])
+ AC_ARG_WITH(nanox_pixel_type,
+ [ --with-nanox-pixel-type=[rgb/0888/888/565/555/332/pal]])
- if test x$enable_video = xyes -a x$enable_video_nanox = xyes; then
- if test x$enable_nanox_debug = xyes; then
- CFLAGS="$CFLAGS -DENABLE_NANOX_DEBUG"
- fi
+ if test x$enable_video = xyes -a x$enable_video_nanox = xyes; then
+ if test x$enable_nanox_debug = xyes; then
+ CFLAGS="$CFLAGS -DENABLE_NANOX_DEBUG"
+ fi
- if test x$enable_nanox_share_memory = xyes; then
- CFLAGS="$CFLAGS -DNANOX_SHARE_MEMORY"
- fi
+ if test x$enable_nanox_share_memory = xyes; then
+ CFLAGS="$CFLAGS -DNANOX_SHARE_MEMORY"
+ fi
- case "$with_nanox_pixel_type" in
- rgb) CFLAGS="$CFLAGS -DNANOX_PIXEL_RGB" ;;
- 0888) CFLAGS="$CFLAGS -DNANOX_PIXEL_0888" ;;
- 888) CFLAGS="$CFLAGS -DNANOX_PIXEL_888" ;;
- 565) CFLAGS="$CFLAGS -DNANOX_PIXEL_565" ;;
- 555) CFLAGS="$CFLAGS -DNANOX_PIXEL_555" ;;
- 332) CFLAGS="$CFLAGS -DNANOX_PIXEL_332" ;;
- pal) CFLAGS="$CFLAGS -DNANOX_PIXEL_PAL" ;;
- *) AC_MSG_ERROR([Invalid nanox_pixel_type]);;
- esac
+ case "$with_nanox_pixel_type" in
+ rgb) CFLAGS="$CFLAGS -DNANOX_PIXEL_RGB" ;;
+ 0888) CFLAGS="$CFLAGS -DNANOX_PIXEL_0888" ;;
+ 888) CFLAGS="$CFLAGS -DNANOX_PIXEL_888" ;;
+ 565) CFLAGS="$CFLAGS -DNANOX_PIXEL_565" ;;
+ 555) CFLAGS="$CFLAGS -DNANOX_PIXEL_555" ;;
+ 332) CFLAGS="$CFLAGS -DNANOX_PIXEL_332" ;;
+ pal) CFLAGS="$CFLAGS -DNANOX_PIXEL_PAL" ;;
+ *) AC_MSG_ERROR([Invalid nanox_pixel_type]);;
+ esac
- CFLAGS="$CFLAGS $X_CFLAGS -DENABLE_NANOX"
- SYSTEM_LIBS="$SYSTEM_LIBS -lnano-X"
- VIDEO_SUBDIRS="$VIDEO_SUBDIRS nanox"
- VIDEO_DRIVERS="$VIDEO_DRIVERS nanox/libvideo_nanox.la"
- fi
+ CFLAGS="$CFLAGS $X_CFLAGS -DENABLE_NANOX"
+ SYSTEM_LIBS="$SYSTEM_LIBS -lnano-X"
+ VIDEO_SUBDIRS="$VIDEO_SUBDIRS nanox"
+ VIDEO_DRIVERS="$VIDEO_DRIVERS nanox/libvideo_nanox.la"
+ fi
}
dnl Find the X11 include and library directories
@@ -495,7 +495,7 @@
AC_PATH_X
AC_PATH_XTRA
if test x$have_x = xyes; then
- CFLAGS="$CFLAGS $X_CFLAGS -DENABLE_X11"
+ CFLAGS="$CFLAGS $X_CFLAGS -DENABLE_X11 -Isrc/video"
if test x$ac_cv_func_shmat != xyes; then
CFLAGS="$CFLAGS -DNO_SHARED_MEMORY"
fi
@@ -511,7 +511,7 @@
video_x11_vm=no
AC_TRY_COMPILE([
#include <X11/Xlib.h>
- #include <X11/extensions/xf86vmode.h>
+ #include <XFree86/extensions/xf86vmode.h>
],[
],[
video_x11_vm=yes
@@ -519,34 +519,15 @@
AC_MSG_RESULT($video_x11_vm)
if test x$video_x11_vm = xyes; then
CFLAGS="$CFLAGS -DXFREE86_VM"
- # Check for nasty XFree86 4.0/Glide hack
- AC_ARG_ENABLE(xfree86_glidehack,
-[ --enable-xfree86-glidehack Alternate vidmode lib for old Glide [default=no]],
- , enable_xfreeglidehack=no)
- if test x$enable_xfree86_glidehack = xyes; then
- ac_save_libs="$LIBS"
- LIBS="$LIBS $X_LIBS -lX11 -lXext"
- if test x$xfree86_glidehack = x; then
- AC_CHECK_LIB(Xxf86vm, XF40VidModeQueryExtension, xfree86_glidehack=Xxf86vm)
- fi
- if test x$xfree86_glidehack = x; then
- AC_CHECK_LIB(Xxf86vm40, XF40VidModeQueryExtension, xfree86_glidehack=Xxf86vm40)
- fi
- LIBS="$ac_save_libs"
- fi
- if test x$xfree86_glidehack != x; then
- CFLAGS="$CFLAGS -DXFREE86_VM_DYNAMIC_HACK"
- SYSTEM_LIBS="$SYSTEM_LIBS -l$xfree86_glidehack"
- else
- SYSTEM_LIBS="$SYSTEM_LIBS -lXxf86vm"
- fi
+ VIDEO_SUBDIRS="$VIDEO_SUBDIRS XFree86/Xxf86vm"
+ VIDEO_DRIVERS="$VIDEO_DRIVERS XFree86/Xxf86vm/libXFree86_Xxf86vm.la"
AC_MSG_CHECKING(for XFree86 VidMode gamma support)
video_x11_vmgamma=no
AC_TRY_COMPILE([
#include <X11/Xlib.h>
- #include <X11/extensions/xf86vmode.h>
+ #include <XFree86/extensions/xf86vmode.h>
],[
- XF86VidModeGamma gamma;
+ SDL_NAME(XF86VidModeGamma) gamma;
],[
video_x11_vmgamma=yes
])
@@ -567,7 +548,7 @@
video_x11_dga=no
AC_TRY_COMPILE([
#include <X11/Xlib.h>
- #include <X11/extensions/xf86dga.h>
+ #include <XFree86/extensions/xf86dga.h>
],[
],[
video_x11_dga=yes
@@ -578,7 +559,8 @@
if test x$enable_video_x11_dgamouse = xyes; then
CFLAGS="$CFLAGS -DDEFAULT_DGAMOUSE"
fi
- SYSTEM_LIBS="$SYSTEM_LIBS -lXxf86dga"
+ VIDEO_SUBDIRS="$VIDEO_SUBDIRS XFree86/Xxf86dga"
+ VIDEO_DRIVERS="$VIDEO_DRIVERS XFree86/Xxf86dga/libXFree86_Xxf86dga.la"
fi
fi
AC_ARG_ENABLE(video-x11-xv,
@@ -592,16 +574,17 @@
#include <sys/ipc.h>
#include <sys/shm.h>
#include <X11/extensions/XShm.h>
- #include <X11/extensions/Xvlib.h>
+ #include <XFree86/extensions/Xvlib.h>
],[
- XvImage *image;
+ SDL_NAME(XvImage) *image;
],[
video_x11_xv=yes
])
AC_MSG_RESULT($video_x11_xv)
if test x$video_x11_xv = xyes; then
CFLAGS="$CFLAGS -DXFREE86_XV"
- SYSTEM_LIBS="$SYSTEM_LIBS -lXv"
+ VIDEO_SUBDIRS="$VIDEO_SUBDIRS XFree86/Xv"
+ VIDEO_DRIVERS="$VIDEO_DRIVERS XFree86/Xv/libXFree86_Xv.la"
fi
fi
AC_ARG_ENABLE(video-x11-xinerama,
@@ -612,16 +595,17 @@
video_x11_xinerama=no
AC_TRY_COMPILE([
#include <X11/Xlib.h>
- #include <X11/extensions/Xinerama.h>
+ #include <XFree86/extensions/Xinerama.h>
],[
- XineramaScreenInfo *xinerama;
+ SDL_NAME(XineramaScreenInfo) *xinerama;
],[
video_x11_xinerama=yes
])
AC_MSG_RESULT($video_x11_xinerama)
if test x$video_x11_xinerama = xyes; then
CFLAGS="$CFLAGS -DHAVE_XINERAMA"
- SYSTEM_LIBS="$SYSTEM_LIBS -lXinerama"
+ VIDEO_SUBDIRS="$VIDEO_SUBDIRS XFree86/Xinerama"
+ VIDEO_DRIVERS="$VIDEO_DRIVERS XFree86/Xinerama/libXFree86_Xinerama.la"
fi
fi
AC_ARG_ENABLE(video-x11-xme,
@@ -648,6 +632,33 @@
fi
}
+dnl Find the X11 DGA 2.0 include and library directories
+CheckDGA()
+{
+ AC_ARG_ENABLE(video-dga,
+[ --enable-video-dga use DGA 2.0 video driver [default=yes]],
+ , enable_video_dga=yes)
+ if test x$video_x11_dga = xyes -a x$enable_video_dga = xyes; then
+ save_CFLAGS="$CFLAGS"; CFLAGS="$CFLAGS -Isrc/video"
+ AC_MSG_CHECKING(for XFree86 DGA 2.0 support)
+ video_x11_dga2=no
+ AC_TRY_COMPILE([
+ #include <X11/Xlib.h>
+ #include <XFree86/extensions/xf86dga.h>
+ ],[
+ SDL_NAME(XDGAEvent) xevent;
+ ],[
+ video_x11_dga2=yes
+ ])
+ AC_MSG_RESULT($video_x11_dga2)
+ if test x$video_x11_dga2 = xyes; then
+ CFLAGS="$CFLAGS -DENABLE_DGA"
+ VIDEO_SUBDIRS="$VIDEO_SUBDIRS dga"
+ VIDEO_DRIVERS="$VIDEO_DRIVERS dga/libvideo_dga.la"
+ fi
+ fi
+}
+
CheckPHOTON()
{
AC_ARG_ENABLE(video-photon,
@@ -677,32 +688,6 @@
fi
}
-dnl Find the X11 DGA 2.0 include and library directories
-CheckDGA()
-{
- AC_ARG_ENABLE(video-dga,
-[ --enable-video-dga use DGA 2.0 video driver [default=yes]],
- , enable_video_dga=yes)
- if test x$video_x11_dga = xyes -a x$enable_video_dga = xyes; then
- AC_MSG_CHECKING(for XFree86 DGA 2.0 support)
- video_x11_dga2=no
- AC_TRY_COMPILE([
- #include <X11/Xlib.h>
- #include <X11/extensions/xf86dga.h>
- ],[
- XDGAEvent xevent;
- ],[
- video_x11_dga2=yes
- ])
- AC_MSG_RESULT($video_x11_dga2)
- if test x$video_x11_dga2 = xyes; then
- CFLAGS="$CFLAGS -DENABLE_DGA"
- VIDEO_SUBDIRS="$VIDEO_SUBDIRS dga"
- VIDEO_DRIVERS="$VIDEO_DRIVERS dga/libvideo_dga.la"
- fi
- fi
-}
-
dnl Find the framebuffer console includes
CheckFBCON()
{
@@ -2335,6 +2320,7 @@
CFLAGS="$CFLAGS -I\$(top_srcdir)/src/main"
CFLAGS="$CFLAGS -I\$(top_srcdir)/src/audio"
CFLAGS="$CFLAGS -I\$(top_srcdir)/src/video"
+CFLAGS="$CFLAGS -I\$(top_srcdir)/src/video/XFree86/extensions"
CFLAGS="$CFLAGS -I\$(top_srcdir)/src/events"
CFLAGS="$CFLAGS -I\$(top_srcdir)/src/joystick"
CFLAGS="$CFLAGS -I\$(top_srcdir)/src/cdrom"
@@ -2391,6 +2377,12 @@
src/audio/windx5/Makefile
src/audio/disk/Makefile
src/video/Makefile
+src/video/XFree86/Makefile
+src/video/XFree86/extensions/Makefile
+src/video/XFree86/Xinerama/Makefile
+src/video/XFree86/Xv/Makefile
+src/video/XFree86/Xxf86dga/Makefile
+src/video/XFree86/Xxf86vm/Makefile
src/video/cybergfx/Makefile
src/video/x11/Makefile
src/video/dga/Makefile
--- a/docs.html Sat Mar 02 16:50:35 2002 +0000
+++ b/docs.html Tue Mar 05 19:55:32 2002 +0000
@@ -16,6 +16,8 @@
Major changes since SDL 1.0.0:
</H2>
<UL>
+ <LI> 1.2.4: Added SDL_LockRect() and SDL_UnlockRect()
+ <LI> 1.2.4: Incorporated XFree86 extension libraries into the source
<LI> 1.2.4: Added initial support for Atari (thanks Patrice!)
<LI> 1.2.4: Added support for joysticks on *BSD (thanks Wilbern!)
<LI> 1.2.4: Added a YUV overlay test program (thanks Jon!)
--- a/include/SDL_video.h Sat Mar 02 16:50:35 2002 +0000
+++ b/include/SDL_video.h Tue Mar 05 19:55:32 2002 +0000
@@ -532,6 +532,26 @@
extern DECLSPEC void SDL_UnlockSurface(SDL_Surface *surface);
/*
+ * SDL_LockRect() locks a portion of the surface designated by the 'rect'
+ * parameter, and saves the resulting pixels and pitch in the arguments.
+ * The rect will be clipped if it extends beyond the bounds of the surface
+ *
+ * This may be more efficient than a full lock if you are using a hardware
+ * surface and plan to make a few changes to small areas in the surface.
+ *
+ * While a rectangle is locked, no other lock or blit call may be called
+ * on the surface. No operating system or library calls should be made
+ * between lock/unlock pairs, as critical system locks may be held during
+ * this time.
+ *
+ * After the surface is unlocked, the pixels pointer is no longer valid.
+ *
+ * SDL_LockRect() returns 0, or -1 if the surface couldn't be locked.
+ */
+extern DECLSPEC int SDL_LockRect(SDL_Surface *surface, SDL_Rect *rect, void **pixels, int *pitch);
+extern DECLSPEC void SDL_UnlockRect(SDL_Surface *surface);
+
+/*
* Load a surface from a seekable SDL data source (memory or file.)
* If 'freesrc' is non-zero, the source will be closed after being read.
* Returns the new surface, or NULL if there was an error.
--- a/src/main/beos/exports/SDL.exp Sat Mar 02 16:50:35 2002 +0000
+++ b/src/main/beos/exports/SDL.exp Tue Mar 05 19:55:32 2002 +0000
@@ -74,6 +74,7 @@
_SDL_GetModState
_SDL_SetModState
_SDL_GetKeyName
+_SDL_SetModuleHandle
_SDL_RegisterApp
_SDL_InitQuickDraw
_SDL_GetMouseState
@@ -143,6 +144,8 @@
_SDL_FreeSurface
_SDL_LockSurface
_SDL_UnlockSurface
+_SDL_LockRect
+_SDL_UnlockRect
_SDL_LoadBMP_RW
_SDL_SaveBMP_RW
_SDL_SetColorKey
@@ -174,3 +177,4 @@
_SDL_WM_IconifyWindow
_SDL_WM_ToggleFullScreen
_SDL_WM_GrabInput
+_SDL_SoftStretch
--- a/src/main/macos/exports/SDL.x Sat Mar 02 16:50:35 2002 +0000
+++ b/src/main/macos/exports/SDL.x Tue Mar 05 19:55:32 2002 +0000
@@ -143,6 +143,8 @@
SDL_FreeSurface
SDL_LockSurface
SDL_UnlockSurface
+ SDL_LockRect
+ SDL_UnlockRect
SDL_LoadBMP_RW
SDL_SaveBMP_RW
SDL_SetColorKey
@@ -174,4 +176,5 @@
SDL_WM_IconifyWindow
SDL_WM_ToggleFullScreen
SDL_WM_GrabInput
+ SDL_SoftStretch
SDL_InitQuickDraw
--- a/src/main/macosx/exports/SDL.x Sat Mar 02 16:50:35 2002 +0000
+++ b/src/main/macosx/exports/SDL.x Tue Mar 05 19:55:32 2002 +0000
@@ -141,6 +141,8 @@
_SDL_FreeSurface
_SDL_LockSurface
_SDL_UnlockSurface
+ _SDL_LockRect
+ _SDL_UnlockRect
_SDL_LoadBMP_RW
_SDL_SaveBMP_RW
_SDL_SetColorKey
--- a/src/main/win32/exports/SDL.def Sat Mar 02 16:50:35 2002 +0000
+++ b/src/main/win32/exports/SDL.def Tue Mar 05 19:55:32 2002 +0000
@@ -74,6 +74,7 @@
SDL_GetModState
SDL_SetModState
SDL_GetKeyName
+ SDL_SetModuleHandle
SDL_RegisterApp
SDL_InitQuickDraw
SDL_GetMouseState
@@ -143,6 +144,8 @@
SDL_FreeSurface
SDL_LockSurface
SDL_UnlockSurface
+ SDL_LockRect
+ SDL_UnlockRect
SDL_LoadBMP_RW
SDL_SaveBMP_RW
SDL_SetColorKey
--- a/src/video/Makefile.am Sat Mar 02 16:50:35 2002 +0000
+++ b/src/video/Makefile.am Tue Mar 05 19:55:32 2002 +0000
@@ -9,7 +9,7 @@
wincommon windib windx5 \
maccommon macdsp macrom quartz \
bwindow ps2gs photon cybergfx epoc \
- ataricommon xbios gem
+ ataricommon xbios gem XFree86
DRIVERS = @VIDEO_DRIVERS@
--- a/src/video/SDL_surface.c Sat Mar 02 16:50:35 2002 +0000
+++ b/src/video/SDL_surface.c Tue Mar 05 19:55:32 2002 +0000
@@ -630,6 +630,10 @@
*/
int SDL_LockSurface (SDL_Surface *surface)
{
+ if ( surface->locked < 0 ) {
+ SDL_SetError("Surface has a rectangle lock");
+ return(-1);
+ }
if ( ! surface->locked ) {
/* Perform the lock */
if ( surface->flags & (SDL_HWSURFACE|SDL_ASYNCBLIT) ) {
@@ -653,6 +657,78 @@
/* Ready to go.. */
return(0);
}
+int SDL_LockRect (SDL_Surface *surface, SDL_Rect *rect, void **pixels, int *pitch)
+{
+ int retval = 0;
+
+ /* Check to see if the surface is already locked */
+ *pixels = NULL;
+ if ( surface->locked != 0 ) {
+ SDL_SetError("Surface is already locked");
+ return(-1);
+ }
+
+ /* Clip the lock to the clipping rectangle of the surface */
+ {
+ SDL_Rect *clip = &surface->clip_rect;
+ int dx, dy;
+ int h = rect->h;
+ int w = rect->w;
+
+ dx = clip->x - rect->x;
+ if(dx > 0) {
+ w -= dx;
+ rect->x += dx;
+ }
+ dx = rect->x + w - clip->x - clip->w;
+ if(dx > 0)
+ w -= dx;
+
+ dy = clip->y - rect->y;
+ if(dy > 0) {
+ h -= dy;
+ rect->y += dy;
+ }
+ dy = rect->y + h - clip->y - clip->h;
+ if(dy > 0)
+ h -= dy;
+
+ if(w > 0 && h > 0) {
+ rect->w = w;
+ rect->h = h;
+ } else {
+ rect->w = 0;
+ rect->h = 0;
+ SDL_SetError("Rectangle was clipped");
+ return(-1);
+ }
+ }
+
+ /* Perform the lock */
+ if ( surface->flags & (SDL_HWSURFACE|SDL_ASYNCBLIT) ) {
+ SDL_VideoDevice *video = current_video;
+ SDL_VideoDevice *this = current_video;
+ if ( video->LockHWSurfaceRect ) {
+ retval = video->LockHWSurfaceRect(this, surface, rect, pixels, pitch);
+ if ( retval == 0 ) {
+ surface->locked = -1;
+ return 0;
+ }
+ }
+ }
+ if ( SDL_MUSTLOCK(surface) ) {
+ retval = SDL_LockSurface(surface);
+ if ( retval < 0 ) {
+ return retval;
+ }
+ }
+ surface->locked = -1;
+ *pixels = (Uint8 *)surface->pixels + rect->y * surface->pitch + rect->x * surface->format->BytesPerPixel;
+ *pitch = surface->pitch;
+
+ /* Ready to go.. */
+ return(0);
+}
/*
* Unlock a previously locked surface
* -- Do not call this from any blit function, as SDL_DrawCursor() may recurse
@@ -663,6 +739,9 @@
void SDL_UnlockSurface (SDL_Surface *surface)
{
/* Only perform an unlock if we are locked */
+ if ( surface->locked < 0 ) {
+ return;
+ }
if ( ! surface->locked || (--surface->locked > 0) ) {
return;
}
@@ -683,6 +762,29 @@
}
}
}
+void SDL_UnlockRect (SDL_Surface *surface)
+{
+ /* Only perform an unlock if we are locked */
+ if ( surface->locked != -1 ) {
+ return;
+ }
+
+ /* Perform the unlock */
+ if ( surface->flags & (SDL_HWSURFACE|SDL_ASYNCBLIT) ) {
+ SDL_VideoDevice *video = current_video;
+ SDL_VideoDevice *this = current_video;
+ if ( video->LockHWSurfaceRect ) {
+ video->UnlockHWSurfaceRect(this, surface);
+ return;
+ }
+ }
+ if ( SDL_MUSTLOCK(surface) ) {
+ surface->locked = 1;
+ SDL_UnlockSurface(surface);
+ } else {
+ surface->locked = 0;
+ }
+}
/*
* Convert a surface into the specified pixel format.
--- a/src/video/SDL_sysvideo.h Sat Mar 02 16:50:35 2002 +0000
+++ b/src/video/SDL_sysvideo.h Tue Mar 05 19:55:32 2002 +0000
@@ -153,6 +153,8 @@
/* Returns a readable/writable surface */
int (*LockHWSurface)(_THIS, SDL_Surface *surface);
void (*UnlockHWSurface)(_THIS, SDL_Surface *surface);
+ int (*LockHWSurfaceRect)(_THIS, SDL_Surface *surface, SDL_Rect *rect, void **pixels, int *pitch);
+ void (*UnlockHWSurfaceRect)(_THIS, SDL_Surface *surface);
/* Performs hardware flipping */
int (*FlipHWSurface)(_THIS, SDL_Surface *surface);
--- a/src/video/SDL_yuv_sw.c Sat Mar 02 16:50:35 2002 +0000
+++ b/src/video/SDL_yuv_sw.c Tue Mar 05 19:55:32 2002 +0000
@@ -1255,7 +1255,7 @@
Cb = lum + 3;
break;
default:
- SDL_SetError("Unsupported YUV format in blit (??)");
+ SDL_SetError("Unsupported YUV format in blit");
return(-1);
}
if ( SDL_MUSTLOCK(display) ) {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/Makefile.am Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,4 @@
+
+SUBDIRS = extensions Xinerama Xv Xxf86dga Xxf86vm
+
+EXTRA_DIST = README
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/README Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,9 @@
+
+The reason these libraries are built outside of the standard XFree86
+tree is so that they can be linked as shared object code directly into
+SDL without causing any symbol collisions with code in the application.
+
+You can't link static library code into shared libraries on non-x86
+Linux platforms. Since these libraries haven't become standard yet,
+we'll just include them directly.
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/Xinerama/Makefile.am Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,5 @@
+
+## Makefile.am for the XFree86 Xinerama library
+
+noinst_LTLIBRARIES = libXFree86_Xinerama.la
+libXFree86_Xinerama_la_SOURCES = Xinerama.c
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/Xinerama/Xinerama.c Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,319 @@
+/* $Xorg: XPanoramiX.c,v 1.4 2000/08/17 19:45:51 cpqbld Exp $ */
+/*****************************************************************
+Copyright (c) 1991, 1997 Digital Equipment Corporation, Maynard, Massachusetts.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING,
+BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL DAMAGES, OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of Digital Equipment Corporation
+shall not be used in advertising or otherwise to promote the sale, use or other
+dealings in this Software without prior written authorization from Digital
+Equipment Corporation.
+******************************************************************/
+/* $XFree86: xc/lib/Xinerama/Xinerama.c,v 1.2 2001/07/23 17:20:28 dawes Exp $ */
+
+#define NEED_EVENTS
+#define NEED_REPLIES
+#include <X11/Xlibint.h>
+#include <X11/Xutil.h>
+#include <X11/extensions/Xext.h> /* in ../include */
+#include "extutil.h" /* in ../include */
+#include "panoramiXext.h"
+#include "panoramiXproto.h" /* in ../include */
+#include "Xinerama.h"
+
+
+static XExtensionInfo _panoramiX_ext_info_data;
+static XExtensionInfo *panoramiX_ext_info = &_panoramiX_ext_info_data;
+static /* const */ char *panoramiX_extension_name = PANORAMIX_PROTOCOL_NAME;
+
+#define PanoramiXCheckExtension(dpy,i,val) \
+ XextCheckExtension (dpy, i, panoramiX_extension_name, val)
+#define PanoramiXSimpleCheckExtension(dpy,i) \
+ XextSimpleCheckExtension (dpy, i, panoramiX_extension_name)
+
+static int close_display();
+static /* const */ XExtensionHooks panoramiX_extension_hooks = {
+ NULL, /* create_gc */
+ NULL, /* copy_gc */
+ NULL, /* flush_gc */
+ NULL, /* free_gc */
+ NULL, /* create_font */
+ NULL, /* free_font */
+ close_display, /* close_display */
+ NULL, /* wire_to_event */
+ NULL, /* event_to_wire */
+ NULL, /* error */
+ NULL, /* error_string */
+};
+
+static XEXT_GENERATE_FIND_DISPLAY (find_display, panoramiX_ext_info,
+ panoramiX_extension_name,
+ &panoramiX_extension_hooks,
+ 0, NULL)
+
+static XEXT_GENERATE_CLOSE_DISPLAY (close_display, panoramiX_ext_info)
+
+
+
+/****************************************************************************
+ * *
+ * PanoramiX public interfaces *
+ * *
+ ****************************************************************************/
+
+Bool SDL_NAME(XPanoramiXQueryExtension) (
+ Display *dpy,
+ int *event_basep,
+ int *error_basep
+)
+{
+ XExtDisplayInfo *info = find_display (dpy);
+
+ if (XextHasExtension(info)) {
+ *event_basep = info->codes->first_event;
+ *error_basep = info->codes->first_error;
+ return True;
+ } else {
+ return False;
+ }
+}
+
+
+Status SDL_NAME(XPanoramiXQueryVersion)(
+ Display *dpy,
+ int *major_versionp,
+ int *minor_versionp
+)
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xPanoramiXQueryVersionReply rep;
+ register xPanoramiXQueryVersionReq *req;
+
+ PanoramiXCheckExtension (dpy, info, 0);
+
+ LockDisplay (dpy);
+ GetReq (PanoramiXQueryVersion, req);
+ req->reqType = info->codes->major_opcode;
+ req->panoramiXReqType = X_PanoramiXQueryVersion;
+ req->clientMajor = PANORAMIX_MAJOR_VERSION;
+ req->clientMinor = PANORAMIX_MINOR_VERSION;
+ if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return 0;
+ }
+ *major_versionp = rep.majorVersion;
+ *minor_versionp = rep.minorVersion;
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return 1;
+}
+
+SDL_NAME(XPanoramiXInfo) *SDL_NAME(XPanoramiXAllocInfo)(void)
+{
+ return (SDL_NAME(XPanoramiXInfo) *) Xmalloc (sizeof (SDL_NAME(XPanoramiXInfo)));
+}
+
+Status SDL_NAME(XPanoramiXGetState) (
+ Display *dpy,
+ Drawable drawable,
+ SDL_NAME(XPanoramiXInfo) *panoramiX_info
+)
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xPanoramiXGetStateReply rep;
+ register xPanoramiXGetStateReq *req;
+
+ PanoramiXCheckExtension (dpy, info, 0);
+
+ LockDisplay (dpy);
+ GetReq (PanoramiXGetState, req);
+ req->reqType = info->codes->major_opcode;
+ req->panoramiXReqType = X_PanoramiXGetState;
+ req->window = drawable;
+ if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return 0;
+ }
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ panoramiX_info->window = rep.window;
+ panoramiX_info->State = rep.state;
+ return 1;
+}
+
+Status SDL_NAME(XPanoramiXGetScreenCount) (
+ Display *dpy,
+ Drawable drawable,
+ SDL_NAME(XPanoramiXInfo) *panoramiX_info
+)
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xPanoramiXGetScreenCountReply rep;
+ register xPanoramiXGetScreenCountReq *req;
+
+ PanoramiXCheckExtension (dpy, info, 0);
+
+ LockDisplay (dpy);
+ GetReq (PanoramiXGetScreenCount, req);
+ req->reqType = info->codes->major_opcode;
+ req->panoramiXReqType = X_PanoramiXGetScreenCount;
+ req->window = drawable;
+ if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return 0;
+ }
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ panoramiX_info->window = rep.window;
+ panoramiX_info->ScreenCount = rep.ScreenCount;
+ return 1;
+}
+
+Status SDL_NAME(XPanoramiXGetScreenSize) (
+ Display *dpy,
+ Drawable drawable,
+ int screen_num,
+ SDL_NAME(XPanoramiXInfo) *panoramiX_info
+)
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xPanoramiXGetScreenSizeReply rep;
+ register xPanoramiXGetScreenSizeReq *req;
+
+ PanoramiXCheckExtension (dpy, info, 0);
+
+ LockDisplay (dpy);
+ GetReq (PanoramiXGetScreenSize, req);
+ req->reqType = info->codes->major_opcode;
+ req->panoramiXReqType = X_PanoramiXGetScreenSize;
+ req->window = drawable;
+ req->screen = screen_num; /* need to define */
+ if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return 0;
+ }
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ panoramiX_info->window = rep.window;
+ panoramiX_info->screen = rep.screen;
+ panoramiX_info->width = rep.width;
+ panoramiX_info->height = rep.height;
+ return 1;
+}
+
+/*******************************************************************\
+ Alternate interface to make up for shortcomings in the original,
+ namely, the omission of the screen origin. The new interface is
+ in the "Xinerama" namespace instead of "PanoramiX".
+\*******************************************************************/
+
+Bool SDL_NAME(XineramaQueryExtension) (
+ Display *dpy,
+ int *event_base,
+ int *error_base
+)
+{
+ return SDL_NAME(XPanoramiXQueryExtension)(dpy, event_base, error_base);
+}
+
+Status SDL_NAME(XineramaQueryVersion)(
+ Display *dpy,
+ int *major,
+ int *minor
+)
+{
+ return SDL_NAME(XPanoramiXQueryVersion)(dpy, major, minor);
+}
+
+Bool SDL_NAME(XineramaIsActive)(Display *dpy)
+{
+ xXineramaIsActiveReply rep;
+ xXineramaIsActiveReq *req;
+ XExtDisplayInfo *info = find_display (dpy);
+
+ if(!XextHasExtension(info))
+ return False; /* server doesn't even have the extension */
+
+ LockDisplay (dpy);
+ GetReq (XineramaIsActive, req);
+ req->reqType = info->codes->major_opcode;
+ req->panoramiXReqType = X_XineramaIsActive;
+ if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return False;
+ }
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return rep.state;
+}
+
+#include <stdio.h>
+
+SDL_NAME(XineramaScreenInfo) *
+SDL_NAME(XineramaQueryScreens)(
+ Display *dpy,
+ int *number
+)
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xXineramaQueryScreensReply rep;
+ xXineramaQueryScreensReq *req;
+ SDL_NAME(XineramaScreenInfo) *scrnInfo = NULL;
+
+ PanoramiXCheckExtension (dpy, info, 0);
+
+ LockDisplay (dpy);
+ GetReq (XineramaQueryScreens, req);
+ req->reqType = info->codes->major_opcode;
+ req->panoramiXReqType = X_XineramaQueryScreens;
+ if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) {
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return NULL;
+ }
+
+ if(rep.number) {
+ if((scrnInfo = Xmalloc(sizeof(SDL_NAME(XineramaScreenInfo)) * rep.number))) {
+ xXineramaScreenInfo scratch;
+ int i;
+
+ for(i = 0; i < rep.number; i++) {
+ _XRead(dpy, (char*)(&scratch), sz_XineramaScreenInfo);
+ scrnInfo[i].screen_number = i;
+ scrnInfo[i].x_org = scratch.x_org;
+ scrnInfo[i].y_org = scratch.y_org;
+ scrnInfo[i].width = scratch.width;
+ scrnInfo[i].height = scratch.height;
+ }
+
+ *number = rep.number;
+ } else
+ _XEatData(dpy, rep.length << 2);
+ }
+
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return scrnInfo;
+}
+
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/Xv/Makefile.am Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,5 @@
+
+## Makefile.am for the XFree86 Xv library
+
+noinst_LTLIBRARIES = libXFree86_Xv.la
+libXFree86_Xv_la_SOURCES = Xv.c Xvlibint.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/Xv/Xv.c Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,1152 @@
+/***********************************************************
+Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts,
+and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Digital or MIT not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+/* $XFree86: xc/lib/Xv/Xv.c,v 1.15 2001/05/11 08:23:22 alanh Exp $ */
+/*
+** File:
+**
+** Xv.c --- Xv library extension module.
+**
+** Author:
+**
+** David Carver (Digital Workstation Engineering/Project Athena)
+**
+** Revisions:
+**
+** 26.06.91 Carver
+** - changed XvFreeAdaptors to XvFreeAdaptorInfo
+** - changed XvFreeEncodings to XvFreeEncodingInfo
+**
+** 11.06.91 Carver
+** - changed SetPortControl to SetPortAttribute
+** - changed GetPortControl to GetPortAttribute
+** - changed QueryBestSize
+**
+** 15.05.91 Carver
+** - version 2.0 upgrade
+**
+** 240.01.91 Carver
+** - version 1.4 upgrade
+**
+*/
+
+#include <stdio.h>
+#include "Xvlibint.h"
+#include <X11/extensions/Xext.h>
+#include <X11/extensions/XShm.h>
+#include "extutil.h"
+
+static XExtensionInfo _xv_info_data;
+static XExtensionInfo *xv_info = &_xv_info_data;
+static char *xv_extension_name = XvName;
+
+#define XvCheckExtension(dpy, i, val) \
+ XextCheckExtension(dpy, i, xv_extension_name, val)
+
+static char *xv_error_string();
+static int xv_close_display();
+static Bool xv_wire_to_event();
+
+static XExtensionHooks xv_extension_hooks = {
+ NULL, /* create_gc */
+ NULL, /* copy_gc */
+ NULL, /* flush_gc */
+ NULL, /* free_gc */
+ NULL, /* create_font */
+ NULL, /* free_font */
+ xv_close_display, /* close_display */
+ xv_wire_to_event, /* wire_to_event */
+ NULL, /* event_to_wire */
+ NULL, /* error */
+ xv_error_string /* error_string */
+};
+
+
+static char *xv_error_list[] =
+{
+ "BadPort", /* XvBadPort */
+ "BadEncoding", /* XvBadEncoding */
+ "BadControl" /* XvBadControl */
+};
+
+static XEXT_GENERATE_CLOSE_DISPLAY (xv_close_display, xv_info)
+
+
+static XEXT_GENERATE_FIND_DISPLAY (xv_find_display, xv_info,
+ xv_extension_name,
+ &xv_extension_hooks,
+ XvNumEvents, NULL)
+
+
+static XEXT_GENERATE_ERROR_STRING (xv_error_string, xv_extension_name,
+ XvNumErrors, xv_error_list)
+
+
+int
+SDL_NAME(XvQueryExtension)(
+ Display *dpy,
+ unsigned int *p_version,
+ unsigned int *p_revision,
+ unsigned int *p_requestBase,
+ unsigned int *p_eventBase,
+ unsigned int *p_errorBase
+){
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ xvQueryExtensionReq *req;
+ xvQueryExtensionReply rep;
+
+ XvCheckExtension(dpy, info, XvBadExtension);
+
+ LockDisplay(dpy);
+
+ XvGetReq(QueryExtension, req);
+
+ if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return XvBadExtension;
+ }
+
+ *p_version = rep.version;
+ *p_revision = rep.revision;
+ *p_requestBase = info->codes->major_opcode;
+ *p_eventBase = info->codes->first_event;
+ *p_errorBase = info->codes->first_error;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return Success;
+}
+
+int
+SDL_NAME(XvQueryAdaptors)(
+ Display *dpy,
+ Window window,
+ unsigned int *p_nAdaptors,
+ SDL_NAME(XvAdaptorInfo) **p_pAdaptors
+){
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ xvQueryAdaptorsReq *req;
+ xvQueryAdaptorsReply rep;
+ int size,ii,jj;
+ char *name;
+ SDL_NAME(XvAdaptorInfo) *pas, *pa;
+ SDL_NAME(XvFormat) *pfs, *pf;
+ char *buffer;
+ union
+ {
+ char *buffer;
+ char *string;
+ xvAdaptorInfo *pa;
+ xvFormat *pf;
+ } u;
+
+ XvCheckExtension(dpy, info, XvBadExtension);
+
+ LockDisplay(dpy);
+
+ XvGetReq(QueryAdaptors, req);
+ req->window = window;
+
+ /* READ THE REPLY */
+
+ if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return(XvBadReply);
+ }
+
+ size = rep.length << 2;
+ if ( (buffer = (char *)Xmalloc ((unsigned) size)) == NULL) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return(XvBadAlloc);
+ }
+ _XRead (dpy, buffer, size);
+
+ u.buffer = buffer;
+
+ /* GET INPUT ADAPTORS */
+
+ if (rep.num_adaptors == 0) {
+ pas = NULL;
+ } else {
+ size = rep.num_adaptors*sizeof(SDL_NAME(XvAdaptorInfo));
+ if ((pas=(SDL_NAME(XvAdaptorInfo) *)Xmalloc(size))==NULL) {
+ Xfree(buffer);
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return(XvBadAlloc);
+ }
+ }
+
+ /* INIT ADAPTOR FIELDS */
+
+ pa = pas;
+ for (ii=0; ii<rep.num_adaptors; ii++) {
+ pa->num_adaptors = 0;
+ pa->name = (char *)NULL;
+ pa->formats = (SDL_NAME(XvFormat) *)NULL;
+ pa++;
+ }
+
+ pa = pas;
+ for (ii=0; ii<rep.num_adaptors; ii++) {
+ pa->type = u.pa->type;
+ pa->base_id = u.pa->base_id;
+ pa->num_ports = u.pa->num_ports;
+ pa->num_formats = u.pa->num_formats;
+ pa->num_adaptors = rep.num_adaptors - ii;
+
+ /* GET ADAPTOR NAME */
+
+ size = u.pa->name_size;
+ u.buffer += (sz_xvAdaptorInfo + 3) & ~3;
+
+ if ( (name = (char *)Xmalloc(size+1)) == NULL)
+ {
+ SDL_NAME(XvFreeAdaptorInfo)(pas);
+ Xfree(buffer);
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return(XvBadAlloc);
+ }
+ (void)strncpy(name, u.string, size);
+ name[size] = '\0';
+ pa->name = name;
+
+ u.buffer += (size + 3) & ~3;
+
+ /* GET FORMATS */
+
+ size = pa->num_formats*sizeof(SDL_NAME(XvFormat));
+ if ((pfs=(SDL_NAME(XvFormat) *)Xmalloc(size))==NULL) {
+ SDL_NAME(XvFreeAdaptorInfo)(pas);
+ Xfree(buffer);
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return(XvBadAlloc);
+ }
+
+ pf = pfs;
+ for (jj=0; jj<pa->num_formats; jj++) {
+ pf->depth = u.pf->depth;
+ pf->visual_id = u.pf->visual;
+ pf++;
+
+ u.buffer += (sz_xvFormat + 3) & ~3;
+ }
+
+ pa->formats = pfs;
+
+ pa++;
+
+ }
+
+ *p_nAdaptors = rep.num_adaptors;
+ *p_pAdaptors = pas;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return (Success);
+}
+
+
+void
+SDL_NAME(XvFreeAdaptorInfo)(SDL_NAME(XvAdaptorInfo) *pAdaptors)
+{
+
+ SDL_NAME(XvAdaptorInfo) *pa;
+ int ii;
+
+ if (!pAdaptors) return;
+
+ pa = pAdaptors;
+
+ for (ii=0; ii<pAdaptors->num_adaptors; ii++, pa++)
+ {
+ if (pa->name)
+ {
+ Xfree(pa->name);
+ }
+ if (pa->formats)
+ {
+ Xfree(pa->formats);
+ }
+ }
+
+ Xfree(pAdaptors);
+}
+
+int
+SDL_NAME(XvQueryEncodings)(
+ Display *dpy,
+ XvPortID port,
+ unsigned int *p_nEncodings,
+ SDL_NAME(XvEncodingInfo) **p_pEncodings
+){
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ xvQueryEncodingsReq *req;
+ xvQueryEncodingsReply rep;
+ int size, jj;
+ char *name;
+ SDL_NAME(XvEncodingInfo) *pes, *pe;
+ char *buffer;
+ union
+ {
+ char *buffer;
+ char *string;
+ xvEncodingInfo *pe;
+ } u;
+
+ XvCheckExtension(dpy, info, XvBadExtension);
+
+ LockDisplay(dpy);
+
+ XvGetReq(QueryEncodings, req);
+ req->port = port;
+
+ /* READ THE REPLY */
+
+ if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return(XvBadReply);
+ }
+
+ size = rep.length << 2;
+ if ( (buffer = (char *)Xmalloc ((unsigned) size)) == NULL) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return(XvBadAlloc);
+ }
+ _XRead (dpy, buffer, size);
+
+ u.buffer = buffer;
+
+ /* GET ENCODINGS */
+
+ size = rep.num_encodings*sizeof(SDL_NAME(XvEncodingInfo));
+ if ( (pes = (SDL_NAME(XvEncodingInfo) *)Xmalloc(size)) == NULL) {
+ Xfree(buffer);
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return(XvBadAlloc);
+ }
+
+ /* INITIALIZE THE ENCODING POINTER */
+
+ pe = pes;
+ for (jj=0; jj<rep.num_encodings; jj++) {
+ pe->name = (char *)NULL;
+ pe->num_encodings = 0;
+ pe++;
+ }
+
+ pe = pes;
+ for (jj=0; jj<rep.num_encodings; jj++) {
+ pe->encoding_id = u.pe->encoding;
+ pe->width = u.pe->width;
+ pe->height = u.pe->height;
+ pe->rate.numerator = u.pe->rate.numerator;
+ pe->rate.denominator = u.pe->rate.denominator;
+ pe->num_encodings = rep.num_encodings - jj;
+
+ size = u.pe->name_size;
+ u.buffer += (sz_xvEncodingInfo + 3) & ~3;
+
+ if ( (name = (char *)Xmalloc(size+1)) == NULL) {
+ Xfree(buffer);
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return(XvBadAlloc);
+ }
+ strncpy(name, u.string, size);
+ name[size] = '\0';
+ pe->name = name;
+ pe++;
+
+ u.buffer += (size + 3) & ~3;
+ }
+
+ *p_nEncodings = rep.num_encodings;
+ *p_pEncodings = pes;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return (Success);
+}
+
+void
+SDL_NAME(XvFreeEncodingInfo)(SDL_NAME(XvEncodingInfo) *pEncodings)
+{
+
+ SDL_NAME(XvEncodingInfo) *pe;
+ int ii;
+
+ if (!pEncodings) return;
+
+ pe = pEncodings;
+
+ for (ii=0; ii<pEncodings->num_encodings; ii++, pe++) {
+ if (pe->name) Xfree(pe->name);
+ }
+
+ Xfree(pEncodings);
+}
+
+int
+SDL_NAME(XvPutVideo)(
+ Display *dpy,
+ XvPortID port,
+ Drawable d,
+ GC gc,
+ int vx, int vy,
+ unsigned int vw, unsigned int vh,
+ int dx, int dy,
+ unsigned int dw, unsigned int dh
+){
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ xvPutVideoReq *req;
+
+ XvCheckExtension(dpy, info, XvBadExtension);
+
+ LockDisplay(dpy);
+
+ FlushGC(dpy, gc);
+
+ XvGetReq(PutVideo, req);
+
+ req->port = port;
+ req->drawable = d;
+ req->gc = gc->gid;
+ req->vid_x = vx;
+ req->vid_y = vy;
+ req->vid_w = vw;
+ req->vid_h = vh;
+ req->drw_x = dx;
+ req->drw_y = dy;
+ req->drw_w = dw;
+ req->drw_h = dh;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return Success;
+}
+
+int
+SDL_NAME(XvPutStill)(
+ Display *dpy,
+ XvPortID port,
+ Drawable d,
+ GC gc,
+ int vx, int vy,
+ unsigned int vw, unsigned int vh,
+ int dx, int dy,
+ unsigned int dw, unsigned int dh
+){
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ xvPutStillReq *req;
+
+ XvCheckExtension(dpy, info, XvBadExtension);
+
+ LockDisplay(dpy);
+
+ FlushGC(dpy, gc);
+
+ XvGetReq(PutStill, req);
+ req->port = port;
+ req->drawable = d;
+ req->gc = gc->gid;
+ req->vid_x = vx;
+ req->vid_y = vy;
+ req->vid_w = vw;
+ req->vid_h = vh;
+ req->drw_x = dx;
+ req->drw_y = dy;
+ req->drw_w = dw;
+ req->drw_h = dh;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return Success;
+}
+
+int
+SDL_NAME(XvGetVideo)(
+ Display *dpy,
+ XvPortID port,
+ Drawable d,
+ GC gc,
+ int vx, int vy,
+ unsigned int vw, unsigned int vh,
+ int dx, int dy,
+ unsigned int dw, unsigned int dh
+){
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ xvGetVideoReq *req;
+
+ XvCheckExtension(dpy, info, XvBadExtension);
+
+ LockDisplay(dpy);
+
+ FlushGC(dpy, gc);
+
+ XvGetReq(GetVideo, req);
+ req->port = port;
+ req->drawable = d;
+ req->gc = gc->gid;
+ req->vid_x = vx;
+ req->vid_y = vy;
+ req->vid_w = vw;
+ req->vid_h = vh;
+ req->drw_x = dx;
+ req->drw_y = dy;
+ req->drw_w = dw;
+ req->drw_h = dh;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return Success;
+}
+
+int
+SDL_NAME(XvGetStill)(
+ Display *dpy,
+ XvPortID port,
+ Drawable d,
+ GC gc,
+ int vx, int vy,
+ unsigned int vw, unsigned int vh,
+ int dx, int dy,
+ unsigned int dw, unsigned int dh
+){
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ xvGetStillReq *req;
+
+ XvCheckExtension(dpy, info, XvBadExtension);
+
+ LockDisplay(dpy);
+
+ FlushGC(dpy, gc);
+
+ XvGetReq(GetStill, req);
+ req->port = port;
+ req->drawable = d;
+ req->gc = gc->gid;
+ req->vid_x = vx;
+ req->vid_y = vy;
+ req->vid_w = vw;
+ req->vid_h = vh;
+ req->drw_x = dx;
+ req->drw_y = dy;
+ req->drw_w = dw;
+ req->drw_h = dh;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return Success;
+}
+
+int
+SDL_NAME(XvStopVideo)(
+ Display *dpy,
+ XvPortID port,
+ Drawable draw
+){
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ xvStopVideoReq *req;
+
+ XvCheckExtension(dpy, info, XvBadExtension);
+
+ LockDisplay(dpy);
+
+ XvGetReq(StopVideo, req);
+ req->port = port;
+ req->drawable = draw;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return Success;
+}
+
+int
+SDL_NAME(XvGrabPort)(
+ Display *dpy,
+ XvPortID port,
+ Time time
+){
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ int result;
+ xvGrabPortReply rep;
+ xvGrabPortReq *req;
+
+ XvCheckExtension(dpy, info, XvBadExtension);
+
+ LockDisplay(dpy);
+
+ XvGetReq(GrabPort, req);
+ req->port = port;
+ req->time = time;
+
+ if (_XReply (dpy, (xReply *) &rep, 0, xTrue) == 0)
+ rep.result = GrabSuccess;
+
+ result = rep.result;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return result;
+}
+
+int
+SDL_NAME(XvUngrabPort)(
+ Display *dpy,
+ XvPortID port,
+ Time time
+){
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ xvUngrabPortReq *req;
+
+ XvCheckExtension(dpy, info, XvBadExtension);
+
+ LockDisplay(dpy);
+
+ XvGetReq(UngrabPort, req);
+ req->port = port;
+ req->time = time;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return Success;
+}
+
+int
+SDL_NAME(XvSelectVideoNotify)(
+ Display *dpy,
+ Drawable drawable,
+ Bool onoff
+){
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ xvSelectVideoNotifyReq *req;
+
+ XvCheckExtension(dpy, info, XvBadExtension);
+
+ LockDisplay(dpy);
+
+ XvGetReq(SelectVideoNotify, req);
+ req->drawable = drawable;
+ req->onoff = onoff;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return Success;
+}
+
+int
+SDL_NAME(XvSelectPortNotify)(
+ Display *dpy,
+ XvPortID port,
+ Bool onoff
+){
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ xvSelectPortNotifyReq *req;
+
+ XvCheckExtension(dpy, info, XvBadExtension);
+
+ LockDisplay(dpy);
+
+ XvGetReq(SelectPortNotify, req);
+ req->port = port;
+ req->onoff = onoff;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return Success;
+}
+
+int
+SDL_NAME(XvSetPortAttribute) (
+ Display *dpy,
+ XvPortID port,
+ Atom attribute,
+ int value
+)
+{
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ xvSetPortAttributeReq *req;
+
+ XvCheckExtension(dpy, info, XvBadExtension);
+
+ LockDisplay(dpy);
+
+ XvGetReq(SetPortAttribute, req);
+ req->port = port;
+ req->attribute = attribute;
+ req->value = value;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return (Success);
+}
+
+int
+SDL_NAME(XvGetPortAttribute) (
+ Display *dpy,
+ XvPortID port,
+ Atom attribute,
+ int *p_value
+)
+{
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ xvGetPortAttributeReq *req;
+ xvGetPortAttributeReply rep;
+
+ XvCheckExtension(dpy, info, XvBadExtension);
+
+ LockDisplay(dpy);
+
+ XvGetReq(GetPortAttribute, req);
+ req->port = port;
+ req->attribute = attribute;
+
+ /* READ THE REPLY */
+
+ if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return(XvBadReply);
+ }
+
+ *p_value = rep.value;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return (Success);
+}
+
+int
+SDL_NAME(XvQueryBestSize)(
+ Display *dpy,
+ XvPortID port,
+ Bool motion,
+ unsigned int vid_w,
+ unsigned int vid_h,
+ unsigned int drw_w,
+ unsigned int drw_h,
+ unsigned int *p_actual_width,
+ unsigned int *p_actual_height
+)
+{
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ xvQueryBestSizeReq *req;
+ xvQueryBestSizeReply rep;
+
+ XvCheckExtension(dpy, info, XvBadExtension);
+
+ LockDisplay(dpy);
+
+ XvGetReq(QueryBestSize, req);
+ req->port = port;
+ req->motion = motion;
+ req->vid_w = vid_w;
+ req->vid_h = vid_h;
+ req->drw_w = drw_w;
+ req->drw_h = drw_h;
+
+ /* READ THE REPLY */
+
+ if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return(XvBadReply);
+ }
+
+ *p_actual_width = rep.actual_width;
+ *p_actual_height = rep.actual_height;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return (Success);
+}
+
+
+SDL_NAME(XvAttribute)*
+SDL_NAME(XvQueryPortAttributes)(Display *dpy, XvPortID port, int *num)
+{
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ xvQueryPortAttributesReq *req;
+ xvQueryPortAttributesReply rep;
+ SDL_NAME(XvAttribute) *ret = NULL;
+
+ *num = 0;
+
+ XvCheckExtension(dpy, info, NULL);
+
+ LockDisplay(dpy);
+
+ XvGetReq(QueryPortAttributes, req);
+ req->port = port;
+
+ /* READ THE REPLY */
+
+ if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return ret;
+ }
+
+ if(rep.num_attributes) {
+ int size = (rep.num_attributes * sizeof(SDL_NAME(XvAttribute))) + rep.text_size;
+
+ if((ret = Xmalloc(size))) {
+ char* marker = (char*)(&ret[rep.num_attributes]);
+ xvAttributeInfo Info;
+ int i;
+
+ for(i = 0; i < rep.num_attributes; i++) {
+ _XRead(dpy, (char*)(&Info), sz_xvAttributeInfo);
+ ret[i].flags = (int)Info.flags;
+ ret[i].min_value = Info.min;
+ ret[i].max_value = Info.max;
+ ret[i].name = marker;
+ _XRead(dpy, marker, Info.size);
+ marker += Info.size;
+ (*num)++;
+ }
+ } else
+ _XEatData(dpy, rep.length << 2);
+ }
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return ret;
+}
+
+SDL_NAME(XvImageFormatValues) * SDL_NAME(XvListImageFormats) (
+ Display *dpy,
+ XvPortID port,
+ int *num
+){
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ xvListImageFormatsReq *req;
+ xvListImageFormatsReply rep;
+ SDL_NAME(XvImageFormatValues) *ret = NULL;
+
+ *num = 0;
+
+ XvCheckExtension(dpy, info, NULL);
+
+ LockDisplay(dpy);
+
+ XvGetReq(ListImageFormats, req);
+ req->port = port;
+
+ /* READ THE REPLY */
+
+ if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return NULL;
+ }
+
+ if(rep.num_formats) {
+ int size = (rep.num_formats * sizeof(SDL_NAME(XvImageFormatValues)));
+
+ if((ret = Xmalloc(size))) {
+ xvImageFormatInfo Info;
+ int i;
+
+ for(i = 0; i < rep.num_formats; i++) {
+ _XRead(dpy, (char*)(&Info), sz_xvImageFormatInfo);
+ ret[i].id = Info.id;
+ ret[i].type = Info.type;
+ ret[i].byte_order = Info.byte_order;
+ memcpy(&(ret[i].guid[0]), &(Info.guid[0]), 16);
+ ret[i].bits_per_pixel = Info.bpp;
+ ret[i].format = Info.format;
+ ret[i].num_planes = Info.num_planes;
+ ret[i].depth = Info.depth;
+ ret[i].red_mask = Info.red_mask;
+ ret[i].green_mask = Info.green_mask;
+ ret[i].blue_mask = Info.blue_mask;
+ ret[i].y_sample_bits = Info.y_sample_bits;
+ ret[i].u_sample_bits = Info.u_sample_bits;
+ ret[i].v_sample_bits = Info.v_sample_bits;
+ ret[i].horz_y_period = Info.horz_y_period;
+ ret[i].horz_u_period = Info.horz_u_period;
+ ret[i].horz_v_period = Info.horz_v_period;
+ ret[i].vert_y_period = Info.vert_y_period;
+ ret[i].vert_u_period = Info.vert_u_period;
+ ret[i].vert_v_period = Info.vert_v_period;
+ memcpy(&(ret[i].component_order[0]), &(Info.comp_order[0]), 32);
+ ret[i].scanline_order = Info.scanline_order;
+ (*num)++;
+ }
+ } else
+ _XEatData(dpy, rep.length << 2);
+ }
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return ret;
+}
+
+SDL_NAME(XvImage) * SDL_NAME(XvCreateImage) (
+ Display *dpy,
+ XvPortID port,
+ int id,
+ char *data,
+ int width,
+ int height
+) {
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ xvQueryImageAttributesReq *req;
+ xvQueryImageAttributesReply rep;
+ SDL_NAME(XvImage) *ret = NULL;
+
+ XvCheckExtension(dpy, info, NULL);
+
+ LockDisplay(dpy);
+
+ XvGetReq(QueryImageAttributes, req);
+ req->id = id;
+ req->port = port;
+ req->width = width;
+ req->height = height;
+
+ /* READ THE REPLY */
+
+ if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return NULL;
+ }
+
+ if((ret = (SDL_NAME(XvImage)*)Xmalloc(sizeof(SDL_NAME(XvImage)) + (rep.num_planes << 3)))) {
+ ret->id = id;
+ ret->width = rep.width;
+ ret->height = rep.height;
+ ret->data_size = rep.data_size;
+ ret->num_planes = rep.num_planes;
+ ret->pitches = (int*)(&ret[1]);
+ ret->offsets = ret->pitches + rep.num_planes;
+ ret->data = data;
+ ret->obdata = NULL;
+ _XRead(dpy, (char*)(ret->pitches), rep.num_planes << 2);
+ _XRead(dpy, (char*)(ret->offsets), rep.num_planes << 2);
+ } else
+ _XEatData(dpy, rep.length << 2);
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return ret;
+}
+
+SDL_NAME(XvImage) * SDL_NAME(XvShmCreateImage) (
+ Display *dpy,
+ XvPortID port,
+ int id,
+ char *data,
+ int width,
+ int height,
+ XShmSegmentInfo *shminfo
+){
+ SDL_NAME(XvImage) *ret;
+
+ ret = SDL_NAME(XvCreateImage)(dpy, port, id, data, width, height);
+
+ if(ret) ret->obdata = (XPointer)shminfo;
+
+ return ret;
+}
+
+int SDL_NAME(XvPutImage) (
+ Display *dpy,
+ XvPortID port,
+ Drawable d,
+ GC gc,
+ SDL_NAME(XvImage) *image,
+ int src_x,
+ int src_y,
+ unsigned int src_w,
+ unsigned int src_h,
+ int dest_x,
+ int dest_y,
+ unsigned int dest_w,
+ unsigned int dest_h
+){
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ xvPutImageReq *req;
+ int len;
+
+ XvCheckExtension(dpy, info, XvBadExtension);
+
+ LockDisplay(dpy);
+
+ FlushGC(dpy, gc);
+
+ XvGetReq(PutImage, req);
+
+ req->port = port;
+ req->drawable = d;
+ req->gc = gc->gid;
+ req->id = image->id;
+ req->src_x = src_x;
+ req->src_y = src_y;
+ req->src_w = src_w;
+ req->src_h = src_h;
+ req->drw_x = dest_x;
+ req->drw_y = dest_y;
+ req->drw_w = dest_w;
+ req->drw_h = dest_h;
+ req->width = image->width;
+ req->height = image->height;
+
+ len = (image->data_size + 3) >> 2;
+ SetReqLen(req, len, len);
+
+ /* Yes it's kindof lame that we are sending the whole thing,
+ but for video all of it may be needed even if displaying
+ only a subsection, and I don't want to go through the
+ trouble of creating subregions to send */
+ Data(dpy, (char *)image->data, image->data_size);
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return Success;
+}
+
+int SDL_NAME(XvShmPutImage) (
+ Display *dpy,
+ XvPortID port,
+ Drawable d,
+ GC gc,
+ SDL_NAME(XvImage) *image,
+ int src_x,
+ int src_y,
+ unsigned int src_w,
+ unsigned int src_h,
+ int dest_x,
+ int dest_y,
+ unsigned int dest_w,
+ unsigned int dest_h,
+ Bool send_event
+){
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ XShmSegmentInfo *shminfo = (XShmSegmentInfo *)image->obdata;
+ xvShmPutImageReq *req;
+
+ XvCheckExtension(dpy, info, XvBadExtension);
+
+ LockDisplay(dpy);
+
+ FlushGC(dpy, gc);
+
+ XvGetReq(ShmPutImage, req);
+
+ req->port = port;
+ req->drawable = d;
+ req->gc = gc->gid;
+ req->shmseg = shminfo->shmseg;
+ req->id = image->id;
+ req->src_x = src_x;
+ req->src_y = src_y;
+ req->src_w = src_w;
+ req->src_h = src_h;
+ req->drw_x = dest_x;
+ req->drw_y = dest_y;
+ req->drw_w = dest_w;
+ req->drw_h = dest_h;
+ req->offset = image->data - shminfo->shmaddr;
+ req->width = image->width;
+ req->height = image->height;
+ req->send_event = send_event;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return Success;
+}
+
+
+static Bool
+xv_wire_to_event(Display *dpy, XEvent *host, xEvent *wire)
+{
+ XExtDisplayInfo *info = xv_find_display(dpy);
+ SDL_NAME(XvEvent) *re = (SDL_NAME(XvEvent) *)host;
+ xvEvent *event = (xvEvent *)wire;
+
+ XvCheckExtension(dpy, info, False);
+
+ switch((event->u.u.type & 0x7F) - info->codes->first_event)
+ {
+ case XvVideoNotify:
+ re->xvvideo.type = event->u.u.type & 0x7f;
+ re->xvvideo.serial =
+ _XSetLastRequestRead(dpy, (xGenericReply *)event);
+ re->xvvideo.send_event = ((event->u.u.type & 0x80) != 0);
+ re->xvvideo.display = dpy;
+ re->xvvideo.time = event->u.videoNotify.time;
+ re->xvvideo.reason = event->u.videoNotify.reason;
+ re->xvvideo.drawable = event->u.videoNotify.drawable;
+ re->xvvideo.port_id = event->u.videoNotify.port;
+ break;
+ case XvPortNotify:
+ re->xvport.type = event->u.u.type & 0x7f;
+ re->xvport.serial =
+ _XSetLastRequestRead(dpy, (xGenericReply *)event);
+ re->xvport.send_event = ((event->u.u.type & 0x80) != 0);
+ re->xvport.display = dpy;
+ re->xvport.time = event->u.portNotify.time;
+ re->xvport.port_id = event->u.portNotify.port;
+ re->xvport.attribute = event->u.portNotify.attribute;
+ re->xvport.value = event->u.portNotify.value;
+ break;
+ default:
+ return False;
+ }
+
+ return (True);
+}
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/Xv/Xvlibint.h Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,76 @@
+/***********************************************************
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
+and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Digital or MIT not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+/* $XFree86: xc/lib/Xv/Xvlibint.h,v 1.5 2001/07/25 15:04:53 dawes Exp $ */
+
+#ifndef XVLIBINT_H
+#define XVLIBINT_H
+/*
+** File:
+**
+** Xvlibint.h --- Xv library internal header file
+**
+** Author:
+**
+** David Carver (Digital Workstation Engineering/Project Athena)
+**
+** Revisions:
+**
+** 01.24.91 Carver
+** - version 1.4 upgrade
+**
+*/
+
+#define NEED_REPLIES
+
+#include <X11/Xlibint.h>
+#include "Xvproto.h"
+#include "Xvlib.h"
+
+#if !defined(UNIXCPP)
+#define XvGetReq(name, req) \
+ WORD64ALIGN\
+ if ((dpy->bufptr + SIZEOF(xv##name##Req)) > dpy->bufmax)\
+ _XFlush(dpy);\
+ req = (xv##name##Req *)(dpy->last_req = dpy->bufptr);\
+ req->reqType = info->codes->major_opcode;\
+ req->xvReqType = xv_##name; \
+ req->length = (SIZEOF(xv##name##Req))>>2;\
+ dpy->bufptr += SIZEOF(xv##name##Req);\
+ dpy->request++
+
+#else /* non-ANSI C uses empty comment instead of "##" for token concatenation */
+#define XvGetReq(name, req) \
+ WORD64ALIGN\
+ if ((dpy->bufptr + SIZEOF(xv/**/name/**/Req)) > dpy->bufmax)\
+ _XFlush(dpy);\
+ req = (xv/**/name/**/Req *)(dpy->last_req = dpy->bufptr);\
+ req->reqType = info->codes->major_opcode;\
+ req->xvReqType = xv_/**/name;\
+ req->length = (SIZEOF(xv/**/name/**/Req))>>2;\
+ dpy->bufptr += SIZEOF(xv/**/name/**/Req);\
+ dpy->request++
+#endif
+
+
+#endif /* XVLIBINT_H */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/Xxf86dga/Makefile.am Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,5 @@
+
+## Makefile.am for the XFree86 Xxf86dga library
+
+noinst_LTLIBRARIES = libXFree86_Xxf86dga.la
+libXFree86_Xxf86dga_la_SOURCES = XF86DGA2.c XF86DGA.c
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/Xxf86dga/XF86DGA.c Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,716 @@
+/* $XFree86: xc/lib/Xxf86dga/XF86DGA.c,v 3.19 2001/08/18 02:41:30 dawes Exp $ */
+/*
+
+Copyright (c) 1995 Jon Tombs
+Copyright (c) 1995,1996 The XFree86 Project, Inc
+
+*/
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD */
+
+#ifdef __EMX__ /* needed here to override certain constants in X headers */
+#define INCL_DOS
+#define INCL_DOSIOCTL
+#include <os2.h>
+#endif
+
+#if defined(linux)
+#define HAS_MMAP_ANON
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <asm/page.h> /* PAGE_SIZE */
+#define HAS_SC_PAGESIZE /* _SC_PAGESIZE may be an enum for Linux */
+#define HAS_GETPAGESIZE
+#endif /* linux */
+
+#if defined(CSRG_BASED)
+#define HAS_MMAP_ANON
+#define HAS_GETPAGESIZE
+#include <sys/types.h>
+#include <sys/mman.h>
+#endif /* CSRG_BASED */
+
+#if defined(DGUX)
+#define HAS_GETPAGESIZE
+#define MMAP_DEV_ZERO
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#endif /* DGUX */
+
+#if defined(SVR4) && !defined(DGUX)
+#define MMAP_DEV_ZERO
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#endif /* SVR4 && !DGUX */
+
+#if defined(sun) && !defined(SVR4) /* SunOS */
+#define MMAP_DEV_ZERO /* doesn't SunOS have MAP_ANON ?? */
+#define HAS_GETPAGESIZE
+#include <sys/types.h>
+#include <sys/mman.h>
+#endif /* sun && !SVR4 */
+
+#ifdef XNO_SYSCONF
+#undef _SC_PAGESIZE
+#endif
+
+
+#define NEED_EVENTS
+#define NEED_REPLIES
+#include <X11/Xlibint.h>
+#include "xf86dga.h"
+#include "xf86dgastr.h"
+#include <X11/extensions/Xext.h>
+#include "extutil.h"
+
+extern XExtDisplayInfo* SDL_NAME(xdga_find_display)(Display*);
+extern char *SDL_NAME(xdga_extension_name);
+
+#define XF86DGACheckExtension(dpy,i,val) \
+ XextCheckExtension (dpy, i, SDL_NAME(xdga_extension_name), val)
+
+/*****************************************************************************
+ * *
+ * public XFree86-DGA Extension routines *
+ * *
+ *****************************************************************************/
+
+Bool SDL_NAME(XF86DGAQueryExtension) (
+ Display *dpy,
+ int *event_basep,
+ int *error_basep
+){
+ return SDL_NAME(XDGAQueryExtension)(dpy, event_basep, error_basep);
+}
+
+Bool SDL_NAME(XF86DGAQueryVersion)(
+ Display* dpy,
+ int* majorVersion,
+ int* minorVersion
+){
+ return SDL_NAME(XDGAQueryVersion)(dpy, majorVersion, minorVersion);
+}
+
+Bool SDL_NAME(XF86DGAGetVideoLL)(
+ Display* dpy,
+ int screen,
+ int *offset,
+ int *width,
+ int *bank_size,
+ int *ram_size
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXF86DGAGetVideoLLReply rep;
+ xXF86DGAGetVideoLLReq *req;
+
+ XF86DGACheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86DGAGetVideoLL, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XF86DGAGetVideoLL;
+ req->screen = screen;
+ if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return False;
+ }
+
+ *offset = /*(char *)*/rep.offset;
+ *width = rep.width;
+ *bank_size = rep.bank_size;
+ *ram_size = rep.ram_size;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+
+Bool SDL_NAME(XF86DGADirectVideoLL)(
+ Display* dpy,
+ int screen,
+ int enable
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXF86DGADirectVideoReq *req;
+
+ XF86DGACheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86DGADirectVideo, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XF86DGADirectVideo;
+ req->screen = screen;
+ req->enable = enable;
+ UnlockDisplay(dpy);
+ SyncHandle();
+ XSync(dpy,False);
+ return True;
+}
+
+Bool SDL_NAME(XF86DGAGetViewPortSize)(
+ Display* dpy,
+ int screen,
+ int *width,
+ int *height
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXF86DGAGetViewPortSizeReply rep;
+ xXF86DGAGetViewPortSizeReq *req;
+
+ XF86DGACheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86DGAGetViewPortSize, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XF86DGAGetViewPortSize;
+ req->screen = screen;
+ if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return False;
+ }
+
+ *width = rep.width;
+ *height = rep.height;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+
+Bool SDL_NAME(XF86DGASetViewPort)(
+ Display* dpy,
+ int screen,
+ int x,
+ int y
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXF86DGASetViewPortReq *req;
+
+ XF86DGACheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86DGASetViewPort, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XF86DGASetViewPort;
+ req->screen = screen;
+ req->x = x;
+ req->y = y;
+ UnlockDisplay(dpy);
+ SyncHandle();
+ XSync(dpy,False);
+ return True;
+}
+
+
+Bool SDL_NAME(XF86DGAGetVidPage)(
+ Display* dpy,
+ int screen,
+ int *vpage
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXF86DGAGetVidPageReply rep;
+ xXF86DGAGetVidPageReq *req;
+
+ XF86DGACheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86DGAGetVidPage, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XF86DGAGetVidPage;
+ req->screen = screen;
+ if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return False;
+ }
+
+ *vpage = rep.vpage;
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+
+Bool SDL_NAME(XF86DGASetVidPage)(
+ Display* dpy,
+ int screen,
+ int vpage
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXF86DGASetVidPageReq *req;
+
+ XF86DGACheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86DGASetVidPage, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XF86DGASetVidPage;
+ req->screen = screen;
+ req->vpage = vpage;
+ UnlockDisplay(dpy);
+ SyncHandle();
+ XSync(dpy,False);
+ return True;
+}
+
+Bool SDL_NAME(XF86DGAInstallColormap)(
+ Display* dpy,
+ int screen,
+ Colormap cmap
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXF86DGAInstallColormapReq *req;
+
+ XF86DGACheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86DGAInstallColormap, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XF86DGAInstallColormap;
+ req->screen = screen;
+ req->id = cmap;
+ UnlockDisplay(dpy);
+ SyncHandle();
+ XSync(dpy,False);
+ return True;
+}
+
+Bool SDL_NAME(XF86DGAQueryDirectVideo)(
+ Display *dpy,
+ int screen,
+ int *flags
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXF86DGAQueryDirectVideoReply rep;
+ xXF86DGAQueryDirectVideoReq *req;
+
+ XF86DGACheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86DGAQueryDirectVideo, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XF86DGAQueryDirectVideo;
+ req->screen = screen;
+ if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return False;
+ }
+ *flags = rep.flags;
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+Bool SDL_NAME(XF86DGAViewPortChanged)(
+ Display *dpy,
+ int screen,
+ int n
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXF86DGAViewPortChangedReply rep;
+ xXF86DGAViewPortChangedReq *req;
+
+ XF86DGACheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86DGAViewPortChanged, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XF86DGAViewPortChanged;
+ req->screen = screen;
+ req->n = n;
+ if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return False;
+ }
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return rep.result;
+}
+
+
+
+/* Helper functions */
+
+#include <X11/Xmd.h>
+#include <XFree86/extensions/xf86dga.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#if defined(ISC)
+# define HAS_SVR3_MMAP
+# include <sys/types.h>
+# include <errno.h>
+
+# include <sys/at_ansi.h>
+# include <sys/kd.h>
+
+# include <sys/sysmacros.h>
+# include <sys/immu.h>
+# include <sys/region.h>
+
+# include <sys/mmap.h>
+#else
+# if !defined(Lynx)
+# if !defined(__EMX__)
+# include <sys/mman.h>
+# endif
+# else
+# include <sys/types.h>
+# include <errno.h>
+# include <smem.h>
+# endif
+#endif
+#include <sys/wait.h>
+#include <signal.h>
+#include <unistd.h>
+
+#if defined(SVR4) && !defined(sun) && !defined(SCO325)
+#define DEV_MEM "/dev/pmem"
+#elif defined(SVR4) && defined(sun)
+#define DEV_MEM "/dev/xsvc"
+#else
+#define DEV_MEM "/dev/mem"
+#endif
+
+typedef struct {
+ unsigned long physaddr; /* actual requested physical address */
+ unsigned long size; /* actual requested map size */
+ unsigned long delta; /* delta to account for page alignment */
+ void * vaddr; /* mapped address, without the delta */
+ int refcount; /* reference count */
+} MapRec, *MapPtr;
+
+typedef struct {
+ Display * display;
+ int screen;
+ MapPtr map;
+} ScrRec, *ScrPtr;
+
+static int mapFd = -1;
+static int numMaps = 0;
+static int numScrs = 0;
+static MapPtr *mapList = NULL;
+static ScrPtr *scrList = NULL;
+
+static MapPtr
+AddMap(void)
+{
+ MapPtr *old;
+
+ old = mapList;
+ mapList = realloc(mapList, sizeof(MapPtr) * (numMaps + 1));
+ if (!mapList) {
+ mapList = old;
+ return NULL;
+ }
+ mapList[numMaps] = malloc(sizeof(MapRec));
+ if (!mapList[numMaps])
+ return NULL;
+ return mapList[numMaps++];
+}
+
+static ScrPtr
+AddScr(void)
+{
+ ScrPtr *old;
+
+ old = scrList;
+ scrList = realloc(scrList, sizeof(ScrPtr) * (numScrs + 1));
+ if (!scrList) {
+ scrList = old;
+ return NULL;
+ }
+ scrList[numScrs] = malloc(sizeof(ScrRec));
+ if (!scrList[numScrs])
+ return NULL;
+ return scrList[numScrs++];
+}
+
+static MapPtr
+FindMap(unsigned long address, unsigned long size)
+{
+ int i;
+
+ for (i = 0; i < numMaps; i++) {
+ if (mapList[i]->physaddr == address &&
+ mapList[i]->size == size)
+ return mapList[i];
+ }
+ return NULL;
+}
+
+static ScrPtr
+FindScr(Display *display, int screen)
+{
+ int i;
+
+ for (i = 0; i < numScrs; i++) {
+ if (scrList[i]->display == display &&
+ scrList[i]->screen == screen)
+ return scrList[i];
+ }
+ return NULL;
+}
+
+static void *
+MapPhysAddress(unsigned long address, unsigned long size)
+{
+ unsigned long offset, delta;
+ int pagesize = -1;
+ void *vaddr;
+ MapPtr mp;
+#if defined(ISC) && defined(HAS_SVR3_MMAP)
+ struct kd_memloc mloc;
+#elif defined(__EMX__)
+ APIRET rc;
+ ULONG action;
+ HFILE hfd;
+#endif
+
+ if ((mp = FindMap(address, size))) {
+ mp->refcount++;
+ return (void *)((unsigned long)mp->vaddr + mp->delta);
+ }
+
+#if defined(_SC_PAGESIZE) && defined(HAS_SC_PAGESIZE)
+ pagesize = sysconf(_SC_PAGESIZE);
+#endif
+#ifdef _SC_PAGE_SIZE
+ if (pagesize == -1)
+ pagesize = sysconf(_SC_PAGE_SIZE);
+#endif
+#ifdef HAS_GETPAGESIZE
+ if (pagesize == -1)
+ pagesize = getpagesize();
+#endif
+#ifdef PAGE_SIZE
+ if (pagesize == -1)
+ pagesize = PAGE_SIZE;
+#endif
+ if (pagesize == -1)
+ pagesize = 4096;
+
+ delta = address % pagesize;
+ offset = address - delta;
+
+#if defined(ISC) && defined(HAS_SVR3_MMAP)
+ if (mapFd < 0) {
+ if ((mapFd = open("/dev/mmap", O_RDWR)) < 0)
+ return NULL;
+ }
+ mloc.vaddr = (char *)0;
+ mloc.physaddr = (char *)offset;
+ mloc.length = size + delta;
+ mloc.ioflg=1;
+
+ if ((vaddr = (void *)ioctl(mapFd, MAP, &mloc)) == (void *)-1)
+ return NULL;
+#elif defined (__EMX__)
+ /*
+ * Dragon warning here! /dev/pmap$ is never closed, except on progam exit.
+ * Consecutive calling of this routine will make PMAP$ driver run out
+ * of memory handles. Some umap/close mechanism should be provided
+ */
+
+ rc = DosOpen("/dev/pmap$", &hfd, &action, 0, FILE_NORMAL, FILE_OPEN,
+ OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE, (PEAOP2)NULL);
+ if (rc != 0)
+ return NULL;
+ {
+ struct map_ioctl {
+ union {
+ ULONG phys;
+ void* user;
+ } a;
+ ULONG size;
+ } pmap,dmap;
+ ULONG plen,dlen;
+#define XFREE86_PMAP 0x76
+#define PMAP_MAP 0x44
+
+ pmap.a.phys = offset;
+ pmap.size = size + delta;
+ rc = DosDevIOCtl(hfd, XFREE86_PMAP, PMAP_MAP,
+ (PULONG)&pmap, sizeof(pmap), &plen,
+ (PULONG)&dmap, sizeof(dmap), &dlen);
+ if (rc == 0) {
+ vaddr = dmap.a.user;
+ }
+ }
+ if (rc != 0)
+ return NULL;
+#elif defined (Lynx)
+ vaddr = (void *)smem_create("XF86DGA", (char *)offset,
+ size + delta, SM_READ|SM_WRITE);
+#else
+#ifndef MAP_FILE
+#define MAP_FILE 0
+#endif
+ if (mapFd < 0) {
+ if ((mapFd = open(DEV_MEM, O_RDWR)) < 0)
+ return NULL;
+ }
+ vaddr = (void *)mmap(NULL, size + delta, PROT_READ | PROT_WRITE,
+ MAP_FILE | MAP_SHARED, mapFd, (off_t)offset);
+ if (vaddr == (void *)-1)
+ return NULL;
+#endif
+
+ if (!vaddr) {
+ if (!(mp = AddMap()))
+ return NULL;
+ mp->physaddr = address;
+ mp->size = size;
+ mp->delta = delta;
+ mp->vaddr = vaddr;
+ mp->refcount = 1;
+ }
+ return (void *)((unsigned long)vaddr + delta);
+}
+
+/*
+ * Still need to find a clean way of detecting the death of a DGA app
+ * and returning things to normal - Jon
+ * This is here to help debugging without rebooting... Also C-A-BS
+ * should restore text mode.
+ */
+
+int
+SDL_NAME(XF86DGAForkApp)(int screen)
+{
+ pid_t pid;
+ int status;
+ int i;
+
+ /* fork the app, parent hangs around to clean up */
+ if ((pid = fork()) > 0) {
+ ScrPtr sp;
+
+ waitpid(pid, &status, 0);
+ for (i = 0; i < numScrs; i++) {
+ sp = scrList[i];
+ SDL_NAME(XF86DGADirectVideoLL)(sp->display, sp->screen, 0);
+ XSync(sp->display, False);
+ }
+ if (WIFEXITED(status))
+ _exit(0);
+ else
+ _exit(-1);
+ }
+ return pid;
+}
+
+
+Bool
+SDL_NAME(XF86DGADirectVideo)(
+ Display *dis,
+ int screen,
+ int enable
+){
+ ScrPtr sp;
+ MapPtr mp = NULL;
+
+ if ((sp = FindScr(dis, screen)))
+ mp = sp->map;
+
+ if (enable & XF86DGADirectGraphics) {
+#if !defined(ISC) && !defined(HAS_SVR3_MMAP) && !defined(Lynx) \
+ && !defined(__EMX__)
+ if (mp && mp->vaddr)
+ mprotect(mp->vaddr, mp->size + mp->delta, PROT_READ | PROT_WRITE);
+#endif
+ } else {
+#if !defined(ISC) && !defined(HAS_SVR3_MMAP) && !defined(Lynx) \
+ && !defined(__EMX__)
+ if (mp && mp->vaddr)
+ mprotect(mp->vaddr, mp->size + mp->delta, PROT_READ);
+#elif defined(Lynx)
+ /* XXX this doesn't allow enable after disable */
+ smem_create(NULL, mp->vaddr, mp->size + mp->delta, SM_DETACH);
+ smem_remove("XF86DGA");
+#endif
+ }
+
+ SDL_NAME(XF86DGADirectVideoLL)(dis, screen, enable);
+ return 1;
+}
+
+
+static void
+XF86cleanup(int sig)
+{
+ ScrPtr sp;
+ int i;
+ static char beenhere = 0;
+
+ if (beenhere)
+ _exit(3);
+ beenhere = 1;
+
+ for (i = 0; i < numScrs; i++) {
+ sp = scrList[i];
+ SDL_NAME(XF86DGADirectVideo)(sp->display, sp->screen, 0);
+ XSync(sp->display, False);
+ }
+ _exit(3);
+}
+
+Bool
+SDL_NAME(XF86DGAGetVideo)(
+ Display *dis,
+ int screen,
+ char **addr,
+ int *width,
+ int *bank,
+ int *ram
+){
+ /*unsigned long*/ int offset;
+ static int beenHere = 0;
+ ScrPtr sp;
+ MapPtr mp;
+
+ if (!(sp = FindScr(dis, screen))) {
+ if (!(sp = AddScr())) {
+ fprintf(stderr, "XF86DGAGetVideo: malloc failure\n");
+ exit(-2);
+ }
+ sp->display = dis;
+ sp->screen = screen;
+ sp->map = NULL;
+ }
+
+ SDL_NAME(XF86DGAGetVideoLL)(dis, screen , &offset, width, bank, ram);
+
+ *addr = MapPhysAddress(offset, *bank);
+ if (*addr == NULL) {
+ fprintf(stderr, "XF86DGAGetVideo: failed to map video memory (%s)\n",
+ strerror(errno));
+ exit(-2);
+ }
+
+ if ((mp = FindMap(offset, *bank)))
+ sp->map = mp;
+
+ if (!beenHere) {
+ beenHere = 1;
+ atexit((void(*)(void))XF86cleanup);
+ /* one shot XF86cleanup attempts */
+ signal(SIGSEGV, XF86cleanup);
+#ifdef SIGBUS
+ signal(SIGBUS, XF86cleanup);
+#endif
+ signal(SIGHUP, XF86cleanup);
+ signal(SIGFPE, XF86cleanup);
+ }
+
+ return 1;
+}
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/Xxf86dga/XF86DGA2.c Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,987 @@
+/* $XFree86: xc/lib/Xxf86dga/XF86DGA2.c,v 1.18 2001/08/17 13:27:51 dawes Exp $ */
+/*
+
+Copyright (c) 1995 Jon Tombs
+Copyright (c) 1995,1996 The XFree86 Project, Inc
+
+*/
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD */
+
+#ifdef __EMX__ /* needed here to override certain constants in X headers */
+#define INCL_DOS
+#define INCL_DOSIOCTL
+#include <os2.h>
+#endif
+
+#define NEED_EVENTS
+#define NEED_REPLIES
+#include <X11/Xlibint.h>
+#include "xf86dga.h"
+#include "xf86dgastr.h"
+#include <X11/extensions/Xext.h>
+#include "extutil.h"
+#include <stdio.h>
+
+#if defined(linux) /* Needed for framebuffer console support */
+#include <sys/ioctl.h>
+#include <linux/fb.h>
+#endif
+
+/* If you change this, change the Bases[] array below as well */
+#define MAX_HEADS 16
+
+char *SDL_NAME(xdga_extension_name) = XF86DGANAME;
+
+static XExtensionInfo _xdga_info_data;
+static XExtensionInfo *xdga_info = &_xdga_info_data;
+
+
+Bool SDL_NAME(XDGAMapFramebuffer)(int, char *, unsigned char*, CARD32, CARD32, CARD32);
+void SDL_NAME(XDGAUnmapFramebuffer)(int);
+unsigned char* SDL_NAME(XDGAGetMappedMemory)(int);
+
+#define XDGACheckExtension(dpy,i,val) \
+ XextCheckExtension (dpy, i, SDL_NAME(xdga_extension_name), val)
+
+/*****************************************************************************
+ * *
+ * private utility routines *
+ * *
+ *****************************************************************************/
+
+static int xdga_close_display(Display *dpy, XExtCodes *codes);
+static Bool xdga_wire_to_event(Display *dpy, XEvent *event, xEvent *wire_ev);
+static Status xdga_event_to_wire(Display *dpy, XEvent *event, xEvent *wire_ev);
+
+static XExtensionHooks xdga_extension_hooks = {
+ NULL, /* create_gc */
+ NULL, /* copy_gc */
+ NULL, /* flush_gc */
+ NULL, /* free_gc */
+ NULL, /* create_font */
+ NULL, /* free_font */
+ xdga_close_display, /* close_display */
+ xdga_wire_to_event, /* wire_to_event */
+ xdga_event_to_wire, /* event_to_wire */
+ NULL, /* error */
+ NULL, /* error_string */
+};
+
+static XEXT_GENERATE_CLOSE_DISPLAY (xdga_close_display, xdga_info)
+
+
+XEXT_GENERATE_FIND_DISPLAY (SDL_NAME(xdga_find_display), xdga_info,
+ "XFree86-DGA",
+ &xdga_extension_hooks,
+ 0, NULL)
+
+
+static Status
+xdga_event_to_wire(
+ Display *dpy,
+ XEvent *event,
+ xEvent *wire_ev
+){
+ return True;
+}
+
+static Bool
+xdga_wire_to_event(
+ Display *dpy,
+ XEvent *event,
+ xEvent *wire_ev
+){
+ dgaEvent *wire = (dgaEvent *) wire_ev;
+ SDL_NAME(XDGAButtonEvent) *bevent;
+ SDL_NAME(XDGAKeyEvent) *kevent;
+ SDL_NAME(XDGAMotionEvent) *mevent;
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+
+ XDGACheckExtension (dpy, info, False);
+
+ switch((wire->u.u.type & 0x7f) - info->codes->first_event) {
+ case MotionNotify:
+ mevent = (SDL_NAME(XDGAMotionEvent)*)event;
+ mevent->type = wire->u.u.type & 0x7F;
+ mevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *)wire);
+ mevent->display = dpy;
+ mevent->screen = wire->u.event.screen;
+ mevent->time = wire->u.event.time;
+ mevent->state = wire->u.event.state;
+ mevent->dx = wire->u.event.dx;
+ mevent->dy = wire->u.event.dy;
+ return True;
+ case ButtonPress:
+ case ButtonRelease:
+ bevent = (SDL_NAME(XDGAButtonEvent)*)event;
+ bevent->type = wire->u.u.type & 0x7F;
+ bevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *)wire);
+ bevent->display = dpy;
+ bevent->screen = wire->u.event.screen;
+ bevent->time = wire->u.event.time;
+ bevent->state = wire->u.event.state;
+ bevent->button = wire->u.u.detail;
+ return True;
+ case KeyPress:
+ case KeyRelease:
+ kevent = (SDL_NAME(XDGAKeyEvent)*)event;
+ kevent->type = wire->u.u.type & 0x7F;
+ kevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *)wire);
+ kevent->display = dpy;
+ kevent->screen = wire->u.event.screen;
+ kevent->time = wire->u.event.time;
+ kevent->state = wire->u.event.state;
+ kevent->keycode = wire->u.u.detail;
+ return True;
+ }
+
+ return False;
+}
+
+
+Bool SDL_NAME(XDGAQueryExtension) (
+ Display *dpy,
+ int *event_basep,
+ int *error_basep
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+
+ if (XextHasExtension(info)) {
+ *event_basep = info->codes->first_event;
+ *error_basep = info->codes->first_error;
+ return True;
+ } else {
+ return False;
+ }
+}
+
+
+Bool SDL_NAME(XDGAQueryVersion)(
+ Display *dpy,
+ int *majorVersion,
+ int *minorVersion
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXDGAQueryVersionReply rep;
+ xXDGAQueryVersionReq *req;
+
+ XDGACheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XDGAQueryVersion, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XDGAQueryVersion;
+ if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return False;
+ }
+ *majorVersion = rep.majorVersion;
+ *minorVersion = rep.minorVersion;
+ UnlockDisplay(dpy);
+ SyncHandle();
+ if (*majorVersion >= 2)
+ {
+ int i, j;
+
+ for (i = 0, j = info->codes->first_event;
+ i < XF86DGANumberEvents;
+ i++, j++)
+ {
+ XESetWireToEvent (dpy, j, xdga_wire_to_event);
+ XESetEventToWire (dpy, j, xdga_event_to_wire);
+ }
+ SDL_NAME(XDGASetClientVersion)(dpy);
+ }
+ return True;
+}
+
+Bool SDL_NAME(XDGASetClientVersion)(
+ Display *dpy
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXDGASetClientVersionReq *req;
+
+ XDGACheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XDGASetClientVersion, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XDGASetClientVersion;
+ req->major = XDGA_MAJOR_VERSION;
+ req->minor = XDGA_MINOR_VERSION;
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+Bool SDL_NAME(XDGAOpenFramebuffer)(
+ Display *dpy,
+ int screen
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXDGAOpenFramebufferReply rep;
+ xXDGAOpenFramebufferReq *req;
+ char *deviceName = NULL;
+ Bool ret;
+
+ XDGACheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XDGAOpenFramebuffer, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XDGAOpenFramebuffer;
+ req->screen = screen;
+ if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return False;
+ }
+
+ if(rep.length) {
+ deviceName = Xmalloc(rep.length << 2);
+ _XRead(dpy, deviceName, rep.length << 2);
+ }
+
+ ret = SDL_NAME(XDGAMapFramebuffer)(screen, deviceName,
+ (unsigned char*)(long)rep.mem1,
+ rep.size, rep.offset, rep.extra);
+
+ if(deviceName)
+ Xfree(deviceName);
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return ret;
+}
+
+void SDL_NAME(XDGACloseFramebuffer)(
+ Display *dpy,
+ int screen
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXDGACloseFramebufferReq *req;
+
+ XextSimpleCheckExtension (dpy, info, SDL_NAME(xdga_extension_name));
+
+ SDL_NAME(XDGAUnmapFramebuffer)(screen);
+
+ LockDisplay(dpy);
+ GetReq(XDGACloseFramebuffer, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XDGACloseFramebuffer;
+ req->screen = screen;
+ UnlockDisplay(dpy);
+ SyncHandle();
+}
+
+
+
+SDL_NAME(XDGAMode)* SDL_NAME(XDGAQueryModes)(
+ Display *dpy,
+ int screen,
+ int *num
+){
+ XExtDisplayInfo *dinfo = SDL_NAME(xdga_find_display) (dpy);
+ xXDGAQueryModesReply rep;
+ xXDGAQueryModesReq *req;
+ SDL_NAME(XDGAMode) *modes = NULL;
+
+ *num = 0;
+
+ XDGACheckExtension (dpy, dinfo, NULL);
+
+ LockDisplay(dpy);
+ GetReq(XDGAQueryModes, req);
+ req->reqType = dinfo->codes->major_opcode;
+ req->dgaReqType = X_XDGAQueryModes;
+ req->screen = screen;
+
+ if (_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+ if(rep.length) {
+ xXDGAModeInfo info;
+ int i, size;
+ char *offset;
+
+ size = rep.length << 2;
+ size -= rep.number * sz_xXDGAModeInfo; /* find text size */
+ modes = (SDL_NAME(XDGAMode)*)Xmalloc((rep.number * sizeof(SDL_NAME(XDGAMode))) + size);
+ offset = (char*)(&modes[rep.number]); /* start of text */
+
+
+ if(modes) {
+ for(i = 0; i < rep.number; i++) {
+ _XRead(dpy, (char*)(&info), sz_xXDGAModeInfo);
+
+ modes[i].num = info.num;
+ modes[i].verticalRefresh =
+ (float)info.vsync_num / (float)info.vsync_den;
+ modes[i].flags = info.flags;
+ modes[i].imageWidth = info.image_width;
+ modes[i].imageHeight = info.image_height;
+ modes[i].pixmapWidth = info.pixmap_width;
+ modes[i].pixmapHeight = info.pixmap_height;
+ modes[i].bytesPerScanline = info.bytes_per_scanline;
+ modes[i].byteOrder = info.byte_order;
+ modes[i].depth = info.depth;
+ modes[i].bitsPerPixel = info.bpp;
+ modes[i].redMask = info.red_mask;
+ modes[i].greenMask = info.green_mask;
+ modes[i].blueMask = info.blue_mask;
+ modes[i].visualClass = info.visual_class;
+ modes[i].viewportWidth = info.viewport_width;
+ modes[i].viewportHeight = info.viewport_height;
+ modes[i].xViewportStep = info.viewport_xstep;
+ modes[i].yViewportStep = info.viewport_ystep;
+ modes[i].maxViewportX = info.viewport_xmax;
+ modes[i].maxViewportY = info.viewport_ymax;
+ modes[i].viewportFlags = info.viewport_flags;
+ modes[i].reserved1 = info.reserved1;
+ modes[i].reserved2 = info.reserved2;
+
+ _XRead(dpy, offset, info.name_size);
+ modes[i].name = offset;
+ offset += info.name_size;
+ }
+ *num = rep.number;
+ } else
+ _XEatData(dpy, rep.length << 2);
+ }
+ }
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return modes;
+}
+
+
+SDL_NAME(XDGADevice) *
+SDL_NAME(XDGASetMode)(
+ Display *dpy,
+ int screen,
+ int mode
+){
+ XExtDisplayInfo *dinfo = SDL_NAME(xdga_find_display) (dpy);
+ xXDGASetModeReply rep;
+ xXDGASetModeReq *req;
+ SDL_NAME(XDGADevice) *dev = NULL;
+ Pixmap pid;
+
+ XDGACheckExtension (dpy, dinfo, NULL);
+
+ LockDisplay(dpy);
+ GetReq(XDGASetMode, req);
+ req->reqType = dinfo->codes->major_opcode;
+ req->dgaReqType = X_XDGASetMode;
+ req->screen = screen;
+ req->mode = mode;
+ req->pid = pid = XAllocID(dpy);
+
+ if (_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+ if(rep.length) {
+ xXDGAModeInfo info;
+ int size;
+
+ size = rep.length << 2;
+ size -= sz_xXDGAModeInfo; /* get text size */
+
+ dev = (SDL_NAME(XDGADevice)*)Xmalloc(sizeof(SDL_NAME(XDGADevice)) + size);
+
+ if(dev) {
+ _XRead(dpy, (char*)(&info), sz_xXDGAModeInfo);
+
+ dev->mode.num = info.num;
+ dev->mode.verticalRefresh =
+ (float)info.vsync_num / (float)info.vsync_den;
+ dev->mode.flags = info.flags;
+ dev->mode.imageWidth = info.image_width;
+ dev->mode.imageHeight = info.image_height;
+ dev->mode.pixmapWidth = info.pixmap_width;
+ dev->mode.pixmapHeight = info.pixmap_height;
+ dev->mode.bytesPerScanline = info.bytes_per_scanline;
+ dev->mode.byteOrder = info.byte_order;
+ dev->mode.depth = info.depth;
+ dev->mode.bitsPerPixel = info.bpp;
+ dev->mode.redMask = info.red_mask;
+ dev->mode.greenMask = info.green_mask;
+ dev->mode.blueMask = info.blue_mask;
+ dev->mode.visualClass = info.visual_class;
+ dev->mode.viewportWidth = info.viewport_width;
+ dev->mode.viewportHeight = info.viewport_height;
+ dev->mode.xViewportStep = info.viewport_xstep;
+ dev->mode.yViewportStep = info.viewport_ystep;
+ dev->mode.maxViewportX = info.viewport_xmax;
+ dev->mode.maxViewportY = info.viewport_ymax;
+ dev->mode.viewportFlags = info.viewport_flags;
+ dev->mode.reserved1 = info.reserved1;
+ dev->mode.reserved2 = info.reserved2;
+
+ dev->mode.name = (char*)(&dev[1]);
+ _XRead(dpy, dev->mode.name, info.name_size);
+
+ dev->pixmap = (rep.flags & XDGAPixmap) ? pid : 0;
+ dev->data = SDL_NAME(XDGAGetMappedMemory)(screen);
+
+ if(dev->data)
+ dev->data += rep.offset;
+ }
+ /* not sure what to do if the allocation fails */
+ }
+ }
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return dev;
+}
+
+
+void SDL_NAME(XDGASetViewport)(
+ Display *dpy,
+ int screen,
+ int x,
+ int y,
+ int flags
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXDGASetViewportReq *req;
+
+ XextSimpleCheckExtension (dpy, info, SDL_NAME(xdga_extension_name));
+
+ LockDisplay(dpy);
+ GetReq(XDGASetViewport, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XDGASetViewport;
+ req->screen = screen;
+ req->x = x;
+ req->y = y;
+ req->flags = flags;
+ UnlockDisplay(dpy);
+ SyncHandle();
+}
+
+
+void SDL_NAME(XDGAInstallColormap)(
+ Display *dpy,
+ int screen,
+ Colormap cmap
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXDGAInstallColormapReq *req;
+
+ XextSimpleCheckExtension (dpy, info, SDL_NAME(xdga_extension_name));
+
+ LockDisplay(dpy);
+ GetReq(XDGAInstallColormap, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XDGAInstallColormap;
+ req->screen = screen;
+ req->cmap = cmap;
+ UnlockDisplay(dpy);
+ SyncHandle();
+}
+
+void SDL_NAME(XDGASelectInput)(
+ Display *dpy,
+ int screen,
+ long mask
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXDGASelectInputReq *req;
+
+ XextSimpleCheckExtension (dpy, info, SDL_NAME(xdga_extension_name));
+
+ LockDisplay(dpy);
+ GetReq(XDGASelectInput, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XDGASelectInput;
+ req->screen = screen;
+ req->mask = mask;
+ UnlockDisplay(dpy);
+ SyncHandle();
+}
+
+void SDL_NAME(XDGAFillRectangle)(
+ Display *dpy,
+ int screen,
+ int x,
+ int y,
+ unsigned int width,
+ unsigned int height,
+ unsigned long color
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXDGAFillRectangleReq *req;
+
+ XextSimpleCheckExtension (dpy, info, SDL_NAME(xdga_extension_name));
+
+ LockDisplay(dpy);
+ GetReq(XDGAFillRectangle, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XDGAFillRectangle;
+ req->screen = screen;
+ req->x = x;
+ req->y = y;
+ req->width = width;
+ req->height = height;
+ req->color = color;
+ UnlockDisplay(dpy);
+ SyncHandle();
+}
+
+void SDL_NAME(XDGACopyArea)(
+ Display *dpy,
+ int screen,
+ int srcx,
+ int srcy,
+ unsigned int width,
+ unsigned int height,
+ int dstx,
+ int dsty
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXDGACopyAreaReq *req;
+
+ XextSimpleCheckExtension (dpy, info, SDL_NAME(xdga_extension_name));
+
+ LockDisplay(dpy);
+ GetReq(XDGACopyArea, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XDGACopyArea;
+ req->screen = screen;
+ req->srcx = srcx;
+ req->srcy = srcy;
+ req->width = width;
+ req->height = height;
+ req->dstx = dstx;
+ req->dsty = dsty;
+ UnlockDisplay(dpy);
+ SyncHandle();
+}
+
+void SDL_NAME(XDGACopyTransparentArea)(
+ Display *dpy,
+ int screen,
+ int srcx,
+ int srcy,
+ unsigned int width,
+ unsigned int height,
+ int dstx,
+ int dsty,
+ unsigned long key
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXDGACopyTransparentAreaReq *req;
+
+ XextSimpleCheckExtension (dpy, info, SDL_NAME(xdga_extension_name));
+
+ LockDisplay(dpy);
+ GetReq(XDGACopyTransparentArea, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XDGACopyTransparentArea;
+ req->screen = screen;
+ req->srcx = srcx;
+ req->srcy = srcy;
+ req->width = width;
+ req->height = height;
+ req->dstx = dstx;
+ req->dsty = dsty;
+ req->key = key;
+ UnlockDisplay(dpy);
+ SyncHandle();
+}
+
+
+int SDL_NAME(XDGAGetViewportStatus)(
+ Display *dpy,
+ int screen
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXDGAGetViewportStatusReply rep;
+ xXDGAGetViewportStatusReq *req;
+ int status = 0;
+
+ XDGACheckExtension (dpy, info, 0);
+
+ LockDisplay(dpy);
+ GetReq(XDGAGetViewportStatus, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XDGAGetViewportStatus;
+ req->screen = screen;
+ if (!_XReply(dpy, (xReply *)&rep, 0, xFalse))
+ status = rep.status;
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return status;
+}
+
+void SDL_NAME(XDGASync)(
+ Display *dpy,
+ int screen
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXDGASyncReply rep;
+ xXDGASyncReq *req;
+
+ XextSimpleCheckExtension (dpy, info, SDL_NAME(xdga_extension_name));
+
+ LockDisplay(dpy);
+ GetReq(XDGASync, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XDGASync;
+ req->screen = screen;
+ _XReply(dpy, (xReply *)&rep, 0, xFalse);
+ UnlockDisplay(dpy);
+ SyncHandle();
+}
+
+
+void SDL_NAME(XDGAChangePixmapMode)(
+ Display *dpy,
+ int screen,
+ int *x,
+ int *y,
+ int mode
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXDGAChangePixmapModeReq *req;
+ xXDGAChangePixmapModeReply rep;
+
+ XextSimpleCheckExtension (dpy, info, SDL_NAME(xdga_extension_name));
+
+ LockDisplay(dpy);
+ GetReq(XDGAChangePixmapMode, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XDGAChangePixmapMode;
+ req->screen = screen;
+ req->x = *x;
+ req->y = *y;
+ req->flags = mode;
+ _XReply(dpy, (xReply *)&rep, 0, xFalse);
+ *x = rep.x;
+ *y = rep.y;
+ UnlockDisplay(dpy);
+ SyncHandle();
+}
+
+Colormap SDL_NAME(XDGACreateColormap)(
+ Display *dpy,
+ int screen,
+ SDL_NAME(XDGADevice) *dev,
+ int alloc
+){
+ XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
+ xXDGACreateColormapReq *req;
+ Colormap cid;
+
+ XDGACheckExtension (dpy, info, -1);
+
+ LockDisplay(dpy);
+ GetReq(XDGACreateColormap, req);
+ req->reqType = info->codes->major_opcode;
+ req->dgaReqType = X_XDGACreateColormap;
+ req->screen = screen;
+ req->mode = dev->mode.num;
+ req->alloc = alloc;
+ cid = req->id = XAllocID(dpy);
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return cid;
+}
+
+
+void SDL_NAME(XDGAKeyEventToXKeyEvent)(
+ SDL_NAME(XDGAKeyEvent)* dk,
+ XKeyEvent* xk
+){
+ xk->type = dk->type;
+ xk->serial = dk->serial;
+ xk->send_event = False;
+ xk->display = dk->display;
+ xk->window = RootWindow(dk->display, dk->screen);
+ xk->root = xk->window;
+ xk->subwindow = None;
+ xk->time = dk->time;
+ xk->x = xk->y = xk->x_root = xk->y_root = 0;
+ xk->state = dk->state;
+ xk->keycode = dk->keycode;
+ xk->same_screen = True;
+}
+
+#include <X11/Xmd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#if defined(ISC)
+# define HAS_SVR3_MMAP
+# include <sys/types.h>
+# include <errno.h>
+
+# include <sys/at_ansi.h>
+# include <sys/kd.h>
+
+# include <sys/sysmacros.h>
+# include <sys/immu.h>
+# include <sys/region.h>
+
+# include <sys/mmap.h>
+#else
+# if !defined(Lynx)
+# if !defined(__EMX__)
+# include <sys/mman.h>
+# endif
+# else
+# include <sys/types.h>
+# include <errno.h>
+# include <smem.h>
+# endif
+#endif
+#include <sys/wait.h>
+#include <signal.h>
+#include <unistd.h>
+
+#if defined(SVR4) && !defined(sun) && !defined(SCO325)
+#define DEV_MEM "/dev/pmem"
+#elif defined(SVR4) && defined(sun)
+#define DEV_MEM "/dev/xsvc"
+#else
+#define DEV_MEM "/dev/mem"
+#endif
+
+
+
+typedef struct _DGAMapRec{
+ unsigned char *physical;
+ unsigned char *virtual;
+ CARD32 size;
+ int fd;
+ int screen;
+ struct _DGAMapRec *next;
+} DGAMapRec, *DGAMapPtr;
+
+static Bool
+DGAMapPhysical(int, char*, unsigned char*, CARD32, CARD32, CARD32, DGAMapPtr);
+static void DGAUnmapPhysical(DGAMapPtr);
+
+static DGAMapPtr _Maps = NULL;
+
+
+unsigned char*
+SDL_NAME(XDGAGetMappedMemory)(int screen)
+{
+ DGAMapPtr pMap = _Maps;
+ unsigned char *pntr = NULL;
+
+ while(pMap != NULL) {
+ if(pMap->screen == screen) {
+ pntr = pMap->virtual;
+ break;
+ }
+ pMap = pMap->next;
+ }
+
+ return pntr;
+}
+
+Bool
+SDL_NAME(XDGAMapFramebuffer)(
+ int screen,
+ char *name, /* optional device name */
+ unsigned char* base, /* physical memory */
+ CARD32 size, /* size */
+ CARD32 offset, /* optional offset */
+ CARD32 extra /* optional extra data */
+){
+ DGAMapPtr pMap = _Maps;
+ Bool result;
+
+ /* is it already mapped ? */
+ while(pMap != NULL) {
+ if(pMap->screen == screen)
+ return True;
+ pMap = pMap->next;
+ }
+
+ if(extra & XDGANeedRoot) {
+ /* we should probably check if we have root permissions and
+ return False here */
+
+ }
+
+ pMap = (DGAMapPtr)Xmalloc(sizeof(DGAMapRec));
+
+ result = DGAMapPhysical(screen, name, base, size, offset, extra, pMap);
+
+ if(result) {
+ pMap->next = _Maps;
+ _Maps = pMap;
+ } else
+ Xfree(pMap);
+
+ return result;
+}
+
+void
+SDL_NAME(XDGAUnmapFramebuffer)(int screen)
+{
+ DGAMapPtr pMap = _Maps;
+ DGAMapPtr pPrev = NULL;
+
+ /* is it already mapped */
+ while(pMap != NULL) {
+ if(pMap->screen == screen)
+ break;
+ pPrev = pMap;
+ pMap = pMap->next;
+ }
+
+ if(!pMap)
+ return;
+
+ DGAUnmapPhysical(pMap);
+
+ if(!pPrev)
+ _Maps = pMap->next;
+ else
+ pPrev->next = pMap->next;
+
+ Xfree(pMap);
+}
+
+
+static Bool
+DGAMapPhysical(
+ int screen,
+ char *name, /* optional device name */
+ unsigned char* base, /* physical memory */
+ CARD32 size, /* size */
+ CARD32 offset, /* optional offset */
+ CARD32 extra, /* optional extra data */
+ DGAMapPtr pMap
+) {
+#if defined(ISC) && defined(HAS_SVR3_MMAP)
+ struct kd_memloc mloc;
+#elif defined(__EMX__)
+ APIRET rc;
+ ULONG action;
+ HFILE hfd;
+#endif
+
+ base += offset;
+
+ pMap->screen = screen;
+ pMap->physical = base;
+ pMap->size = size;
+
+#if defined(ISC) && defined(HAS_SVR3_MMAP)
+ if ((pMap->fd = open("/dev/mmap", O_RDWR)) < 0)
+ return False;
+ mloc.vaddr = (char *)0;
+ mloc.physaddr = (char *)base;
+ mloc.length = size;
+ mloc.ioflg=1;
+
+ if ((pMap->virtual = (void *)ioctl(pMap->fd, MAP, &mloc)) == (void *)-1)
+ return False;
+#elif defined (__EMX__)
+ /*
+ * Dragon warning here! /dev/pmap$ is never closed, except on progam exit.
+ * Consecutive calling of this routine will make PMAP$ driver run out
+ * of memory handles. Some umap/close mechanism should be provided
+ */
+
+ rc = DosOpen("/dev/pmap$", &hfd, &action, 0, FILE_NORMAL, FILE_OPEN,
+ OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE, (PEAOP2)NULL);
+ if (rc != 0)
+ return False;
+ {
+ struct map_ioctl {
+ union {
+ ULONG phys;
+ void* user;
+ } a;
+ ULONG size;
+ } pmap,dmap;
+ ULONG plen,dlen;
+#define XFREE86_PMAP 0x76
+#define PMAP_MAP 0x44
+
+ pmap.a.phys = base;
+ pmap.size = size;
+ rc = DosDevIOCtl(hfd, XFREE86_PMAP, PMAP_MAP,
+ (PULONG)&pmap, sizeof(pmap), &plen,
+ (PULONG)&dmap, sizeof(dmap), &dlen);
+ if (rc == 0) {
+ pMap->virtual = dmap.a.user;
+ }
+ }
+ if (rc != 0)
+ return False;
+#elif defined (Lynx)
+ pMap->virtual = smem_create("XF86DGA", (char*)base, size, SM_READ|SM_WRITE);
+#else
+#ifndef MAP_FILE
+#define MAP_FILE 0
+#endif
+ if (!name)
+ name = DEV_MEM;
+ if ((pMap->fd = open(name, O_RDWR)) < 0)
+#if defined(linux)
+ { /* /dev/fb0 fallback added by Sam Lantinga <hercules@lokigames.com> */
+ /* Try to fall back to /dev/fb on Linux - FIXME: verify the device */
+ struct fb_fix_screeninfo finfo;
+
+ if ((pMap->fd = open("/dev/fb0", O_RDWR)) < 0) {
+ return False;
+ }
+ /* The useable framebuffer console memory may not be the whole
+ framebuffer that X has access to. :-(
+ */
+ if ( ioctl(pMap->fd, FBIOGET_FSCREENINFO, &finfo) < 0 ) {
+ close(pMap->fd);
+ return False;
+ }
+ /* Warning: On PPC, the size and virtual need to be offset by:
+ (((long)finfo.smem_start) -
+ (((long)finfo.smem_start)&~(PAGE_SIZE-1)))
+ */
+ base = 0;
+ size = finfo.smem_len;
+ }
+#else
+ return False;
+#endif
+ pMap->virtual = mmap(NULL, size, PROT_READ | PROT_WRITE,
+ MAP_FILE | MAP_SHARED, pMap->fd, (off_t)base);
+ if (pMap->virtual == (void *)-1)
+ return False;
+#endif
+
+#if !defined(ISC) && !defined(HAS_SVR3_MMAP) && !defined(Lynx) \
+ && !defined(__EMX__)
+ mprotect(pMap->virtual, size, PROT_READ | PROT_WRITE);
+#endif
+
+ return True;
+}
+
+
+
+static void
+DGAUnmapPhysical(DGAMapPtr pMap)
+{
+#if !defined(ISC) && !defined(HAS_SVR3_MMAP) && !defined(Lynx) \
+ && !defined(__EMX__)
+ mprotect(pMap->virtual,pMap->size, PROT_READ);
+#elif defined(Lynx)
+ /* XXX this doesn't allow enable after disable */
+ smem_create(NULL, pMap->virtual, pMap->size, SM_DETACH);
+ smem_remove("XF86DGA");
+#endif
+
+
+ /* We need to unmap and close too !!!!!!!!!!*/
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/Xxf86vm/Makefile.am Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,5 @@
+
+## Makefile.am for the XFree86 Xxf86vm library
+
+noinst_LTLIBRARIES = libXFree86_Xxf86vm.la
+libXFree86_Xxf86vm_la_SOURCES = XF86VMode.c
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/Xxf86vm/XF86VMode.c Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,1210 @@
+/* $XConsortium: XF86VMode.c /main/2 1995/11/14 18:17:58 kaleb $ */
+/* $XFree86: xc/lib/Xxf86vm/XF86VMode.c,v 3.32 2001/07/25 15:04:54 dawes Exp $ */
+/*
+
+Copyright (c) 1995 Kaleb S. KEITHLEY
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES
+OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of Kaleb S. KEITHLEY
+shall not be used in advertising or otherwise to promote the sale, use
+or other dealings in this Software without prior written authorization
+from Kaleb S. KEITHLEY.
+
+*/
+/* $XConsortium: XF86VMode.c /main/4 1996/01/16 07:52:25 kaleb CHECKEDOUT $ */
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD */
+
+#define NEED_EVENTS
+#define NEED_REPLIES
+#ifndef XBUILD_IN_CLIENT
+#include <X11/Xlibint.h>
+#include "xf86vmstr.h"
+#include <X11/extensions/Xext.h>
+#include "extutil.h"
+#else
+#include "lib/X11/Xlibint.h"
+#include "include/extensions/xf86vmstr.h"
+#include "include/extensions/Xext.h"
+#include "include/extensions/extutil.h"
+#endif
+
+#ifdef DEBUG
+#include <stdio.h>
+#endif
+
+#ifndef MODE_BAD
+#define MODE_BAD 255
+#endif
+
+static XExtensionInfo _xf86vidmode_info_data;
+static XExtensionInfo *xf86vidmode_info = &_xf86vidmode_info_data;
+static char *xf86vidmode_extension_name = XF86VIDMODENAME;
+
+#define XF86VidModeCheckExtension(dpy,i,val) \
+ XextCheckExtension (dpy, i, xf86vidmode_extension_name, val)
+
+/*****************************************************************************
+ * *
+ * private utility routines *
+ * *
+ *****************************************************************************/
+
+static XEXT_CLOSE_DISPLAY_PROTO(close_display);
+static /* const */ XExtensionHooks xf86vidmode_extension_hooks = {
+ NULL, /* create_gc */
+ NULL, /* copy_gc */
+ NULL, /* flush_gc */
+ NULL, /* free_gc */
+ NULL, /* create_font */
+ NULL, /* free_font */
+ close_display, /* close_display */
+ NULL, /* wire_to_event */
+ NULL, /* event_to_wire */
+ NULL, /* error */
+ NULL, /* error_string */
+};
+
+static XEXT_GENERATE_FIND_DISPLAY (find_display, xf86vidmode_info,
+ xf86vidmode_extension_name,
+ &xf86vidmode_extension_hooks,
+ 0, NULL)
+
+static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86vidmode_info)
+
+
+/*****************************************************************************
+ * *
+ * public XFree86-VidMode Extension routines *
+ * *
+ *****************************************************************************/
+
+Bool
+SDL_NAME(XF86VidModeQueryExtension) (dpy, event_basep, error_basep)
+ Display *dpy;
+ int *event_basep, *error_basep;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+
+ if (XextHasExtension(info)) {
+ *event_basep = info->codes->first_event;
+ *error_basep = info->codes->first_error;
+ return True;
+ } else {
+ return False;
+ }
+}
+
+Bool
+SDL_NAME(XF86VidModeQueryVersion)(dpy, majorVersion, minorVersion)
+ Display* dpy;
+ int* majorVersion;
+ int* minorVersion;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xXF86VidModeQueryVersionReply rep;
+ xXF86VidModeQueryVersionReq *req;
+
+ XF86VidModeCheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86VidModeQueryVersion, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeQueryVersion;
+ if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return False;
+ }
+ *majorVersion = rep.majorVersion;
+ *minorVersion = rep.minorVersion;
+ UnlockDisplay(dpy);
+ SyncHandle();
+ if (*majorVersion >= 2)
+ SDL_NAME(XF86VidModeSetClientVersion)(dpy);
+ return True;
+}
+
+Bool
+SDL_NAME(XF86VidModeSetClientVersion)(Display *dpy)
+{
+ XExtDisplayInfo *info = find_display(dpy);
+ xXF86VidModeSetClientVersionReq *req;
+
+ XF86VidModeCheckExtension(dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86VidModeSetClientVersion, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeSetClientVersion;
+ req->major = XF86VIDMODE_MAJOR_VERSION;
+ req->minor = XF86VIDMODE_MINOR_VERSION;
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+Bool
+SDL_NAME(XF86VidModeSetGamma)(Display *dpy, int screen, SDL_NAME(XF86VidModeGamma) *Gamma)
+{
+ XExtDisplayInfo *info = find_display(dpy);
+ xXF86VidModeSetGammaReq *req;
+
+ XF86VidModeCheckExtension(dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86VidModeSetGamma, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeSetGamma;
+ req->screen = screen;
+ req->red = (CARD32)(Gamma->red * 10000.);
+ req->green = (CARD32)(Gamma->green * 10000.);
+ req->blue = (CARD32)(Gamma->blue * 10000.);
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+Bool
+SDL_NAME(XF86VidModeGetGamma)(Display *dpy, int screen, SDL_NAME(XF86VidModeGamma) *Gamma)
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xXF86VidModeGetGammaReply rep;
+ xXF86VidModeGetGammaReq *req;
+
+ XF86VidModeCheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86VidModeGetGamma, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeGetGamma;
+ req->screen = screen;
+ if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return False;
+ }
+ Gamma->red = ((float)rep.red) / 10000.;
+ Gamma->green = ((float)rep.green) / 10000.;
+ Gamma->blue = ((float)rep.blue) / 10000.;
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+Bool
+SDL_NAME(XF86VidModeGetModeLine)(dpy, screen, dotclock, modeline)
+ Display* dpy;
+ int screen;
+ int* dotclock;
+ SDL_NAME(XF86VidModeModeLine)* modeline;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xXF86VidModeGetModeLineReply rep;
+ xXF86OldVidModeGetModeLineReply oldrep;
+ xXF86VidModeGetModeLineReq *req;
+ int majorVersion, minorVersion;
+
+ XF86VidModeCheckExtension (dpy, info, False);
+ SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion);
+
+ LockDisplay(dpy);
+ GetReq(XF86VidModeGetModeLine, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeGetModeLine;
+ req->screen = screen;
+
+ if (majorVersion < 2) {
+ if (!_XReply(dpy, (xReply *)&oldrep,
+ (SIZEOF(xXF86OldVidModeGetModeLineReply) - SIZEOF(xReply)) >> 2, xFalse)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return False;
+ }
+ *dotclock = oldrep.dotclock;
+ modeline->hdisplay = oldrep.hdisplay;
+ modeline->hsyncstart = oldrep.hsyncstart;
+ modeline->hsyncend = oldrep.hsyncend;
+ modeline->htotal = oldrep.htotal;
+ modeline->hskew = 0;
+ modeline->vdisplay = oldrep.vdisplay;
+ modeline->vsyncstart = oldrep.vsyncstart;
+ modeline->vsyncend = oldrep.vsyncend;
+ modeline->vtotal = oldrep.vtotal;
+ modeline->flags = oldrep.flags;
+ modeline->privsize = oldrep.privsize;
+ } else {
+ if (!_XReply(dpy, (xReply *)&rep,
+ (SIZEOF(xXF86VidModeGetModeLineReply) - SIZEOF(xReply)) >> 2, xFalse)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return False;
+ }
+ *dotclock = rep.dotclock;
+ modeline->hdisplay = rep.hdisplay;
+ modeline->hsyncstart = rep.hsyncstart;
+ modeline->hsyncend = rep.hsyncend;
+ modeline->htotal = rep.htotal;
+ modeline->hskew = rep.hskew;
+ modeline->vdisplay = rep.vdisplay;
+ modeline->vsyncstart = rep.vsyncstart;
+ modeline->vsyncend = rep.vsyncend;
+ modeline->vtotal = rep.vtotal;
+ modeline->flags = rep.flags;
+ modeline->privsize = rep.privsize;
+ }
+
+ if (modeline->privsize > 0) {
+ if (!(modeline->private = Xcalloc(modeline->privsize, sizeof(INT32)))) {
+ _XEatData(dpy, (modeline->privsize) * sizeof(INT32));
+ Xfree(modeline->private);
+ return False;
+ }
+ _XRead(dpy, (char*)modeline->private, modeline->privsize * sizeof(INT32));
+ } else {
+ modeline->private = NULL;
+ }
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+Bool
+SDL_NAME(XF86VidModeGetAllModeLines)(dpy, screen, modecount, modelinesPtr)
+ Display* dpy;
+ int screen;
+ int* modecount;
+ SDL_NAME(XF86VidModeModeInfo) ***modelinesPtr;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xXF86VidModeGetAllModeLinesReply rep;
+ xXF86VidModeGetAllModeLinesReq *req;
+ SDL_NAME(XF86VidModeModeInfo) *mdinfptr, **modelines;
+ xXF86VidModeModeInfo xmdline;
+ xXF86OldVidModeModeInfo oldxmdline;
+ int i;
+ int majorVersion, minorVersion;
+ Bool protocolBug = False;
+
+ XF86VidModeCheckExtension (dpy, info, False);
+
+ /*
+ * Note: There was a bug in the protocol implementation in versions
+ * 0.x with x < 8 (the .private field wasn't being passed over the wire).
+ * Check the server's version, and accept the old format if appropriate.
+ */
+
+ SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion);
+ if (majorVersion == 0 && minorVersion < 8) {
+ protocolBug = True;
+#ifdef DEBUG
+ fprintf(stderr, "XF86VidModeGetAllModeLines: Warning: Xserver is"
+ "running an old version (%d.%d)\n", majorVersion,
+ minorVersion);
+#endif
+ }
+
+ LockDisplay(dpy);
+ GetReq(XF86VidModeGetAllModeLines, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeGetAllModeLines;
+ req->screen = screen;
+ if (!_XReply(dpy, (xReply *)&rep,
+ (SIZEOF(xXF86VidModeGetAllModeLinesReply) - SIZEOF(xReply)) >> 2, xFalse)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return False;
+ }
+
+ *modecount = rep.modecount;
+
+ if (!(modelines = (SDL_NAME(XF86VidModeModeInfo) **) Xcalloc(rep.modecount,
+ sizeof(SDL_NAME(XF86VidModeModeInfo) *)
+ +sizeof(SDL_NAME(XF86VidModeModeInfo))))) {
+ if (majorVersion < 2)
+ _XEatData(dpy, (rep.modecount) * sizeof(xXF86OldVidModeModeInfo));
+ else
+ _XEatData(dpy, (rep.modecount) * sizeof(xXF86VidModeModeInfo));
+ Xfree(modelines);
+ return False;
+ }
+ mdinfptr = (SDL_NAME(XF86VidModeModeInfo) *) (
+ (char *) modelines
+ + rep.modecount*sizeof(SDL_NAME(XF86VidModeModeInfo) *)
+ );
+
+ for (i = 0; i < rep.modecount; i++) {
+ modelines[i] = mdinfptr++;
+ if (majorVersion < 2) {
+ _XRead(dpy, (char*)&oldxmdline, sizeof(xXF86OldVidModeModeInfo));
+ modelines[i]->dotclock = oldxmdline.dotclock;
+ modelines[i]->hdisplay = oldxmdline.hdisplay;
+ modelines[i]->hsyncstart = oldxmdline.hsyncstart;
+ modelines[i]->hsyncend = oldxmdline.hsyncend;
+ modelines[i]->htotal = oldxmdline.htotal;
+ modelines[i]->hskew = 0;
+ modelines[i]->vdisplay = oldxmdline.vdisplay;
+ modelines[i]->vsyncstart = oldxmdline.vsyncstart;
+ modelines[i]->vsyncend = oldxmdline.vsyncend;
+ modelines[i]->vtotal = oldxmdline.vtotal;
+ modelines[i]->flags = oldxmdline.flags;
+ if (protocolBug) {
+ modelines[i]->privsize = 0;
+ modelines[i]->private = NULL;
+ } else {
+ modelines[i]->privsize = oldxmdline.privsize;
+ if (oldxmdline.privsize > 0) {
+ if (!(modelines[i]->private =
+ Xcalloc(oldxmdline.privsize, sizeof(INT32)))) {
+ _XEatData(dpy, (oldxmdline.privsize) * sizeof(INT32));
+ Xfree(modelines[i]->private);
+ } else {
+ _XRead(dpy, (char*)modelines[i]->private,
+ oldxmdline.privsize * sizeof(INT32));
+ }
+ } else {
+ modelines[i]->private = NULL;
+ }
+ }
+ } else {
+ _XRead(dpy, (char*)&xmdline, sizeof(xXF86VidModeModeInfo));
+ modelines[i]->dotclock = xmdline.dotclock;
+ modelines[i]->hdisplay = xmdline.hdisplay;
+ modelines[i]->hsyncstart = xmdline.hsyncstart;
+ modelines[i]->hsyncend = xmdline.hsyncend;
+ modelines[i]->htotal = xmdline.htotal;
+ modelines[i]->hskew = xmdline.hskew;
+ modelines[i]->vdisplay = xmdline.vdisplay;
+ modelines[i]->vsyncstart = xmdline.vsyncstart;
+ modelines[i]->vsyncend = xmdline.vsyncend;
+ modelines[i]->vtotal = xmdline.vtotal;
+ modelines[i]->flags = xmdline.flags;
+ if (protocolBug) {
+ modelines[i]->privsize = 0;
+ modelines[i]->private = NULL;
+ } else {
+ modelines[i]->privsize = xmdline.privsize;
+ if (xmdline.privsize > 0) {
+ if (!(modelines[i]->private =
+ Xcalloc(xmdline.privsize, sizeof(INT32)))) {
+ _XEatData(dpy, (xmdline.privsize) * sizeof(INT32));
+ Xfree(modelines[i]->private);
+ } else {
+ _XRead(dpy, (char*)modelines[i]->private,
+ xmdline.privsize * sizeof(INT32));
+ }
+ } else {
+ modelines[i]->private = NULL;
+ }
+ }
+ }
+ }
+ *modelinesPtr = modelines;
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+/*
+ * GetReq replacement for use with VidMode protocols earlier than 2.0
+ */
+#if !defined(UNIXCPP) || defined(ANSICPP)
+#define GetOldReq(name, oldname, req) \
+ WORD64ALIGN\
+ if ((dpy->bufptr + SIZEOF(x##oldname##Req)) > dpy->bufmax)\
+ _XFlush(dpy);\
+ req = (x##oldname##Req *)(dpy->last_req = dpy->bufptr);\
+ req->reqType = X_##name;\
+ req->length = (SIZEOF(x##oldname##Req))>>2;\
+ dpy->bufptr += SIZEOF(x##oldname##Req);\
+ dpy->request++
+
+#else /* non-ANSI C uses empty comment instead of "##" for token concatenation */
+#define GetOldReq(name, oldname, req) \
+ WORD64ALIGN\
+ if ((dpy->bufptr + SIZEOF(x/**/oldname/**/Req)) > dpy->bufmax)\
+ _XFlush(dpy);\
+ req = (x/**/oldname/**/Req *)(dpy->last_req = dpy->bufptr);\
+ req->reqType = X_/**/name;\
+ req->length = (SIZEOF(x/**/oldname/**/Req))>>2;\
+ dpy->bufptr += SIZEOF(x/**/oldname/**/Req);\
+ dpy->request++
+#endif
+
+Bool
+SDL_NAME(XF86VidModeAddModeLine) (dpy, screen, newmodeline, aftermodeline)
+ Display *dpy;
+ int screen;
+ SDL_NAME(XF86VidModeModeInfo)* newmodeline;
+ SDL_NAME(XF86VidModeModeInfo)* aftermodeline;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xXF86VidModeAddModeLineReq *req;
+ xXF86OldVidModeAddModeLineReq *oldreq;
+ int majorVersion, minorVersion;
+
+ XF86VidModeCheckExtension (dpy, info, False);
+ SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion);
+
+ LockDisplay(dpy);
+ if (majorVersion < 2) {
+ GetOldReq(XF86VidModeAddModeLine, XF86OldVidModeAddModeLine, oldreq);
+ oldreq->reqType = info->codes->major_opcode;
+ oldreq->xf86vidmodeReqType = X_XF86VidModeAddModeLine;
+ oldreq->screen = screen;
+ oldreq->dotclock = newmodeline->dotclock;
+ oldreq->hdisplay = newmodeline->hdisplay;
+ oldreq->hsyncstart = newmodeline->hsyncstart;
+ oldreq->hsyncend = newmodeline->hsyncend;
+ oldreq->htotal = newmodeline->htotal;
+ oldreq->vdisplay = newmodeline->vdisplay;
+ oldreq->vsyncstart = newmodeline->vsyncstart;
+ oldreq->vsyncend = newmodeline->vsyncend;
+ oldreq->vtotal = newmodeline->vtotal;
+ oldreq->flags = newmodeline->flags;
+ oldreq->privsize = newmodeline->privsize;
+ if (aftermodeline != NULL) {
+ oldreq->after_dotclock = aftermodeline->dotclock;
+ oldreq->after_hdisplay = aftermodeline->hdisplay;
+ oldreq->after_hsyncstart = aftermodeline->hsyncstart;
+ oldreq->after_hsyncend = aftermodeline->hsyncend;
+ oldreq->after_htotal = aftermodeline->htotal;
+ oldreq->after_vdisplay = aftermodeline->vdisplay;
+ oldreq->after_vsyncstart = aftermodeline->vsyncstart;
+ oldreq->after_vsyncend = aftermodeline->vsyncend;
+ oldreq->after_vtotal = aftermodeline->vtotal;
+ oldreq->after_flags = aftermodeline->flags;
+ } else {
+ oldreq->after_dotclock = 0;
+ oldreq->after_hdisplay = 0;
+ oldreq->after_hsyncstart = 0;
+ oldreq->after_hsyncend = 0;
+ oldreq->after_htotal = 0;
+ oldreq->after_vdisplay = 0;
+ oldreq->after_vsyncstart = 0;
+ oldreq->after_vsyncend = 0;
+ oldreq->after_vtotal = 0;
+ oldreq->after_flags = 0;
+ }
+ if (newmodeline->privsize) {
+ oldreq->length += newmodeline->privsize;
+ Data32(dpy, (long *) newmodeline->private,
+ newmodeline->privsize * sizeof(INT32));
+ }
+ } else {
+ GetReq(XF86VidModeAddModeLine, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeAddModeLine;
+ req->screen = screen;
+ req->dotclock = newmodeline->dotclock;
+ req->hdisplay = newmodeline->hdisplay;
+ req->hsyncstart = newmodeline->hsyncstart;
+ req->hsyncend = newmodeline->hsyncend;
+ req->htotal = newmodeline->htotal;
+ req->hskew = newmodeline->hskew;
+ req->vdisplay = newmodeline->vdisplay;
+ req->vsyncstart = newmodeline->vsyncstart;
+ req->vsyncend = newmodeline->vsyncend;
+ req->vtotal = newmodeline->vtotal;
+ req->flags = newmodeline->flags;
+ req->privsize = newmodeline->privsize;
+ if (aftermodeline != NULL) {
+ req->after_dotclock = aftermodeline->dotclock;
+ req->after_hdisplay = aftermodeline->hdisplay;
+ req->after_hsyncstart = aftermodeline->hsyncstart;
+ req->after_hsyncend = aftermodeline->hsyncend;
+ req->after_htotal = aftermodeline->htotal;
+ req->after_hskew = aftermodeline->hskew;
+ req->after_vdisplay = aftermodeline->vdisplay;
+ req->after_vsyncstart = aftermodeline->vsyncstart;
+ req->after_vsyncend = aftermodeline->vsyncend;
+ req->after_vtotal = aftermodeline->vtotal;
+ req->after_flags = aftermodeline->flags;
+ } else {
+ req->after_dotclock = 0;
+ req->after_hdisplay = 0;
+ req->after_hsyncstart = 0;
+ req->after_hsyncend = 0;
+ req->after_htotal = 0;
+ req->after_hskew = 0;
+ req->after_vdisplay = 0;
+ req->after_vsyncstart = 0;
+ req->after_vsyncend = 0;
+ req->after_vtotal = 0;
+ req->after_flags = 0;
+ }
+ if (newmodeline->privsize) {
+ req->length += newmodeline->privsize;
+ Data32(dpy, (long *) newmodeline->private,
+ newmodeline->privsize * sizeof(INT32));
+ }
+ }
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+Bool
+SDL_NAME(XF86VidModeDeleteModeLine) (dpy, screen, modeline)
+ Display *dpy;
+ int screen;
+ SDL_NAME(XF86VidModeModeInfo)* modeline;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xXF86VidModeDeleteModeLineReq *req;
+ xXF86OldVidModeDeleteModeLineReq *oldreq;
+ int majorVersion, minorVersion;
+
+ XF86VidModeCheckExtension (dpy, info, 0);
+ SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion);
+
+ LockDisplay(dpy);
+ if (majorVersion < 2) {
+ GetOldReq(XF86VidModeDeleteModeLine, XF86OldVidModeDeleteModeLine, oldreq);
+ oldreq->reqType = info->codes->major_opcode;
+ oldreq->xf86vidmodeReqType = X_XF86VidModeDeleteModeLine;
+ oldreq->screen = screen;
+ oldreq->dotclock = modeline->dotclock;
+ oldreq->hdisplay = modeline->hdisplay;
+ oldreq->hsyncstart = modeline->hsyncstart;
+ oldreq->hsyncend = modeline->hsyncend;
+ oldreq->htotal = modeline->htotal;
+ oldreq->vdisplay = modeline->vdisplay;
+ oldreq->vsyncstart = modeline->vsyncstart;
+ oldreq->vsyncend = modeline->vsyncend;
+ oldreq->vtotal = modeline->vtotal;
+ oldreq->flags = modeline->flags;
+ oldreq->privsize = modeline->privsize;
+ if (modeline->privsize) {
+ oldreq->length += modeline->privsize;
+ Data32(dpy, (long *) modeline->private,
+ modeline->privsize * sizeof(INT32));
+ }
+ } else {
+ GetReq(XF86VidModeDeleteModeLine, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeDeleteModeLine;
+ req->screen = screen;
+ req->dotclock = modeline->dotclock;
+ req->hdisplay = modeline->hdisplay;
+ req->hsyncstart = modeline->hsyncstart;
+ req->hsyncend = modeline->hsyncend;
+ req->htotal = modeline->htotal;
+ req->hskew = modeline->hskew;
+ req->vdisplay = modeline->vdisplay;
+ req->vsyncstart = modeline->vsyncstart;
+ req->vsyncend = modeline->vsyncend;
+ req->vtotal = modeline->vtotal;
+ req->flags = modeline->flags;
+ req->privsize = modeline->privsize;
+ if (modeline->privsize) {
+ req->length += modeline->privsize;
+ Data32(dpy, (long *) modeline->private,
+ modeline->privsize * sizeof(INT32));
+ }
+ }
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+Bool
+SDL_NAME(XF86VidModeModModeLine) (dpy, screen, modeline)
+ Display *dpy;
+ int screen;
+ SDL_NAME(XF86VidModeModeLine)* modeline;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xXF86VidModeModModeLineReq *req;
+ xXF86OldVidModeModModeLineReq *oldreq;
+ int majorVersion, minorVersion;
+
+ XF86VidModeCheckExtension (dpy, info, 0);
+ SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion);
+
+ LockDisplay(dpy);
+ if (majorVersion < 2) {
+ GetOldReq(XF86VidModeModModeLine, XF86OldVidModeModModeLine, oldreq);
+ oldreq->reqType = info->codes->major_opcode;
+ oldreq->xf86vidmodeReqType = X_XF86VidModeModModeLine;
+ oldreq->screen = screen;
+ oldreq->hdisplay = modeline->hdisplay;
+ oldreq->hsyncstart = modeline->hsyncstart;
+ oldreq->hsyncend = modeline->hsyncend;
+ oldreq->htotal = modeline->htotal;
+ oldreq->vdisplay = modeline->vdisplay;
+ oldreq->vsyncstart = modeline->vsyncstart;
+ oldreq->vsyncend = modeline->vsyncend;
+ oldreq->vtotal = modeline->vtotal;
+ oldreq->flags = modeline->flags;
+ oldreq->privsize = modeline->privsize;
+ if (modeline->privsize) {
+ oldreq->length += modeline->privsize;
+ Data32(dpy, (long *) modeline->private,
+ modeline->privsize * sizeof(INT32));
+ }
+ } else {
+ GetReq(XF86VidModeModModeLine, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeModModeLine;
+ req->screen = screen;
+ req->hdisplay = modeline->hdisplay;
+ req->hsyncstart = modeline->hsyncstart;
+ req->hsyncend = modeline->hsyncend;
+ req->htotal = modeline->htotal;
+ req->hskew = modeline->hskew;
+ req->vdisplay = modeline->vdisplay;
+ req->vsyncstart = modeline->vsyncstart;
+ req->vsyncend = modeline->vsyncend;
+ req->vtotal = modeline->vtotal;
+ req->flags = modeline->flags;
+ req->privsize = modeline->privsize;
+ if (modeline->privsize) {
+ req->length += modeline->privsize;
+ Data32(dpy, (long *) modeline->private,
+ modeline->privsize * sizeof(INT32));
+ }
+ }
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+Status
+SDL_NAME(XF86VidModeValidateModeLine) (dpy, screen, modeline)
+ Display *dpy;
+ int screen;
+ SDL_NAME(XF86VidModeModeInfo)* modeline;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xXF86VidModeValidateModeLineReq *req;
+ xXF86OldVidModeValidateModeLineReq *oldreq;
+ xXF86VidModeValidateModeLineReply rep;
+ int majorVersion, minorVersion;
+
+ XF86VidModeCheckExtension (dpy, info, 0);
+ SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion);
+
+ LockDisplay(dpy);
+
+ if (majorVersion < 2) {
+ GetOldReq(XF86VidModeValidateModeLine, XF86OldVidModeValidateModeLine, oldreq);
+ oldreq->reqType = info->codes->major_opcode;
+ oldreq->xf86vidmodeReqType = X_XF86VidModeValidateModeLine;
+ oldreq->screen = screen;
+ oldreq->dotclock = modeline->dotclock;
+ oldreq->hdisplay = modeline->hdisplay;
+ oldreq->hsyncstart = modeline->hsyncstart;
+ oldreq->hsyncend = modeline->hsyncend;
+ oldreq->htotal = modeline->htotal;
+ oldreq->vdisplay = modeline->vdisplay;
+ oldreq->vsyncstart = modeline->vsyncstart;
+ oldreq->vsyncend = modeline->vsyncend;
+ oldreq->vtotal = modeline->vtotal;
+ oldreq->flags = modeline->flags;
+ oldreq->privsize = modeline->privsize;
+ if (modeline->privsize) {
+ oldreq->length += modeline->privsize;
+ Data32(dpy, (long *) modeline->private,
+ modeline->privsize * sizeof(INT32));
+ }
+ } else {
+ GetReq(XF86VidModeValidateModeLine, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeValidateModeLine;
+ req->screen = screen;
+ req->dotclock = modeline->dotclock;
+ req->hdisplay = modeline->hdisplay;
+ req->hsyncstart = modeline->hsyncstart;
+ req->hsyncend = modeline->hsyncend;
+ req->htotal = modeline->htotal;
+ req->hskew = modeline->hskew;
+ req->vdisplay = modeline->vdisplay;
+ req->vsyncstart = modeline->vsyncstart;
+ req->vsyncend = modeline->vsyncend;
+ req->vtotal = modeline->vtotal;
+ req->flags = modeline->flags;
+ req->privsize = modeline->privsize;
+ if (modeline->privsize) {
+ req->length += modeline->privsize;
+ Data32(dpy, (long *) modeline->private,
+ modeline->privsize * sizeof(INT32));
+ }
+ }
+ if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return MODE_BAD;
+ }
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return rep.status;
+}
+
+Bool
+SDL_NAME(XF86VidModeSwitchMode)(dpy, screen, zoom)
+ Display* dpy;
+ int screen;
+ int zoom;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xXF86VidModeSwitchModeReq *req;
+
+ XF86VidModeCheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86VidModeSwitchMode, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeSwitchMode;
+ req->screen = screen;
+ req->zoom = zoom;
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+Bool
+SDL_NAME(XF86VidModeSwitchToMode)(dpy, screen, modeline)
+ Display* dpy;
+ int screen;
+ SDL_NAME(XF86VidModeModeInfo)* modeline;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xXF86VidModeSwitchToModeReq *req;
+ xXF86OldVidModeSwitchToModeReq *oldreq;
+ int majorVersion, minorVersion;
+ Bool protocolBug = False;
+
+ XF86VidModeCheckExtension (dpy, info, False);
+
+ /*
+ * Note: There was a bug in the protocol implementation in versions
+ * 0.x with x < 8 (the .private field wasn't expected to be sent over
+ * the wire). Check the server's version, and accept the old format
+ * if appropriate.
+ */
+
+ SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion);
+ if (majorVersion == 0 && minorVersion < 8) {
+ protocolBug = True;
+#ifdef DEBUG
+ fprintf(stderr, "XF86VidModeSwitchToMode: Warning: Xserver is"
+ "running an old version (%d.%d)\n", majorVersion,
+ minorVersion);
+#endif
+ }
+
+ LockDisplay(dpy);
+ if (majorVersion < 2) {
+ GetOldReq(XF86VidModeSwitchToMode, XF86OldVidModeSwitchToMode, oldreq);
+ oldreq->reqType = info->codes->major_opcode;
+ oldreq->xf86vidmodeReqType = X_XF86VidModeSwitchToMode;
+ oldreq->screen = screen;
+ oldreq->dotclock = modeline->dotclock;
+ oldreq->hdisplay = modeline->hdisplay;
+ oldreq->hsyncstart = modeline->hsyncstart;
+ oldreq->hsyncend = modeline->hsyncend;
+ oldreq->htotal = modeline->htotal;
+ oldreq->vdisplay = modeline->vdisplay;
+ oldreq->vsyncstart = modeline->vsyncstart;
+ oldreq->vsyncend = modeline->vsyncend;
+ oldreq->vtotal = modeline->vtotal;
+ oldreq->flags = modeline->flags;
+ if (protocolBug) {
+ oldreq->privsize = 0;
+ } else {
+ oldreq->privsize = modeline->privsize;
+ if (modeline->privsize) {
+ oldreq->length += modeline->privsize;
+ Data32(dpy, (long *) modeline->private,
+ modeline->privsize * sizeof(INT32));
+ }
+ }
+ } else {
+ GetReq(XF86VidModeSwitchToMode, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeSwitchToMode;
+ req->screen = screen;
+ req->dotclock = modeline->dotclock;
+ req->hdisplay = modeline->hdisplay;
+ req->hsyncstart = modeline->hsyncstart;
+ req->hsyncend = modeline->hsyncend;
+ req->htotal = modeline->htotal;
+ req->hskew = modeline->hskew;
+ req->vdisplay = modeline->vdisplay;
+ req->vsyncstart = modeline->vsyncstart;
+ req->vsyncend = modeline->vsyncend;
+ req->vtotal = modeline->vtotal;
+ req->flags = modeline->flags;
+ if (protocolBug) {
+ req->privsize = 0;
+ } else {
+ req->privsize = modeline->privsize;
+ if (modeline->privsize) {
+ req->length += modeline->privsize;
+ Data32(dpy, (long *) modeline->private,
+ modeline->privsize * sizeof(INT32));
+ }
+ }
+ }
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+Bool
+SDL_NAME(XF86VidModeLockModeSwitch)(dpy, screen, lock)
+ Display* dpy;
+ int screen;
+ int lock;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xXF86VidModeLockModeSwitchReq *req;
+
+ XF86VidModeCheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86VidModeLockModeSwitch, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeLockModeSwitch;
+ req->screen = screen;
+ req->lock = lock;
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+Bool
+SDL_NAME(XF86VidModeGetMonitor)(dpy, screen, monitor)
+ Display* dpy;
+ int screen;
+ SDL_NAME(XF86VidModeMonitor)* monitor;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xXF86VidModeGetMonitorReply rep;
+ xXF86VidModeGetMonitorReq *req;
+ CARD32 syncrange;
+ int i;
+
+ XF86VidModeCheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86VidModeGetMonitor, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeGetMonitor;
+ req->screen = screen;
+ if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return False;
+ }
+ monitor->nhsync = rep.nhsync;
+ monitor->nvsync = rep.nvsync;
+#if 0
+ monitor->bandwidth = (float)rep.bandwidth / 1e6;
+#endif
+ if (rep.vendorLength) {
+ if (!(monitor->vendor = (char *)Xcalloc(rep.vendorLength + 1, 1))) {
+ _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
+ ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3));
+ return False;
+ }
+ } else {
+ monitor->vendor = NULL;
+ }
+ if (rep.modelLength) {
+ if (!(monitor->model = Xcalloc(rep.modelLength + 1, 1))) {
+ _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
+ ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3));
+ if (monitor->vendor)
+ Xfree(monitor->vendor);
+ return False;
+ }
+ } else {
+ monitor->model = NULL;
+ }
+ if (!(monitor->hsync = Xcalloc(rep.nhsync, sizeof(SDL_NAME(XF86VidModeSyncRange))))) {
+ _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
+ ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3));
+
+ if (monitor->vendor)
+ Xfree(monitor->vendor);
+ if (monitor->model)
+ Xfree(monitor->model);
+ return False;
+ }
+ if (!(monitor->vsync = Xcalloc(rep.nvsync, sizeof(SDL_NAME(XF86VidModeSyncRange))))) {
+ _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
+ ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3));
+ if (monitor->vendor)
+ Xfree(monitor->vendor);
+ if (monitor->model)
+ Xfree(monitor->model);
+ Xfree(monitor->hsync);
+ return False;
+ }
+ for (i = 0; i < rep.nhsync; i++) {
+ _XRead(dpy, (char *)&syncrange, 4);
+ monitor->hsync[i].lo = (float)(syncrange & 0xFFFF) / 100.0;
+ monitor->hsync[i].hi = (float)(syncrange >> 16) / 100.0;
+ }
+ for (i = 0; i < rep.nvsync; i++) {
+ _XRead(dpy, (char *)&syncrange, 4);
+ monitor->vsync[i].lo = (float)(syncrange & 0xFFFF) / 100.0;
+ monitor->vsync[i].hi = (float)(syncrange >> 16) / 100.0;
+ }
+ if (rep.vendorLength)
+ _XReadPad(dpy, monitor->vendor, rep.vendorLength);
+ else
+ monitor->vendor = "";
+ if (rep.modelLength)
+ _XReadPad(dpy, monitor->model, rep.modelLength);
+ else
+ monitor->model = "";
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+Bool
+SDL_NAME(XF86VidModeGetViewPort)(dpy, screen, x, y)
+ Display* dpy;
+ int screen;
+ int *x, *y;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xXF86VidModeGetViewPortReply rep;
+ xXF86VidModeGetViewPortReq *req;
+ int majorVersion, minorVersion;
+ Bool protocolBug = False;
+
+ XF86VidModeCheckExtension (dpy, info, False);
+
+ /*
+ * Note: There was a bug in the protocol implementation in versions
+ * 0.x with x < 8 (no reply was sent, so the client would hang)
+ * Check the server's version, and don't wait for a reply with older
+ * versions.
+ */
+
+ SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion);
+ if (majorVersion == 0 && minorVersion < 8) {
+ protocolBug = True;
+#ifdef DEBUG
+ fprintf(stderr, "XF86VidModeGetViewPort: Warning: Xserver is"
+ "running an old version (%d.%d)\n", majorVersion,
+ minorVersion);
+#endif
+ }
+ LockDisplay(dpy);
+ GetReq(XF86VidModeGetViewPort, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeGetViewPort;
+ req->screen = screen;
+ if (protocolBug) {
+ *x = 0;
+ *y = 0;
+ } else {
+ if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return False;
+ }
+ *x = rep.x;
+ *y = rep.y;
+ }
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+Bool
+SDL_NAME(XF86VidModeSetViewPort)(dpy, screen, x, y)
+ Display* dpy;
+ int screen;
+ int x, y;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xXF86VidModeSetViewPortReq *req;
+
+ XF86VidModeCheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86VidModeSetViewPort, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeSetViewPort;
+ req->screen = screen;
+ req->x = x;
+ req->y = y;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+Bool
+SDL_NAME(XF86VidModeGetDotClocks)(dpy, screen,
+ flagsPtr, numclocksPtr, maxclocksPtr, clocksPtr)
+ Display* dpy;
+ int screen;
+ int *flagsPtr, *numclocksPtr, *maxclocksPtr, *clocksPtr[];
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xXF86VidModeGetDotClocksReply rep;
+ xXF86VidModeGetDotClocksReq *req;
+ int i, *dotclocks;
+ CARD32 dotclk;
+
+ XF86VidModeCheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86VidModeGetDotClocks, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeGetDotClocks;
+ req->screen = screen;
+ if (!_XReply(dpy, (xReply *)&rep,
+ (SIZEOF(xXF86VidModeGetDotClocksReply) - SIZEOF(xReply)) >> 2, xFalse))
+ {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return False;
+ }
+ *numclocksPtr = rep.clocks;
+ *maxclocksPtr = rep.maxclocks;
+ *flagsPtr = rep.flags;
+
+ if (!(dotclocks = (int*) Xcalloc(rep.clocks, sizeof(int)))) {
+ _XEatData(dpy, (rep.clocks) * 4);
+ Xfree(dotclocks);
+ return False;
+ }
+
+ for (i = 0; i < rep.clocks; i++) {
+ _XRead(dpy, (char*)&dotclk, 4);
+ dotclocks[i] = dotclk;
+ }
+ *clocksPtr = dotclocks;
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+Bool
+SDL_NAME(XF86VidModeSetGammaRamp) (
+ Display *dpy,
+ int screen,
+ int size,
+ unsigned short *red,
+ unsigned short *green,
+ unsigned short *blue
+)
+{
+ int length = (size + 1) & ~1;
+ XExtDisplayInfo *info = find_display (dpy);
+ xXF86VidModeSetGammaRampReq *req;
+
+ XF86VidModeCheckExtension (dpy, info, False);
+ LockDisplay(dpy);
+ GetReq(XF86VidModeSetGammaRamp, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeSetGammaRamp;
+ req->screen = screen;
+ req->length += (length >> 1) * 3;
+ req->size = size;
+ _XSend(dpy, (char*)red, size * 2);
+ _XSend(dpy, (char*)green, size * 2);
+ _XSend(dpy, (char*)blue, size * 2);
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+
+Bool
+SDL_NAME(XF86VidModeGetGammaRamp) (
+ Display *dpy,
+ int screen,
+ int size,
+ unsigned short *red,
+ unsigned short *green,
+ unsigned short *blue
+)
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xXF86VidModeGetGammaRampReq *req;
+ xXF86VidModeGetGammaRampReply rep;
+
+ XF86VidModeCheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86VidModeGetGammaRamp, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeGetGammaRamp;
+ req->screen = screen;
+ req->size = size;
+ if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) {
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return False;
+ }
+ if(rep.size) {
+ _XRead(dpy, (char*)red, rep.size << 1);
+ _XRead(dpy, (char*)green, rep.size << 1);
+ _XRead(dpy, (char*)blue, rep.size << 1);
+ }
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
+Bool SDL_NAME(XF86VidModeGetGammaRampSize)(
+ Display *dpy,
+ int screen,
+ int *size
+)
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xXF86VidModeGetGammaRampSizeReq *req;
+ xXF86VidModeGetGammaRampSizeReply rep;
+
+ *size = 0;
+
+ XF86VidModeCheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(XF86VidModeGetGammaRampSize, req);
+ req->reqType = info->codes->major_opcode;
+ req->xf86vidmodeReqType = X_XF86VidModeGetGammaRampSize;
+ req->screen = screen;
+ if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return False;
+ }
+ *size = rep.size;
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return True;
+}
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/extensions/Makefile.am Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,16 @@
+
+noinst_HEADERS = \
+ extutil.h \
+ panoramiXext.h \
+ panoramiXproto.h \
+ SDLname.h \
+ xf86dga1.h \
+ xf86dga1str.h \
+ xf86dga.h \
+ xf86dgastr.h \
+ xf86vmode.h \
+ xf86vmstr.h \
+ Xinerama.h \
+ Xv.h \
+ Xvlib.h \
+ Xvproto.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/extensions/SDLname.h Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,8 @@
+
+#ifndef _SDLname_h_
+#define _SDLname_h_
+
+#define NeedFunctionPrototypes 1
+#define SDL_NAME(X) SDL_##X
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/extensions/Xinerama.h Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,46 @@
+/* $XFree86: xc/include/extensions/Xinerama.h,v 3.2 2000/03/01 01:04:20 dawes Exp $ */
+
+#ifndef _Xinerama_h
+#define _Xinerama_h
+
+#include "SDLname.h"
+
+typedef struct {
+ int screen_number;
+ short x_org;
+ short y_org;
+ short width;
+ short height;
+} SDL_NAME(XineramaScreenInfo);
+
+Bool SDL_NAME(XineramaQueryExtension) (
+ Display *dpy,
+ int *event_base,
+ int *error_base
+);
+
+Status SDL_NAME(XineramaQueryVersion)(
+ Display *dpy,
+ int *major,
+ int *minor
+);
+
+Bool SDL_NAME(XineramaIsActive)(Display *dpy);
+
+
+/*
+ Returns the number of heads and a pointer to an array of
+ structures describing the position and size of the individual
+ heads. Returns NULL and number = 0 if Xinerama is not active.
+
+ Returned array should be freed with XFree().
+*/
+
+SDL_NAME(XineramaScreenInfo) *
+SDL_NAME(XineramaQueryScreens)(
+ Display *dpy,
+ int *number
+);
+
+#endif /* _Xinerama_h */
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/extensions/Xv.h Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,129 @@
+/***********************************************************
+Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts,
+and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Digital or MIT not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+/* $XFree86: xc/include/extensions/Xv.h,v 1.5 1999/12/11 19:28:48 mvojkovi Exp $ */
+
+#ifndef XV_H
+#define XV_H
+/*
+** File:
+**
+** Xv.h --- Xv shared library and server header file
+**
+** Author:
+**
+** David Carver (Digital Workstation Engineering/Project Athena)
+**
+** Revisions:
+**
+** 05.15.91 Carver
+** - version 2.0 upgrade
+**
+** 01.24.91 Carver
+** - version 1.4 upgrade
+**
+*/
+
+#include <X11/X.h>
+
+#define XvName "XVideo"
+#define XvVersion 2
+#define XvRevision 2
+
+/* Symbols */
+
+typedef XID XvPortID;
+typedef XID XvEncodingID;
+
+#define XvNone 0
+
+#define XvInput 0
+#define XvOutput 1
+
+#define XvInputMask (1L<<XvInput)
+#define XvOutputMask (1L<<XvOutput)
+#define XvVideoMask 0x00000004
+#define XvStillMask 0x00000008
+#define XvImageMask 0x00000010
+
+/* These two are not client viewable */
+#define XvPixmapMask 0x00010000
+#define XvWindowMask 0x00020000
+
+
+#define XvGettable 0x01
+#define XvSettable 0x02
+
+#define XvRGB 0
+#define XvYUV 1
+
+#define XvPacked 0
+#define XvPlanar 1
+
+#define XvTopToBottom 0
+#define XvBottomToTop 1
+
+
+/* Events */
+
+#define XvVideoNotify 0
+#define XvPortNotify 1
+#define XvNumEvents 2
+
+/* Video Notify Reasons */
+
+#define XvStarted 0
+#define XvStopped 1
+#define XvBusy 2
+#define XvPreempted 3
+#define XvHardError 4
+#define XvLastReason 4
+
+#define XvNumReasons (XvLastReason + 1)
+
+#define XvStartedMask (1L<<XvStarted)
+#define XvStoppedMask (1L<<XvStopped)
+#define XvBusyMask (1L<<XvBusy)
+#define XvPreemptedMask (1L<<XvPreempted)
+#define XvHardErrorMask (1L<<XvHardError)
+
+#define XvAnyReasonMask ((1L<<XvNumReasons) - 1)
+#define XvNoReasonMask 0
+
+/* Errors */
+
+#define XvBadPort 0
+#define XvBadEncoding 1
+#define XvBadControl 2
+#define XvNumErrors 3
+
+/* Status */
+
+#define XvBadExtension 1
+#define XvAlreadyGrabbed 2
+#define XvInvalidTime 3
+#define XvBadReply 4
+#define XvBadAlloc 5
+
+#endif /* XV_H */
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/extensions/Xvlib.h Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,433 @@
+/***********************************************************
+Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts,
+and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Digital or MIT not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+/* $XFree86: xc/include/extensions/Xvlib.h,v 1.3 1999/12/11 19:28:48 mvojkovi Exp $ */
+
+#ifndef XVLIB_H
+#define XVLIB_H
+/*
+** File:
+**
+** Xvlib.h --- Xv library public header file
+**
+** Author:
+**
+** David Carver (Digital Workstation Engineering/Project Athena)
+**
+** Revisions:
+**
+** 26.06.91 Carver
+** - changed XvFreeAdaptors to XvFreeAdaptorInfo
+** - changed XvFreeEncodings to XvFreeEncodingInfo
+**
+** 11.06.91 Carver
+** - changed SetPortControl to SetPortAttribute
+** - changed GetPortControl to GetPortAttribute
+** - changed QueryBestSize
+**
+** 05.15.91 Carver
+** - version 2.0 upgrade
+**
+** 01.24.91 Carver
+** - version 1.4 upgrade
+**
+*/
+
+#include <X11/Xfuncproto.h>
+#include <XFree86/extensions/Xv.h>
+#include "SDLname.h"
+
+typedef struct {
+ int numerator;
+ int denominator;
+} SDL_NAME(XvRational);
+
+typedef struct {
+ int flags; /* XvGettable, XvSettable */
+ int min_value;
+ int max_value;
+ char *name;
+} SDL_NAME(XvAttribute);
+
+typedef struct {
+ XvEncodingID encoding_id;
+ char *name;
+ unsigned long width;
+ unsigned long height;
+ SDL_NAME(XvRational) rate;
+ unsigned long num_encodings;
+} SDL_NAME(XvEncodingInfo);
+
+typedef struct {
+ char depth;
+ unsigned long visual_id;
+} SDL_NAME(XvFormat);
+
+typedef struct {
+ XvPortID base_id;
+ unsigned long num_ports;
+ char type;
+ char *name;
+ unsigned long num_formats;
+ SDL_NAME(XvFormat) *formats;
+ unsigned long num_adaptors;
+} SDL_NAME(XvAdaptorInfo);
+
+typedef struct {
+ int type;
+ unsigned long serial; /* # of last request processed by server */
+ Bool send_event; /* true if this came from a SendEvent request */
+ Display *display; /* Display the event was read from */
+ Drawable drawable; /* drawable */
+ unsigned long reason; /* what generated this event */
+ XvPortID port_id; /* what port */
+ Time time; /* milliseconds */
+} SDL_NAME(XvVideoNotifyEvent);
+
+typedef struct {
+ int type;
+ unsigned long serial; /* # of last request processed by server */
+ Bool send_event; /* true if this came from a SendEvent request */
+ Display *display; /* Display the event was read from */
+ XvPortID port_id; /* what port */
+ Time time; /* milliseconds */
+ Atom attribute; /* atom that identifies attribute */
+ long value; /* value of attribute */
+} SDL_NAME(XvPortNotifyEvent);
+
+typedef union {
+ int type;
+ SDL_NAME(XvVideoNotifyEvent) xvvideo;
+ SDL_NAME(XvPortNotifyEvent) xvport;
+ long pad[24];
+} SDL_NAME(XvEvent);
+
+typedef struct {
+ int id; /* Unique descriptor for the format */
+ int type; /* XvRGB, XvYUV */
+ int byte_order; /* LSBFirst, MSBFirst */
+ char guid[16]; /* Globally Unique IDentifier */
+ int bits_per_pixel;
+ int format; /* XvPacked, XvPlanar */
+ int num_planes;
+
+ /* for RGB formats only */
+ int depth;
+ unsigned int red_mask;
+ unsigned int green_mask;
+ unsigned int blue_mask;
+
+ /* for YUV formats only */
+ unsigned int y_sample_bits;
+ unsigned int u_sample_bits;
+ unsigned int v_sample_bits;
+ unsigned int horz_y_period;
+ unsigned int horz_u_period;
+ unsigned int horz_v_period;
+ unsigned int vert_y_period;
+ unsigned int vert_u_period;
+ unsigned int vert_v_period;
+ char component_order[32]; /* eg. UYVY */
+ int scanline_order; /* XvTopToBottom, XvBottomToTop */
+} SDL_NAME(XvImageFormatValues);
+
+typedef struct {
+ int id;
+ int width, height;
+ int data_size; /* bytes */
+ int num_planes;
+ int *pitches; /* bytes */
+ int *offsets; /* bytes */
+ char *data;
+ XPointer obdata;
+} SDL_NAME(XvImage);
+
+_XFUNCPROTOBEGIN
+
+extern int SDL_NAME(XvQueryExtension)(
+#if NeedFunctionPrototypes
+ Display* /* display */,
+ unsigned int* /* p_version */,
+ unsigned int* /* p_revision */,
+ unsigned int* /* p_requestBase */,
+ unsigned int* /* p_eventBase */,
+ unsigned int* /* p_errorBase */
+#endif
+);
+
+extern int SDL_NAME(XvQueryAdaptors)(
+#if NeedFunctionPrototypes
+ Display* /* display */,
+ Window /* window */,
+ unsigned int* /* p_nAdaptors */,
+ SDL_NAME(XvAdaptorInfo)** /* p_pAdaptors */
+#endif
+);
+
+extern int SDL_NAME(XvQueryEncodings)(
+#if NeedFunctionPrototypes
+ Display* /* display */,
+ XvPortID /* port */,
+ unsigned int* /* p_nEncoding */,
+ SDL_NAME(XvEncodingInfo)** /* p_pEncoding */
+#endif
+);
+
+extern int SDL_NAME(XvPutVideo)(
+#if NeedFunctionPrototypes
+ Display* /* display */,
+ XvPortID /* port */,
+ Drawable /* d */,
+ GC /* gc */,
+ int /* vx */,
+ int /* vy */,
+ unsigned int /* vw */,
+ unsigned int /* vh */,
+ int /* dx */,
+ int /* dy */,
+ unsigned int /* dw */,
+ unsigned int /* dh */
+#endif
+);
+
+extern int SDL_NAME(XvPutStill)(
+#if NeedFunctionPrototypes
+ Display* /* display */,
+ XvPortID /* port */,
+ Drawable /* d */,
+ GC /* gc */,
+ int /* vx */,
+ int /* vy */,
+ unsigned int /* vw */,
+ unsigned int /* vh */,
+ int /* dx */,
+ int /* dy */,
+ unsigned int /* dw */,
+ unsigned int /* dh */
+#endif
+);
+
+extern int SDL_NAME(XvGetVideo)(
+#if NeedFunctionPrototypes
+ Display* /* display */,
+ XvPortID /* port */,
+ Drawable /* d */,
+ GC /* gc */,
+ int /* vx */,
+ int /* vy */,
+ unsigned int /* vw */,
+ unsigned int /* vh */,
+ int /* dx */,
+ int /* dy */,
+ unsigned int /* dw */,
+ unsigned int /* dh */
+#endif
+);
+
+extern int SDL_NAME(XvGetStill)(
+#if NeedFunctionPrototypes
+ Display* /* display */,
+ XvPortID /* port */,
+ Drawable /* d */,
+ GC /* gc */,
+ int /* vx */,
+ int /* vy */,
+ unsigned int /* vw */,
+ unsigned int /* vh */,
+ int /* dx */,
+ int /* dy */,
+ unsigned int /* dw */,
+ unsigned int /* dh */
+#endif
+);
+
+extern int SDL_NAME(XvStopVideo)(
+#if NeedFunctionPrototypes
+ Display* /* display */,
+ XvPortID /* port */,
+ Drawable /* drawable */
+#endif
+);
+
+extern int SDL_NAME(XvGrabPort)(
+#if NeedFunctionPrototypes
+ Display* /* display */,
+ XvPortID /* port */,
+ Time /* time */
+#endif
+);
+
+extern int SDL_NAME(XvUngrabPort)(
+#if NeedFunctionPrototypes
+ Display* /* display */,
+ XvPortID /* port */,
+ Time /* time */
+#endif
+);
+
+extern int SDL_NAME(XvSelectVideoNotify)(
+#if NeedFunctionPrototypes
+ Display* /* display */,
+ Drawable /* drawable */,
+ Bool /* onoff */
+#endif
+);
+
+extern int SDL_NAME(XvSelectPortNotify)(
+#if NeedFunctionPrototypes
+ Display* /* display */,
+ XvPortID /* port */,
+ Bool /* onoff */
+#endif
+);
+
+extern int SDL_NAME(XvSetPortAttribute)(
+#if NeedFunctionPrototypes
+ Display* /* display */,
+ XvPortID /* port */,
+ Atom /* attribute */,
+ int /* value */
+#endif
+);
+
+extern int SDL_NAME(XvGetPortAttribute)(
+#if NeedFunctionPrototypes
+ Display* /* display */,
+ XvPortID /* port */,
+ Atom /* attribute */,
+ int* /* p_value */
+#endif
+);
+
+extern int SDL_NAME(XvQueryBestSize)(
+#if NeedFunctionPrototypes
+ Display* /* display */,
+ XvPortID /* port */,
+ Bool /* motion */,
+ unsigned int /* vid_w */,
+ unsigned int /* vid_h */,
+ unsigned int /* drw_w */,
+ unsigned int /* drw_h */,
+ unsigned int* /* p_actual_width */,
+ unsigned int* /* p_actual_width */
+#endif
+);
+
+extern SDL_NAME(XvAttribute)* SDL_NAME(XvQueryPortAttributes)(
+#if NeedFunctionPrototypes
+ Display* /* display */,
+ XvPortID /* port */,
+ int* /* number */
+#endif
+);
+
+
+extern void SDL_NAME(XvFreeAdaptorInfo)(
+#if NeedFunctionPrototypes
+ SDL_NAME(XvAdaptorInfo)* /* adaptors */
+#endif
+);
+
+extern void SDL_NAME(XvFreeEncodingInfo)(
+#if NeedFunctionPrototypes
+ SDL_NAME(XvEncodingInfo)* /* encodings */
+#endif
+);
+
+
+extern SDL_NAME(XvImageFormatValues) * SDL_NAME(XvListImageFormats) (
+#if NeedFunctionPrototypes
+ Display *display,
+ XvPortID port_id,
+ int *count_return
+#endif
+);
+
+extern SDL_NAME(XvImage) * SDL_NAME(XvCreateImage) (
+#if NeedFunctionPrototypes
+ Display *display,
+ XvPortID port,
+ int id,
+ char *data,
+ int width,
+ int height
+#endif
+);
+
+extern int SDL_NAME(XvPutImage) (
+#if NeedFunctionPrototypes
+ Display *display,
+ XvPortID id,
+ Drawable d,
+ GC gc,
+ SDL_NAME(XvImage) *image,
+ int src_x,
+ int src_y,
+ unsigned int src_w,
+ unsigned int src_h,
+ int dest_x,
+ int dest_y,
+ unsigned int dest_w,
+ unsigned int dest_h
+#endif
+);
+
+extern int SDL_NAME(XvShmPutImage) (
+#if NeedFunctionPrototypes
+ Display *display,
+ XvPortID id,
+ Drawable d,
+ GC gc,
+ SDL_NAME(XvImage) *image,
+ int src_x,
+ int src_y,
+ unsigned int src_w,
+ unsigned int src_h,
+ int dest_x,
+ int dest_y,
+ unsigned int dest_w,
+ unsigned int dest_h,
+ Bool send_event
+#endif
+);
+
+#ifdef _XSHM_H_
+
+extern SDL_NAME(XvImage) * SDL_NAME(XvShmCreateImage) (
+#if NeedFunctionPrototypes
+ Display *display,
+ XvPortID port,
+ int id,
+ char* data,
+ int width,
+ int height,
+ XShmSegmentInfo *shminfo
+#endif
+);
+
+#endif
+
+
+_XFUNCPROTOEND
+
+#endif /* XVLIB_H */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/extensions/Xvproto.h Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,604 @@
+/***********************************************************
+Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts,
+and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Digital or MIT not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+/* $XFree86: xc/include/extensions/Xvproto.h,v 1.6 2001/05/07 21:37:12 tsi Exp $ */
+
+#ifndef XVPROTO_H
+#define XVPROTO_H
+/*
+** File:
+**
+** Xvproto.h --- Xv protocol header file
+**
+** Author:
+**
+** David Carver (Digital Workstation Engineering/Project Athena)
+**
+** Revisions:
+**
+** 11.06.91 Carver
+** - changed SetPortControl to SetPortAttribute
+** - changed GetPortControl to GetPortAttribute
+** - changed QueryBestSize
+**
+** 15.05.91 Carver
+** - version 2.0 upgrade
+**
+** 24.01.91 Carver
+** - version 1.4 upgrade
+**
+*/
+
+#include <X11/Xmd.h>
+
+/* Symbols: These are undefined at the end of this file to restore the
+ values they have in Xv.h */
+
+#define XvPortID CARD32
+#define XvEncodingID CARD32
+#define ShmSeg CARD32
+#define VisualID CARD32
+#define Drawable CARD32
+#define GContext CARD32
+#define Time CARD32
+#define Atom CARD32
+
+/* Structures */
+
+typedef struct {
+ INT32 numerator B32;
+ INT32 denominator B32;
+} xvRational;
+#define sz_xvRational 8
+
+typedef struct {
+ XvPortID base_id B32;
+ CARD16 name_size B16;
+ CARD16 num_ports B16;
+ CARD16 num_formats B16;
+ CARD8 type;
+ CARD8 pad;
+} xvAdaptorInfo;
+#define sz_xvAdaptorInfo 12
+
+typedef struct {
+ XvEncodingID encoding B32;
+ CARD16 name_size B16;
+ CARD16 width B16, height B16;
+ xvRational rate;
+ CARD16 pad B16;
+} xvEncodingInfo;
+#define sz_xvEncodingInfo (12 + sz_xvRational)
+
+typedef struct {
+ VisualID visual B32;
+ CARD8 depth;
+ CARD8 pad1;
+ CARD16 pad2 B16;
+} xvFormat;
+#define sz_xvFormat 8
+
+typedef struct {
+ CARD32 flags B32;
+ INT32 min B32;
+ INT32 max B32;
+ CARD32 size B32;
+} xvAttributeInfo;
+#define sz_xvAttributeInfo 16
+
+typedef struct {
+ CARD32 id B32;
+ CARD8 type;
+ CARD8 byte_order;
+ CARD16 pad1 B16;
+ CARD8 guid[16];
+ CARD8 bpp;
+ CARD8 num_planes;
+ CARD16 pad2 B16;
+ CARD8 depth;
+ CARD8 pad3;
+ CARD16 pad4 B16;
+ CARD32 red_mask B32;
+ CARD32 green_mask B32;
+ CARD32 blue_mask B32;
+ CARD8 format;
+ CARD8 pad5;
+ CARD16 pad6 B16;
+ CARD32 y_sample_bits B32;
+ CARD32 u_sample_bits B32;
+ CARD32 v_sample_bits B32;
+ CARD32 horz_y_period B32;
+ CARD32 horz_u_period B32;
+ CARD32 horz_v_period B32;
+ CARD32 vert_y_period B32;
+ CARD32 vert_u_period B32;
+ CARD32 vert_v_period B32;
+ CARD8 comp_order[32];
+ CARD8 scanline_order;
+ CARD8 pad7;
+ CARD16 pad8 B16;
+ CARD32 pad9 B32;
+ CARD32 pad10 B32;
+} xvImageFormatInfo;
+#define sz_xvImageFormatInfo 128
+
+
+/* Requests */
+
+#define xv_QueryExtension 0
+#define xv_QueryAdaptors 1
+#define xv_QueryEncodings 2
+#define xv_GrabPort 3
+#define xv_UngrabPort 4
+#define xv_PutVideo 5
+#define xv_PutStill 6
+#define xv_GetVideo 7
+#define xv_GetStill 8
+#define xv_StopVideo 9
+#define xv_SelectVideoNotify 10
+#define xv_SelectPortNotify 11
+#define xv_QueryBestSize 12
+#define xv_SetPortAttribute 13
+#define xv_GetPortAttribute 14
+#define xv_QueryPortAttributes 15
+#define xv_ListImageFormats 16
+#define xv_QueryImageAttributes 17
+#define xv_PutImage 18
+#define xv_ShmPutImage 19
+#define xv_LastRequest xv_ShmPutImage
+
+#define xvNumRequests (xv_LastRequest + 1)
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+} xvQueryExtensionReq;
+#define sz_xvQueryExtensionReq 4
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+ CARD32 window B32;
+} xvQueryAdaptorsReq;
+#define sz_xvQueryAdaptorsReq 8
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+ CARD32 port B32;
+} xvQueryEncodingsReq;
+#define sz_xvQueryEncodingsReq 8
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+ XvPortID port B32;
+ Drawable drawable B32;
+ GContext gc B32;
+ INT16 vid_x B16;
+ INT16 vid_y B16;
+ CARD16 vid_w B16;
+ CARD16 vid_h B16;
+ INT16 drw_x B16;
+ INT16 drw_y B16;
+ CARD16 drw_w B16;
+ CARD16 drw_h B16;
+} xvPutVideoReq;
+#define sz_xvPutVideoReq 32
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+ XvPortID port B32;
+ Drawable drawable B32;
+ GContext gc B32;
+ INT16 vid_x B16;
+ INT16 vid_y B16;
+ CARD16 vid_w B16;
+ CARD16 vid_h B16;
+ INT16 drw_x B16;
+ INT16 drw_y B16;
+ CARD16 drw_w B16;
+ CARD16 drw_h B16;
+} xvPutStillReq;
+#define sz_xvPutStillReq 32
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+ XvPortID port B32;
+ Drawable drawable B32;
+ GContext gc B32;
+ INT16 vid_x B16;
+ INT16 vid_y B16;
+ CARD16 vid_w B16;
+ CARD16 vid_h B16;
+ INT16 drw_x B16;
+ INT16 drw_y B16;
+ CARD16 drw_w B16;
+ CARD16 drw_h B16;
+} xvGetVideoReq;
+#define sz_xvGetVideoReq 32
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+ XvPortID port B32;
+ Drawable drawable B32;
+ GContext gc B32;
+ INT16 vid_x B16;
+ INT16 vid_y B16;
+ CARD16 vid_w B16;
+ CARD16 vid_h B16;
+ INT16 drw_x B16;
+ INT16 drw_y B16;
+ CARD16 drw_w B16;
+ CARD16 drw_h B16;
+} xvGetStillReq;
+#define sz_xvGetStillReq 32
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+ XvPortID port B32;
+ Time time B32;
+} xvGrabPortReq;
+#define sz_xvGrabPortReq 12
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+ XvPortID port B32;
+ Time time B32;
+} xvUngrabPortReq;
+#define sz_xvUngrabPortReq 12
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+ Drawable drawable B32;
+ BOOL onoff;
+ CARD8 pad1;
+ CARD16 pad2;
+} xvSelectVideoNotifyReq;
+#define sz_xvSelectVideoNotifyReq 12
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+ XvPortID port B32;
+ BOOL onoff;
+ CARD8 pad1;
+ CARD16 pad2;
+} xvSelectPortNotifyReq;
+#define sz_xvSelectPortNotifyReq 12
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+ XvPortID port B32;
+ Drawable drawable B32;
+} xvStopVideoReq;
+#define sz_xvStopVideoReq 12
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+ XvPortID port B32;
+ Atom attribute B32;
+ INT32 value B32;
+} xvSetPortAttributeReq;
+#define sz_xvSetPortAttributeReq 16
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+ XvPortID port B32;
+ Atom attribute B32;
+} xvGetPortAttributeReq;
+#define sz_xvGetPortAttributeReq 12
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+ XvPortID port B32;
+ CARD16 vid_w B16;
+ CARD16 vid_h B16;
+ CARD16 drw_w B16;
+ CARD16 drw_h B16;
+ CARD8 motion;
+ CARD8 pad1;
+ CARD16 pad2 B16;
+} xvQueryBestSizeReq;
+#define sz_xvQueryBestSizeReq 20
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+ XvPortID port B32;
+} xvQueryPortAttributesReq;
+#define sz_xvQueryPortAttributesReq 8
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+ XvPortID port B32;
+ Drawable drawable B32;
+ GContext gc B32;
+ CARD32 id B32;
+ INT16 src_x B16;
+ INT16 src_y B16;
+ CARD16 src_w B16;
+ CARD16 src_h B16;
+ INT16 drw_x B16;
+ INT16 drw_y B16;
+ CARD16 drw_w B16;
+ CARD16 drw_h B16;
+ CARD16 width B16;
+ CARD16 height B16;
+} xvPutImageReq;
+#define sz_xvPutImageReq 40
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+ XvPortID port B32;
+ Drawable drawable B32;
+ GContext gc B32;
+ ShmSeg shmseg B32;
+ CARD32 id B32;
+ CARD32 offset B32;
+ INT16 src_x B16;
+ INT16 src_y B16;
+ CARD16 src_w B16;
+ CARD16 src_h B16;
+ INT16 drw_x B16;
+ INT16 drw_y B16;
+ CARD16 drw_w B16;
+ CARD16 drw_h B16;
+ CARD16 width B16;
+ CARD16 height B16;
+ CARD8 send_event;
+ CARD8 pad1;
+ CARD16 pad2 B16;
+} xvShmPutImageReq;
+#define sz_xvShmPutImageReq 52
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+ XvPortID port B32;
+} xvListImageFormatsReq;
+#define sz_xvListImageFormatsReq 8
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 xvReqType;
+ CARD16 length B16;
+ CARD32 port B32;
+ CARD32 id B32;
+ CARD16 width B16;
+ CARD16 height B16;
+} xvQueryImageAttributesReq;
+#define sz_xvQueryImageAttributesReq 16
+
+
+/* Replies */
+
+typedef struct _QueryExtensionReply {
+ BYTE type; /* X_Reply */
+ CARD8 padb1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD16 version B16;
+ CARD16 revision B16;
+ CARD32 padl4 B32;
+ CARD32 padl5 B32;
+ CARD32 padl6 B32;
+ CARD32 padl7 B32;
+ CARD32 padl8 B32;
+} xvQueryExtensionReply;
+#define sz_xvQueryExtensionReply 32
+
+typedef struct _QueryAdaptorsReply {
+ BYTE type; /* X_Reply */
+ CARD8 padb1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD16 num_adaptors B16;
+ CARD16 pads3 B16;
+ CARD32 padl4 B32;
+ CARD32 padl5 B32;
+ CARD32 padl6 B32;
+ CARD32 padl7 B32;
+ CARD32 padl8 B32;
+} xvQueryAdaptorsReply;
+#define sz_xvQueryAdaptorsReply 32
+
+typedef struct _QueryEncodingsReply {
+ BYTE type; /* X_Reply */
+ CARD8 padb1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD16 num_encodings B16;
+ CARD32 padl3 B32;
+ CARD32 padl4 B32;
+ CARD32 padl5 B32;
+ CARD32 padl6 B32;
+ CARD32 padl7 B32;
+ CARD32 padl8 B32;
+} xvQueryEncodingsReply;
+#define sz_xvQueryEncodingsReply 32
+
+typedef struct {
+ BYTE type; /* X_Reply */
+ BYTE result;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32; /* 0 */
+ CARD32 padl3 B32;
+ CARD32 padl4 B32;
+ CARD32 padl5 B32;
+ CARD32 padl6 B32;
+ CARD32 padl7 B32;
+ CARD32 padl8 B32;
+} xvGrabPortReply;
+#define sz_xvGrabPortReply 32
+
+typedef struct {
+ BYTE type; /* X_Reply */
+ BYTE padb1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32; /* 0 */
+ INT32 value B32;
+ CARD32 padl4 B32;
+ CARD32 padl5 B32;
+ CARD32 padl6 B32;
+ CARD32 padl7 B32;
+ CARD32 padl8 B32;
+} xvGetPortAttributeReply;
+#define sz_xvGetPortAttributeReply 32
+
+typedef struct {
+ BYTE type; /* X_Reply */
+ BYTE padb1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32; /* 0 */
+ CARD16 actual_width B16;
+ CARD16 actual_height B16;
+ CARD32 padl4 B32;
+ CARD32 padl5 B32;
+ CARD32 padl6 B32;
+ CARD32 padl7 B32;
+ CARD32 padl8 B32;
+} xvQueryBestSizeReply;
+#define sz_xvQueryBestSizeReply 32
+
+typedef struct {
+ BYTE type; /* X_Reply */
+ BYTE padb1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32; /* 0 */
+ CARD32 num_attributes B32;
+ CARD32 text_size B32;
+ CARD32 padl5 B32;
+ CARD32 padl6 B32;
+ CARD32 padl7 B32;
+ CARD32 padl8 B32;
+} xvQueryPortAttributesReply;
+#define sz_xvQueryPortAttributesReply 32
+
+typedef struct {
+ BYTE type; /* X_Reply */
+ BYTE padb1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 num_formats B32;
+ CARD32 padl4 B32;
+ CARD32 padl5 B32;
+ CARD32 padl6 B32;
+ CARD32 padl7 B32;
+ CARD32 padl8 B32;
+} xvListImageFormatsReply;
+#define sz_xvListImageFormatsReply 32
+
+typedef struct {
+ BYTE type; /* X_Reply */
+ BYTE padb1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 num_planes B32;
+ CARD32 data_size B32;
+ CARD16 width B16;
+ CARD16 height B16;
+ CARD32 padl6 B32;
+ CARD32 padl7 B32;
+ CARD32 padl8 B32;
+} xvQueryImageAttributesReply;
+#define sz_xvQueryImageAttributesReply 32
+
+/* DEFINE EVENT STRUCTURE */
+
+typedef struct {
+ union {
+ struct {
+ BYTE type;
+ BYTE detail;
+ CARD16 sequenceNumber B16;
+ } u;
+ struct {
+ BYTE type;
+ BYTE reason;
+ CARD16 sequenceNumber B16;
+ Time time B32;
+ Drawable drawable B32;
+ XvPortID port B32;
+ CARD32 padl5 B32;
+ CARD32 padl6 B32;
+ CARD32 padl7 B32;
+ CARD32 padl8 B32;
+ } videoNotify;
+ struct {
+ BYTE type;
+ BYTE padb1;
+ CARD16 sequenceNumber B16;
+ Time time B32;
+ XvPortID port B32;
+ Atom attribute B32;
+ INT32 value B32;
+ CARD32 padl6 B32;
+ CARD32 padl7 B32;
+ CARD32 padl8 B32;
+ } portNotify;
+ } u;
+} xvEvent;
+
+#undef XvPortID
+#undef XvEncodingID
+#undef ShmSeg
+#undef VisualID
+#undef Drawable
+#undef GContext
+#undef Time
+#undef Atom
+
+#endif /* XVPROTO_H */
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/extensions/extutil.h Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,224 @@
+/*
+ * $Xorg: extutil.h,v 1.4 2001/02/09 02:03:24 xorgcvs Exp $
+ *
+Copyright 1989, 1998 The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ *
+ * Author: Jim Fulton, MIT The Open Group
+ *
+ * Xlib Extension-Writing Utilities
+ *
+ * This package contains utilities for writing the client API for various
+ * protocol extensions. THESE INTERFACES ARE NOT PART OF THE X STANDARD AND
+ * ARE SUBJECT TO CHANGE!
+ */
+/* $XFree86: xc/include/extensions/extutil.h,v 1.9 2001/12/14 19:53:28 dawes Exp $ */
+
+#ifndef _EXTUTIL_H_
+#define _EXTUTIL_H_
+
+#include <X11/extensions/Xext.h>
+
+/*
+ * We need to keep a list of open displays since the Xlib display list isn't
+ * public. We also have to per-display info in a separate block since it isn't
+ * stored directly in the Display structure.
+ */
+typedef struct _XExtDisplayInfo {
+ struct _XExtDisplayInfo *next; /* keep a linked list */
+ Display *display; /* which display this is */
+ XExtCodes *codes; /* the extension protocol codes */
+ XPointer data; /* extra data for extension to use */
+} XExtDisplayInfo;
+
+typedef struct _XExtensionInfo {
+ XExtDisplayInfo *head; /* start of list */
+ XExtDisplayInfo *cur; /* most recently used */
+ int ndisplays; /* number of displays */
+} XExtensionInfo;
+
+typedef struct _XExtensionHooks {
+ int (*create_gc)(
+#if NeedNestedPrototypes
+ Display* /* display */,
+ GC /* gc */,
+ XExtCodes* /* codes */
+#endif
+);
+ int (*copy_gc)(
+#if NeedNestedPrototypes
+ Display* /* display */,
+ GC /* gc */,
+ XExtCodes* /* codes */
+#endif
+);
+ int (*flush_gc)(
+#if NeedNestedPrototypes
+ Display* /* display */,
+ GC /* gc */,
+ XExtCodes* /* codes */
+#endif
+);
+ int (*free_gc)(
+#if NeedNestedPrototypes
+ Display* /* display */,
+ GC /* gc */,
+ XExtCodes* /* codes */
+#endif
+);
+ int (*create_font)(
+#if NeedNestedPrototypes
+ Display* /* display */,
+ XFontStruct* /* fs */,
+ XExtCodes* /* codes */
+#endif
+);
+ int (*free_font)(
+#if NeedNestedPrototypes
+ Display* /* display */,
+ XFontStruct* /* fs */,
+ XExtCodes* /* codes */
+#endif
+);
+ int (*close_display)(
+#if NeedNestedPrototypes
+ Display* /* display */,
+ XExtCodes* /* codes */
+#endif
+);
+ Bool (*wire_to_event)(
+#if NeedNestedPrototypes
+ Display* /* display */,
+ XEvent* /* re */,
+ xEvent* /* event */
+#endif
+);
+ Status (*event_to_wire)(
+#if NeedNestedPrototypes
+ Display* /* display */,
+ XEvent* /* re */,
+ xEvent* /* event */
+#endif
+);
+ int (*error)(
+#if NeedNestedPrototypes
+ Display* /* display */,
+ xError* /* err */,
+ XExtCodes* /* codes */,
+ int* /* ret_code */
+#endif
+);
+ char *(*error_string)(
+#if NeedNestedPrototypes
+ Display* /* display */,
+ int /* code */,
+ XExtCodes* /* codes */,
+ char* /* buffer */,
+ int /* nbytes */
+#endif
+);
+} XExtensionHooks;
+
+extern XExtensionInfo *XextCreateExtension(
+#if NeedFunctionPrototypes
+ void
+#endif
+);
+extern void XextDestroyExtension(
+#if NeedFunctionPrototypes
+ XExtensionInfo* /* info */
+#endif
+);
+extern XExtDisplayInfo *XextAddDisplay(
+#if NeedFunctionPrototypes
+ XExtensionInfo* /* extinfo */,
+ Display* /* dpy */,
+ char* /* ext_name */,
+ XExtensionHooks* /* hooks */,
+ int /* nevents */,
+ XPointer /* data */
+#endif
+);
+extern int XextRemoveDisplay(
+#if NeedFunctionPrototypes
+ XExtensionInfo* /* extinfo */,
+ Display* /* dpy */
+#endif
+);
+extern XExtDisplayInfo *XextFindDisplay(
+#if NeedFunctionPrototypes
+ XExtensionInfo* /* extinfo */,
+ Display* /* dpy */
+#endif
+);
+
+#define XextHasExtension(i) ((i) && ((i)->codes))
+#define XextCheckExtension(dpy,i,name,val) \
+ if (!XextHasExtension(i)) { XMissingExtension (dpy, name); return val; }
+#define XextSimpleCheckExtension(dpy,i,name) \
+ if (!XextHasExtension(i)) { XMissingExtension (dpy, name); return; }
+
+
+/*
+ * helper macros to generate code that is common to all extensions; caller
+ * should prefix it with static if extension source is in one file; this
+ * could be a utility function, but have to stack 6 unused arguments for
+ * something that is called many, many times would be bad.
+ */
+#define XEXT_GENERATE_FIND_DISPLAY(proc,extinfo,extname,hooks,nev,data) \
+XExtDisplayInfo *proc (Display *dpy) \
+{ \
+ XExtDisplayInfo *dpyinfo; \
+ if (!extinfo) { if (!(extinfo = XextCreateExtension())) return NULL; } \
+ if (!(dpyinfo = XextFindDisplay (extinfo, dpy))) \
+ dpyinfo = XextAddDisplay (extinfo,dpy,extname,hooks,nev,data); \
+ return dpyinfo; \
+}
+
+#define XEXT_FIND_DISPLAY_PROTO(proc) \
+ XExtDisplayInfo *proc(Display *dpy)
+
+#define XEXT_GENERATE_CLOSE_DISPLAY(proc,extinfo) \
+int proc (Display *dpy, XExtCodes *codes) \
+{ \
+ return XextRemoveDisplay (extinfo, dpy); \
+}
+
+#define XEXT_CLOSE_DISPLAY_PROTO(proc) \
+ int proc(Display *dpy, XExtCodes *codes)
+
+#define XEXT_GENERATE_ERROR_STRING(proc,extname,nerr,errl) \
+char *proc (Display *dpy, int code, XExtCodes *codes, char *buf, int n) \
+{ \
+ code -= codes->first_error; \
+ if (code >= 0 && code < nerr) { \
+ char tmp[256]; \
+ sprintf (tmp, "%s.%d", extname, code); \
+ XGetErrorDatabaseText (dpy, "XProtoError", tmp, errl[code], buf, n); \
+ return buf; \
+ } \
+ return (char *)0; \
+}
+
+#define XEXT_ERROR_STRING_PROTO(proc) \
+ char *proc(Display *dpy, int code, XExtCodes *codes, char *buf, int n)
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/extensions/panoramiXext.h Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,52 @@
+/* $Xorg: panoramiXext.h,v 1.4 2000/08/18 04:05:45 coskrey Exp $ */
+/*****************************************************************
+Copyright (c) 1991, 1997 Digital Equipment Corporation, Maynard, Massachusetts.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING,
+BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL DAMAGES, OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of Digital Equipment Corporation
+shall not be used in advertising or otherwise to promote the sale, use or other
+dealings in this Software without prior written authorization from Digital
+Equipment Corporation.
+******************************************************************/
+/*
+ * PanoramiX definitions
+ */
+/* $XFree86: xc/include/extensions/panoramiXext.h,v 3.6 2001/01/17 17:53:22 dawes Exp $ */
+
+#include "SDLname.h"
+
+/* THIS IS NOT AN X PROJECT TEAM SPECIFICATION */
+
+#define PANORAMIX_MAJOR_VERSION 1 /* current version number */
+#define PANORAMIX_MINOR_VERSION 1
+
+typedef struct {
+ Window window; /* PanoramiX window - may not exist */
+ int screen;
+ int State; /* PanroamiXOff, PanoramiXOn */
+ int width; /* width of this screen */
+ int height; /* height of this screen */
+ int ScreenCount; /* real physical number of screens */
+ XID eventMask; /* selected events for this client */
+} SDL_NAME(XPanoramiXInfo);
+
+extern SDL_NAME(XPanoramiXInfo) *SDL_NAME(XPanoramiXAllocInfo) (
+#if NeedFunctionPrototypes
+ void
+#endif
+);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/extensions/panoramiXproto.h Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,192 @@
+/* $Xorg: panoramiXproto.h,v 1.4 2000/08/18 04:05:45 coskrey Exp $ */
+/*****************************************************************
+Copyright (c) 1991, 1997 Digital Equipment Corporation, Maynard, Massachusetts.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING,
+BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL DAMAGES, OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of Digital Equipment Corporation
+shall not be used in advertising or otherwise to promote the sale, use or other
+dealings in this Software without prior written authorization from Digital
+Equipment Corporation.
+******************************************************************/
+/* $XFree86: xc/include/extensions/panoramiXproto.h,v 3.6 2001/01/17 17:53:22 dawes Exp $ */
+
+/* THIS IS NOT AN X PROJECT TEAM SPECIFICATION */
+
+#ifndef _PANORAMIXPROTO_H_
+#define _PANORAMIXPROTO_H_
+
+#define PANORAMIX_PROTOCOL_NAME "XINERAMA"
+
+#define X_PanoramiXQueryVersion 0
+#define X_PanoramiXGetState 1
+#define X_PanoramiXGetScreenCount 2
+#define X_PanoramiXGetScreenSize 3
+
+#define X_XineramaIsActive 4
+#define X_XineramaQueryScreens 5
+
+typedef struct _PanoramiXQueryVersion {
+ CARD8 reqType; /* always PanoramiXReqCode */
+ CARD8 panoramiXReqType; /* always X_PanoramiXQueryVersion */
+ CARD16 length B16;
+ CARD8 clientMajor;
+ CARD8 clientMinor;
+ CARD16 unused B16;
+} xPanoramiXQueryVersionReq;
+
+#define sz_xPanoramiXQueryVersionReq 8
+
+typedef struct {
+ CARD8 type; /* must be X_Reply */
+ CARD8 pad1; /* unused */
+ CARD16 sequenceNumber B16; /* last sequence number */
+ CARD32 length B32; /* 0 */
+ CARD16 majorVersion B16;
+ CARD16 minorVersion B16;
+ CARD32 pad2 B32; /* unused */
+ CARD32 pad3 B32; /* unused */
+ CARD32 pad4 B32; /* unused */
+ CARD32 pad5 B32; /* unused */
+ CARD32 pad6 B32; /* unused */
+} xPanoramiXQueryVersionReply;
+
+#define sz_xPanoramiXQueryVersionReply 32
+
+
+typedef struct _PanoramiXGetState {
+ CARD8 reqType; /* always PanoramiXReqCode */
+ CARD8 panoramiXReqType; /* always X_PanoramiXGetState */
+ CARD16 length B16;
+ CARD32 window B32;
+} xPanoramiXGetStateReq;
+#define sz_xPanoramiXGetStateReq 8
+
+typedef struct {
+ BYTE type;
+ BYTE state;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 window B32;
+ CARD32 pad1 B32; /* unused */
+ CARD32 pad2 B32; /* unused */
+ CARD32 pad3 B32; /* unused */
+ CARD32 pad4 B32; /* unused */
+ CARD32 pad5 B32; /* unused */
+} xPanoramiXGetStateReply;
+
+#define sz_panoramiXGetStateReply 32
+
+typedef struct _PanoramiXGetScreenCount {
+ CARD8 reqType; /* always PanoramiXReqCode */
+ CARD8 panoramiXReqType; /* always X_PanoramiXGetScreenCount */
+ CARD16 length B16;
+ CARD32 window B32;
+} xPanoramiXGetScreenCountReq;
+#define sz_xPanoramiXGetScreenCountReq 8
+
+typedef struct {
+ BYTE type;
+ BYTE ScreenCount;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 window B32;
+ CARD32 pad1 B32; /* unused */
+ CARD32 pad2 B32; /* unused */
+ CARD32 pad3 B32; /* unused */
+ CARD32 pad4 B32; /* unused */
+ CARD32 pad5 B32; /* unused */
+} xPanoramiXGetScreenCountReply;
+#define sz_panoramiXGetScreenCountReply 32
+
+typedef struct _PanoramiXGetScreenSize {
+ CARD8 reqType; /* always PanoramiXReqCode */
+ CARD8 panoramiXReqType; /* always X_PanoramiXGetState */
+ CARD16 length B16;
+ CARD32 window B32;
+ CARD32 screen B32;
+} xPanoramiXGetScreenSizeReq;
+#define sz_xPanoramiXGetScreenSizeReq 12
+
+typedef struct {
+ BYTE type;
+ CARD8 pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 width B32;
+ CARD32 height B32;
+ CARD32 window B32;
+ CARD32 screen B32;
+ CARD32 pad2 B32; /* unused */
+ CARD32 pad3 B32; /* unused */
+} xPanoramiXGetScreenSizeReply;
+#define sz_panoramiXGetScreenSizeReply 32
+
+/************ Alternate protocol ******************/
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 panoramiXReqType;
+ CARD16 length B16;
+} xXineramaIsActiveReq;
+#define sz_xXineramaIsActiveReq 4
+
+typedef struct {
+ BYTE type;
+ CARD8 pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 state B32;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+ CARD32 pad6 B32;
+} xXineramaIsActiveReply;
+#define sz_XineramaIsActiveReply 32
+
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 panoramiXReqType;
+ CARD16 length B16;
+} xXineramaQueryScreensReq;
+#define sz_xXineramaQueryScreensReq 4
+
+typedef struct {
+ BYTE type;
+ CARD8 pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 number B32;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+ CARD32 pad6 B32;
+} xXineramaQueryScreensReply;
+#define sz_XineramaQueryScreensReply 32
+
+typedef struct {
+ INT16 x_org B16;
+ INT16 y_org B16;
+ CARD16 width B16;
+ CARD16 height B16;
+} xXineramaScreenInfo;
+#define sz_XineramaScreenInfo 8
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/extensions/xf86dga.h Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,265 @@
+/*
+ Copyright (c) 1999 XFree86 Inc
+*/
+/* $XFree86: xc/include/extensions/xf86dga.h,v 3.21 2001/08/01 00:44:36 tsi Exp $ */
+
+#ifndef _XF86DGA_H_
+#define _XF86DGA_H_
+
+#include <X11/Xfuncproto.h>
+#include <XFree86/extensions/xf86dga1.h>
+#include "SDLname.h"
+
+#define X_XDGAQueryVersion 0
+
+/* 1 through 9 are in xf86dga1.h */
+
+/* 10 and 11 are reserved to avoid conflicts with rogue DGA extensions */
+
+#define X_XDGAQueryModes 12
+#define X_XDGASetMode 13
+#define X_XDGASetViewport 14
+#define X_XDGAInstallColormap 15
+#define X_XDGASelectInput 16
+#define X_XDGAFillRectangle 17
+#define X_XDGACopyArea 18
+#define X_XDGACopyTransparentArea 19
+#define X_XDGAGetViewportStatus 20
+#define X_XDGASync 21
+#define X_XDGAOpenFramebuffer 22
+#define X_XDGACloseFramebuffer 23
+#define X_XDGASetClientVersion 24
+#define X_XDGAChangePixmapMode 25
+#define X_XDGACreateColormap 26
+
+
+#define XDGAConcurrentAccess 0x00000001
+#define XDGASolidFillRect 0x00000002
+#define XDGABlitRect 0x00000004
+#define XDGABlitTransRect 0x00000008
+#define XDGAPixmap 0x00000010
+
+#define XDGAInterlaced 0x00010000
+#define XDGADoublescan 0x00020000
+
+#define XDGAFlipImmediate 0x00000001
+#define XDGAFlipRetrace 0x00000002
+
+#define XDGANeedRoot 0x00000001
+
+#define XF86DGANumberEvents 7
+
+#define XDGAPixmapModeLarge 0
+#define XDGAPixmapModeSmall 1
+
+#define XF86DGAClientNotLocal 0
+#define XF86DGANoDirectVideoMode 1
+#define XF86DGAScreenNotActive 2
+#define XF86DGADirectNotActivated 3
+#define XF86DGAOperationNotSupported 4
+#define XF86DGANumberErrors (XF86DGAOperationNotSupported + 1)
+
+
+typedef struct {
+ int num; /* A unique identifier for the mode (num > 0) */
+ char *name; /* name of mode given in the XF86Config */
+ float verticalRefresh;
+ int flags; /* DGA_CONCURRENT_ACCESS, etc... */
+ int imageWidth; /* linear accessible portion (pixels) */
+ int imageHeight;
+ int pixmapWidth; /* Xlib accessible portion (pixels) */
+ int pixmapHeight; /* both fields ignored if no concurrent access */
+ int bytesPerScanline;
+ int byteOrder; /* MSBFirst, LSBFirst */
+ int depth;
+ int bitsPerPixel;
+ unsigned long redMask;
+ unsigned long greenMask;
+ unsigned long blueMask;
+ short visualClass;
+ int viewportWidth;
+ int viewportHeight;
+ int xViewportStep; /* viewport position granularity */
+ int yViewportStep;
+ int maxViewportX; /* max viewport origin */
+ int maxViewportY;
+ int viewportFlags; /* types of page flipping possible */
+ int reserved1;
+ int reserved2;
+} SDL_NAME(XDGAMode);
+
+
+typedef struct {
+ SDL_NAME(XDGAMode) mode;
+ unsigned char *data;
+ Pixmap pixmap;
+} SDL_NAME(XDGADevice);
+
+
+#ifndef _XF86DGA_SERVER_
+_XFUNCPROTOBEGIN
+
+typedef struct {
+ int type;
+ unsigned long serial;
+ Display *display;
+ int screen;
+ Time time;
+ unsigned int state;
+ unsigned int button;
+} SDL_NAME(XDGAButtonEvent);
+
+typedef struct {
+ int type;
+ unsigned long serial;
+ Display *display;
+ int screen;
+ Time time;
+ unsigned int state;
+ unsigned int keycode;
+} SDL_NAME(XDGAKeyEvent);
+
+typedef struct {
+ int type;
+ unsigned long serial;
+ Display *display;
+ int screen;
+ Time time;
+ unsigned int state;
+ int dx;
+ int dy;
+} SDL_NAME(XDGAMotionEvent);
+
+typedef union {
+ int type;
+ SDL_NAME(XDGAButtonEvent) xbutton;
+ SDL_NAME(XDGAKeyEvent) xkey;
+ SDL_NAME(XDGAMotionEvent) xmotion;
+ long pad[24];
+} SDL_NAME(XDGAEvent);
+
+Bool SDL_NAME(XDGAQueryExtension)(
+ Display *dpy,
+ int *eventBase,
+ int *erroBase
+);
+
+Bool SDL_NAME(XDGAQueryVersion)(
+ Display *dpy,
+ int *majorVersion,
+ int *minorVersion
+);
+
+SDL_NAME(XDGAMode)* SDL_NAME(XDGAQueryModes)(
+ Display *dpy,
+ int screen,
+ int *num
+);
+
+SDL_NAME(XDGADevice)* SDL_NAME(XDGASetMode)(
+ Display *dpy,
+ int screen,
+ int mode
+);
+
+Bool SDL_NAME(XDGAOpenFramebuffer)(
+ Display *dpy,
+ int screen
+);
+
+void SDL_NAME(XDGACloseFramebuffer)(
+ Display *dpy,
+ int screen
+);
+
+void SDL_NAME(XDGASetViewport)(
+ Display *dpy,
+ int screen,
+ int x,
+ int y,
+ int flags
+);
+
+void SDL_NAME(XDGAInstallColormap)(
+ Display *dpy,
+ int screen,
+ Colormap cmap
+);
+
+Colormap SDL_NAME(XDGACreateColormap)(
+ Display *dpy,
+ int screen,
+ SDL_NAME(XDGADevice) *device,
+ int alloc
+);
+
+void SDL_NAME(XDGASelectInput)(
+ Display *dpy,
+ int screen,
+ long event_mask
+);
+
+void SDL_NAME(XDGAFillRectangle)(
+ Display *dpy,
+ int screen,
+ int x,
+ int y,
+ unsigned int width,
+ unsigned int height,
+ unsigned long color
+);
+
+
+void SDL_NAME(XDGACopyArea)(
+ Display *dpy,
+ int screen,
+ int srcx,
+ int srcy,
+ unsigned int width,
+ unsigned int height,
+ int dstx,
+ int dsty
+);
+
+
+void SDL_NAME(XDGACopyTransparentArea)(
+ Display *dpy,
+ int screen,
+ int srcx,
+ int srcy,
+ unsigned int width,
+ unsigned int height,
+ int dstx,
+ int dsty,
+ unsigned long key
+);
+
+int SDL_NAME(XDGAGetViewportStatus)(
+ Display *dpy,
+ int screen
+);
+
+void SDL_NAME(XDGASync)(
+ Display *dpy,
+ int screen
+);
+
+Bool SDL_NAME(XDGASetClientVersion)(
+ Display *dpy
+);
+
+void SDL_NAME(XDGAChangePixmapMode)(
+ Display *dpy,
+ int screen,
+ int *x,
+ int *y,
+ int mode
+);
+
+
+void SDL_NAME(XDGAKeyEventToXKeyEvent)(SDL_NAME(XDGAKeyEvent)* dk, XKeyEvent* xk);
+
+
+_XFUNCPROTOEND
+#endif /* _XF86DGA_SERVER_ */
+#endif /* _XF86DGA_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/extensions/xf86dga1.h Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,169 @@
+/* $XFree86: xc/include/extensions/xf86dga1.h,v 1.2 1999/04/17 07:05:41 dawes Exp $ */
+/*
+
+Copyright (c) 1995 Jon Tombs
+Copyright (c) 1995 XFree86 Inc
+
+*/
+
+/************************************************************************
+
+ THIS IS THE OLD DGA API AND IS OBSOLETE. PLEASE DO NOT USE IT ANYMORE
+
+************************************************************************/
+
+#ifndef _XF86DGA1_H_
+#define _XF86DGA1_H_
+
+#include <X11/Xfuncproto.h>
+#include "SDLname.h"
+
+#define X_XF86DGAQueryVersion 0
+#define X_XF86DGAGetVideoLL 1
+#define X_XF86DGADirectVideo 2
+#define X_XF86DGAGetViewPortSize 3
+#define X_XF86DGASetViewPort 4
+#define X_XF86DGAGetVidPage 5
+#define X_XF86DGASetVidPage 6
+#define X_XF86DGAInstallColormap 7
+#define X_XF86DGAQueryDirectVideo 8
+#define X_XF86DGAViewPortChanged 9
+
+#define XF86DGADirectPresent 0x0001
+#define XF86DGADirectGraphics 0x0002
+#define XF86DGADirectMouse 0x0004
+#define XF86DGADirectKeyb 0x0008
+#define XF86DGAHasColormap 0x0100
+#define XF86DGADirectColormap 0x0200
+
+
+
+
+#ifndef _XF86DGA_SERVER_
+
+_XFUNCPROTOBEGIN
+
+Bool SDL_NAME(XF86DGAQueryVersion)(
+#if NeedFunctionPrototypes
+ Display* /* dpy */,
+ int* /* majorVersion */,
+ int* /* minorVersion */
+#endif
+);
+
+Bool SDL_NAME(XF86DGAQueryExtension)(
+#if NeedFunctionPrototypes
+ Display* /* dpy */,
+ int* /* event_base */,
+ int* /* error_base */
+#endif
+);
+
+Status SDL_NAME(XF86DGAGetVideoLL)(
+#if NeedFunctionPrototypes
+ Display* /* dpy */,
+ int /* screen */,
+ int * /* base addr */,
+ int * /* width */,
+ int * /* bank_size */,
+ int * /* ram_size */
+#endif
+);
+
+Status SDL_NAME(XF86DGAGetVideo)(
+#if NeedFunctionPrototypes
+ Display* /* dpy */,
+ int /* screen */,
+ char ** /* base addr */,
+ int * /* width */,
+ int * /* bank_size */,
+ int * /* ram_size */
+#endif
+);
+
+Status SDL_NAME(XF86DGADirectVideo)(
+#if NeedFunctionPrototypes
+ Display* /* dpy */,
+ int /* screen */,
+ int /* enable */
+#endif
+);
+
+Status SDL_NAME(XF86DGADirectVideoLL)(
+#if NeedFunctionPrototypes
+ Display* /* dpy */,
+ int /* screen */,
+ int /* enable */
+#endif
+);
+
+Status SDL_NAME(XF86DGAGetViewPortSize)(
+#if NeedFunctionPrototypes
+ Display* /* dpy */,
+ int /* screen */,
+ int * /* width */,
+ int * /* height */
+#endif
+);
+
+Status SDL_NAME(XF86DGASetViewPort)(
+#if NeedFunctionPrototypes
+ Display* /* dpy */,
+ int /* screen */,
+ int x /* X */,
+ int y /* Y */
+#endif
+);
+
+Status SDL_NAME(XF86DGAGetVidPage)(
+#if NeedFunctionPrototypes
+ Display* /* dpy */,
+ int /* screen */,
+ int * /* vid page */
+#endif
+);
+
+Status SDL_NAME(XF86DGASetVidPage)(
+#if NeedFunctionPrototypes
+ Display* /* dpy */,
+ int /* screen */,
+ int /* vid page */
+#endif
+);
+
+Status SDL_NAME(XF86DGAInstallColormap)(
+#if NeedFunctionPrototypes
+ Display* /* dpy */,
+ int /* screen */,
+ Colormap /*Colormap */
+#endif
+);
+
+int SDL_NAME(XF86DGAForkApp)(
+#if NeedFunctionPrototypes
+ int screen
+#endif
+);
+
+Status SDL_NAME(XF86DGAQueryDirectVideo)(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ int /* screen */,
+ int * /* flags */
+#endif
+);
+
+Bool SDL_NAME(XF86DGAViewPortChanged)(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ int /* screen */,
+ int /* n */
+#endif
+);
+
+
+_XFUNCPROTOEND
+
+#endif /* _XF86DGA_SERVER_ */
+
+#endif /* _XF86DGA1_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/extensions/xf86dga1str.h Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,194 @@
+/* $XFree86: xc/include/extensions/xf86dga1str.h,v 1.2 1999/05/03 12:15:37 dawes Exp $ */
+/*
+
+Copyright (c) 1995 Jon Tombs
+Copyright (c) 1995 XFree86 Inc.
+
+*/
+
+#ifndef _XF86DGASTR1_H_
+#define _XF86DGASTR1_H_
+
+typedef struct _XF86DGAQueryVersion {
+ CARD8 reqType; /* always DGAReqCode */
+ CARD8 dgaReqType; /* always X_DGAQueryVersion */
+ CARD16 length B16;
+} xXF86DGAQueryVersionReq;
+#define sz_xXF86DGAQueryVersionReq 4
+
+typedef struct {
+ BYTE type; /* X_Reply */
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD16 majorVersion B16; /* major version of DGA protocol */
+ CARD16 minorVersion B16; /* minor version of DGA protocol */
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+ CARD32 pad6 B32;
+} xXF86DGAQueryVersionReply;
+#define sz_xXF86DGAQueryVersionReply 32
+
+typedef struct _XF86DGAGetVideoLL {
+ CARD8 reqType; /* always DGAReqCode */
+ CARD8 dgaReqType; /* always X_XF86DGAGetVideoLL */
+ CARD16 length B16;
+ CARD16 screen B16;
+ CARD16 pad B16;
+} xXF86DGAGetVideoLLReq;
+#define sz_xXF86DGAGetVideoLLReq 8
+
+typedef struct _XF86DGAInstallColormap{
+ CARD8 reqType;
+ CARD8 dgaReqType;
+ CARD16 length B16;
+ CARD16 screen B16;
+ CARD16 pad2;
+ CARD32 id B32; /* colormap. */
+} xXF86DGAInstallColormapReq;
+#define sz_xXF86DGAInstallColormapReq 12
+
+
+typedef struct {
+ BYTE type;
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 offset B32;
+ CARD32 width B32;
+ CARD32 bank_size B32;
+ CARD32 ram_size B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+} xXF86DGAGetVideoLLReply;
+#define sz_xXF86DGAGetVideoLLReply 32
+
+typedef struct _XF86DGADirectVideo {
+ CARD8 reqType; /* always DGAReqCode */
+ CARD8 dgaReqType; /* always X_XF86DGADirectVideo */
+ CARD16 length B16;
+ CARD16 screen B16;
+ CARD16 enable B16;
+} xXF86DGADirectVideoReq;
+#define sz_xXF86DGADirectVideoReq 8
+
+
+typedef struct _XF86DGAGetViewPortSize {
+ CARD8 reqType; /* always DGAReqCode */
+ CARD8 dgaReqType; /* always X_XF86DGAGetViewPort */
+ CARD16 length B16;
+ CARD16 screen B16;
+ CARD16 pad B16;
+} xXF86DGAGetViewPortSizeReq;
+#define sz_xXF86DGAGetViewPortSizeReq 8
+
+typedef struct {
+ BYTE type;
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 width B32;
+ CARD32 height B32;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+} xXF86DGAGetViewPortSizeReply;
+#define sz_xXF86DGAGetViewPortSizeReply 32
+
+typedef struct _XF86DGASetViewPort {
+ CARD8 reqType; /* always DGAReqCode */
+ CARD8 dgaReqType; /* always X_XF86DGASetViewPort */
+ CARD16 length B16;
+ CARD16 screen B16;
+ CARD16 pad B16;
+ CARD32 x B32;
+ CARD32 y B32;
+} xXF86DGASetViewPortReq;
+#define sz_xXF86DGASetViewPortReq 16
+
+typedef struct _XF86DGAGetVidPage {
+ CARD8 reqType; /* always DGAReqCode */
+ CARD8 dgaReqType; /* always X_XF86DGAGetVidPage */
+ CARD16 length B16;
+ CARD16 screen B16;
+ CARD16 pad B16;
+} xXF86DGAGetVidPageReq;
+#define sz_xXF86DGAGetVidPageReq 8
+
+typedef struct {
+ BYTE type;
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 vpage B32;
+ CARD32 pad B32;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+} xXF86DGAGetVidPageReply;
+#define sz_xXF86DGAGetVidPageReply 32
+
+
+typedef struct _XF86DGASetVidPage {
+ CARD8 reqType; /* always DGAReqCode */
+ CARD8 dgaReqType; /* always X_XF86DGASetVidPage */
+ CARD16 length B16;
+ CARD16 screen B16;
+ CARD16 vpage B16;
+} xXF86DGASetVidPageReq;
+#define sz_xXF86DGASetVidPageReq 8
+
+
+typedef struct _XF86DGAQueryDirectVideo {
+ CARD8 reqType; /* always DGAReqCode */
+ CARD8 dgaReqType; /* always X_DGAQueryVersion */
+ CARD16 length B16;
+ CARD16 screen B16;
+ CARD16 pad B16;
+} xXF86DGAQueryDirectVideoReq;
+#define sz_xXF86DGAQueryDirectVideoReq 8
+
+typedef struct {
+ BYTE type;
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 flags B32;
+ CARD32 pad B32;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+} xXF86DGAQueryDirectVideoReply;
+#define sz_xXF86DGAQueryDirectVideoReply 32
+
+
+typedef struct _XF86DGAViewPortChanged {
+ CARD8 reqType; /* always DGAReqCode */
+ CARD8 dgaReqType; /* always X_DGAQueryVersion */
+ CARD16 length B16;
+ CARD16 screen B16;
+ CARD16 n B16;
+} xXF86DGAViewPortChangedReq;
+#define sz_xXF86DGAViewPortChangedReq 8
+
+typedef struct {
+ BYTE type;
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 result B32;
+ CARD32 pad B32;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+} xXF86DGAViewPortChangedReply;
+#define sz_xXF86DGAViewPortChangedReply 32
+
+#endif /* _XF86DGASTR1_H_ */
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/extensions/xf86dgastr.h Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,344 @@
+/* $XFree86: xc/include/extensions/xf86dgastr.h,v 3.14 2001/08/01 00:44:36 tsi Exp $ */
+/*
+
+Copyright (c) 1995 Jon Tombs
+Copyright (c) 1995 XFree86 Inc.
+
+*/
+
+#ifndef _XF86DGASTR_H_
+#define _XF86DGASTR_H_
+
+#include <XFree86/extensions/xf86dga1str.h>
+
+#define XF86DGANAME "XFree86-DGA"
+
+#define XDGA_MAJOR_VERSION 2 /* current version numbers */
+#define XDGA_MINOR_VERSION 0
+
+
+typedef struct _XDGAQueryVersion {
+ CARD8 reqType; /* always DGAReqCode */
+ CARD8 dgaReqType; /* always X_DGAQueryVersion */
+ CARD16 length B16;
+} xXDGAQueryVersionReq;
+#define sz_xXDGAQueryVersionReq 4
+
+typedef struct {
+ BYTE type; /* X_Reply */
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD16 majorVersion B16; /* major version of DGA protocol */
+ CARD16 minorVersion B16; /* minor version of DGA protocol */
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+ CARD32 pad6 B32;
+} xXDGAQueryVersionReply;
+#define sz_xXDGAQueryVersionReply 32
+
+typedef struct _XDGAQueryModes {
+ CARD8 reqType;
+ CARD8 dgaReqType;
+ CARD16 length B16;
+ CARD32 screen B32;
+} xXDGAQueryModesReq;
+#define sz_xXDGAQueryModesReq 8
+
+typedef struct {
+ BYTE type; /* X_Reply */
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 number B32; /* number of modes available */
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+ CARD32 pad6 B32;
+} xXDGAQueryModesReply;
+#define sz_xXDGAQueryModesReply 32
+
+
+typedef struct _XDGASetMode {
+ CARD8 reqType;
+ CARD8 dgaReqType;
+ CARD16 length B16;
+ CARD32 screen B32;
+ CARD32 mode B32; /* mode number to init */
+ CARD32 pid B32; /* Pixmap descriptor */
+} xXDGASetModeReq;
+#define sz_xXDGASetModeReq 16
+
+typedef struct {
+ BYTE type; /* X_Reply */
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 offset B32; /* offset into framebuffer map */
+ CARD32 flags B32;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+} xXDGASetModeReply;
+#define sz_xXDGASetModeReply 32
+
+typedef struct {
+ CARD8 byte_order;
+ CARD8 depth;
+ CARD16 num B16;
+ CARD16 bpp B16;
+ CARD16 name_size B16;
+ CARD32 vsync_num B32;
+ CARD32 vsync_den B32;
+ CARD32 flags B32;
+ CARD16 image_width B16;
+ CARD16 image_height B16;
+ CARD16 pixmap_width B16;
+ CARD16 pixmap_height B16;
+ CARD32 bytes_per_scanline B32;
+ CARD32 red_mask B32;
+ CARD32 green_mask B32;
+ CARD32 blue_mask B32;
+ CARD16 visual_class B16;
+ CARD16 pad1 B16;
+ CARD16 viewport_width B16;
+ CARD16 viewport_height B16;
+ CARD16 viewport_xstep B16;
+ CARD16 viewport_ystep B16;
+ CARD16 viewport_xmax B16;
+ CARD16 viewport_ymax B16;
+ CARD32 viewport_flags B32;
+ CARD32 reserved1 B32;
+ CARD32 reserved2 B32;
+} xXDGAModeInfo;
+#define sz_xXDGAModeInfo 72
+
+typedef struct _XDGAOpenFramebuffer {
+ CARD8 reqType;
+ CARD8 dgaReqType;
+ CARD16 length B16;
+ CARD32 screen B32;
+} xXDGAOpenFramebufferReq;
+#define sz_xXDGAOpenFramebufferReq 8
+
+typedef struct {
+ BYTE type; /* X_Reply */
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32; /* device name size if there is one */
+ CARD32 mem1 B32; /* physical memory */
+ CARD32 mem2 B32; /* spillover for _alpha_ */
+ CARD32 size B32; /* size of map in bytes */
+ CARD32 offset B32; /* optional offset into device */
+ CARD32 extra B32; /* extra info associated with the map */
+ CARD32 pad2 B32;
+} xXDGAOpenFramebufferReply;
+#define sz_xXDGAOpenFramebufferReply 32
+
+
+typedef struct _XDGACloseFramebuffer {
+ CARD8 reqType;
+ CARD8 dgaReqType;
+ CARD16 length B16;
+ CARD32 screen B32;
+} xXDGACloseFramebufferReq;
+#define sz_xXDGACloseFramebufferReq 8
+
+
+typedef struct _XDGASetViewport {
+ CARD8 reqType;
+ CARD8 dgaReqType;
+ CARD16 length B16;
+ CARD32 screen B32;
+ CARD16 x B16;
+ CARD16 y B16;
+ CARD32 flags B32;
+} xXDGASetViewportReq;
+#define sz_xXDGASetViewportReq 16
+
+
+typedef struct _XDGAInstallColormap {
+ CARD8 reqType;
+ CARD8 dgaReqType;
+ CARD16 length B16;
+ CARD32 screen B32;
+ CARD32 cmap B32;
+} xXDGAInstallColormapReq;
+#define sz_xXDGAInstallColormapReq 12
+
+typedef struct _XDGASelectInput {
+ CARD8 reqType;
+ CARD8 dgaReqType;
+ CARD16 length B16;
+ CARD32 screen B32;
+ CARD32 mask B32;
+} xXDGASelectInputReq;
+#define sz_xXDGASelectInputReq 12
+
+typedef struct _XDGAFillRectangle {
+ CARD8 reqType;
+ CARD8 dgaReqType;
+ CARD16 length B16;
+ CARD32 screen B32;
+ CARD16 x B16;
+ CARD16 y B16;
+ CARD16 width B16;
+ CARD16 height B16;
+ CARD32 color B32;
+} xXDGAFillRectangleReq;
+#define sz_xXDGAFillRectangleReq 20
+
+
+typedef struct _XDGACopyArea {
+ CARD8 reqType;
+ CARD8 dgaReqType;
+ CARD16 length B16;
+ CARD32 screen B32;
+ CARD16 srcx B16;
+ CARD16 srcy B16;
+ CARD16 width B16;
+ CARD16 height B16;
+ CARD16 dstx B16;
+ CARD16 dsty B16;
+} xXDGACopyAreaReq;
+#define sz_xXDGACopyAreaReq 20
+
+typedef struct _XDGACopyTransparentArea {
+ CARD8 reqType;
+ CARD8 dgaReqType;
+ CARD16 length B16;
+ CARD32 screen B32;
+ CARD16 srcx B16;
+ CARD16 srcy B16;
+ CARD16 width B16;
+ CARD16 height B16;
+ CARD16 dstx B16;
+ CARD16 dsty B16;
+ CARD32 key B32;
+} xXDGACopyTransparentAreaReq;
+#define sz_xXDGACopyTransparentAreaReq 24
+
+
+typedef struct _XDGAGetViewportStatus {
+ CARD8 reqType;
+ CARD8 dgaReqType;
+ CARD16 length B16;
+ CARD32 screen B32;
+} xXDGAGetViewportStatusReq;
+#define sz_xXDGAGetViewportStatusReq 8
+
+typedef struct {
+ BYTE type;
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 status B32;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+ CARD32 pad6 B32;
+} xXDGAGetViewportStatusReply;
+#define sz_xXDGAGetViewportStatusReply 32
+
+typedef struct _XDGASync {
+ CARD8 reqType;
+ CARD8 dgaReqType;
+ CARD16 length B16;
+ CARD32 screen B32;
+} xXDGASyncReq;
+#define sz_xXDGASyncReq 8
+
+typedef struct {
+ BYTE type;
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+ CARD32 pad6 B32;
+ CARD32 pad7 B32;
+} xXDGASyncReply;
+#define sz_xXDGASyncReply 32
+
+typedef struct _XDGASetClientVersion {
+ CARD8 reqType;
+ CARD8 dgaReqType;
+ CARD16 length B16;
+ CARD16 major B16;
+ CARD16 minor B16;
+} xXDGASetClientVersionReq;
+#define sz_xXDGASetClientVersionReq 8
+
+
+typedef struct {
+ CARD8 reqType;
+ CARD8 dgaReqType;
+ CARD16 length B16;
+ CARD32 screen B32;
+ CARD16 x B16;
+ CARD16 y B16;
+ CARD32 flags B32;
+} xXDGAChangePixmapModeReq;
+#define sz_xXDGAChangePixmapModeReq 16
+
+typedef struct {
+ BYTE type;
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD16 x B16;
+ CARD16 y B16;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+ CARD32 pad6 B32;
+ CARD32 pad7 B32;
+} xXDGAChangePixmapModeReply;
+#define sz_xXDGAChangePixmapModeReply 32
+
+typedef struct _XDGACreateColormap {
+ CARD8 reqType;
+ CARD8 dgaReqType;
+ CARD16 length B16;
+ CARD32 screen B32;
+ CARD32 id B32;
+ CARD32 mode B32;
+ CARD8 alloc;
+ CARD8 pad1;
+ CARD16 pad2;
+} xXDGACreateColormapReq;
+#define sz_xXDGACreateColormapReq 20
+
+
+typedef struct {
+ union {
+ struct {
+ BYTE type;
+ BYTE detail;
+ CARD16 sequenceNumber B16;
+ } u;
+ struct {
+ CARD32 pad0 B32;
+ CARD32 time B32;
+ INT16 dx B16;
+ INT16 dy B16;
+ INT16 screen B16;
+ CARD16 state B16;
+ CARD32 pad1 B32;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ } event;
+ } u;
+} dgaEvent;
+
+
+#endif /* _XF86DGASTR_H_ */
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/extensions/xf86vmode.h Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,314 @@
+/* $XFree86: xc/include/extensions/xf86vmode.h,v 3.30 2001/05/07 20:09:50 mvojkovi Exp $ */
+/*
+
+Copyright 1995 Kaleb S. KEITHLEY
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES
+OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of Kaleb S. KEITHLEY
+shall not be used in advertising or otherwise to promote the sale, use
+or other dealings in this Software without prior written authorization
+from Kaleb S. KEITHLEY
+
+*/
+/* $Xorg: xf86vmode.h,v 1.3 2000/08/18 04:05:46 coskrey Exp $ */
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */
+
+#ifndef _XF86VIDMODE_H_
+#define _XF86VIDMODE_H_
+
+#include <X11/Xfuncproto.h>
+#include <X11/Xmd.h>
+#include "SDLname.h"
+
+#define X_XF86VidModeQueryVersion 0
+#define X_XF86VidModeGetModeLine 1
+#define X_XF86VidModeModModeLine 2
+#define X_XF86VidModeSwitchMode 3
+#define X_XF86VidModeGetMonitor 4
+#define X_XF86VidModeLockModeSwitch 5
+#define X_XF86VidModeGetAllModeLines 6
+#define X_XF86VidModeAddModeLine 7
+#define X_XF86VidModeDeleteModeLine 8
+#define X_XF86VidModeValidateModeLine 9
+#define X_XF86VidModeSwitchToMode 10
+#define X_XF86VidModeGetViewPort 11
+#define X_XF86VidModeSetViewPort 12
+/* new for version 2.x of this extension */
+#define X_XF86VidModeGetDotClocks 13
+#define X_XF86VidModeSetClientVersion 14
+#define X_XF86VidModeSetGamma 15
+#define X_XF86VidModeGetGamma 16
+#define X_XF86VidModeGetGammaRamp 17
+#define X_XF86VidModeSetGammaRamp 18
+#define X_XF86VidModeGetGammaRampSize 19
+
+#define CLKFLAG_PROGRAMABLE 1
+
+#ifdef XF86VIDMODE_EVENTS
+#define XF86VidModeNotify 0
+#define XF86VidModeNumberEvents (XF86VidModeNotify + 1)
+
+#define XF86VidModeNotifyMask 0x00000001
+
+#define XF86VidModeNonEvent 0
+#define XF86VidModeModeChange 1
+#else
+#define XF86VidModeNumberEvents 0
+#endif
+
+#define XF86VidModeBadClock 0
+#define XF86VidModeBadHTimings 1
+#define XF86VidModeBadVTimings 2
+#define XF86VidModeModeUnsuitable 3
+#define XF86VidModeExtensionDisabled 4
+#define XF86VidModeClientNotLocal 5
+#define XF86VidModeZoomLocked 6
+#define XF86VidModeNumberErrors (XF86VidModeZoomLocked + 1)
+
+#ifndef _XF86VIDMODE_SERVER_
+
+typedef struct {
+ unsigned short hdisplay;
+ unsigned short hsyncstart;
+ unsigned short hsyncend;
+ unsigned short htotal;
+ unsigned short hskew;
+ unsigned short vdisplay;
+ unsigned short vsyncstart;
+ unsigned short vsyncend;
+ unsigned short vtotal;
+ unsigned int flags;
+ int privsize;
+#if defined(__cplusplus) || defined(c_plusplus)
+ /* private is a C++ reserved word */
+ INT32 *c_private;
+#else
+ INT32 *private;
+#endif
+} SDL_NAME(XF86VidModeModeLine);
+
+typedef struct {
+ unsigned int dotclock;
+ unsigned short hdisplay;
+ unsigned short hsyncstart;
+ unsigned short hsyncend;
+ unsigned short htotal;
+ unsigned short hskew;
+ unsigned short vdisplay;
+ unsigned short vsyncstart;
+ unsigned short vsyncend;
+ unsigned short vtotal;
+ unsigned int flags;
+ int privsize;
+#if defined(__cplusplus) || defined(c_plusplus)
+ /* private is a C++ reserved word */
+ INT32 *c_private;
+#else
+ INT32 *private;
+#endif
+} SDL_NAME(XF86VidModeModeInfo);
+
+typedef struct {
+ float hi;
+ float lo;
+} SDL_NAME(XF86VidModeSyncRange);
+
+typedef struct {
+ char* vendor;
+ char* model;
+ float EMPTY;
+ unsigned char nhsync;
+ SDL_NAME(XF86VidModeSyncRange)* hsync;
+ unsigned char nvsync;
+ SDL_NAME(XF86VidModeSyncRange)* vsync;
+} SDL_NAME(XF86VidModeMonitor);
+
+typedef struct {
+ int type; /* of event */
+ unsigned long serial; /* # of last request processed by server */
+ Bool send_event; /* true if this came from a SendEvent req */
+ Display *display; /* Display the event was read from */
+ Window root; /* root window of event screen */
+ int state; /* What happened */
+ int kind; /* What happened */
+ Bool forced; /* extents of new region */
+ Time time; /* event timestamp */
+} SDL_NAME(XF86VidModeNotifyEvent);
+
+typedef struct {
+ float red; /* Red Gamma value */
+ float green; /* Green Gamma value */
+ float blue; /* Blue Gamma value */
+} SDL_NAME(XF86VidModeGamma);
+
+
+#define SDL_XF86VidModeSelectNextMode(disp, scr) \
+ SDL_NAME(XF86VidModeSwitchMode)(disp, scr, 1)
+#define SDL_XF86VidModeSelectPrevMode(disp, scr) \
+ SDL_NAME(XF86VidModeSwitchMode)(disp, scr, -1)
+
+_XFUNCPROTOBEGIN
+
+Bool SDL_NAME(XF86VidModeQueryVersion)(
+ Display* /* dpy */,
+ int* /* majorVersion */,
+ int* /* minorVersion */
+);
+
+Bool SDL_NAME(XF86VidModeQueryExtension)(
+ Display* /* dpy */,
+ int* /* event_base */,
+ int* /* error_base */
+);
+
+Bool SDL_NAME(XF86VidModeSetClientVersion)(
+ Display* /* dpy */
+);
+
+Bool SDL_NAME(XF86VidModeGetModeLine)(
+ Display* /* dpy */,
+ int /* screen */,
+ int* /* dotclock */,
+ SDL_NAME(XF86VidModeModeLine)* /* modeline */
+);
+
+Bool SDL_NAME(XF86VidModeGetAllModeLines)(
+ Display* /* dpy */,
+ int /* screen */,
+ int* /* modecount */,
+ SDL_NAME(XF86VidModeModeInfo)*** /* modelinesPtr */
+);
+
+Bool SDL_NAME(XF86VidModeAddModeLine)(
+ Display* /* dpy */,
+ int /* screen */,
+ SDL_NAME(XF86VidModeModeInfo)* /* new modeline */,
+ SDL_NAME(XF86VidModeModeInfo)* /* after modeline */
+);
+
+Bool SDL_NAME(XF86VidModeDeleteModeLine)(
+ Display* /* dpy */,
+ int /* screen */,
+ SDL_NAME(XF86VidModeModeInfo)* /* modeline */
+);
+
+Bool SDL_NAME(XF86VidModeModModeLine)(
+ Display* /* dpy */,
+ int /* screen */,
+ SDL_NAME(XF86VidModeModeLine)* /* modeline */
+);
+
+Status SDL_NAME(XF86VidModeValidateModeLine)(
+ Display* /* dpy */,
+ int /* screen */,
+ SDL_NAME(XF86VidModeModeInfo)* /* modeline */
+);
+
+Bool SDL_NAME(XF86VidModeSwitchMode)(
+ Display* /* dpy */,
+ int /* screen */,
+ int /* zoom */
+);
+
+Bool SDL_NAME(XF86VidModeSwitchToMode)(
+ Display* /* dpy */,
+ int /* screen */,
+ SDL_NAME(XF86VidModeModeInfo)* /* modeline */
+);
+
+Bool SDL_NAME(XF86VidModeLockModeSwitch)(
+ Display* /* dpy */,
+ int /* screen */,
+ int /* lock */
+);
+
+Bool SDL_NAME(XF86VidModeGetMonitor)(
+ Display* /* dpy */,
+ int /* screen */,
+ SDL_NAME(XF86VidModeMonitor)* /* monitor */
+);
+
+Bool SDL_NAME(XF86VidModeGetViewPort)(
+ Display* /* dpy */,
+ int /* screen */,
+ int* /* x return */,
+ int* /* y return */
+);
+
+Bool SDL_NAME(XF86VidModeSetViewPort)(
+ Display* /* dpy */,
+ int /* screen */,
+ int /* x */,
+ int /* y */
+);
+
+Bool SDL_NAME(XF86VidModeGetDotClocks)(
+ Display* /* dpy */,
+ int /* screen */,
+ int* /* flags return */,
+ int* /* number of clocks return */,
+ int* /* max dot clock return */,
+ int** /* clocks return */
+);
+
+Bool SDL_NAME(XF86VidModeGetGamma)(
+ Display* /* dpy */,
+ int /* screen */,
+ SDL_NAME(XF86VidModeGamma)* /* Gamma */
+);
+
+Bool SDL_NAME(XF86VidModeSetGamma)(
+ Display* /* dpy */,
+ int /* screen */,
+ SDL_NAME(XF86VidModeGamma)* /* Gamma */
+);
+
+Bool SDL_NAME(XF86VidModeSetGammaRamp)(
+ Display* /* dpy */,
+ int /* screen */,
+ int /* size */,
+ unsigned short* /* red array */,
+ unsigned short* /* green array */,
+ unsigned short* /* blue array */
+);
+
+Bool SDL_NAME(XF86VidModeGetGammaRamp)(
+ Display* /* dpy */,
+ int /* screen */,
+ int /* size */,
+ unsigned short* /* red array */,
+ unsigned short* /* green array */,
+ unsigned short* /* blue array */
+);
+
+Bool SDL_NAME(XF86VidModeGetGammaRampSize)(
+ Display* /* dpy */,
+ int /* screen */,
+ int* /* size */
+);
+
+
+_XFUNCPROTOEND
+
+#endif
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/Xext/extensions/xf86vmstr.h Tue Mar 05 19:55:32 2002 +0000
@@ -0,0 +1,546 @@
+/* $XFree86: xc/include/extensions/xf86vmstr.h,v 3.27 2001/08/01 00:44:36 tsi Exp $ */
+/*
+
+Copyright 1995 Kaleb S. KEITHLEY
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES
+OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of Kaleb S. KEITHLEY
+shall not be used in advertising or otherwise to promote the sale, use
+or other dealings in this Software without prior written authorization
+from Kaleb S. KEITHLEY
+
+*/
+/* $Xorg: xf86vmstr.h,v 1.3 2000/08/18 04:05:46 coskrey Exp $ */
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */
+
+#ifndef _XF86VIDMODESTR_H_
+#define _XF86VIDMODESTR_H_
+
+#include <XFree86/extensions/xf86vmode.h>
+
+#define XF86VIDMODENAME "XFree86-VidModeExtension"
+
+#define XF86VIDMODE_MAJOR_VERSION 2 /* current version numbers */
+#define XF86VIDMODE_MINOR_VERSION 1
+/*
+ * major version 0 == uses parameter-to-wire functions in XFree86 libXxf86vm.
+ * major version 1 == uses parameter-to-wire functions hard-coded in xvidtune
+ * client.
+ * major version 2 == uses new protocol version in XFree86 4.0.
+ */
+
+typedef struct _XF86VidModeQueryVersion {
+ CARD8 reqType; /* always XF86VidModeReqCode */
+ CARD8 xf86vidmodeReqType; /* always X_XF86VidModeQueryVersion */
+ CARD16 length B16;
+} xXF86VidModeQueryVersionReq;
+#define sz_xXF86VidModeQueryVersionReq 4
+
+typedef struct {
+ BYTE type; /* X_Reply */
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD16 majorVersion B16; /* major version of XF86VidMode */
+ CARD16 minorVersion B16; /* minor version of XF86VidMode */
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+ CARD32 pad6 B32;
+} xXF86VidModeQueryVersionReply;
+#define sz_xXF86VidModeQueryVersionReply 32
+
+typedef struct _XF86VidModeGetModeLine {
+ CARD8 reqType; /* always XF86VidModeReqCode */
+ CARD8 xf86vidmodeReqType;
+ CARD16 length B16;
+ CARD16 screen B16;
+ CARD16 pad B16;
+} xXF86VidModeGetModeLineReq,
+ xXF86VidModeGetAllModeLinesReq,
+ xXF86VidModeGetMonitorReq,
+ xXF86VidModeGetViewPortReq,
+ xXF86VidModeGetDotClocksReq;
+#define sz_xXF86VidModeGetModeLineReq 8
+#define sz_xXF86VidModeGetAllModeLinesReq 8
+#define sz_xXF86VidModeGetMonitorReq 8
+#define sz_xXF86VidModeGetViewPortReq 8
+#define sz_xXF86VidModeGetDotClocksReq 8
+
+typedef struct {
+ BYTE type; /* X_Reply */
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 dotclock B32;
+ CARD16 hdisplay B16;
+ CARD16 hsyncstart B16;
+ CARD16 hsyncend B16;
+ CARD16 htotal B16;
+ CARD16 hskew B16;
+ CARD16 vdisplay B16;
+ CARD16 vsyncstart B16;
+ CARD16 vsyncend B16;
+ CARD16 vtotal B16;
+ CARD16 pad2 B16;
+ CARD32 flags B32;
+ CARD32 reserved1 B32;
+ CARD32 reserved2 B32;
+ CARD32 reserved3 B32;
+ CARD32 privsize B32;
+} xXF86VidModeGetModeLineReply;
+#define sz_xXF86VidModeGetModeLineReply 52
+
+/* 0.x version */
+typedef struct {
+ BYTE type; /* X_Reply */
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 dotclock B32;
+ CARD16 hdisplay B16;
+ CARD16 hsyncstart B16;
+ CARD16 hsyncend B16;
+ CARD16 htotal B16;
+ CARD16 vdisplay B16;
+ CARD16 vsyncstart B16;
+ CARD16 vsyncend B16;
+ CARD16 vtotal B16;
+ CARD32 flags B32;
+ CARD32 privsize B32;
+} xXF86OldVidModeGetModeLineReply;
+#define sz_xXF86OldVidModeGetModeLineReply 36
+
+typedef struct {
+ CARD32 dotclock B32;
+ CARD16 hdisplay B16;
+ CARD16 hsyncstart B16;
+ CARD16 hsyncend B16;
+ CARD16 htotal B16;
+ CARD32 hskew B16;
+ CARD16 vdisplay B16;
+ CARD16 vsyncstart B16;
+ CARD16 vsyncend B16;
+ CARD16 vtotal B16;
+ CARD16 pad1 B16;
+ CARD32 flags B32;
+ CARD32 reserved1 B32;
+ CARD32 reserved2 B32;
+ CARD32 reserved3 B32;
+ CARD32 privsize B32;
+} xXF86VidModeModeInfo;
+
+/* 0.x version */
+typedef struct {
+ CARD32 dotclock B32;
+ CARD16 hdisplay B16;
+ CARD16 hsyncstart B16;
+ CARD16 hsyncend B16;
+ CARD16 htotal B16;
+ CARD16 vdisplay B16;
+ CARD16 vsyncstart B16;
+ CARD16 vsyncend B16;
+ CARD16 vtotal B16;
+ CARD32 flags B32;
+ CARD32 privsize B32;
+} xXF86OldVidModeModeInfo;
+
+typedef struct {
+ BYTE type; /* X_Reply */
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 modecount B32;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+ CARD32 pad6 B32;
+} xXF86VidModeGetAllModeLinesReply;
+#define sz_xXF86VidModeGetAllModeLinesReply 32
+
+typedef struct _XF86VidModeAddModeLine {
+ CARD8 reqType; /* always XF86VidModeReqCode */
+ CARD8 xf86vidmodeReqType; /* always X_XF86VidModeAddMode */
+ CARD16 length B16;
+ CARD32 screen B32; /* could be CARD16 but need the pad */
+ CARD32 dotclock B32;
+ CARD16 hdisplay B16;
+ CARD16 hsyncstart B16;
+ CARD16 hsyncend B16;
+ CARD16 htotal B16;
+ CARD16 hskew B16;
+ CARD16 vdisplay B16;
+ CARD16 vsyncstart B16;
+ CARD16 vsyncend B16;
+ CARD16 vtotal B16;
+ CARD16 pad1 B16;
+ CARD32 flags B32;
+ CARD32 reserved1 B32;
+ CARD32 reserved2 B32;
+ CARD32 reserved3 B32;
+ CARD32 privsize B32;
+ CARD32 after_dotclock B32;
+ CARD16 after_hdisplay B16;
+ CARD16 after_hsyncstart B16;
+ CARD16 after_hsyncend B16;
+ CARD16 after_htotal B16;
+ CARD16 after_hskew B16;
+ CARD16 after_vdisplay B16;
+ CARD16 after_vsyncstart B16;
+ CARD16 after_vsyncend B16;
+ CARD16 after_vtotal B16;
+ CARD16 pad2 B16;
+ CARD32 after_flags B32;
+ CARD32 reserved4 B32;
+ CARD32 reserved5 B32;
+ CARD32 reserved6 B32;
+} xXF86VidModeAddModeLineReq;
+#define sz_xXF86VidModeAddModeLineReq 92
+
+/* 0.x version */
+typedef struct _XF86OldVidModeAddModeLine {
+ CARD8 reqType; /* always XF86VidModeReqCode */
+ CARD8 xf86vidmodeReqType; /* always X_XF86VidModeAddMode */
+ CARD16 length B16;
+ CARD32 screen B32; /* could be CARD16 but need the pad */
+ CARD32 dotclock B32;
+ CARD16 hdisplay B16;
+ CARD16 hsyncstart B16;
+ CARD16 hsyncend B16;
+ CARD16 htotal B16;
+ CARD16 vdisplay B16;
+ CARD16 vsyncstart B16;
+ CARD16 vsyncend B16;
+ CARD16 vtotal B16;
+ CARD32 flags B32;
+ CARD32 privsize B32;
+ CARD32 after_dotclock B32;
+ CARD16 after_hdisplay B16;
+ CARD16 after_hsyncstart B16;
+ CARD16 after_hsyncend B16;
+ CARD16 after_htotal B16;
+ CARD16 after_vdisplay B16;
+ CARD16 after_vsyncstart B16;
+ CARD16 after_vsyncend B16;
+ CARD16 after_vtotal B16;
+ CARD32 after_flags B32;
+} xXF86OldVidModeAddModeLineReq;
+#define sz_xXF86OldVidModeAddModeLineReq 60
+
+typedef struct _XF86VidModeModModeLine {
+ CARD8 reqType; /* always XF86VidModeReqCode */
+ CARD8 xf86vidmodeReqType; /* always X_XF86VidModeModModeLine */
+ CARD16 length B16;
+ CARD32 screen B32; /* could be CARD16 but need the pad */
+ CARD16 hdisplay B16;
+ CARD16 hsyncstart B16;
+ CARD16 hsyncend B16;
+ CARD16 htotal B16;
+ CARD16 hskew B16;
+ CARD16 vdisplay B16;
+ CARD16 vsyncstart B16;
+ CARD16 vsyncend B16;
+ CARD16 vtotal B16;
+ CARD16 pad1 B16;
+ CARD32 flags B32;
+ CARD32 reserved1 B32;
+ CARD32 reserved2 B32;
+ CARD32 reserved3 B32;
+ CARD32 privsize B32;
+} xXF86VidModeModModeLineReq;
+#define sz_xXF86VidModeModModeLineReq 48
+
+/* 0.x version */
+typedef struct _XF86OldVidModeModModeLine {
+ CARD8 reqType; /* always XF86OldVidModeReqCode */
+ CARD8 xf86vidmodeReqType; /* always X_XF86OldVidModeModModeLine */
+ CARD16 length B16;
+ CARD32 screen B32; /* could be CARD16 but need the pad */
+ CARD16 hdisplay B16;
+ CARD16 hsyncstart B16;
+ CARD16 hsyncend B16;
+ CARD16 htotal B16;
+ CARD16 vdisplay B16;
+ CARD16 vsyncstart B16;
+ CARD16 vsyncend B16;
+ CARD16 vtotal B16;
+ CARD32 flags B32;
+ CARD32 privsize B32;
+} xXF86OldVidModeModModeLineReq;
+#define sz_xXF86OldVidModeModModeLineReq 32
+
+typedef struct _XF86VidModeValidateModeLine {
+ CARD8 reqType; /* always XF86VidModeReqCode */
+ CARD8 xf86vidmodeReqType;
+ CARD16 length B16;
+ CARD32 screen B32; /* could be CARD16 but need the pad */
+ CARD32 dotclock B32;
+ CARD16 hdisplay B16;
+ CARD16 hsyncstart B16;
+ CARD16 hsyncend B16;
+ CARD16 htotal B16;
+ CARD16 hskew B16;
+ CARD16 vdisplay B16;
+ CARD16 vsyncstart B16;
+ CARD16 vsyncend B16;
+ CARD16 vtotal B16;
+ CARD16 pad1 B16;
+ CARD32 flags B32;
+ CARD32 reserved1 B32;
+ CARD32 reserved2 B32;
+ CARD32 reserved3 B32;
+ CARD32 privsize B32;
+} xXF86VidModeDeleteModeLineReq,
+ xXF86VidModeValidateModeLineReq,
+ xXF86VidModeSwitchToModeReq;
+#define sz_xXF86VidModeDeleteModeLineReq 52
+#define sz_xXF86VidModeValidateModeLineReq 52
+#define sz_xXF86VidModeSwitchToModeReq 52
+
+/* 0.x version */
+typedef struct _XF86OldVidModeValidateModeLine {
+ CARD8 reqType; /* always XF86OldVidModeReqCode */
+ CARD8 xf86vidmodeReqType;
+ CARD16 length B16;
+ CARD32 screen B32; /* could be CARD16 but need the pad */
+ CARD32 dotclock B32;
+ CARD16 hdisplay B16;
+ CARD16 hsyncstart B16;
+ CARD16 hsyncend B16;
+ CARD16 htotal B16;
+ CARD16 vdisplay B16;
+ CARD16 vsyncstart B16;
+ CARD16 vsyncend B16;
+ CARD16 vtotal B16;
+ CARD32 flags B32;
+ CARD32 privsize B32;
+} xXF86OldVidModeDeleteModeLineReq,
+ xXF86OldVidModeValidateModeLineReq,
+ xXF86OldVidModeSwitchToModeReq;
+#define sz_xXF86OldVidModeDeleteModeLineReq 36
+#define sz_xXF86OldVidModeValidateModeLineReq 36
+#define sz_xXF86OldVidModeSwitchToModeReq 36
+
+typedef struct _XF86VidModeSwitchMode {
+ CARD8 reqType; /* always XF86VidModeReqCode */
+ CARD8 xf86vidmodeReqType; /* always X_XF86VidModeSwitchMode */
+ CARD16 length B16;
+ CARD16 screen B16;
+ CARD16 zoom B16;
+} xXF86VidModeSwitchModeReq;
+#define sz_xXF86VidModeSwitchModeReq 8
+
+typedef struct _XF86VidModeLockModeSwitch {
+ CARD8 reqType; /* always XF86VidModeReqCode */
+ CARD8 xf86vidmodeReqType; /* always X_XF86VidModeLockModeSwitch */
+ CARD16 length B16;
+ CARD16 screen B16;
+ CARD16 lock B16;
+} xXF86VidModeLockModeSwitchReq;
+#define sz_xXF86VidModeLockModeSwitchReq 8
+
+typedef struct {
+ BYTE type; /* X_Reply */
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 status B32;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+ CARD32 pad6 B32;
+} xXF86VidModeValidateModeLineReply;
+#define sz_xXF86VidModeValidateModeLineReply 32
+
+typedef struct {
+ BYTE type; /* X_Reply */
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD8 vendorLength;
+ CARD8 modelLength;
+ CARD8 nhsync;
+ CARD8 nvsync;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+ CARD32 pad6 B32;
+} xXF86VidModeGetMonitorReply;
+#define sz_xXF86VidModeGetMonitorReply 32
+
+typedef struct {
+ BYTE type;
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 x B32;
+ CARD32 y B32;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+} xXF86VidModeGetViewPortReply;
+#define sz_xXF86VidModeGetViewPortReply 32
+
+typedef struct _XF86VidModeSetViewPort {
+ CARD8 reqType; /* always VidModeReqCode */
+ CARD8 xf86vidmodeReqType; /* always X_XF86VidModeSetViewPort */
+ CARD16 length B16;
+ CARD16 screen B16;
+ CARD16 pad B16;
+ CARD32 x B32;
+ CARD32 y B32;
+} xXF86VidModeSetViewPortReq;
+#define sz_xXF86VidModeSetViewPortReq 16
+
+typedef struct {
+ BYTE type;
+ BOOL pad1;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 flags B32;
+ CARD32 clocks B32;
+ CARD32 maxclocks B32;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+} xXF86VidModeGetDotClocksReply;
+#define sz_xXF86VidModeGetDotClocksReply 32
+
+typedef struct _XF86VidModeSetClientVersion {
+ CARD8 reqType; /* always XF86VidModeReqCode */
+ CARD8 xf86vidmodeReqType;
+ CARD16 length B16;
+ CARD16 major B16;
+ CARD16 minor B16;
+} xXF86VidModeSetClientVersionReq;
+#define sz_xXF86VidModeSetClientVersionReq 8
+
+typedef struct _XF86VidModeGetGamma {
+ CARD8 reqType; /* always XF86VidModeReqCode */
+ CARD8 xf86vidmodeReqType;
+ CARD16 length B16;
+ CARD16 screen B16;
+ CARD16 pad B16;
+ CARD32 pad1 B32;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+ CARD32 pad6 B32;
+} xXF86VidModeGetGammaReq;
+#define sz_xXF86VidModeGetGammaReq 32
+
+typedef struct {
+ BYTE type;
+ BOOL pad;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD32 red B32;
+ CARD32 green B32;
+ CARD32 blue B32;
+ CARD32 pad1 B32;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+} xXF86VidModeGetGammaReply;
+#define sz_xXF86VidModeGetGammaReply 32
+
+typedef struct _XF86VidModeSetGamma {
+ CARD8 reqType; /* always XF86VidModeReqCode */
+ CARD8 xf86vidmodeReqType;
+ CARD16 length B16;
+ CARD16 screen B16;
+ CARD16 pad B16;
+ CARD32 red B32;
+ CARD32 green B32;
+ CARD32 blue B32;
+ CARD32 pad1 B32;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+} xXF86VidModeSetGammaReq;
+#define sz_xXF86VidModeSetGammaReq 32
+
+
+typedef struct _XF86VidModeSetGammaRamp {
+ CARD8 reqType; /* always XF86VidModeReqCode */
+ CARD8 xf86vidmodeReqType;
+ CARD16 length B16;
+ CARD16 screen B16;
+ CARD16 size B16;
+} xXF86VidModeSetGammaRampReq;
+#define sz_xXF86VidModeSetGammaRampReq 8
+
+typedef struct _XF86VidModeGetGammaRamp {
+ CARD8 reqType; /* always XF86VidModeReqCode */
+ CARD8 xf86vidmodeReqType;
+ CARD16 length B16;
+ CARD16 screen B16;
+ CARD16 size B16;
+} xXF86VidModeGetGammaRampReq;
+#define sz_xXF86VidModeGetGammaRampReq 8
+
+typedef struct {
+ BYTE type;
+ BOOL pad;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD16 size B16;
+ CARD16 pad0 B16;
+ CARD32 pad1 B32;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+} xXF86VidModeGetGammaRampReply;
+#define sz_xXF86VidModeGetGammaRampReply 32
+
+typedef struct _XF86VidModeGetGammaRampSize {
+ CARD8 reqType; /* always XF86VidModeReqCode */
+ CARD8 xf86vidmodeReqType;
+ CARD16 length B16;
+ CARD16 screen B16;
+ CARD16 pad B16;
+} xXF86VidModeGetGammaRampSizeReq;
+#define sz_xXF86VidModeGetGammaRampSizeReq 8
+
+typedef struct {
+ BYTE type;
+ BOOL pad;
+ CARD16 sequenceNumber B16;
+ CARD32 length B32;
+ CARD16 size B16;
+ CARD16 pad0 B16;
+ CARD32 pad1 B32;
+ CARD32 pad2 B32;
+ CARD32 pad3 B32;
+ CARD32 pad4 B32;
+ CARD32 pad5 B32;
+} xXF86VidModeGetGammaRampSizeReply;
+#define sz_xXF86VidModeGetGammaRampSizeReply 32
+
+
+#endif /* _XF86VIDMODESTR_H_ */
+
--- a/src/video/dga/SDL_dgaevents.c Sat Mar 02 16:50:35 2002 +0000
+++ b/src/video/dga/SDL_dgaevents.c Tue Mar 05 19:55:32 2002 +0000
@@ -29,7 +29,7 @@
#include <stdio.h>
#include <X11/Xlib.h>
-#include <X11/extensions/xf86dga.h>
+#include <XFree86/extensions/xf86dga.h>
#include "SDL_sysvideo.h"
#include "SDL_events_c.h"
@@ -45,7 +45,7 @@
static int DGA_DispatchEvent(_THIS)
{
int posted;
- XDGAEvent xevent;
+ SDL_NAME(XDGAEvent) xevent;
XNextEvent(DGA_Display, (XEvent *)&xevent);
@@ -82,7 +82,7 @@
SDL_keysym keysym;
XKeyEvent xkey;
- XDGAKeyEventToXKeyEvent(&xevent.xkey, &xkey);
+ SDL_NAME(XDGAKeyEventToXKeyEvent)(&xevent.xkey, &xkey);
posted = SDL_PrivateKeyboard((xevent.type == KeyPress),
X11_TranslateKey(DGA_Display,
&xkey, xkey.keycode,
--- a/src/video/dga/SDL_dgavideo.c Sat Mar 02 16:50:35 2002 +0000
+++ b/src/video/dga/SDL_dgavideo.c Tue Mar 05 19:55:32 2002 +0000
@@ -31,7 +31,7 @@
#include <stdlib.h>
#include <string.h>
#include <X11/Xlib.h>
-#include <X11/extensions/xf86dga.h>
+#include <XFree86/extensions/xf86dga.h>
#ifdef HAVE_ALLOCA_H
#include <alloca.h>
@@ -87,15 +87,15 @@
if ( dpy ) {
int events, errors, major, minor;
- if ( XDGAQueryExtension(dpy, &events, &errors) &&
- XDGAQueryVersion(dpy, &major, &minor) ) {
+ if ( SDL_NAME(XDGAQueryExtension)(dpy, &events, &errors) &&
+ SDL_NAME(XDGAQueryVersion)(dpy, &major, &minor) ) {
int screen;
screen = DefaultScreen(dpy);
if ( (major >= 2) &&
- XDGAOpenFramebuffer(dpy, screen) ) {
+ SDL_NAME(XDGAOpenFramebuffer)(dpy, screen) ) {
available = 1;
- XDGACloseFramebuffer(dpy, screen);
+ SDL_NAME(XDGACloseFramebuffer)(dpy, screen);
}
}
XCloseDisplay(dpy);
@@ -216,14 +216,14 @@
static Uint32 get_video_size(_THIS)
{
/* This is a non-exported function from libXxf86dga.a */
- extern unsigned char *XDGAGetMappedMemory(int screen);
+ extern unsigned char *SDL_NAME(XDGAGetMappedMemory)(int screen);
FILE *proc;
unsigned long mem;
unsigned start, stop;
char line[BUFSIZ];
Uint32 size;
- mem = (unsigned long)XDGAGetMappedMemory(DGA_Screen);
+ mem = (unsigned long)SDL_NAME(XDGAGetMappedMemory)(DGA_Screen);
size = 0;
proc = fopen("/proc/self/maps", "r");
if ( proc ) {
@@ -240,7 +240,7 @@
}
#ifdef DGA_DEBUG
-static void PrintMode(XDGAMode *mode)
+static void PrintMode(SDL_NAME(XDGAMode) *mode)
{
printf("Mode: %s (%dx%d) at %d bpp (%f refresh, %d pitch) num: %d\n",
mode->name,
@@ -278,8 +278,8 @@
static int cmpmodes(const void *va, const void *vb)
{
- const XDGAMode *a = (const XDGAMode *)va;
- const XDGAMode *b = (const XDGAMode *)vb;
+ const SDL_NAME(XDGAMode) *a = (const SDL_NAME(XDGAMode) *)va;
+ const SDL_NAME(XDGAMode) *b = (const SDL_NAME(XDGAMode) *)vb;
/* Prefer DirectColor visuals for otherwise equal modes */
if ( (a->viewportWidth == b->viewportWidth) &&
@@ -295,7 +295,7 @@
return b->viewportHeight - a->viewportHeight;
}
}
-static void UpdateHWInfo(_THIS, XDGAMode *mode)
+static void UpdateHWInfo(_THIS, SDL_NAME(XDGAMode) *mode)
{
this->info.wm_available = 0;
this->info.hw_available = 1;
@@ -323,7 +323,7 @@
int event_base, error_base;
int major_version, minor_version;
Visual *visual;
- XDGAMode *modes;
+ SDL_NAME(XDGAMode) *modes;
int i, num_modes;
/* Open the X11 display */
@@ -336,8 +336,8 @@
}
/* Check for the DGA extension */
- if ( ! XDGAQueryExtension(DGA_Display, &event_base, &error_base) ||
- ! XDGAQueryVersion(DGA_Display, &major_version, &minor_version) ) {
+ if ( ! SDL_NAME(XDGAQueryExtension)(DGA_Display, &event_base, &error_base) ||
+ ! SDL_NAME(XDGAQueryVersion)(DGA_Display, &major_version, &minor_version) ) {
SDL_SetError("DGA extension not available");
XCloseDisplay(DGA_Display);
return(-1);
@@ -377,14 +377,14 @@
}
/* Open access to the framebuffer */
- if ( ! XDGAOpenFramebuffer(DGA_Display, DGA_Screen) ) {
+ if ( ! SDL_NAME(XDGAOpenFramebuffer)(DGA_Display, DGA_Screen) ) {
SDL_SetError("Unable to map the video memory");
XCloseDisplay(DGA_Display);
return(-1);
}
/* Query for the list of available video modes */
- modes = XDGAQueryModes(DGA_Display, DGA_Screen, &num_modes);
+ modes = SDL_NAME(XDGAQueryModes)(DGA_Display, DGA_Screen, &num_modes);
qsort(modes, num_modes, sizeof *modes, cmpmodes);
for ( i=0; i<num_modes; ++i ) {
#ifdef DGA_DEBUG
@@ -429,9 +429,9 @@
SDL_Surface *DGA_SetVideoMode(_THIS, SDL_Surface *current,
int width, int height, int bpp, Uint32 flags)
{
- XDGAMode *modes;
+ SDL_NAME(XDGAMode) *modes;
int i, num_modes;
- XDGADevice *mode;
+ SDL_NAME(XDGADevice) *mode;
int screen_len;
Uint8 *surfaces_mem;
int surfaces_len;
@@ -443,7 +443,7 @@
}
/* Search for a matching video mode */
- modes = XDGAQueryModes(DGA_Display, DGA_Screen, &num_modes);
+ modes = SDL_NAME(XDGAQueryModes)(DGA_Display, DGA_Screen, &num_modes);
qsort(modes, num_modes, sizeof *modes, cmpmodes);
for ( i=0; i<num_modes; ++i ) {
int depth;
@@ -468,7 +468,7 @@
}
/* Set the video mode */
- mode = XDGASetMode(DGA_Display, DGA_Screen, modes[i].num);
+ mode = SDL_NAME(XDGASetMode)(DGA_Display, DGA_Screen, modes[i].num);
XFree(modes);
if ( mode == NULL ) {
SDL_SetError("Unable to switch to requested mode");
@@ -495,7 +495,7 @@
/* Create a colormap if necessary */
if ( (DGA_visualClass == PseudoColor) ||
(DGA_visualClass == DirectColor) ) {
- DGA_colormap = XDGACreateColormap(DGA_Display, DGA_Screen,
+ DGA_colormap = SDL_NAME(XDGACreateColormap)(DGA_Display, DGA_Screen,
mode, AllocAll);
if ( DGA_visualClass == PseudoColor ) {
current->flags |= SDL_HWPALETTE;
@@ -507,10 +507,10 @@
this->screen = NULL;
}
} else {
- DGA_colormap = XDGACreateColormap(DGA_Display, DGA_Screen,
+ DGA_colormap = SDL_NAME(XDGACreateColormap)(DGA_Display, DGA_Screen,
mode, AllocNone);
}
- XDGAInstallColormap(DGA_Display, DGA_Screen, DGA_colormap);
+ SDL_NAME(XDGAInstallColormap)(DGA_Display, DGA_Screen, DGA_colormap);
/* Update the hardware capabilities */
UpdateHWInfo(this, &mode->mode);
@@ -520,7 +520,7 @@
surfaces_len = (mode->mode.imageHeight*current->pitch - screen_len);
/* Update for double-buffering, if we can */
- XDGASetViewport(DGA_Display, DGA_Screen, 0, 0, XDGAFlipRetrace);
+ SDL_NAME(XDGASetViewport)(DGA_Display, DGA_Screen, 0, 0, XDGAFlipRetrace);
if ( flags & SDL_DOUBLEBUF ) {
if ( mode->mode.imageHeight >= (current->h*2) ) {
current->flags |= SDL_DOUBLEBUF;
@@ -556,7 +556,7 @@
input_mask = (KeyPressMask | KeyReleaseMask);
input_mask |= (ButtonPressMask | ButtonReleaseMask);
input_mask |= PointerMotionMask;
- XDGASelectInput(DGA_Display, DGA_Screen, input_mask);
+ SDL_NAME(XDGASelectInput)(DGA_Display, DGA_Screen, input_mask);
}
/* We're done */
@@ -652,7 +652,7 @@
vidmem_bucket *bucket;
/* Wait for graphic operations to complete */
- XDGASync(DGA_Display, DGA_Screen);
+ SDL_NAME(XDGASync)(DGA_Display, DGA_Screen);
/* Clear all surface dirty bits */
for ( bucket=&surfaces; bucket; bucket=bucket->next ) {
@@ -807,7 +807,7 @@
/* Don't fill the visible part of the screen, wait until flipped */
LOCK_DISPLAY();
if ( was_flipped && (dst == this->screen) ) {
- while ( XDGAGetViewportStatus(DGA_Display, DGA_Screen) )
+ while ( SDL_NAME(XDGAGetViewportStatus)(DGA_Display, DGA_Screen) )
/* Keep waiting for the hardware ... */ ;
was_flipped = 0;
}
@@ -819,7 +819,7 @@
#if 0
printf("Hardware accelerated rectangle fill: %dx%d at %d,%d\n", w, h, x, y);
#endif
- XDGAFillRectangle(DGA_Display, DGA_Screen, x, y, w, h, color);
+ SDL_NAME(XDGAFillRectangle)(DGA_Display, DGA_Screen, x, y, w, h, color);
XFlush(DGA_Display);
DGA_AddBusySurface(dst);
UNLOCK_DISPLAY();
@@ -838,7 +838,7 @@
/* Don't blit to the visible part of the screen, wait until flipped */
LOCK_DISPLAY();
if ( was_flipped && (dst == this->screen) ) {
- while ( XDGAGetViewportStatus(DGA_Display, DGA_Screen) )
+ while ( SDL_NAME(XDGAGetViewportStatus)(DGA_Display, DGA_Screen) )
/* Keep waiting for the hardware ... */ ;
was_flipped = 0;
}
@@ -854,10 +854,10 @@
printf("Blitting %dx%d from %d,%d to %d,%d\n", w, h, srcx, srcy, dstx, dsty);
#endif
if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) {
- XDGACopyTransparentArea(DGA_Display, DGA_Screen,
+ SDL_NAME(XDGACopyTransparentArea)(DGA_Display, DGA_Screen,
srcx, srcy, w, h, dstx, dsty, src->format->colorkey);
} else {
- XDGACopyArea(DGA_Display, DGA_Screen,
+ SDL_NAME(XDGACopyArea)(DGA_Display, DGA_Screen,
srcx, srcy, w, h, dstx, dsty);
}
XFlush(DGA_Display);
@@ -897,7 +897,7 @@
static __inline__ void DGA_WaitFlip(_THIS)
{
if ( was_flipped ) {
- while ( XDGAGetViewportStatus(DGA_Display, DGA_Screen) )
+ while ( SDL_NAME(XDGAGetViewportStatus)(DGA_Display, DGA_Screen) )
/* Keep waiting for the hardware ... */ ;
was_flipped = 0;
}
@@ -937,7 +937,7 @@
DGA_WaitBusySurfaces(this);
}
DGA_WaitFlip(this);
- XDGASetViewport(DGA_Display, DGA_Screen,
+ SDL_NAME(XDGASetViewport)(DGA_Display, DGA_Screen,
0, flip_yoffset[flip_page], XDGAFlipRetrace);
XFlush(DGA_Display);
UNLOCK_DISPLAY();
@@ -1024,12 +1024,12 @@
}
/* Unmap memory and reset video mode */
- XDGACloseFramebuffer(DGA_Display, DGA_Screen);
+ SDL_NAME(XDGACloseFramebuffer)(DGA_Display, DGA_Screen);
if ( this->screen ) {
/* Tell SDL not to free the pixels */
this->screen->pixels = NULL;
}
- XDGASetMode(DGA_Display, DGA_Screen, 0);
+ SDL_NAME(XDGASetMode)(DGA_Display, DGA_Screen, 0);
/* Clear the lock mutex */
if ( hw_lock != NULL ) {
--- a/src/video/windx5/SDL_dx5video.c Sat Mar 02 16:50:35 2002 +0000
+++ b/src/video/windx5/SDL_dx5video.c Tue Mar 05 19:55:32 2002 +0000
@@ -421,6 +421,7 @@
static int DX5_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key);
static int DX5_SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 alpha);
static int DX5_LockHWSurface(_THIS, SDL_Surface *surface);
+static int DX5_LockHWSurfaceRect(_THIS, SDL_Surface *surface, SDL_Rect *rect, void **pixels, int *pitch);
static void DX5_UnlockHWSurface(_THIS, SDL_Surface *surface);
static int DX5_FlipHWSurface(_THIS, SDL_Surface *surface);
static void DX5_FreeHWSurface(_THIS, SDL_Surface *surface);
@@ -591,7 +592,9 @@
device->SetHWColorKey = DX5_SetHWColorKey;
device->SetHWAlpha = DX5_SetHWAlpha;
device->LockHWSurface = DX5_LockHWSurface;
+ device->LockHWSurfaceRect = DX5_LockHWSurfaceRect;
device->UnlockHWSurface = DX5_UnlockHWSurface;
+ device->UnlockHWSurfaceRect = DX5_UnlockHWSurface;
device->FlipHWSurface = DX5_FlipHWSurface;
device->FreeHWSurface = DX5_FreeHWSurface;
#ifdef IID_IDirectDrawGammaControl
@@ -1910,6 +1913,43 @@
surface->pixels = ddsd.lpSurface;
return(0);
}
+static int DX5_LockHWSurfaceRect(_THIS, SDL_Surface *surface, SDL_Rect *rect, void **pixels, int *pitch)
+{
+ HRESULT result;
+ LPDIRECTDRAWSURFACE3 dd_surface;
+ DDSURFACEDESC ddsd;
+ RECT ddrect;
+
+ /* Calculate the lock rectangle */
+ ddrect.top = rect->y;
+ ddrect.bottom = rect->y+rect->h;
+ ddrect.left = rect->x;
+ ddrect.right = rect->x+rect->w;
+
+ /* Lock and load! */
+ dd_surface = surface->hwdata->dd_writebuf;
+ memset(&ddsd, 0, sizeof(ddsd));
+ ddsd.dwSize = sizeof(ddsd);
+ result = IDirectDrawSurface3_Lock(dd_surface, &ddrect, &ddsd,
+ (DDLOCK_NOSYSLOCK|DDLOCK_WAIT), NULL);
+ if ( result == DDERR_SURFACELOST ) {
+ result = IDirectDrawSurface3_Restore(
+ surface->hwdata->dd_surface);
+ result = IDirectDrawSurface3_Lock(dd_surface, &ddrect, &ddsd,
+ (DDLOCK_NOSYSLOCK|DDLOCK_WAIT), NULL);
+ }
+ if ( result != DD_OK ) {
+ SetDDerror("DirectDrawSurface3::Lock", result);
+ return(-1);
+ }
+ *pixels = ddsd.lpSurface;
+#if defined(NONAMELESSUNION)
+ *pitch = ddsd.u1.lPitch;
+#else
+ *pitch = (Uint16)ddsd.lPitch;
+#endif
+ return(0);
+}
static void DX5_UnlockHWSurface(_THIS, SDL_Surface *surface)
{
--- a/src/video/x11/SDL_x11dga.c Sat Mar 02 16:50:35 2002 +0000
+++ b/src/video/x11/SDL_x11dga.c Tue Mar 05 19:55:32 2002 +0000
@@ -61,9 +61,9 @@
}
/* Only use DGA mouse if the cursor is not showing (in relative mode) */
if ( use_dgamouse && local_X11 && !(using_dga & DGA_MOUSE) &&
- XF86DGAQueryExtension(SDL_Display, &dga_event, &dga_error) &&
- XF86DGAQueryVersion(SDL_Display, &dga_major, &dga_minor) ) {
- if ( XF86DGADirectVideo(SDL_Display, SDL_Screen, XF86DGADirectMouse) ) {
+ SDL_NAME(XF86DGAQueryExtension)(SDL_Display, &dga_event, &dga_error) &&
+ SDL_NAME(XF86DGAQueryVersion)(SDL_Display, &dga_major, &dga_minor) ) {
+ if ( SDL_NAME(XF86DGADirectVideo)(SDL_Display, SDL_Screen, XF86DGADirectMouse) ) {
using_dga |= DGA_MOUSE;
}
}
@@ -77,9 +77,9 @@
int flags;
if ( using_dga & DGA_MOUSE ) {
- XF86DGAQueryDirectVideo(SDL_Display, SDL_Screen, &flags);
+ SDL_NAME(XF86DGAQueryDirectVideo)(SDL_Display, SDL_Screen, &flags);
if ( ! (flags & XF86DGADirectMouse) ) {
- XF86DGADirectVideo(SDL_Display,SDL_Screen,XF86DGADirectMouse);
+ SDL_NAME(XF86DGADirectVideo)(SDL_Display,SDL_Screen,XF86DGADirectMouse);
}
}
#endif
@@ -89,7 +89,7 @@
{
#ifdef XFREE86_DGAMOUSE
if ( using_dga & DGA_MOUSE ) {
- XF86DGADirectVideo(SDL_Display, SDL_Screen, 0);
+ SDL_NAME(XF86DGADirectVideo)(SDL_Display, SDL_Screen, 0);
using_dga &= ~DGA_MOUSE;
}
#endif /* XFREE86_DGAMOUSE */
--- a/src/video/x11/SDL_x11gamma.c Sat Mar 02 16:50:35 2002 +0000
+++ b/src/video/x11/SDL_x11gamma.c Tue Mar 05 19:55:32 2002 +0000
@@ -38,7 +38,7 @@
{
#ifdef XFREE86_VMGAMMA
if (use_vidmode >= 200) {
- XF86VidModeGamma gamma;
+ SDL_NAME(XF86VidModeGamma) gamma;
Bool succeeded;
/* Clamp the gamma values */
@@ -67,7 +67,7 @@
gamma.blue = blue;
}
if ( SDL_GetAppState() & SDL_APPACTIVE ) {
- succeeded = XVidMode(SetGamma, (SDL_Display, SDL_Screen, &gamma));
+ succeeded = SDL_NAME(XF86VidModeSetGamma)(SDL_Display, SDL_Screen, &gamma);
XSync(SDL_Display, False);
} else {
gamma_saved[0] = gamma.red;
@@ -99,8 +99,8 @@
{
#ifdef XFREE86_VMGAMMA
if (use_vidmode >= 2) {
- XF86VidModeGamma gamma;
- if (XVidMode(GetGamma, (SDL_Display, SDL_Screen, &gamma))) {
+ SDL_NAME(XF86VidModeGamma) gamma;
+ if (SDL_NAME(XF86VidModeGetGamma)(SDL_Display, SDL_Screen, &gamma)) {
*red = gamma.red;
*green = gamma.green;
*blue = gamma.blue;
--- a/src/video/x11/SDL_x11modes.c Sat Mar 02 16:50:35 2002 +0000
+++ b/src/video/x11/SDL_x11modes.c Tue Mar 05 19:55:32 2002 +0000
@@ -40,16 +40,16 @@
#include "SDL_x11image_c.h"
#ifdef HAVE_XINERAMA
-#include <X11/extensions/Xinerama.h>
+#include <XFree86/extensions/Xinerama.h>
#endif
#define MAX(a, b) (a > b ? a : b)
#ifdef XFREE86_VM
-Bool XVidMode(GetModeInfo, (Display *dpy, int scr, XF86VidModeModeInfo *info))
+Bool SDL_NAME(XF86VidModeGetModeInfo)(Display *dpy, int scr, SDL_NAME(XF86VidModeModeInfo) *info)
{
- XF86VidModeModeLine *l = (XF86VidModeModeLine*)((char*)info + sizeof info->dotclock);
- return XVidMode(GetModeLine, (dpy, scr, &info->dotclock, l));
+ SDL_NAME(XF86VidModeModeLine) *l = (SDL_NAME(XF86VidModeModeLine)*)((char*)info + sizeof info->dotclock);
+ return SDL_NAME(XF86VidModeGetModeLine)(dpy, scr, &info->dotclock, l);
}
#endif /* XFREE86_VM */
@@ -57,25 +57,25 @@
static void save_mode(_THIS)
{
memset(&saved_mode, 0, sizeof(saved_mode));
- XVidMode(GetModeInfo, (SDL_Display,SDL_Screen,&saved_mode));
- XVidMode(GetViewPort, (SDL_Display,SDL_Screen,&saved_view.x,&saved_view.y));
+ SDL_NAME(XF86VidModeGetModeInfo)(SDL_Display,SDL_Screen,&saved_mode);
+ SDL_NAME(XF86VidModeGetViewPort)(SDL_Display,SDL_Screen,&saved_view.x,&saved_view.y);
}
#endif
#ifdef XFREE86_VM
static void restore_mode(_THIS)
{
- XF86VidModeModeLine mode;
+ SDL_NAME(XF86VidModeModeLine) mode;
int unused;
- if ( XVidMode(GetModeLine, (SDL_Display, SDL_Screen, &unused, &mode)) ) {
+ if ( SDL_NAME(XF86VidModeGetModeLine)(SDL_Display, SDL_Screen, &unused, &mode) ) {
if ( (saved_mode.hdisplay != mode.hdisplay) ||
(saved_mode.vdisplay != mode.vdisplay) ) {
- XVidMode(SwitchToMode, (SDL_Display, SDL_Screen, &saved_mode));
+ SDL_NAME(XF86VidModeSwitchToMode)(SDL_Display, SDL_Screen, &saved_mode);
}
}
if ( (saved_view.x != 0) || (saved_view.y != 0) ) {
- XVidMode(SetViewPort, (SDL_Display, SDL_Screen, saved_view.x, saved_view.y));
+ SDL_NAME(XF86VidModeSetViewPort)(SDL_Display, SDL_Screen, saved_view.x, saved_view.y);
}
}
#endif
@@ -83,8 +83,8 @@
#ifdef XFREE86_VM
static int cmpmodes(const void *va, const void *vb)
{
- const XF86VidModeModeInfo *a = *(const XF86VidModeModeInfo**)va;
- const XF86VidModeModeInfo *b = *(const XF86VidModeModeInfo**)vb;
+ const SDL_NAME(XF86VidModeModeInfo) *a = *(const SDL_NAME(XF86VidModeModeInfo)**)va;
+ const SDL_NAME(XF86VidModeModeInfo) *b = *(const SDL_NAME(XF86VidModeModeInfo)**)vb;
if(a->hdisplay > b->hdisplay)
return -1;
return b->vdisplay - a->vdisplay;
@@ -97,13 +97,13 @@
{
#ifdef XFREE86_VM
if ( use_vidmode ) {
- XF86VidModeModeLine mode;
- XF86VidModeModeInfo **modes;
+ SDL_NAME(XF86VidModeModeLine) mode;
+ SDL_NAME(XF86VidModeModeInfo) **modes;
int i;
int nmodes;
- if ( XVidMode(GetModeLine, (SDL_Display, SDL_Screen, &i, &mode)) &&
- XVidMode(GetAllModeLines, (SDL_Display,SDL_Screen,&nmodes,&modes))){
+ if ( SDL_NAME(XF86VidModeGetModeLine)(SDL_Display, SDL_Screen, &i, &mode) &&
+ SDL_NAME(XF86VidModeGetAllModeLines)(SDL_Display,SDL_Screen,&nmodes,&modes)){
qsort(modes, nmodes, sizeof *modes, cmpmodes);
#ifdef XFREE86_DEBUG
printf("Available modes:\n");
@@ -119,7 +119,7 @@
}
if ( (modes[i]->hdisplay != mode.hdisplay) ||
(modes[i]->vdisplay != mode.vdisplay) ) {
- XVidMode(SwitchToMode, (SDL_Display, SDL_Screen, modes[i]));
+ SDL_NAME(XF86VidModeSwitchToMode)(SDL_Display, SDL_Screen, modes[i]);
}
XFree(modes);
}
@@ -172,10 +172,10 @@
{
#ifdef XFREE86_VM
if ( use_vidmode ) {
- XF86VidModeModeLine mode;
+ SDL_NAME(XF86VidModeModeLine) mode;
int unused;
- if ( XVidMode(GetModeLine, (SDL_Display, SDL_Screen, &unused, &mode)) ) {
+ if ( SDL_NAME(XF86VidModeGetModeLine)(SDL_Display, SDL_Screen, &unused, &mode) ) {
*w = mode.hdisplay;
*h = mode.vdisplay;
return;
@@ -268,7 +268,7 @@
int buggy_X11;
int vm_major, vm_minor;
int nmodes;
- XF86VidModeModeInfo **modes;
+ SDL_NAME(XF86VidModeModeInfo) **modes;
#endif
#ifdef HAVE_XIGXME
int xme_major, xme_minor;
@@ -310,8 +310,8 @@
#endif
/* Enumerate the available fullscreen modes */
if ( ! buggy_X11 ) {
- if ( XVidMode(QueryExtension, (SDL_Display, &vm_event, &vm_error)) &&
- XVidMode(QueryVersion, (SDL_Display, &vm_major, &vm_minor)) ) {
+ if ( SDL_NAME(XF86VidModeQueryExtension)(SDL_Display, &vm_event, &vm_error) &&
+ SDL_NAME(XF86VidModeQueryVersion)(SDL_Display, &vm_major, &vm_minor) ) {
#ifdef BROKEN_XFREE86_4001
#ifdef X_XF86VidModeGetDotClocks /* Compiled under XFree86 4.0 */
/* Earlier X servers hang when doing vidmode */
@@ -330,7 +330,7 @@
}
}
if ( ! buggy_X11 &&
- XVidMode(GetAllModeLines, (SDL_Display, SDL_Screen,&nmodes,&modes)) ) {
+ SDL_NAME(XF86VidModeGetAllModeLines)(SDL_Display, SDL_Screen,&nmodes,&modes) ) {
qsort(modes, nmodes, sizeof *modes, cmpmodes);
SDL_modelist = (SDL_Rect **)malloc((nmodes+2)*sizeof(SDL_Rect *));
@@ -533,16 +533,16 @@
#ifdef HAVE_XINERAMA
/* Query Xinerama extention */
- if ( XineramaQueryExtension(SDL_Display, &i, &i) &&
- XineramaIsActive(SDL_Display) ) {
+ if ( SDL_NAME(XineramaQueryExtension)(SDL_Display, &i, &i) &&
+ SDL_NAME(XineramaIsActive)(SDL_Display) ) {
/* Find out which screen is the zero'th one */
int screens;
- XineramaScreenInfo *xinerama;
+ SDL_NAME(XineramaScreenInfo) *xinerama;
#ifdef XINERAMA_DEBUG
printf("X11 detected Xinerama:\n");
#endif
- xinerama = XineramaQueryScreens(SDL_Display, &screens);
+ xinerama = SDL_NAME(XineramaQueryScreens)(SDL_Display, &screens);
for ( i = 0; i < screens; i++ ) {
#ifdef XINERAMA_DEBUG
printf("xinerama %d: %dx%d+%d+%d\n",
@@ -703,7 +703,7 @@
#ifdef XFREE86_VM
/* Save the current video mode */
if ( use_vidmode ) {
- XVidMode(LockModeSwitch, (SDL_Display, SDL_Screen, True));
+ SDL_NAME(XF86VidModeLockModeSwitch)(SDL_Display, SDL_Screen, True);
}
#endif
currently_fullscreen = 1;
@@ -740,7 +740,7 @@
#ifdef XFREE86_VM
if ( use_vidmode ) {
restore_mode(this);
- XVidMode(LockModeSwitch, (SDL_Display, SDL_Screen, False));
+ SDL_NAME(XF86VidModeLockModeSwitch)(SDL_Display, SDL_Screen, False);
}
#endif
--- a/src/video/x11/SDL_x11video.h Sat Mar 02 16:50:35 2002 +0000
+++ b/src/video/x11/SDL_x11video.h Tue Mar 05 19:55:32 2002 +0000
@@ -37,16 +37,11 @@
#include <X11/extensions/XShm.h>
#endif
#ifdef XFREE86_DGAMOUSE
-#include <X11/extensions/xf86dga.h>
+#include <XFree86/extensions/xf86dga.h>
#endif
#ifdef XFREE86_VM
-#include <X11/extensions/xf86vmode.h>
-#ifdef XFREE86_VM_DYNAMIC_HACK
-#define XVidMode(func, args) XF40VidMode##func args
-#else
-#define XVidMode(func, args) XF86VidMode##func args
+#include <XFree86/extensions/xf86vmode.h>
#endif
-#endif /* XFREE86_VM */
#ifdef HAVE_XIGXME
#include <X11/extensions/xme.h>
#endif
@@ -118,7 +113,7 @@
/* Variables used by the X11 video mode code */
#ifdef XFREE86_VM
- XF86VidModeModeInfo saved_mode;
+ SDL_NAME(XF86VidModeModeInfo) saved_mode;
struct {
int x, y;
} saved_view;
--- a/src/video/x11/SDL_x11yuv.c Sat Mar 02 16:50:35 2002 +0000
+++ b/src/video/x11/SDL_x11yuv.c Tue Mar 05 19:55:32 2002 +0000
@@ -35,7 +35,7 @@
#include <sys/ipc.h>
#include <sys/shm.h>
#include <X11/extensions/XShm.h>
-#include <X11/extensions/Xvlib.h>
+#include <XFree86/extensions/Xvlib.h>
#include "SDL_error.h"
#include "SDL_video.h"
@@ -64,7 +64,7 @@
struct private_yuvhwdata {
int port;
XShmSegmentInfo yuvshm;
- XvImage *image;
+ SDL_NAME(XvImage) *image;
};
@@ -75,13 +75,13 @@
int xv_port;
int i, j, k;
int adaptors;
- XvAdaptorInfo *ainfo;
+ SDL_NAME(XvAdaptorInfo) *ainfo;
XShmSegmentInfo *yuvshm;
/* Look for the XVideo extension with a valid port for this format */
xv_port = -1;
- if ( (Success == XvQueryExtension(GFX_Display, &j, &j, &j, &j, &j)) &&
- (Success == XvQueryAdaptors(GFX_Display,
+ if ( (Success == SDL_NAME(XvQueryExtension)(GFX_Display, &j, &j, &j, &j, &j)) &&
+ (Success == SDL_NAME(XvQueryAdaptors)(GFX_Display,
RootWindow(GFX_Display, SDL_Screen),
&adaptors, &ainfo)) ) {
#ifdef USE_LAST_ADAPTOR
@@ -106,8 +106,8 @@
if ( (ainfo[i].type & XvInputMask) &&
(ainfo[i].type & XvImageMask) ) {
int num_formats;
- XvImageFormatValues *formats;
- formats = XvListImageFormats(GFX_Display,
+ SDL_NAME(XvImageFormatValues) *formats;
+ formats = SDL_NAME(XvListImageFormats)(GFX_Display,
ainfo[i].base_id, &num_formats);
#ifdef USE_LAST_ADAPTOR
for ( j=0; j < num_formats; ++j ) {
@@ -116,7 +116,7 @@
#endif /* USE_LAST_ADAPTOR */
if ( (Uint32)formats[j].id == format ) {
for ( k=0; k < ainfo[i].num_ports; ++k ) {
- if ( Success == XvGrabPort(GFX_Display, ainfo[i].base_id+k, CurrentTime) ) {
+ if ( Success == SDL_NAME(XvGrabPort)(GFX_Display, ainfo[i].base_id+k, CurrentTime) ) {
xv_port = ainfo[i].base_id+k;
break;
}
@@ -134,7 +134,7 @@
/* Create the overlay structure */
overlay = (SDL_Overlay *)malloc(sizeof *overlay);
if ( overlay == NULL ) {
- XvUngrabPort(GFX_Display, xv_port, CurrentTime);
+ SDL_NAME(XvUngrabPort)(GFX_Display, xv_port, CurrentTime);
SDL_OutOfMemory();
return(NULL);
}
@@ -153,7 +153,7 @@
hwdata = (struct private_yuvhwdata *)malloc(sizeof *hwdata);
overlay->hwdata = hwdata;
if ( hwdata == NULL ) {
- XvUngrabPort(GFX_Display, xv_port, CurrentTime);
+ SDL_NAME(XvUngrabPort)(GFX_Display, xv_port, CurrentTime);
SDL_OutOfMemory();
SDL_FreeYUVOverlay(overlay);
return(NULL);
@@ -161,7 +161,7 @@
yuvshm = &hwdata->yuvshm;
memset(yuvshm, 0, sizeof(*yuvshm));
hwdata->port = xv_port;
- hwdata->image = XvShmCreateImage(GFX_Display, xv_port, format,
+ hwdata->image = SDL_NAME(XvShmCreateImage)(GFX_Display, xv_port, format,
0, width, height, yuvshm);
#ifdef PITCH_WORKAROUND
@@ -184,7 +184,7 @@
}
XFree(hwdata->image);
- hwdata->image = XvShmCreateImage(GFX_Display, xv_port, format,
+ hwdata->image = SDL_NAME(XvShmCreateImage)(GFX_Display, xv_port, format,
0, width, height, yuvshm);
}
#endif
@@ -252,7 +252,7 @@
struct private_yuvhwdata *hwdata;
hwdata = overlay->hwdata;
- XvShmPutImage(GFX_Display, hwdata->port, SDL_Window, SDL_GC,
+ SDL_NAME(XvShmPutImage)(GFX_Display, hwdata->port, SDL_Window, SDL_GC,
hwdata->image, 0, 0, overlay->w, overlay->h,
dstrect->x, dstrect->y, dstrect->w, dstrect->h, False);
XSync(GFX_Display, False);
@@ -265,7 +265,7 @@
hwdata = overlay->hwdata;
if ( hwdata ) {
- XvUngrabPort(GFX_Display, hwdata->port, CurrentTime);
+ SDL_NAME(XvUngrabPort)(GFX_Display, hwdata->port, CurrentTime);
if ( hwdata->yuvshm.shmaddr ) {
XShmDetach(GFX_Display, &hwdata->yuvshm);
shmdt(hwdata->yuvshm.shmaddr);
--- a/test/configure.in Sat Mar 02 16:50:35 2002 +0000
+++ b/test/configure.in Tue Mar 05 19:55:32 2002 +0000
@@ -66,11 +66,7 @@
AC_MSG_CHECKING(for OpenGL support)
have_opengl=no
AC_TRY_COMPILE([
- #if defined(__APPLE__) && defined(__MACH__)
- #include <OpenGL/gl.h>
- #else
- #include <GL/gl.h>
- #endif
+ #include "SDL_opengl.h"
],[
],[
have_opengl=yes