pandory500/SDL-mirror
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Added SDL_LockRect() and SDL_UnlockRect()

Browse source 
Incorporated XFree86 extension libraries into the source

--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%40293
This commit is contained in:
Sam Lantinga 2002-03-05 19:55:32 +00:00
parent 84075e735c
commit a1db24829f
49 changed files with 8397 additions and 201 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Makefile.am
View file

@ -45,7 +45,7 @@ EXTRA_DIST = \
EpocBuildFiles.zip \
WhatsNew \
docs.html \
sdl.m4 \
sdl.m4 \
SDL.spec \
autogen.sh \
strip_fPIC.sh

6
WhatsNew
View file

@ -3,6 +3,12 @@ This is a list of API changes in SDL's version history.
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

180
configure.in
View file

@ -372,7 +372,7 @@ dnl See if the NAS audio interface is supported
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 @@ dnl rcg07142001 See if the user wants the disk writer audio driver...
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 @@ CheckNASM()
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 @@ CheckX11()
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 @@ CheckX11()
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 @@ CheckX11()
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 @@ CheckX11()
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 @@ CheckX11()
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 @@ CheckX11()
#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 @@ CheckX11()
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 @@ CheckX11()
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 @@ CheckPHOTON()
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 -I\$(top_srcdir)/src/$ARCH"
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/windib/Makefile
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

2
docs.html
View file

@ -16,6 +16,8 @@ be found at the <A HREF="http://www.libsdl.org/"> main SDL page</A>.
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!)

20
include/SDL_video.h
View file

@ -531,6 +531,26 @@ extern DECLSPEC void SDL_FreeSurface(SDL_Surface *surface);
extern DECLSPEC int SDL_LockSurface(SDL_Surface *surface);
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.

4
src/main/beos/exports/SDL.exp
View file

@ -74,6 +74,7 @@ _SDL_GetKeyState
_SDL_GetModState
_SDL_SetModState
_SDL_GetKeyName
_SDL_SetModuleHandle
_SDL_RegisterApp
_SDL_InitQuickDraw
_SDL_GetMouseState
@ -143,6 +144,8 @@ _SDL_CreateRGBSurfaceFrom
_SDL_FreeSurface
_SDL_LockSurface
_SDL_UnlockSurface
_SDL_LockRect
_SDL_UnlockRect
_SDL_LoadBMP_RW
_SDL_SaveBMP_RW
_SDL_SetColorKey
@ -174,3 +177,4 @@ _SDL_WM_SetIcon
_SDL_WM_IconifyWindow
_SDL_WM_ToggleFullScreen
_SDL_WM_GrabInput
_SDL_SoftStretch

3
src/main/macos/exports/SDL.x
View file

@ -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

2
src/main/macosx/exports/SDL.x
View file

@ -141,6 +141,8 @@
_SDL_FreeSurface
_SDL_LockSurface
_SDL_UnlockSurface
_SDL_LockRect
_SDL_UnlockRect
_SDL_LoadBMP_RW
_SDL_SaveBMP_RW
_SDL_SetColorKey

3
src/main/win32/exports/SDL.def
View file

@ -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

2
src/video/Makefile.am
View file

@ -9,7 +9,7 @@ DIST_SUBDIRS = dummy x11 dga nanox fbcon directfb vgl svga ggi aalib \
wincommon windib windx5 \
maccommon macdsp macrom quartz \
bwindow ps2gs photon cybergfx epoc \
ataricommon xbios gem
ataricommon xbios gem XFree86
DRIVERS = @VIDEO_DRIVERS@

102
src/video/SDL_surface.c
View file

@ -630,6 +630,10 @@ int SDL_FillRect(SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color)
*/
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 @@ int SDL_LockSurface (SDL_Surface *surface)
/* 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 @@ int SDL_LockSurface (SDL_Surface *surface)
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_UnlockSurface (SDL_Surface *surface)
}
}
}
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.

2
src/video/SDL_sysvideo.h
View file

@ -153,6 +153,8 @@ struct SDL_VideoDevice {
/* 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);

2
src/video/SDL_yuv_sw.c
View file

@ -1255,7 +1255,7 @@ int SDL_DisplayYUV_SW(_THIS, SDL_Overlay *overlay, SDL_Rect *dstrect)
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) ) {

4
src/video/Xext/Makefile.am Normal file
View file

@ -0,0 +1,4 @@
SUBDIRS = extensions Xinerama Xv Xxf86dga Xxf86vm
EXTRA_DIST = README

9
src/video/Xext/README Normal file
View file

@ -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.

5
src/video/Xext/Xinerama/Makefile.am Normal file
View file

@ -0,0 +1,5 @@
## Makefile.am for the XFree86 Xinerama library
noinst_LTLIBRARIES = libXFree86_Xinerama.la
libXFree86_Xinerama_la_SOURCES = Xinerama.c

319
src/video/Xext/Xinerama/Xinerama.c Normal file
View file

@ -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;
}

5
src/video/Xext/Xv/Makefile.am Normal file
View file

@ -0,0 +1,5 @@
## Makefile.am for the XFree86 Xv library
noinst_LTLIBRARIES = libXFree86_Xv.la
libXFree86_Xv_la_SOURCES = Xv.c Xvlibint.h

1152
src/video/Xext/Xv/Xv.c Normal file
View file

File diff suppressed because it is too large Load diff

76
src/video/Xext/Xv/Xvlibint.h Normal file
View file

@ -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 */

