Under the terms of version 1.1, "once Covered Code has been published
under a particular version of the License, Recipient may, for the
duration of the License, continue to use it under the terms of that
version, or choose to use such Covered Code under the terms of any
subsequent version published by SGI."
FreeB 2.0 license refers to "dates of first publication". They are here
taken to be 1991-2000, as noted in the original license text:
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
Official FreeB 2.0 text:
http://oss.sgi.com/projects/FreeB/SGIFreeSWLicB.2.0.pdf
As always, this code has not been tested for conformance with the OpenGL
specification. OpenGL conformance testing is available from
http://khronos.org/ and is required for use of the OpenGL logo in
product advertising and promotion.
Add #include "glheader.h" for definition of __builtin_expect for compilers
that don't support it.
Signed-off-by: Brian Paul <brian.paul@tungstengraphics.com>
caveats:
- does not work with old (i.e. libGLcore) xserver:
- made unbindContext a noop
- extensions:
GLX_SGI_make_current_read
GLX_EXT_texture_from_pixmap
GLX_MESA_copy_sub_buffer
This reverts commit 7688791fc5, and takes
us back to generating the glapi files straight into the xserver tree.
Conflicts:
src/glx/x11/indirect_size_get.c
Since the only valid consumer of the DRI drivers is the X.Org xserver,
this changes the default DRI driver directory to match xorg-server:
${libdir}/dri. The old default of /usr/X11R6/modules/dri was wrong for
nearly all current systems.
Consistently cleanup the depend.bak files created by makedepend. Also,
realclean has been changed to use a single find command, which speeds it
up considerably.
Fixes compiz with direct rendering when both GLX_TEXTURE_2D_EXT and
GLX_TEXTURE_RECTANGLE_EXT are supported for a GLXPixmap and the
application didn't specify the texture target as a GLX drawable attribute
when creating the GLX drawable.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
to check whether oldGC is used for direct rendering in
function MakeContextCurrent. However it is possible
oldGC->driContext is already freed. fix bug #14926.
This makes make install work again for non-glx libGL implementations.
The make install logic is split into three sub-targets: install-libgl,
install-osmesa, install-drivers. The install target in src/glx/x11
is then implemented using the src/mesa make install-libgl rule.
Thanks to Dan Nicholson for pointing out the breakage.
After commit 6fd82f6fbd, we would
overwrite the libPath default value with NULL if libGL was running
non-setuid and none of the env vars were set.
Thanks to Magnus Kessler <Magnus.Kessler@gmx.net> for spotting it.
This patch moves __DRIdisplayPrivateRec definition into dri_glx.c and
let's dri_glx.c allocate the __DRIdisplay struct pointer to from
__GLXdisplayPrivate.
A small step towards moving more of the dri functionality into dri_glx.c.
No need to jump through hoops to track __DRIdrivers and avoid dlopening the
same .so more than twice, dlopen() does this internally. Besides, we
were already bypassing this and dlopening drivers for each screen,
whether or not they were already dlopened.
The DriverAPI is internal to the DRI drivers and GetDrawableMSC
obsoletes GetMSC. Also, since the DRI driver interface has not yet
been released, just drop the getMSC function from the DRI interface
instead using the ABI preserving version mechanism.
Finally, using void pointer privates in the DRI interface is not allowed,
always pass the actual types around (__DRIdrawable in this case) to
enhance type safety and readability of the code.
Instead of generating the glapi sources for the xserver and commiting
them to the xserver tree, we can keep them in the mesa tree and change
the xserver build to use the files from the mesa tree.
This makes the xserver glx build more robust as it reduces the chances
for mismatches of the glX API used in the xserver vs. in mesa.
If the server didn't send a value, assume it's not supported.
A more generic solution might be better for this kind of problem, but an
attempt for this failed (see https://bugs.freedesktop.org/show_bug.cgi?id=9264)
and this allows compiz to work with drivers that support
GL_EXT_framebuffer_object.
Consolidate support for synchronizing to and retrieving vblank counters. Also
fix the core vblank code to return monotonic MSC counters, which are required
by some GLX extensions. Adding support for multiple pipes to a low level
driver is fairly easy, the Intel 965 driver provides simple example code (see
intel_buffers.c:intelWindowMoved()).
The new code bumps the media stream counter extension version to 2 and adds a
new getDrawableMSC callback. This callback takes a drawablePrivate pointer,
which is used to calculate the MSC value seen by clients based on the actual
vblank counter(s) returned from the kernel. The new drawable private fields
are as follows:
- vblSeq - used for tracking vblank counts for buffer swapping
- vblFlags - flags (e.g. current pipe), updated by low level driver
- msc_base - MSC counter from the last time the current pipe changed
- vblank_base - kernel DRM vblank counter from the last time the pipe changed
Using the above variables, the core vblank code (in vblank.c) can calculate a
monotonic MSC value. The low level DRI drivers are responsible for updating
the current pipe (by setting VBLANK_FLAG_SECONDARY for example in vblFlags)
along with msc_base and vblank_base whenever the pipe associated with a given
drawable changes (again, see intelWindowMoved for an example of this).
Drivers should fill in the GetDrawableMSC DriverAPIRec field to point to
driDrawableGetMSC32 and add code for pipe switching as outlined above to fully
support the new scheme.
The old version just set GLX_DRAWABLE_TYPE to GLX_WINDOW_BIT for
configs received through glXGetVisualConfigs and to
GLX_WINDOW_BIT | GLX_PIXMAP_BIT for configs received as FBConfigs.
The X server needs to send this info, but keep the workaround for now.
Fixes#12835.
The old implementation fetches fbconfigs or glx visuals once and assumes the list
describes both fbconfigs and glx visuals. This patch splits it up and fetches
visuals and fbconfigs in two steps and keep the two lists separate. A server
could have no glx visuals or no glx fbconfigs and the old code wouldn't know the
difference.
This new API lets the loader examine DRI level extensions provided by the
driver in a forward compatible manner.
Much of the churn in the DRI interface is adding support for new
extensions or removing old, unused extensions. This new extension
mechanism lets the loader query the extensions provided by the driver
and implement the extensions it knows about. Deprecating extensions
is done by not exporting that extension in the list, which doesn't
require keeping old function pointers around to preserve ABI.
The entrypoints take a mix of __DRIscreen * and void * (screen private)
arguments (similarly for contexts and drawables). This patch does away
with passing the private void pointer and always only passes the fully
typed __DRIscreen pointer and always as the first argument.
This makes the interface more consistent and increases type safety, and
catches a bug where we would pass a screen private to DRIdrawable::getSBC.
The screenConfigs field of __DRIscreen points back to the containing
__GLXscreenConfigs struct. This is a serious abstraction violation; it
assumes that the loader is libGL and that there *is* a __GLXscreenConfigs
type in the loader.
Using the containerOf macro, we can get from the __DRIscreen pointer to
the containing __GLXscreenConfigs struct, at a place in the stack
where the above is a valid assumption. Besides, the __DRI* structs shouldn't
hold state other than the private pointer.
__glXinitialize() can't be called with the GLX lock held. Just
pass in the __GLXscreenConfigs pointer so we don't have to look it
up in __GLXdisplayPrivate.
As for createDrawable and destroyDrawable, these functions immediately
upon entry to driCreateNewContext and immediately before exit from
driDestroyContext. Instead of passing function pointers back and forth
just obtain the drm_context_t prior to calling DRIscreen::createNewContext
and pass it as a parameter.
This change also lets us keep the DRI context XID in the libGL loader only.
All the DRI driver did was call the createDrawable callback immediately
upon entry to DRIscreen::createNewDrawable to get the drm_drawable_t.
We can just call that before calling into the DRI driver and pass the
returned drm_drawable_t as an argument to the DRI entry point.
Likewise for destroyDrawable.
Also, DRIdrawablePrivate::draw isn't used anywhere, and since the
driver no longer needs the XID of the drawable we can now drop that.
Many DRI entry points took a __DRInativeDisplay pointer and a screen
index as arguments. The only use for the native display pointer was to
pass it back to the loader when looking up the __DRIscreen for the given
screen index.
Instead, let's just pass in the __DRIscreen pointer directly, which
let's drop the __DRInativeDisplay type and the getScreen function.
The assumption is now that the loader will be able to retrieve context
from the __DRIscreen pointer when necessary.
This fixes a regression from commit f81b1dbe374fe446f6ef676e70a72952ffb47d4e:
Since then, driDestroyDisplay gets called from __glXFreeDisplayPrivate. It
dlcloses the handles associated with the display but fails to remove their
references from the Drivers list, so subsequent calls to OpenDriver return a
stale handle and an invalid createNewScreenFunc pointer. The attempt to call
the latter results in a segfault when running amoeba, e.g.
With this, tools like ximagesrc in gstreamer correctly see updates from GL
rendering. Support requires that the Xdamage library be current (but will be
disabled if not present) plus a new X Server with support for the new
XDamagePost request. libGL now has a new interface version, and also links
against libXdamage and libXfixes to support it, but backwards compatibility
is retained.
Currently, all drivers report damage at SwapBuffers time through common code --
front buffer rendering doesn't result in damage being reported. Also, the
damage is against the root window, as our drivers don't yet render to backing
store when they should (composited environments).
Fixes a GLX protocol problem when binding an indirect rendering context
after a direct rendering context. In this case, the oldContetTag sent to
the server should be None, but the currectContextTag stored in the direct
rendering context (i.e., -1) was sent instead.
I always build with -DGLX_USE_TLS, so I never hit these paths. glapi.h is
required in some places because _glapi_Dispatch is declared there, but
_glapi_tls_Dispatch is declared in glthread.h.
glDeleteTextures and glDeleteTexturesEXT were erroneously listed as
aliases of each other. For anything /except/ GLX protocol they are
aliases. This set of changes allows functions that are functionally
identical but have different GLX protocol to be listed as aliases.
When building with GLX_INDIRECT_RENDERING set, different static
functions are used. These functions determine whether the current
context is direct rendering or not. If the context is direct
rendering, the aliased function (e.g., glDeleteTextures in the case of
glDeleteTexturesEXT) is called. If the context is not direct
rendering, the correct GLX protocol is sent.
For a deeper explanation of what is changed, please see:
http://dri.freedesktop.org/wiki/PartiallyAliasedFunctions
Rearrange most of the internals of MakeContextCurrent. Put all of the code to
bind the new context up front. If that is successful, unbind the old context.
This saves a lot of code and removes some locking crazyiness.
This patch has been tested for indirect rendering with glxinfo, glxgears,
manywin, and wincopy.
There were two sets of bugs in the vertex program (ARB and NV)
protocol. First, several of the ARB functions were missing the
'doubles_in_order="true"' annotation. Second, after the ARB decided
that glVertexAttrib*ARB functions must not alias fixed-function state
for GLSL, Nvidia re-assigned GLX protocol opcodes for
glVertexAttrib*NV (circa Septeber 2004). For some reason gl_API.xml
was never updated to reflect this, and the updated version of the
GL_NV_vertex_program spec never made into the registry.
Nvidia no longer supports this extension, and they no longer export its
entry points from their libGL. There's no reason for us to keep dragging it
around either.
The functions for GL_EXT_paletted_texture that do not share GLX
protocol with GL_ARB_imaging are supposed to alias the similar
functions from GL_SGI_color_table. They didn't. This patch corrects
this problem and enables GLX protocol for both extensions.
Since this removes 3 entries from the dispatch table, this change
creates a lot of changes in the generated files.
tells the scripts to assign an available offset to the function. The
important changes are in src/mesa/glapi/gl_XML.py and
src/mesa/glapi/*.xml.
Since the DRI drivers only depend on functions required by the ABI
(e.g., GL 1.2 + ARB_multitexture) having fixed offsets, all functions
not in the ABI use "assign" mode. This has caused the offset of
basically every function outside the ABI to change. I have verified
that a libGL with this patch works with a DRI driver without the patch.
Futher, several function were removed from the dispatch tables
altogether. These are the functions for the following extensions:
GL_SGIS_texture_filter4
GL_SGIS_texture4D
GL_SGIS_detail_texture
GL_SGIS_sharpen_texture
GL_SGIX_sprite
GL_SGIX_instruments
GL_SGIX_framezoom
GL_SGIX_tag_sample_buffer
GL_SGIX_reference_plane
GL_SGIX_flush_raster
GL_SGIX_list_priority
GL_SGIX_fragment_lighting
GL_PGI_misc_hints
GL_EXT_index_material
GL_EXT_index_func
GL_3DFX_tbuffer
This removes 50 functions from the dispatch table.
Some applications end up dlopening libGL without RTLD_GLOBAL, so the libGL
symbols referenced by the driver can't be unresolved when libGL dlopens it.
This attempts to make the libGL symbols visible to the driver by dlopening
libGL (again) with RTLD_GLOBAL before dlopening the driver and dlclosing
the obtained handle afterwards.
__glXCalcualteUsableExtensions. By having both callers of
__glXProcessServerString initialize the bit-fields passed in, we guarantee
that the correct amount of data is initialized:
This fixes bugzilla #7353.
But later, in __glXPopArrayState(), we were using that field to set
the active_texture_unit. The value was garbage and could lead to
things blowing up.
See bug 6863.
big, ugly, error prone switch-statement is replaced with a compact table.
I also added numerous comments, including a comment explaining how the
format parameter is validated.
Explicitly pass GL_FLOAT as the type in the cases where that is the only
possible value (e.g., everywhere except the call to glColorPointer).
Validate that stride is >= 0.
Tested with all modes (including the two error modes) of
progs/tests/interleave.c.
Bug: #5001, #5058
Reviewed by: Brian Paul
should be defined. It was flawed on some platforms (e.g., Darwin & mingw).
Instead, rely on the build system to define it on the compiler command line.
This also reverts ajax's hand-edit to indirect_size.c. I'll fix that on the
X.org side of things later today.
the driver. The loader now takes care of this for the driver.
Remove _glapi_DispatchTSD and give _glapi_Dispatch its semantic (i.e.,
having a NULL value means that the application is multithreaded and
_glapi_get_dispatch must be called).
Gut all of the dispatch override code. This removes _glapi_RealDispatch,
_glapi_tls_RealDispatch, _glapi_begin_dispatch_override,
_glapi_end_dispatch_override, and _glapi_get_override_dispatch.
Remove _glapi_get_proc_address, _glapi_get_proc_name, _glapi_get_version,
and _glapi_check_table from the loader / driver interface.
Reviewed by: Brian Paul
Make sure that all the values used in the clean-up code are initialized at
some point. It is still unclear to me as to why GCC does not complain. I
suspect the problem may be due to the depth of if-statement nesting.
direct-rendering is possible on a given screen. It is not possible to
determine this by just looking at driDisplay.private in the display
structure. However, it is possible to determine this by looking at
driScreen.private in the screen structure. This field is only non-NULL if a
DRI driver has been successfully loaded and bootstrapped. Once we get to
that point, we know that direct-rendering is at least theoretically
possible.
This fixes bugzilla #2875.
DRI drivers using the "old" interface relied on certain fields being at
certain offsets. Removing the structures would break that. Now that the
old interface is no longer supported, the dead data can finally die.
linux-dri, but it disables support for direct-rendering in it. This config
mainly exists so that I can verify that changes to libGL haven't broken
builds on non-DRI platforms.
_glapi_add_entrypoint has been replaced by a new routine called
_glapi_add_dispatch. This new routine dynamically assignes dispatch offsets
to functions added. This allows IHVs to add support for extension functions
that do not have assigned dispatch offsets.
It also means that a driver has no idea what offset will be assigned to a
function. The vast majority of the changes in this commit account for that.
An additional table, driDispatchRemapTable, is added. Functions not in the
Linux OpenGL ABI (i.e., anything not in GL 1.2 + ARB_multitexture) has a
fixed offset in this new table. The entry in this table specifies the
offset in of the function in the real dispatch table.
The internal interface was also bumped from version 20050725 to 20050727.
This has been tested with various programs in progs/demos on:
radeon (Radeon Mobility M6)
r128 (Rage 128 Pro)
mga (G400)