Mercurial > sdl-ios-xcode
changeset 292:eadc0746dfaf
Added SDL_LockRect() and SDL_UnlockRect()
Incorporated XFree86 extension libraries into the source
line wrap: on
line diff
--- 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