5
src/video/Xext/Xxf86dga/Makefile.am Normal file
View file

@ -0,0 +1,5 @@
## Makefile.am for the XFree86 Xxf86dga library
noinst_LTLIBRARIES = libXFree86_Xxf86dga.la
libXFree86_Xxf86dga_la_SOURCES = XF86DGA2.c XF86DGA.c

716
src/video/Xext/Xxf86dga/XF86DGA.c Normal file
View file

@ -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;
}

987
src/video/Xext/Xxf86dga/XF86DGA2.c Normal file
View file

@ -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 !!!!!!!!!!*/
}

5
src/video/Xext/Xxf86vm/Makefile.am Normal file
View file

@ -0,0 +1,5 @@
## Makefile.am for the XFree86 Xxf86vm library
noinst_LTLIBRARIES = libXFree86_Xxf86vm.la
libXFree86_Xxf86vm_la_SOURCES = XF86VMode.c

1210
src/video/Xext/Xxf86vm/XF86VMode.c Normal file
View file

File diff suppressed because it is too large Load diff

16
src/video/Xext/extensions/Makefile.am Normal file
View file

@ -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

8
src/video/Xext/extensions/SDLname.h Normal file
View file

@ -0,0 +1,8 @@
#ifndef _SDLname_h_
#define _SDLname_h_
#define NeedFunctionPrototypes 1
#define SDL_NAME(X) SDL_##X
#endif

46
src/video/Xext/extensions/Xinerama.h Normal file
View file

@ -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 */

129
src/video/Xext/extensions/Xv.h Normal file
View file

@ -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 */

433
src/video/Xext/extensions/Xvlib.h Normal file
View file

@ -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 */

604
src/video/Xext/extensions/Xvproto.h Normal file
View file

@ -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 */

224
src/video/Xext/extensions/extutil.h Normal file
View file

@ -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

52
src/video/Xext/extensions/panoramiXext.h Normal file
View file

@ -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
);

192
src/video/Xext/extensions/panoramiXproto.h Normal file
View file

@ -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

265
src/video/Xext/extensions/xf86dga.h Normal file
View file

@ -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_ */

169
src/video/Xext/extensions/xf86dga1.h Normal file
View file

@ -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_ */

194
src/video/Xext/extensions/xf86dga1str.h Normal file
View file

@ -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_ */

344
src/video/Xext/extensions/xf86dgastr.h Normal file
View file

@ -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_ */

314
src/video/Xext/extensions/xf86vmode.h Normal file
View file

@ -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

546
src/video/Xext/extensions/xf86vmstr.h Normal file
View file

@ -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_ */

6
src/video/dga/SDL_dgaevents.c
View file

@ -29,7 +29,7 @@ static char rcsid =
#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 @@ extern SDL_keysym *X11_TranslateKey(Display *display, XKeyEvent *xkey,
static int DGA_DispatchEvent(_THIS)
{
int posted;
XDGAEvent xevent;
SDL_NAME(XDGAEvent) xevent;
XNextEvent(DGA_Display, (XEvent *)&xevent);
@ -82,7 +82,7 @@ static int DGA_DispatchEvent(_THIS)
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,

70
src/video/dga/SDL_dgavideo.c
View file

@ -31,7 +31,7 @@ static char rcsid =
#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 @@ static int DGA_Available(void)
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 int DGA_AddMode(_THIS, int bpp, int w, int h)
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 @@ static Uint32 get_video_size(_THIS)
}
#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 void PrintMode(XDGAMode *mode)
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 @@ static int cmpmodes(const void *va, const void *vb)
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 @@ static int DGA_VideoInit(_THIS, SDL_PixelFormat *vformat)
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 @@ static int DGA_VideoInit(_THIS, SDL_PixelFormat *vformat)
}
/* 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 @@ static int DGA_VideoInit(_THIS, SDL_PixelFormat *vformat)
}
/* 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 @@ static void DGA_DirectUpdate(_THIS, int numrects, SDL_Rect *rects);
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 @@ SDL_Surface *DGA_SetVideoMode(_THIS, SDL_Surface *current,
}
/* 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 @@ SDL_Surface *DGA_SetVideoMode(_THIS, SDL_Surface *current,
}
/* 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 @@ SDL_Surface *DGA_SetVideoMode(_THIS, SDL_Surface *current,
/* 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 @@ SDL_Surface *DGA_SetVideoMode(_THIS, SDL_Surface *current,
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 @@ SDL_Surface *DGA_SetVideoMode(_THIS, SDL_Surface *current,
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 @@ SDL_Surface *DGA_SetVideoMode(_THIS, SDL_Surface *current,
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 @@ static __inline__ void DGA_WaitBusySurfaces(_THIS)
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 @@ static int DGA_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color)
/* 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 @@ static int DGA_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color)
#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 @@ static int HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect,
/* 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 @@ static int HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect,
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 int DGA_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst)
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 @@ static int DGA_FlipHWSurface(_THIS, SDL_Surface *surface)
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 @@ void DGA_VideoQuit(_THIS)
}
/* 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 ) {

40
src/video/windx5/SDL_dx5video.c
View file

@ -421,6 +421,7 @@ static int DX5_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *dstrect, Uint32 col
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 @@ static SDL_VideoDevice *DX5_CreateDevice(int devindex)
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 @@ static int DX5_LockHWSurface(_THIS, SDL_Surface *surface)
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)
{

12
src/video/x11/SDL_x11dga.c
View file

@ -61,9 +61,9 @@ void X11_EnableDGAMouse(_THIS)
}
/* 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 @@ void X11_CheckDGAMouse(_THIS)
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 @@ void X11_DisableDGAMouse(_THIS)
{
#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 */

