We should pass back the glXGetProcAddress to the underlying
gl dispatch initialization function to get those gl function
pointers.
Signed-off-by: Zhigang Gong <zhigang.gong@linux.intel.com>
In Xephyr, screen pixmap is different from other pixmap.
It use fbo zero and texture zero. We initialize it during
creating screen resources.
Signed-off-by: Zhigang Gong <zhigang.gong@linux.intel.com>
As now we use pixmap to handle cursor, and pixmaps are related to
current screen. If we close the screen, then we have to destroy all
the related cursors.
Signed-off-by: Zhigang Gong <zhigang.gong@linux.intel.com>
The previous implementation call preInit again to reopen
the device if the device is closed by eglTerminate. Now
we don't need it anymore, as glamor dix doesn't call
eglTerminate any more when close screen.
Signed-off-by: Zhigang Gong <zhigang.gong@linux.intel.com>
We already have a glamor egl module at glamor directory which
could initialize and create egl context and also can attach a
gbm buffer to a specified pixmap or to the screen pixmap. This
commit remove all the duplicated code here and use the glamor_dix
module directly.
As we don't want to handle egl stuffs in this layer, we have to
change the way to handle hardware cursor. Previous method is to
call egl functions to create a egl image and then bind the image
to a texutre then call gl functions to load texture image to the
cursor bo. Now we can bind the cursor bo to a cursor pixmap and
then use putimage to load new image to the cursor bo. Then we can
completely avoid to call egl or gl functions directly in this
ddx driver.
Signed-off-by: Zhigang Gong <zhigang.gong@linux.intel.com>
Now we can allocate frame buffer during the screen initialization.
And set mode major when enter VT. This is the correct logic. The
previous implementation defer the set mode major to create screen
resource which will cause the switching between VTs broken.
Signed-off-by: Zhigang Gong <zhigang.gong@linux.intel.com>
Create a new structure glamor_gl_dispatch to hold all the
gl function's pointer and initialize them at run time ,
rather than use them directly. To do this is to avoid
symbol conflicts.
Signed-off-by: Zhigang Gong <zhigang.gong@linux.intel.com>
As in glamor_glyphs_init, we may need to create pixmap. Thus it must
be called after the pixmap resources allocation. Just move it to
screen resource creation stage is good enough for mow.
Also introduce a macro GLAMOR_FOR_XORG to glamor.h. As glamor may
be used by Xephyr which doesn't don't have those xorg header files
and also don't need the egl extension.
Signed-off-by: Zhigang Gong <zhigang.gong@linux.intel.com>
Glamor doesn't need to use GLEW. We can parse the extension by
ourself. This patch also fix the fbo size checking from a hard
coded style to a dynamic checking style.
Signed-off-by: Zhigang Gong <zhigang.gong@gmail.com>
Now, to build a gles2 version of glamor server, we could
use ./autogen.sh --enable-glamor-ddx --enable-glamor-gles2
Signed-off-by: Zhigang Gong <zhigang.gong@gmail.com>
First commit to enable gles2 support. --enable-glamor-ddx
--enable-glamor-gles2 will set thwo MACROs GLAMOR_DDX and
GLAMOR_GLES2.
Currently, the gles2 support is still incomplete.
Signed-off-by: Zhigang Gong <zhigang.gong@linux.intel.com>
As the eglTerminate will close the card when close screen, we may
need to reopen it at next time create a screen resource. and thus
we need to re initialize the drmmode crtc also. Otherwise , the
cursor handling will be broken as it has the wrong fd.
Major refactoring.
1. Rewrite the pixmap texture uploading and downloading functions.
Add some new functions for both the prepare/finish access and
the new performance feature dynamic texture uploading, which
could download and upload the current image to/from a private
texture/fbo. In the uploading or downloading phase, we need to
handle two things:
The first is the yInverted option, If it set, then we don't need
to flip y. If not set, if it is from a dynamic texture uploading
then we don't need to flip either if the current drawing process
will flip it latter. If it is from finish_access, then we must
flip the y axis.
The second thing is the alpha channel hanlding, if the pixmap's
format is something like x8a8r8g8, x1r5g5b5 which means it doesn't
has alpha channel, but it do has those extra bits. Then we need to
wire those bits to 1.
2. Add almost all the required picture format support.
This is not as trivial as it looks like. The previous implementation
only support GL_a8,GL_a8r8g8b8,GL_x8r8g8b8. All the other format,
we have to fallback to cpu. The reason why we can't simply add those
other color format is because the exists of picture. one drawable
pixmap may has one or even more container pictures. The drawable pixmap's
depth can't map to a specified color format, for example depth 16 can
mapped to r5g6b5, x1r5g5b5, a1r5g5b5, or even b5g6r5. So we can't get
get the color format just from the depth value. But the pixmap do not
has a pict_format element. We have to make a new one in the pixmap
private data structure. Reroute the CreatePicture to glamor_create_picture
and then store the picture's format to the pixmap's private structure.
This is not an ideal solution, as there may be more than one pictures
refer to the same pixmap. Then we will have trouble. There is an example
in glamor_composite_with_shader. The source and mask often share the
same pixmap, but use different picture format. Our current solution is to
combine those two different picture formats to one which will not lose any
data. Then change the source's format to this new format and then upload
the pixmap to texture once. It works. If we fail to find a matched new
format then we fallback.
There still is a potential problem, if two pictures refer to the same
pixmap, and one of them destroy the picture, but the other still remained
to be used latter. We don't handle that situation currently. To be fixed.
3. Dynamic texture uploading.
This is a performance feature. Although we don't like the client to hold
a pixmap data to shared memory and we can't accelerate it. And even worse,
we may need to fallback all the required pixmaps to cpu memory and then
process them on CPU. This feature is to mitigate this penalty. When the
target pixmap has a valid gl fbo attached to it. But the other pixmaps are
not. Then it will be more efficient to upload the other pixmaps to GPU and
then do the blitting or rendering on GPU than fallback all the pixmaps to CPU.
To enable this feature, I experienced a significant performance improvement
in the Game "Mines" :).
4. Debug facility.
Modify the debug output mechanism. Now add a new macro:
glamor_debug_output(_level_, _format_,...) to conditional output some messages
according to the environment variable GLAMOR_DEBUG. We have the following
levels currently.
exports GLAMOR_DEBUG to 3 will enable all the above messages.
5. Changes in pixmap private data structure.
Add some for the full color format supports and relate it to the pictures which
already described. Also Add the following new elements:
gl_fbo - to indicates whether this pixmap is on gpu only.
gl_tex - to indicates whether the tex is valid and is containing the pixmap's
image originally.
As we bring the dynamic pixmap uploading feature, so a cpu memory pixmap may
also has a valid fbo or tex attached to it. So we will have to use the above
new element to check it true type.
After this commit, we can pass the rendercheck testing for all the picture formats.
And is much much fater than fallback to cpu when doing rendercheck testing.
Signed-off-by: Zhigang Gong <zhigang.gong@linux.intel.com>
This commit fixed two bugs when one client reset the connection.
The first is that we should reopen the graphic device when the previous
node was closed during the screen closing. The second one is we should
call glamor_close_screen (not the ddx version) prior to call
eglTerminate(). As eglTerminate will release the share library. And
the glamor_close_screen may still need to call openGL APIs and thus
will hit segfault. And renamed the ddx functions to avoid naming
conflications with the glamor functions.
GC is redefined in the X11/Xlib.h and include/gcstruct.h which is
a xorg header file. Just use a macro to simply avoid the conflict.
Need revisit latter to find a correct way to fix this problem.
Due to the coordinate system on EGL is different from FBO
object. To support EGL surface well, we add this new feature.
When calling glamor_init from EGL ddx driver, it should use
the new flag GLAMOR_INVERTED_Y_AXIS.
As current glamor implementation depends on the glx library in the
mesa package which is conflict with the version in xorg. We have to
--disable-glx when build Xephyr. But this leads to the linking error
here. We comment out the calling to ephyrHijackGLXExtension() now.
Need revisit latter.
This should avoid a bunch of absurdity with GLX front buffer handling,
fix exposes, and improve performance. For now we're copying the whole
buffer while glamor is developed.
Swapping the wrong size was never caught because swap{l,s} are macros.
It's clear in the case of Xext/xres.c, that the author believed
client_major/minor to be CARD16 from looking at the code in the first
hunk.
v2: dmx.c fixes from Keith.
Reviewed-by: Peter Harris <pharris@opentext.com>
Signed-off-by: Matt Turner <mattst88@gmail.com>
Also, fix whitespace, mainly around
swaps(&rep.sequenceNumber)
Reviewed-by: Peter Harris <pharris@opentext.com>
Signed-off-by: Matt Turner <mattst88@gmail.com>
Zhigang Gong
Zhenyu Wang
Zhigang Gong
Kristian Høgsberg
Eric Anholt
Keith Packard
Matt Turner