fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-06 13:48:06 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

st/egl: Use xlib_sw_winsys in ximage backend.

Browse source
This commit is contained in:
Chia-I Wu 2010-03-08 10:09:43 +08:00
parent da92f6db5b
commit 95c5c69b50
8 changed files with 46 additions and 451 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
src/gallium/state_trackers/egl/common/egl_g3d.c
View file

@ -507,20 +507,6 @@ egl_g3d_add_configs(_EGLDriver *drv, _EGLDisplay *dpy, EGLint id)
return id;
}
/**
* Flush the front buffer of the context's draw surface.
*/
static void
egl_g3d_flush_frontbuffer(struct pipe_screen *screen,
struct pipe_surface *surf, void *context_private)
{
struct egl_g3d_context *gctx = egl_g3d_context(context_private);
struct egl_g3d_surface *gsurf = egl_g3d_surface(gctx->base.DrawSurface);
if (gsurf)
gsurf->native->flush_frontbuffer(gsurf->native);
}
/**
* Re-validate the context.
*/
@ -581,7 +567,6 @@ egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy,
goto fail;
}
gdpy->native->screen->flush_frontbuffer = egl_g3d_flush_frontbuffer;
gdpy->native->screen->update_buffer = egl_g3d_update_buffer;
egl_g3d_init_st(&gdrv->base);

3
src/gallium/state_trackers/egl/common/native.h
View file