8
src/video/x11/SDL_x11gamma.c
View file

@ -38,7 +38,7 @@ static int X11_SetGammaNoLock(_THIS, float red, float green, float blue)
{
#ifdef XFREE86_VMGAMMA
if (use_vidmode >= 200) {
XF86VidModeGamma gamma;
SDL_NAME(XF86VidModeGamma) gamma;
Bool succeeded;
/* Clamp the gamma values */
@ -67,7 +67,7 @@ static int X11_SetGammaNoLock(_THIS, float red, float green, float blue)
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 @@ static int X11_GetGammaNoLock(_THIS, float *red, float *green, float *blue)
{
#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;

58
src/video/x11/SDL_x11modes.c
View file

@ -40,16 +40,16 @@ static char rcsid =
#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 @@ Bool XVidMode(GetModeInfo, (Display *dpy, int scr, XF86VidModeModeInfo *info))
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 @@ static void restore_mode(_THIS)
#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 @@ static void set_best_resolution(_THIS, int width, int height)
{
#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 @@ static void set_best_resolution(_THIS, int width, int height)
}
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 @@ static void get_real_resolution(_THIS, int* w, int* h)
{
#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 X11_GetVideoModes(_THIS)
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 @@ int X11_GetVideoModes(_THIS)
#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 @@ int X11_GetVideoModes(_THIS)
}
}
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 @@ int X11_GetVideoModes(_THIS)
#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 @@ int X11_EnterFullScreen(_THIS)
#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 @@ int X11_LeaveFullScreen(_THIS)
#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

11
src/video/x11/SDL_x11video.h
View file

@ -37,16 +37,11 @@ static char rcsid =
#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 @@ struct SDL_PrivateVideoData {
/* 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;

28
src/video/x11/SDL_x11yuv.c
View file

@ -35,7 +35,7 @@ static char rcsid =
#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 @@ static struct private_yuvhwfuncs x11_yuvfuncs = {
struct private_yuvhwdata {
int port;
XShmSegmentInfo yuvshm;
XvImage *image;
SDL_NAME(XvImage) *image;
};
@ -75,13 +75,13 @@ SDL_Overlay *X11_CreateYUVOverlay(_THIS, int width, int height, Uint32 format, S
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 @@ SDL_Overlay *X11_CreateYUVOverlay(_THIS, int width, int height, Uint32 format, S
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 @@ SDL_Overlay *X11_CreateYUVOverlay(_THIS, int width, int height, Uint32 format, S
#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 @@ SDL_Overlay *X11_CreateYUVOverlay(_THIS, int width, int height, Uint32 format, S
/* 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 @@ SDL_Overlay *X11_CreateYUVOverlay(_THIS, int width, int height, Uint32 format, S
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 @@ SDL_Overlay *X11_CreateYUVOverlay(_THIS, int width, int height, Uint32 format, S
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 @@ SDL_Overlay *X11_CreateYUVOverlay(_THIS, int width, int height, Uint32 format, S
}
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 @@ int X11_DisplayYUVOverlay(_THIS, SDL_Overlay *overlay, SDL_Rect *dstrect)
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 @@ void X11_FreeYUVOverlay(_THIS, SDL_Overlay *overlay)
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);

6
test/configure.in
View file

@ -66,11 +66,7 @@ dnl Check for OpenGL
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