@ -137,9 +137,6 @@ struct native_display_modeset;
struct native_display {
/**
* The pipe screen of the native display.
*
* Note that the "flush_frontbuffer" and "update_buffer" callbacks will be
* overridden.
*/
struct pipe_screen *screen;

11
src/gallium/state_trackers/egl/x11/native_x11.c
View file

@ -141,16 +141,9 @@ native_create_display(EGLNativeDisplayType dpy)
if (!ndpy) {
EGLint level = (force_sw) ? _EGL_INFO : _EGL_WARNING;
boolean use_shm;
/*
* XXX st/mesa calls pipe_screen::update_buffer in st_validate_state.
* When SHM is used, there is a good chance that the shared memory
* segment is detached before the softpipe tile cache is flushed.
*/
use_shm = FALSE;
_eglLog(level, "use software%s fallback", (use_shm) ? " (SHM)" : "");
ndpy = x11_create_ximage_display(dpy, use_shm);
_eglLog(level, "use software fallback");
ndpy = x11_create_ximage_display(dpy);
}
return ndpy;

2
src/gallium/state_trackers/egl/x11/native_x11.h
View file

@ -29,7 +29,7 @@
#include "common/native.h"
struct native_display *
x11_create_ximage_display(EGLNativeDisplayType dpy, boolean use_xshm);
x11_create_ximage_display(EGLNativeDisplayType dpy);
struct native_display *
x11_create_dri2_display(EGLNativeDisplayType dpy, struct drm_api *api);

192
src/gallium/state_trackers/egl/x11/native_ximage.c
View file

@ -28,17 +28,15 @@
#include <sys/shm.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/extensions/XShm.h>
#include "util/u_memory.h"
#include "util/u_math.h"
#include "util/u_format.h"
#include "pipe/p_compiler.h"
#include "util/u_simple_screen.h"
#include "util/u_inlines.h"
#include "softpipe/sp_winsys.h"
#include "state_tracker/xlib_sw_winsys.h"
#include "egllog.h"
#include "sw_winsys.h"
#include "native_x11.h"
#include "x11_screen.h"
@ -56,19 +54,15 @@ struct ximage_display {
struct x11_screen *xscr;
int xscr_number;
boolean use_xshm;
struct xm_driver *driver;
struct pipe_winsys *winsys;
struct ximage_config *configs;
int num_configs;
};
struct ximage_buffer {
XImage *ximage;
struct pipe_texture *texture;
XShmSegmentInfo *shm_info;
boolean xshm_attached;
struct xlib_drawable xdraw;
};
struct ximage_surface {
@ -119,18 +113,6 @@ ximage_surface_free_buffer(struct native_surface *nsurf,
struct ximage_buffer *xbuf = &xsurf->buffers[which];
pipe_texture_reference(&xbuf->texture, NULL);
if (xbuf->shm_info) {
if (xbuf->xshm_attached)
XShmDetach(xsurf->xdpy->dpy, xbuf->shm_info);
if (xbuf->shm_info->shmaddr != (void *) -1)
shmdt(xbuf->shm_info->shmaddr);
if (xbuf->shm_info->shmid != -1)
shmctl(xbuf->shm_info->shmid, IPC_RMID, 0);
xbuf->shm_info->shmaddr = (void *) -1;
xbuf->shm_info->shmid = -1;
}
}
static boolean
@ -154,40 +136,26 @@ ximage_surface_alloc_buffer(struct native_surface *nsurf,
templ.depth0 = 1;
templ.tex_usage = PIPE_TEXTURE_USAGE_RENDER_TARGET;
if (xbuf->shm_info) {
struct pipe_buffer *pbuf;
unsigned stride, size;
void *addr = NULL;
stride = util_format_get_stride(xsurf->color_format, xsurf->width);
/* alignment should depend on visual? */
stride = align(stride, 4);
size = stride * xsurf->height;
/* create and attach shm object */
xbuf->shm_info->shmid = shmget(IPC_PRIVATE, size, 0755);
if (xbuf->shm_info->shmid != -1) {
xbuf->shm_info->shmaddr =
shmat(xbuf->shm_info->shmid, NULL, 0);
if (xbuf->shm_info->shmaddr != (void *) -1) {
if (XShmAttach(xsurf->xdpy->dpy, xbuf->shm_info)) {
addr = xbuf->shm_info->shmaddr;
xbuf->xshm_attached = TRUE;
}
}
}
if (addr) {
pbuf = screen->user_buffer_create(screen, addr, size);
if (pbuf) {
xbuf->texture =
screen->texture_blanket(screen, &templ, &stride, pbuf);
pipe_buffer_reference(&pbuf, NULL);
}
if (xsurf->type != XIMAGE_SURFACE_TYPE_PBUFFER) {
switch (which) {
case NATIVE_ATTACHMENT_FRONT_LEFT:
case NATIVE_ATTACHMENT_FRONT_RIGHT:
templ.tex_usage |= PIPE_TEXTURE_USAGE_PRIMARY;
break;
case NATIVE_ATTACHMENT_BACK_LEFT:
case NATIVE_ATTACHMENT_BACK_RIGHT:
templ.tex_usage |= PIPE_TEXTURE_USAGE_DISPLAY_TARGET;
break;
default:
break;
}
}
else {
xbuf->texture = screen->texture_create(screen, &templ);
xbuf->texture = screen->texture_create(screen, &templ);
if (xbuf->texture) {
xbuf->xdraw.visual = xsurf->visual.visual;
xbuf->xdraw.depth = xsurf->visual.depth;
xbuf->xdraw.drawable = xsurf->drawable;
xbuf->xdraw.gc = xsurf->gc;
}
/* clean up the buffer if allocation failed */
@ -257,18 +225,10 @@ ximage_surface_update_buffers(struct native_surface *nsurf, uint buffer_mask)
new_valid = 0x0;
for (att = 0; att < NUM_NATIVE_ATTACHMENTS; att++) {
if (native_attachment_mask_test(buffer_mask, att)) {
struct ximage_buffer *xbuf = &xsurf->buffers[att];
/* reallocate the texture */
if (!ximage_surface_alloc_buffer(&xsurf->base, att))
break;
/* update ximage */
if (xbuf->ximage) {
xbuf->ximage->width = xsurf->width;
xbuf->ximage->height = xsurf->height;
}
new_valid |= (1 << att);
if (buffer_mask == new_valid)
break;
@ -288,43 +248,22 @@ ximage_surface_draw_buffer(struct native_surface *nsurf,
struct ximage_surface *xsurf = ximage_surface(nsurf);
struct ximage_buffer *xbuf = &xsurf->buffers[which];
struct pipe_screen *screen = xsurf->xdpy->base.screen;
struct pipe_transfer *transfer;
struct pipe_surface *psurf;
if (xsurf->type == XIMAGE_SURFACE_TYPE_PBUFFER)
return TRUE;
assert(xsurf->drawable && xbuf->ximage && xbuf->texture);
assert(xsurf->drawable && xbuf->texture);
transfer = screen->get_tex_transfer(screen, xbuf->texture,
0, 0, 0, PIPE_TRANSFER_READ, 0, 0, xsurf->width, xsurf->height);
if (!transfer)
/* what's the cost of surface creation? */
psurf = screen->get_tex_surface(screen,
xbuf->texture, 0, 0, 0, PIPE_BUFFER_USAGE_CPU_READ);
if (!psurf)
return FALSE;
xbuf->ximage->bytes_per_line = transfer->stride;
xbuf->ximage->data = screen->transfer_map(screen, transfer);
if (!xbuf->ximage->data) {
screen->tex_transfer_destroy(transfer);
return FALSE;
}
screen->flush_frontbuffer(screen, psurf, &xbuf->xdraw);
if (xbuf->shm_info)
XShmPutImage(xsurf->xdpy->dpy, xsurf->drawable, xsurf->gc,
xbuf->ximage, 0, 0, 0, 0, xsurf->width, xsurf->height, False);
else
XPutImage(xsurf->xdpy->dpy, xsurf->drawable, xsurf->gc,
xbuf->ximage, 0, 0, 0, 0, xsurf->width, xsurf->height);
xbuf->ximage->data = NULL;
screen->transfer_unmap(screen, transfer);
/*
* softpipe allows the pipe transfer to be re-used, but we don't want to
* rely on that behavior.
*/
screen->tex_transfer_destroy(transfer);
XSync(xsurf->xdpy->dpy, FALSE);
pipe_surface_reference(&psurf, NULL);
return TRUE;
}
@ -351,20 +290,20 @@ ximage_surface_swap_buffers(struct native_surface *nsurf)
boolean ret;
/* display the back buffer first */
ret = ximage_surface_draw_buffer(nsurf, NATIVE_ATTACHMENT_BACK_LEFT);
ret = ximage_surface_draw_buffer(&xsurf->base,
NATIVE_ATTACHMENT_BACK_LEFT);
/* force buffers to be updated in next validation call */
xsurf->server_stamp++;
xfront = &xsurf->buffers[NATIVE_ATTACHMENT_FRONT_LEFT];
xback = &xsurf->buffers[NATIVE_ATTACHMENT_BACK_LEFT];
/* skip swapping so that the front buffer is allocated only when needed */
if (!xfront->texture)
return ret;
xtmp = *xfront;
*xfront = *xback;
*xback = xtmp;
/* skip swapping unless there is a front buffer */
if (xfront->texture) {
xtmp = *xfront;
*xfront = *xback;
*xback = xtmp;
}
return ret;
}
@ -419,15 +358,8 @@ ximage_surface_destroy(struct native_surface *nsurf)
struct ximage_surface *xsurf = ximage_surface(nsurf);
int i;
for (i = 0; i < NUM_NATIVE_ATTACHMENTS; i++) {
struct ximage_buffer *xbuf = &xsurf->buffers[i];
for (i = 0; i < NUM_NATIVE_ATTACHMENTS; i++)
ximage_surface_free_buffer(&xsurf->base, i);
/* xbuf->shm_info is owned by xbuf->ximage? */
if (xbuf->ximage) {
XDestroyImage(xbuf->ximage);
xbuf->ximage = NULL;
}
}
if (xsurf->type != XIMAGE_SURFACE_TYPE_PBUFFER)
XFreeGC(xsurf->xdpy->dpy, xsurf->gc);
@ -443,7 +375,6 @@ ximage_display_create_surface(struct native_display *ndpy,
struct ximage_display *xdpy = ximage_display(ndpy);
struct ximage_config *xconf = ximage_config(nconf);
struct ximage_surface *xsurf;
int i;
xsurf = CALLOC_STRUCT(ximage_surface);
if (!xsurf)
@ -466,43 +397,6 @@ ximage_display_create_surface(struct native_display *ndpy,
/* initialize the geometry */
ximage_surface_update_buffers(&xsurf->base, 0x0);
for (i = 0; i < NUM_NATIVE_ATTACHMENTS; i++) {
struct ximage_buffer *xbuf = &xsurf->buffers[i];
if (xdpy->use_xshm) {
xbuf->shm_info = calloc(1, sizeof(*xbuf->shm_info));
if (xbuf->shm_info) {
/* initialize shm info */
xbuf->shm_info->shmid = -1;
xbuf->shm_info->shmaddr = (void *) -1;
xbuf->shm_info->readOnly = TRUE;
xbuf->ximage = XShmCreateImage(xsurf->xdpy->dpy,
xsurf->visual.visual,
xsurf->visual.depth,
ZPixmap, NULL,
xbuf->shm_info,
0, 0);
}
}
else {
xbuf->ximage = XCreateImage(xsurf->xdpy->dpy,
xsurf->visual.visual,
xsurf->visual.depth,
ZPixmap, 0, /* format, offset */
NULL, /* data */
0, 0, /* size */
8, /* bitmap_pad */
0); /* bytes_per_line */
}
if (!xbuf->ximage) {
XFreeGC(xdpy->dpy, xsurf->gc);
free(xsurf);
return NULL;
}
}
}
xsurf->base.destroy = ximage_surface_destroy;
@ -694,7 +588,6 @@ ximage_display_destroy(struct native_display *ndpy)
free(xdpy->configs);
xdpy->base.screen->destroy(xdpy->base.screen);
free(xdpy->winsys);
x11_screen_destroy(xdpy->xscr);
if (xdpy->own_dpy)
@ -703,7 +596,7 @@ ximage_display_destroy(struct native_display *ndpy)
}
struct native_display *
x11_create_ximage_display(EGLNativeDisplayType dpy, boolean use_xshm)
x11_create_ximage_display(EGLNativeDisplayType dpy)
{
struct ximage_display *xdpy;
@ -728,11 +621,8 @@ x11_create_ximage_display(EGLNativeDisplayType dpy, boolean use_xshm)
return NULL;
}
xdpy->use_xshm =
(use_xshm && x11_screen_support(xdpy->xscr, X11_SCREEN_EXTENSION_XSHM));
xdpy->winsys = create_sw_winsys();
xdpy->base.screen = softpipe_create_screen(xdpy->winsys);
xdpy->driver = xlib_sw_winsys_init();
xdpy->base.screen = xdpy->driver->create_pipe_screen(xdpy->dpy);
xdpy->base.destroy = ximage_display_destroy;

231
src/gallium/state_trackers/egl/x11/sw_winsys.c
View file

@ -1,231 +0,0 @@
/**************************************************************************
*
* Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
* All Rights Reserved.
*
* 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, sub license, 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 (including the
* next paragraph) 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 NON-INFRINGEMENT.
* IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.
*
**************************************************************************/
/**
* Totally software-based winsys layer.
* Note that the one winsys function that we can't implement here
* is flush_frontbuffer().
* Whoever uses this code will have to provide that.
*
* Authors: Brian Paul
*/
#include "util/u_simple_screen.h"
#include "pipe/p_state.h"
#include "util/u_inlines.h"
#include "util/u_format.h"
#include "util/u_math.h"
#include "util/u_memory.h"
#include "sw_winsys.h"
/** Subclass of pipe_winsys */
struct sw_pipe_winsys
{
struct pipe_winsys Base;
/* no extra fields for now */
};
/** subclass of pipe_buffer */
struct sw_pipe_buffer
{
struct pipe_buffer Base;
boolean UserBuffer; /** Is this a user-space buffer? */
void *Data;
void *Mapped;
};
/** cast wrapper */
static INLINE struct sw_pipe_buffer *
sw_pipe_buffer(struct pipe_buffer *b)
{
return (struct sw_pipe_buffer *) b;
}
static const char *
get_name(struct pipe_winsys *pws)
{
return "software";
}
/** Create new pipe_buffer and allocate storage of given size */
static struct pipe_buffer *
buffer_create(struct pipe_winsys *pws,
unsigned alignment,
unsigned usage,
unsigned size)
{
struct sw_pipe_buffer *buffer = CALLOC_STRUCT(sw_pipe_buffer);
if (!buffer)
return NULL;
pipe_reference_init(&buffer->Base.reference, 1);
buffer->Base.alignment = alignment;
buffer->Base.usage = usage;
buffer->Base.size = size;
/* align to 16-byte multiple for Cell */
buffer->Data = align_malloc(size, MAX2(alignment, 16));
return &buffer->Base;
}
/**
* Create buffer which wraps user-space data.
*/
static struct pipe_buffer *
user_buffer_create(struct pipe_winsys *pws, void *ptr, unsigned bytes)
{
struct sw_pipe_buffer *buffer = CALLOC_STRUCT(sw_pipe_buffer);
if (!buffer)
return NULL;
pipe_reference_init(&buffer->Base.reference, 1);
buffer->Base.size = bytes;
buffer->UserBuffer = TRUE;
buffer->Data = ptr;
return &buffer->Base;
}
static void *
buffer_map(struct pipe_winsys *pws, struct pipe_buffer *buf, unsigned flags)
{
struct sw_pipe_buffer *buffer = sw_pipe_buffer(buf);
buffer->Mapped = buffer->Data;
return buffer->Mapped;
}
static void
buffer_unmap(struct pipe_winsys *pws, struct pipe_buffer *buf)
{
struct sw_pipe_buffer *buffer = sw_pipe_buffer(buf);
buffer->Mapped = NULL;
}
static void
buffer_destroy(struct pipe_buffer *buf)
{
struct sw_pipe_buffer *buffer = sw_pipe_buffer(buf);
if (buffer->Data && !buffer->UserBuffer) {
align_free(buffer->Data);
buffer->Data = NULL;
}
free(buffer);
}
static struct pipe_buffer *
surface_buffer_create(struct pipe_winsys *winsys,
unsigned width, unsigned height,
enum pipe_format format,
unsigned usage,
unsigned tex_usage,
unsigned *stride)
{
const unsigned alignment = 64;
unsigned nblocksy;
nblocksy = util_format_get_nblocksy(format, height);
*stride = align(util_format_get_stride(format, width), alignment);
return winsys->buffer_create(winsys, alignment,
usage,
*stride * nblocksy);
}
static void
fence_reference(struct pipe_winsys *sws, struct pipe_fence_handle **ptr,
struct pipe_fence_handle *fence)
{
/* no-op */
}
static int
fence_signalled(struct pipe_winsys *sws, struct pipe_fence_handle *fence,
unsigned flag)
{
/* no-op */
return 0;
}
static int
fence_finish(struct pipe_winsys *sws, struct pipe_fence_handle *fence,
unsigned flag)
{
/* no-op */
return 0;
}
/**
* Create/return a new pipe_winsys object.
*/
struct pipe_winsys *
create_sw_winsys(void)
{
struct sw_pipe_winsys *ws = CALLOC_STRUCT(sw_pipe_winsys);
if (!ws)
return NULL;
/* Fill in this struct with callbacks that pipe will need to
* communicate with the window system, buffer manager, etc.
*/
ws->Base.buffer_create = buffer_create;
ws->Base.user_buffer_create = user_buffer_create;
ws->Base.buffer_map = buffer_map;
ws->Base.buffer_unmap = buffer_unmap;
ws->Base.buffer_destroy = buffer_destroy;
ws->Base.surface_buffer_create = surface_buffer_create;
ws->Base.fence_reference = fence_reference;
ws->Base.fence_signalled = fence_signalled;
ws->Base.fence_finish = fence_finish;
ws->Base.flush_frontbuffer = NULL; /* not implemented here! */
ws->Base.get_name = get_name;
return &ws->Base;
}

40
src/gallium/state_trackers/egl/x11/sw_winsys.h
View file

@ -1,40 +0,0 @@
/**************************************************************************
*
* Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
* All Rights Reserved.
*
* 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, sub license, 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 (including the
* next paragraph) 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 NON-INFRINGEMENT.
* IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.
*
**************************************************************************/
#ifndef SW_WINSYS_H
#define SW_WINSYS_H
struct pipe_winsys;
extern struct pipe_winsys *
create_sw_winsys(void);
#endif /* SW_WINSYS_H */

3
src/gallium/winsys/drm/Makefile.egl
View file

@ -13,7 +13,8 @@ EGL_DRIVER_OBJECTS = $(EGL_DRIVER_SOURCES:.c=.o)
common_LIBS = -ldrm -lm -ldl
x11_ST = $(TOP)/src/gallium/state_trackers/egl/libeglx11.a
x11_ST = $(TOP)/src/gallium/state_trackers/egl/libeglx11.a \
$(TOP)/src/gallium/winsys/xlib/libws_xlib.a
x11_LIBS = $(common_LIBS) -lX11 -lXext -lXfixes
kms_ST = $(TOP)/src/gallium/state_trackers/egl/libeglkms.a