diff options
Diffstat (limited to 'src/gallium/state_trackers')
78 files changed, 2370 insertions, 778 deletions
diff --git a/src/gallium/state_trackers/Android.mk b/src/gallium/state_trackers/Android.mk index e0ae537505..65588694d6 100644 --- a/src/gallium/state_trackers/Android.mk +++ b/src/gallium/state_trackers/Android.mk @@ -28,6 +28,7 @@ LOCAL_C_INCLUDES := \ external/mesa/src/gallium/auxiliary \ external/mesa/src/egl/main \ external/mesa/src/gallium/state_trackers/egl \ + external/mesa/src/gallium/winsys \ external/mesa/src/gallium/winsys/sw \ external/mesa/src/gralloc \ external/drm \ diff --git a/src/gallium/state_trackers/d3d1x/dxgi/src/dxgi_native.cpp b/src/gallium/state_trackers/d3d1x/dxgi/src/dxgi_native.cpp index a54324a04f..741a97f897 100644 --- a/src/gallium/state_trackers/d3d1x/dxgi/src/dxgi_native.cpp +++ b/src/gallium/state_trackers/d3d1x/dxgi/src/dxgi_native.cpp @@ -256,11 +256,16 @@ struct GalliumDXGIAdapter { this->parent = factory; + /* FIXME handler should be static */ handler.invalid_surface = handle_invalid_surface; handler.new_drm_screen = dxgi_loader_create_drm_screen; handler.new_sw_screen = dxgi_loader_create_sw_screen; - display = platform->create_display(dpy, &handler, this); + platform->set_event_handler(&handler); + + display = platform->create_display(dpy, FALSE, this); if(!display) + display = platform->create_display(dpy, TRUE, this); + if(!display) throw E_FAIL; memset(&desc, 0, sizeof(desc)); std::string s = std::string("GalliumD3D on ") + display->screen->get_name(display->screen) + " by " + display->screen->get_vendor(display->screen); @@ -789,9 +794,9 @@ struct dxgi_blitter const unsigned semantic_indices[] = { 0, 0 }; vs = util_make_vertex_passthrough_shader(pipe, 2, semantic_names, semantic_indices); - vbuf.buffer = pipe_buffer_create(pipe->screen, PIPE_BIND_VERTEX_BUFFER, sizeof(quad_data)); + vbuf.buffer = pipe_buffer_create(pipe->screen, PIPE_BIND_VERTEX_BUFFER, + PIPE_USAGE_STREAM, sizeof(quad_data)); vbuf.buffer_offset = 0; - vbuf.max_index = ~0; vbuf.stride = 4 * sizeof(float); pipe_buffer_write(pipe, vbuf.buffer, 0, sizeof(quad_data), quad_data); @@ -1229,7 +1234,7 @@ struct GalliumDXGISwapChain : public GalliumDXGIObject<IDXGISwapChain, GalliumDX if(dst_surface) pipe->surface_destroy(pipe, dst_surface); - pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, 0); + pipe->flush(pipe, 0); att = (db) ? NATIVE_ATTACHMENT_BACK_LEFT : NATIVE_ATTACHMENT_FRONT_LEFT; if(!surface->present(surface, att, FALSE, 0)) diff --git a/src/gallium/state_trackers/d3d1x/gd3d11/d3d11_context.h b/src/gallium/state_trackers/d3d1x/gd3d11/d3d11_context.h index e1ba6c184f..12f2aaddc9 100644 --- a/src/gallium/state_trackers/d3d1x/gd3d11/d3d11_context.h +++ b/src/gallium/state_trackers/d3d1x/gd3d11/d3d11_context.h @@ -623,7 +623,6 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> vertex_buffers[start + i].buffer = buffer ? ((GalliumD3D11Buffer*)buffer)->resource : 0; vertex_buffers[start + i].buffer_offset = new_offsets[i]; vertex_buffers[start + i].stride = new_strides[i]; - vertex_buffers[start + i].max_index = ~0; last_different = i; } } @@ -1824,7 +1823,7 @@ changed: virtual void STDMETHODCALLTYPE Flush(void) { SYNCHRONIZED; - pipe->flush(pipe, PIPE_FLUSH_FRAME, 0); + pipe->flush(pipe, 0); } /* In Direct3D 10, if the reference count of an object drops to 0, it is automatically diff --git a/src/gallium/state_trackers/d3d1x/gd3d11/d3d11_screen.h b/src/gallium/state_trackers/d3d1x/gd3d11/d3d11_screen.h index 9cfdc837d8..f678ac7f73 100644 --- a/src/gallium/state_trackers/d3d1x/gd3d11/d3d11_screen.h +++ b/src/gallium/state_trackers/d3d1x/gd3d11/d3d11_screen.h @@ -299,25 +299,25 @@ struct GalliumD3D11ScreenImpl : public GalliumD3D11Screen sampler_view |= D3D11_FORMAT_SUPPORT_SHADER_SAMPLE_COMPARISON; /* TODO: do this properly when Gallium drivers actually support index/vertex format queries */ - if(screen->is_format_supported(screen, format, PIPE_BUFFER, 0, PIPE_BIND_VERTEX_BUFFER, 0) - || (screen->is_format_supported(screen, format, PIPE_BUFFER, 0, PIPE_BIND_INDEX_BUFFER, 0) + if(screen->is_format_supported(screen, format, PIPE_BUFFER, 0, PIPE_BIND_VERTEX_BUFFER) + || (screen->is_format_supported(screen, format, PIPE_BUFFER, 0, PIPE_BIND_INDEX_BUFFER) || format == PIPE_FORMAT_R8_UNORM)) support |= buffer; - if(screen->is_format_supported(screen, format, PIPE_BUFFER, 0, PIPE_BIND_STREAM_OUTPUT, 0)) + if(screen->is_format_supported(screen, format, PIPE_BUFFER, 0, PIPE_BIND_STREAM_OUTPUT)) support |= buffer | D3D11_FORMAT_SUPPORT_SO_BUFFER; - if(screen->is_format_supported(screen, format, PIPE_TEXTURE_1D, 0, PIPE_BIND_SAMPLER_VIEW, 0)) + if(screen->is_format_supported(screen, format, PIPE_TEXTURE_1D, 0, PIPE_BIND_SAMPLER_VIEW)) support |= D3D11_FORMAT_SUPPORT_TEXTURE1D | sampler_view; - if(screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0, PIPE_BIND_SAMPLER_VIEW, 0)) + if(screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0, PIPE_BIND_SAMPLER_VIEW)) support |= D3D11_FORMAT_SUPPORT_TEXTURE2D | sampler_view; - if(screen->is_format_supported(screen, format, PIPE_TEXTURE_CUBE, 0, PIPE_BIND_SAMPLER_VIEW, 0)) + if(screen->is_format_supported(screen, format, PIPE_TEXTURE_CUBE, 0, PIPE_BIND_SAMPLER_VIEW)) support |= D3D11_FORMAT_SUPPORT_TEXTURE2D | sampler_view; - if(screen->is_format_supported(screen, format, PIPE_TEXTURE_3D, 0, PIPE_BIND_SAMPLER_VIEW, 0)) + if(screen->is_format_supported(screen, format, PIPE_TEXTURE_3D, 0, PIPE_BIND_SAMPLER_VIEW)) support |= D3D11_FORMAT_SUPPORT_TEXTURE3D | sampler_view; - if(screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0, PIPE_BIND_RENDER_TARGET, 0)) + if(screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0, PIPE_BIND_RENDER_TARGET)) support |= D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_RENDER_TARGET | D3D11_FORMAT_SUPPORT_BLENDABLE; - if(screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0, PIPE_BIND_DEPTH_STENCIL, 0)) + if(screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0, PIPE_BIND_DEPTH_STENCIL)) support |= D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_DEPTH_STENCIL; - if(screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0, PIPE_BIND_DISPLAY_TARGET, 0)) + if(screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0, PIPE_BIND_DISPLAY_TARGET)) support |= D3D11_FORMAT_SUPPORT_DISPLAY; format_support[format] = support; } diff --git a/src/gallium/state_trackers/d3d1x/progs/bin/d3d10tri.exe b/src/gallium/state_trackers/d3d1x/progs/bin/d3d10tri.exe Binary files differdeleted file mode 100755 index 77ab03fcce..0000000000 --- a/src/gallium/state_trackers/d3d1x/progs/bin/d3d10tri.exe +++ /dev/null diff --git a/src/gallium/state_trackers/d3d1x/progs/bin/d3d11gears.exe b/src/gallium/state_trackers/d3d1x/progs/bin/d3d11gears.exe Binary files differdeleted file mode 100755 index c2cd296a40..0000000000 --- a/src/gallium/state_trackers/d3d1x/progs/bin/d3d11gears.exe +++ /dev/null diff --git a/src/gallium/state_trackers/d3d1x/progs/bin/d3d11spikysphere.exe b/src/gallium/state_trackers/d3d1x/progs/bin/d3d11spikysphere.exe Binary files differdeleted file mode 100755 index c3bc667fb3..0000000000 --- a/src/gallium/state_trackers/d3d1x/progs/bin/d3d11spikysphere.exe +++ /dev/null diff --git a/src/gallium/state_trackers/d3d1x/progs/bin/d3d11tex.exe b/src/gallium/state_trackers/d3d1x/progs/bin/d3d11tex.exe Binary files differdeleted file mode 100755 index 0be5cb8dd7..0000000000 --- a/src/gallium/state_trackers/d3d1x/progs/bin/d3d11tex.exe +++ /dev/null diff --git a/src/gallium/state_trackers/d3d1x/progs/bin/d3d11tri.exe b/src/gallium/state_trackers/d3d1x/progs/bin/d3d11tri.exe Binary files differdeleted file mode 100755 index abada5484b..0000000000 --- a/src/gallium/state_trackers/d3d1x/progs/bin/d3d11tri.exe +++ /dev/null diff --git a/src/gallium/state_trackers/dri/common/dri_context.c b/src/gallium/state_trackers/dri/common/dri_context.c index 3d5d24e692..e23c1bcafa 100644 --- a/src/gallium/state_trackers/dri/common/dri_context.c +++ b/src/gallium/state_trackers/dri/common/dri_context.c @@ -141,12 +141,18 @@ GLboolean dri_unbind_context(__DRIcontext * cPriv) { /* dri_util.c ensures cPriv is not null */ + struct dri_screen *screen = dri_screen(cPriv->driScreenPriv); struct dri_context *ctx = dri_context(cPriv); + struct dri_drawable *draw = dri_drawable(ctx->dPriv); + struct dri_drawable *read = dri_drawable(ctx->rPriv); + struct st_api *stapi = screen->st_api; if (--ctx->bind_count == 0) { if (ctx->st == ctx->stapi->get_current(ctx->stapi)) { - ctx->st->flush(ctx->st, PIPE_FLUSH_RENDER_CACHE, NULL); - ctx->stapi->make_current(ctx->stapi, NULL, NULL, NULL); + ctx->st->flush(ctx->st, ST_FLUSH_FRONT, NULL); + stapi->make_current(stapi, NULL, NULL, NULL); + draw->context = NULL; + read->context = NULL; } } @@ -165,21 +171,27 @@ dri_make_current(__DRIcontext * cPriv, struct st_context_iface *old_st = ctx->stapi->get_current(ctx->stapi); if (old_st && old_st != ctx->st) - old_st->flush(old_st, PIPE_FLUSH_RENDER_CACHE, NULL); + old_st->flush(old_st, ST_FLUSH_FRONT, NULL); ++ctx->bind_count; + if (!driDrawPriv && !driReadPriv) + return ctx->stapi->make_current(ctx->stapi, ctx->st, NULL, NULL); + else if (!driDrawPriv || !driReadPriv) + return GL_FALSE; + + draw->context = ctx; if (ctx->dPriv != driDrawPriv) { ctx->dPriv = driDrawPriv; draw->texture_stamp = driDrawPriv->lastStamp - 1; } + read->context = ctx; if (ctx->rPriv != driReadPriv) { ctx->rPriv = driReadPriv; read->texture_stamp = driReadPriv->lastStamp - 1; } - ctx->stapi->make_current(ctx->stapi, ctx->st, - (draw) ? &draw->base : NULL, (read) ? &read->base : NULL); + ctx->stapi->make_current(ctx->stapi, ctx->st, &draw->base, &read->base); return GL_TRUE; } diff --git a/src/gallium/state_trackers/dri/common/dri_drawable.c b/src/gallium/state_trackers/dri/common/dri_drawable.c index 5fd6e7863c..28a33ac7d0 100644 --- a/src/gallium/state_trackers/dri/common/dri_drawable.c +++ b/src/gallium/state_trackers/dri/common/dri_drawable.c @@ -132,6 +132,7 @@ dri_create_buffer(__DRIscreen * sPriv, drawable->base.validate = dri_st_framebuffer_validate; drawable->base.st_manager_private = (void *) drawable; + drawable->screen = screen; drawable->sPriv = sPriv; drawable->dPriv = dPriv; dPriv->driverPrivate = (void *)drawable; @@ -233,6 +234,7 @@ const __DRItexBufferExtension driTexBufferExtension = { { __DRI_TEX_BUFFER, __DRI_TEX_BUFFER_VERSION }, dri_set_tex_buffer, dri_set_tex_buffer2, + NULL, }; /** diff --git a/src/gallium/state_trackers/dri/common/dri_drawable.h b/src/gallium/state_trackers/dri/common/dri_drawable.h index 2ff6b71329..7f1aa512ca 100644 --- a/src/gallium/state_trackers/dri/common/dri_drawable.h +++ b/src/gallium/state_trackers/dri/common/dri_drawable.h @@ -41,6 +41,9 @@ struct dri_drawable struct st_framebuffer_iface base; struct st_visual stvis; + struct dri_screen *screen; + struct dri_context *context; + /* dri */ __DRIdrawable *dPriv; __DRIscreen *sPriv; diff --git a/src/gallium/state_trackers/dri/common/dri_screen.c b/src/gallium/state_trackers/dri/common/dri_screen.c index f6e22c74b4..5931df993b 100644 --- a/src/gallium/state_trackers/dri/common/dri_screen.c +++ b/src/gallium/state_trackers/dri/common/dri_screen.c @@ -81,34 +81,34 @@ dri_fill_in_modes(struct dri_screen *screen, pf_x8z24 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z24X8_UNORM, PIPE_TEXTURE_2D, 0, - PIPE_BIND_DEPTH_STENCIL, 0); + PIPE_BIND_DEPTH_STENCIL); pf_z24x8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_X8Z24_UNORM, PIPE_TEXTURE_2D, 0, - PIPE_BIND_DEPTH_STENCIL, 0); + PIPE_BIND_DEPTH_STENCIL); pf_s8z24 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED, PIPE_TEXTURE_2D, 0, - PIPE_BIND_DEPTH_STENCIL, 0); + PIPE_BIND_DEPTH_STENCIL); pf_z24s8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM, PIPE_TEXTURE_2D, 0, - PIPE_BIND_DEPTH_STENCIL, 0); + PIPE_BIND_DEPTH_STENCIL); pf_a8r8g8b8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_B8G8R8A8_UNORM, PIPE_TEXTURE_2D, 0, - PIPE_BIND_RENDER_TARGET, 0); + PIPE_BIND_RENDER_TARGET); pf_x8r8g8b8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_B8G8R8X8_UNORM, PIPE_TEXTURE_2D, 0, - PIPE_BIND_RENDER_TARGET, 0); + PIPE_BIND_RENDER_TARGET); pf_r5g6b5 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_B5G6R5_UNORM, PIPE_TEXTURE_2D, 0, - PIPE_BIND_RENDER_TARGET, 0); + PIPE_BIND_RENDER_TARGET); /* We can only get a 16 or 32 bit depth buffer with getBuffersWithFormat */ if (dri_with_format(screen->sPriv)) { pf_z16 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z16_UNORM, PIPE_TEXTURE_2D, 0, - PIPE_BIND_DEPTH_STENCIL, 0); + PIPE_BIND_DEPTH_STENCIL); pf_z32 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z32_UNORM, PIPE_TEXTURE_2D, 0, - PIPE_BIND_DEPTH_STENCIL, 0); + PIPE_BIND_DEPTH_STENCIL); } else { pf_z16 = FALSE; pf_z32 = FALSE; @@ -142,7 +142,7 @@ dri_fill_in_modes(struct dri_screen *screen, for (i = 1; i < 5; i++) { if (p_screen->is_format_supported(p_screen, PIPE_FORMAT_B5G6R5_UNORM, PIPE_TEXTURE_2D, i*2, - PIPE_BIND_RENDER_TARGET, 0)) { + PIPE_BIND_RENDER_TARGET)) { msaa_samples_array[msaa_samples_factor] = i * 2; msaa_samples_factor++; } @@ -161,7 +161,7 @@ dri_fill_in_modes(struct dri_screen *screen, for (i = 1; i < 5; i++) { if (p_screen->is_format_supported(p_screen, PIPE_FORMAT_B8G8R8A8_UNORM, PIPE_TEXTURE_2D, i*2, - PIPE_BIND_RENDER_TARGET, 0)) { + PIPE_BIND_RENDER_TARGET)) { msaa_samples_array[msaa_samples_factor] = i * 2; msaa_samples_factor++; } @@ -183,7 +183,7 @@ dri_fill_in_modes(struct dri_screen *screen, for (i = 1; i < 5; i++) { if (p_screen->is_format_supported(p_screen, PIPE_FORMAT_B8G8R8X8_UNORM, PIPE_TEXTURE_2D, i*2, - PIPE_BIND_RENDER_TARGET, 0)) { + PIPE_BIND_RENDER_TARGET)) { msaa_samples_array[msaa_samples_factor] = i * 2; msaa_samples_factor++; } @@ -235,7 +235,6 @@ dri_fill_st_visual(struct st_visual *stvis, struct dri_screen *screen, return; stvis->samples = mode->samples; - stvis->render_buffer = ST_ATTACHMENT_INVALID; if (mode->redBits == 8) { if (mode->alphaBits == 8) @@ -274,8 +273,11 @@ dri_fill_st_visual(struct st_visual *stvis, struct dri_screen *screen, PIPE_FORMAT_R16G16B16A16_SNORM : PIPE_FORMAT_NONE; stvis->buffer_mask |= ST_ATTACHMENT_FRONT_LEFT_MASK; - if (mode->doubleBufferMode) + stvis->render_buffer = ST_ATTACHMENT_FRONT_LEFT; + if (mode->doubleBufferMode) { stvis->buffer_mask |= ST_ATTACHMENT_BACK_LEFT_MASK; + stvis->render_buffer = ST_ATTACHMENT_BACK_LEFT; + } if (mode->stereoMode) { stvis->buffer_mask |= ST_ATTACHMENT_FRONT_RIGHT_MASK; if (mode->doubleBufferMode) diff --git a/src/gallium/state_trackers/dri/drm/dri2.c b/src/gallium/state_trackers/dri/drm/dri2.c index a9d05a80fb..30326a23d6 100644 --- a/src/gallium/state_trackers/dri/drm/dri2.c +++ b/src/gallium/state_trackers/dri/drm/dri2.c @@ -38,6 +38,7 @@ #include "dri_screen.h" #include "dri_context.h" #include "dri_drawable.h" +#include "dri2_buffer.h" /** * DRI2 flush extension. @@ -51,7 +52,7 @@ static void dri2_invalidate_drawable(__DRIdrawable *dPriv) { struct dri_drawable *drawable = dri_drawable(dPriv); - struct dri_context *ctx = dri_context(dPriv->driContextPriv); + struct dri_context *ctx = drawable->context; dri2InvalidateDrawable(dPriv); drawable->dPriv->lastStamp = *drawable->dPriv->pStamp; @@ -259,6 +260,92 @@ dri2_drawable_process_buffers(struct dri_drawable *drawable, memcpy(drawable->old, buffers, sizeof(__DRIbuffer) * count); } +static __DRIbuffer * +dri2_allocate_buffer(__DRIscreen *sPriv, + unsigned attachment, unsigned format, + int width, int height) +{ + struct dri_screen *screen = dri_screen(sPriv); + struct dri2_buffer *buffer; + struct pipe_resource templ; + enum st_attachment_type statt; + enum pipe_format pf; + unsigned bind = 0; + struct winsys_handle whandle; + + switch (attachment) { + case __DRI_BUFFER_FRONT_LEFT: + case __DRI_BUFFER_FAKE_FRONT_LEFT: + statt = ST_ATTACHMENT_FRONT_LEFT; + bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW; + break; + case __DRI_BUFFER_BACK_LEFT: + statt = ST_ATTACHMENT_BACK_LEFT; + bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW; + break; + case __DRI_BUFFER_DEPTH: + case __DRI_BUFFER_DEPTH_STENCIL: + case __DRI_BUFFER_STENCIL: + statt = ST_ATTACHMENT_DEPTH_STENCIL; + bind = PIPE_BIND_DEPTH_STENCIL; /* XXX sampler? */ + break; + default: + statt = ST_ATTACHMENT_INVALID; + break; + } + + switch (format) { + case 32: + pf = PIPE_FORMAT_B8G8R8X8_UNORM; + break; + case 16: + pf = PIPE_FORMAT_Z16_UNORM; + break; + default: + return NULL; + } + + buffer = CALLOC_STRUCT(dri2_buffer); + if (!buffer) + return NULL; + + memset(&templ, 0, sizeof(templ)); + templ.bind = bind; + templ.format = pf; + templ.target = PIPE_TEXTURE_2D; + templ.last_level = 0; + templ.width0 = width; + templ.height0 = height; + templ.depth0 = 1; + templ.array_size = 1; + + buffer->resource = + screen->base.screen->resource_create(screen->base.screen, &templ); + if (!buffer->resource) + return NULL; + + memset(&whandle, 0, sizeof(whandle)); + whandle.type = DRM_API_HANDLE_TYPE_SHARED; + screen->base.screen->resource_get_handle(screen->base.screen, + buffer->resource, &whandle); + + buffer->base.attachment = attachment; + buffer->base.name = whandle.handle; + buffer->base.cpp = util_format_get_blocksize(pf); + buffer->base.pitch = whandle.stride; + + return &buffer->base; +} + +static void +dri2_release_buffer(__DRIscreen *sPriv, __DRIbuffer *bPriv) +{ + struct dri2_buffer *buffer = dri2_buffer(bPriv); + + pipe_resource_reference(&buffer->resource, NULL); + FREE(buffer); +} + /* * Backend functions for st_framebuffer interface. */ @@ -373,7 +460,7 @@ static __DRIimage * dri2_create_image_from_renderbuffer(__DRIcontext *context, int renderbuffer, void *loaderPrivate) { - struct dri_context *ctx = dri_context(context->driverPrivate); + struct dri_context *ctx = dri_context(context); if (!ctx->st->get_resource_for_egl_image) return NULL; @@ -424,6 +511,7 @@ dri2_create_image(__DRIscreen *_screen, templ.width0 = width; templ.height0 = height; templ.depth0 = 1; + templ.array_size = 1; img->texture = screen->base.screen->resource_create(screen->base.screen, &templ); if (!img->texture) { @@ -601,6 +689,9 @@ const struct __DriverAPIRec driDriverAPI = { .SwapBuffers = NULL, .CopySubBuffer = NULL, + + .AllocateBuffer = dri2_allocate_buffer, + .ReleaseBuffer = dri2_release_buffer, }; /* This is the table of extensions that the loader will dlsym() for. */ diff --git a/src/gallium/state_trackers/dri/drm/dri2_buffer.h b/src/gallium/state_trackers/dri/drm/dri2_buffer.h new file mode 100644 index 0000000000..1cd8dbbda2 --- /dev/null +++ b/src/gallium/state_trackers/dri/drm/dri2_buffer.h @@ -0,0 +1,22 @@ +#ifndef DRI2_BUFFER_H +#define DRI2_BUFFER_H + +#include "dri_wrapper.h" + +struct pipe_surface; + +struct dri2_buffer +{ + __DRIbuffer base; + struct pipe_resource *resource; +}; + +static INLINE struct dri2_buffer * +dri2_buffer(__DRIbuffer * driBufferPriv) +{ + return (struct dri2_buffer *) driBufferPriv; +} + +#endif + +/* vim: set sw=3 ts=8 sts=3 expandtab: */ diff --git a/src/gallium/state_trackers/dri/sw/drisw.c b/src/gallium/state_trackers/dri/sw/drisw.c index 30088b0968..ac11f7c47f 100644 --- a/src/gallium/state_trackers/dri/sw/drisw.c +++ b/src/gallium/state_trackers/dri/sw/drisw.c @@ -139,7 +139,7 @@ drisw_swap_buffers(__DRIdrawable *dPriv) ptex = drawable->textures[ST_ATTACHMENT_BACK_LEFT]; if (ptex) { - ctx->st->flush(ctx->st, PIPE_FLUSH_RENDER_CACHE, NULL); + ctx->st->flush(ctx->st, ST_FLUSH_FRONT, NULL); drisw_copy_to_front(dPriv, ptex); } @@ -233,6 +233,7 @@ drisw_allocate_textures(struct dri_drawable *drawable, */ static const __DRIextension *drisw_screen_extensions[] = { + &driTexBufferExtension.base, NULL }; diff --git a/src/gallium/state_trackers/egl/Makefile b/src/gallium/state_trackers/egl/Makefile index 8cfcef968e..53673a78a9 100644 --- a/src/gallium/state_trackers/egl/Makefile +++ b/src/gallium/state_trackers/egl/Makefile @@ -23,6 +23,14 @@ x11_SOURCES = $(wildcard x11/*.c) \ $(TOP)/src/glx/dri2.c x11_OBJECTS = $(x11_SOURCES:.c=.o) +wayland_INCLUDES = \ + -I$(TOP)/src/gallium/winsys \ + -I$(TOP)/src/egl/wayland/wayland-egl \ + -I$(TOP)/src/egl/wayland/wayland-drm \ + $(shell pkg-config --cflags-only-I libdrm wayland-client) + +wayland_SOURCES = $(wildcard wayland/*.c) +wayland_OBJECTS = $(wayland_SOURCES:.c=.o) drm_INCLUDES = -I$(TOP)/src/gallium/winsys $(shell pkg-config --cflags-only-I libdrm) drm_SOURCES = $(wildcard drm/*.c) @@ -45,6 +53,10 @@ ifneq ($(findstring x11, $(EGL_PLATFORMS)),) EGL_OBJECTS += $(x11_OBJECTS) EGL_CPPFLAGS += -DHAVE_X11_BACKEND endif +ifneq ($(findstring wayland, $(EGL_PLATFORMS)),) +EGL_OBJECTS += $(wayland_OBJECTS) +EGL_CPPFLAGS += -DHAVE_WAYLAND_BACKEND +endif ifneq ($(findstring drm, $(EGL_PLATFORMS)),) EGL_OBJECTS += $(drm_OBJECTS) EGL_CPPFLAGS += -DHAVE_DRM_BACKEND @@ -87,6 +99,9 @@ $(common_OBJECTS): %.o: %.c $(x11_OBJECTS): %.o: %.c $(call egl-cc,x11) +$(wayland_OBJECTS): %.o: %.c + $(call egl-cc,wayland) + $(drm_OBJECTS): %.o: %.c $(call egl-cc,drm) diff --git a/src/gallium/state_trackers/egl/SConscript b/src/gallium/state_trackers/egl/SConscript index 50c7681995..9ade76ecbb 100644 --- a/src/gallium/state_trackers/egl/SConscript +++ b/src/gallium/state_trackers/egl/SConscript @@ -10,11 +10,8 @@ env.Append(CPPPATH = [ '#/src/gallium/winsys/sw', '.', ]) -env.Append(CPPDEFINES = [ - 'HAVE_GDI_BACKEND', -]) -common_sources = [ +sources = [ 'common/egl_g3d.c', 'common/egl_g3d_api.c', 'common/egl_g3d_image.c', @@ -23,12 +20,31 @@ common_sources = [ 'common/native_helper.c', ] -gdi_sources = common_sources + [ - 'gdi/native_gdi.c', -] +if env['platform'] == 'windows': + env.Append(CPPDEFINES = ['HAVE_GDI_BACKEND']) + sources.append('gdi/native_gdi.c') +else: + if env['x11']: + env.Append(CPPDEFINES = ['HAVE_X11_BACKEND']) + env.Prepend(CPPPATH = [ + '#/src/glx', + '#/src/mapi', + ]) + sources.append([ + 'x11/native_x11.c', + 'x11/native_dri2.c', + 'x11/native_ximage.c', + 'x11/x11_screen.c', + 'x11/glxinit.c']) + if env['dri']: + env.Append(CPPDEFINES = ['GLX_DIRECT_RENDERING']) + sources.append(['#/src/glx/dri2.c']) + if env['drm']: + env.Append(CPPDEFINES = ['HAVE_DRM_BACKEND']) + sources.append(['drm/native_drm.c', 'drm/modeset.c']) -st_egl_gdi = env.ConvenienceLibrary( - target = 'st_egl_gdi', - source = gdi_sources, +st_egl = env.ConvenienceLibrary( + target = 'st_egl', + source = sources, ) -Export('st_egl_gdi') +Export('st_egl') diff --git a/src/gallium/state_trackers/egl/android/native_android.cpp b/src/gallium/state_trackers/egl/android/native_android.cpp index 450eae3868..a584d54db4 100644 --- a/src/gallium/state_trackers/egl/android/native_android.cpp +++ b/src/gallium/state_trackers/egl/android/native_android.cpp @@ -34,7 +34,13 @@ extern "C" { #include "egllog.h" + +/* see get_drm_screen_name */ +#include <xf86drm.h> +#include <radeon_drm.h> +#include "radeon/drm/radeon_drm_public.h" } + #include "util/u_memory.h" #include "util/u_inlines.h" #include "util/u_format.h" @@ -157,12 +163,12 @@ import_buffer(struct android_display *adpy, const struct pipe_resource *templ, if (templ->bind & PIPE_BIND_RENDER_TARGET) { if (!screen->is_format_supported(screen, templ->format, - templ->target, 0, PIPE_BIND_RENDER_TARGET, 0)) + templ->target, 0, PIPE_BIND_RENDER_TARGET)) LOGW("importing unsupported buffer as render target"); } if (templ->bind & PIPE_BIND_SAMPLER_VIEW) { if (!screen->is_format_supported(screen, templ->format, - templ->target, 0, PIPE_BIND_SAMPLER_VIEW, 0)) + templ->target, 0, PIPE_BIND_SAMPLER_VIEW)) LOGW("importing unsupported buffer as sampler view"); } @@ -399,7 +405,7 @@ android_display_create_window_surface(struct native_display *ndpy, LOGW("native window format 0x%x != config format 0x%x", format, nconf->color_format); if (!adpy->base.screen->is_format_supported(adpy->base.screen, - format, PIPE_TEXTURE_2D, 0, PIPE_BIND_RENDER_TARGET, 0)) { + format, PIPE_TEXTURE_2D, 0, PIPE_BIND_RENDER_TARGET)) { LOGE("and the native window cannot be used as a render target"); return NULL; } @@ -452,7 +458,7 @@ android_display_init_configs(struct native_display *ndpy) color_format = get_pipe_format(native_formats[i]); if (color_format == PIPE_FORMAT_NONE || !adpy->base.screen->is_format_supported(adpy->base.screen, - color_format, PIPE_TEXTURE_2D, 0, PIPE_BIND_RENDER_TARGET, 0)) { + color_format, PIPE_TEXTURE_2D, 0, PIPE_BIND_RENDER_TARGET)) { LOGI("skip unsupported native format 0x%x", native_formats[i]); continue; } @@ -461,8 +467,6 @@ android_display_init_configs(struct native_display *ndpy) aconf->base.buffer_mask = 1 << NATIVE_ATTACHMENT_BACK_LEFT; aconf->base.color_format = color_format; aconf->base.window_bit = TRUE; - if (!adpy->use_drm) - aconf->base.slow_config = TRUE; aconf->base.native_visual_type = native_formats[i]; } @@ -470,66 +474,94 @@ android_display_init_configs(struct native_display *ndpy) return TRUE; } +static const char * +get_drm_screen_name(int fd, drmVersionPtr version) +{ + const char *name = version->name; + + if (name && !strcmp(name, "radeon")) { + int chip_id; + struct drm_radeon_info info; + + memset(&info, 0, sizeof(info)); + info.request = RADEON_INFO_DEVICE_ID; + info.value = pointer_to_intptr(&chip_id); + if (drmCommandWriteRead(fd, DRM_RADEON_INFO, &info, sizeof(info)) != 0) + return NULL; + + name = is_r3xx(chip_id) ? "r300" : "r600"; + } + + return name; +} + static boolean -android_display_init(struct native_display *ndpy) +android_display_init_drm(struct native_display *ndpy) { struct android_display *adpy = android_display(ndpy); const hw_module_t *mod; int fd, err; - boolean force_sw; - char value[PROPERTY_VALUE_MAX]; - - if (property_get("debug.mesa.software", value, NULL)) - force_sw = (atoi(value) != 0); - else - force_sw = debug_get_bool_option("EGL_SOFTWARE", FALSE); - /* try DRM first */ - if (!force_sw) { - err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &mod); - if (!err) { - const gralloc_module_t *gr = (gralloc_module_t *) mod; + err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &mod); + if (!err) { + const gralloc_module_t *gr = (gralloc_module_t *) mod; - err = -EINVAL; - if (gr->perform) - err = gr->perform(gr, GRALLOC_MODULE_PERFORM_GET_DRM_FD, &fd); + err = -EINVAL; + if (gr->perform) + err = gr->perform(gr, GRALLOC_MODULE_PERFORM_GET_DRM_FD, &fd); + } + if (!err && fd >= 0) { + drmVersionPtr version; + const char *name; + + version = drmGetVersion(fd); + if (version) { + name = get_drm_screen_name(fd, version); + if (name) { + adpy->base.screen = + adpy->event_handler->new_drm_screen(&adpy->base, name, fd); + } + drmFreeVersion(version); } - if (!err && fd >= 0) { - adpy->base.screen = - adpy->event_handler->new_drm_screen(&adpy->base, "i915", fd); - if (adpy->base.screen) - adpy->use_drm = TRUE; + else { + _eglLog(_EGL_WARNING, "invalid fd %d", fd); + err = -EINVAL; } if (adpy->base.screen) - LOGI("using DRM screen"); - else - LOGE("failed to create DRM screen"); + adpy->use_drm = TRUE; } - /* try SW screen */ - if (!adpy->base.screen) { - struct sw_winsys *ws = android_create_sw_winsys(); + if (adpy->base.screen) { + LOGI("using DRM screen"); + return TRUE; + } + else { + LOGE("failed to create DRM screen"); + return FALSE; + } +} - if (ws) { - adpy->base.screen = - adpy->event_handler->new_sw_screen(&adpy->base, ws); - } +static boolean +android_display_init_sw(struct native_display *ndpy) +{ + struct android_display *adpy = android_display(ndpy); + struct sw_winsys *ws; - if (adpy->base.screen) - LOGI("using SW screen"); - else - LOGE("failed to create SW screen"); + ws = android_create_sw_winsys(); + if (ws) { + adpy->base.screen = + adpy->event_handler->new_sw_screen(&adpy->base, ws); } if (adpy->base.screen) { - if (!android_display_init_configs(&adpy->base)) { - adpy->base.screen->destroy(adpy->base.screen); - adpy->base.screen = NULL; - } + LOGI("using SW screen"); + return TRUE; + } + else { + LOGE("failed to create SW screen"); + return FALSE; } - - return (adpy->base.screen != NULL); } static void @@ -603,9 +635,11 @@ static struct native_display_buffer android_display_buffer = { static struct android_display * android_display_create(struct native_event_handler *event_handler, - void *user_data) + boolean use_sw, void *user_data) { struct android_display *adpy; + char value[PROPERTY_VALUE_MAX]; + boolean force_sw; adpy = CALLOC_STRUCT(android_display); if (!adpy) @@ -614,7 +648,23 @@ android_display_create(struct native_event_handler *event_handler, adpy->event_handler = event_handler; adpy->base.user_data = user_data; - if (!android_display_init(&adpy->base)) { + if (property_get("debug.mesa.software", value, NULL)) + force_sw = (atoi(value) != 0); + else + force_sw = debug_get_bool_option("EGL_SOFTWARE", FALSE); + + if (force_sw || use_sw) + android_display_init_sw(&adpy->base); + else + android_display_init_drm(&adpy->base); + + if (!adpy->base.screen) { + FREE(adpy); + return NULL; + } + + if (!android_display_init_configs(&adpy->base)) { + adpy->base.screen->destroy(adpy->base.screen); FREE(adpy); return NULL; } @@ -629,19 +679,27 @@ android_display_create(struct native_event_handler *event_handler, return adpy; } +static struct native_event_handler *android_event_handler; + +static void +native_set_event_handler(struct native_event_handler *event_handler) +{ + android_event_handler = event_handler; +} + static struct native_display * -native_create_display(void *dpy, struct native_event_handler *event_handler, - void *user_data) +native_create_display(void *dpy, boolean use_sw, void *user_data) { struct android_display *adpy; - adpy = android_display_create(event_handler, user_data); + adpy = android_display_create(android_event_handler, use_sw, user_data); return (adpy) ? &adpy->base : NULL; } static const struct native_platform android_platform = { "Android", /* name */ + native_set_event_handler, native_create_display }; diff --git a/src/gallium/state_trackers/egl/common/egl_g3d.c b/src/gallium/state_trackers/egl/common/egl_g3d.c index 604091aac0..e455167473 100644 --- a/src/gallium/state_trackers/egl/common/egl_g3d.c +++ b/src/gallium/state_trackers/egl/common/egl_g3d.c @@ -38,6 +38,46 @@ #include "egl_g3d_loader.h" #include "native.h" +static void +egl_g3d_invalid_surface(struct native_display *ndpy, + struct native_surface *nsurf, + unsigned int seq_num) +{ + /* XXX not thread safe? */ + struct egl_g3d_surface *gsurf = egl_g3d_surface(nsurf->user_data); + struct egl_g3d_context *gctx; + + /* + * Some functions such as egl_g3d_copy_buffers create a temporary native + * surface. There is no gsurf associated with it. + */ + gctx = (gsurf) ? egl_g3d_context(gsurf->base.CurrentContext) : NULL; + if (gctx) + gctx->stctxi->notify_invalid_framebuffer(gctx->stctxi, gsurf->stfbi); +} + +static struct pipe_screen * +egl_g3d_new_drm_screen(struct native_display *ndpy, const char *name, int fd) +{ + _EGLDisplay *dpy = (_EGLDisplay *) ndpy->user_data; + struct egl_g3d_display *gdpy = egl_g3d_display(dpy); + return gdpy->loader->create_drm_screen(name, fd); +} + +static struct pipe_screen * +egl_g3d_new_sw_screen(struct native_display *ndpy, struct sw_winsys *ws) +{ + _EGLDisplay *dpy = (_EGLDisplay *) ndpy->user_data; + struct egl_g3d_display *gdpy = egl_g3d_display(dpy); + return gdpy->loader->create_sw_screen(ws); +} + +static struct native_event_handler egl_g3d_native_event_handler = { + egl_g3d_invalid_surface, + egl_g3d_new_drm_screen, + egl_g3d_new_sw_screen +}; + /** * Get the native platform. */ @@ -62,6 +102,12 @@ egl_g3d_get_platform(_EGLDriver *drv, _EGLPlatformType plat) #ifdef HAVE_X11_BACKEND nplat = native_get_x11_platform(); #endif + break; + case _EGL_PLATFORM_WAYLAND: + plat_name = "wayland"; +#ifdef HAVE_WAYLAND_BACKEND + nplat = native_get_wayland_platform(); +#endif break; case _EGL_PLATFORM_DRM: plat_name = "DRM"; @@ -85,7 +131,9 @@ egl_g3d_get_platform(_EGLDriver *drv, _EGLPlatformType plat) break; } - if (!nplat) + if (nplat) + nplat->set_event_handler(&egl_g3d_native_event_handler); + else _eglLog(_EGL_WARNING, "unsupported platform %s", plat_name); gdrv->platforms[plat] = nplat; @@ -189,17 +237,21 @@ init_config_attributes(_EGLConfig *conf, const struct native_config *nconf, } surface_type = 0x0; - if (nconf->window_bit) - surface_type |= EGL_WINDOW_BIT; - if (nconf->pixmap_bit) - surface_type |= EGL_PIXMAP_BIT; + /* pixmap surfaces should be EGL_SINGLE_BUFFER */ + if (nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_FRONT_LEFT)) { + if (nconf->pixmap_bit) + surface_type |= EGL_PIXMAP_BIT; + } + /* the others surfaces should be EGL_BACK_BUFFER (or settable) */ + if (nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_BACK_LEFT)) { + if (nconf->window_bit) + surface_type |= EGL_WINDOW_BIT; #ifdef EGL_MESA_screen_surface - if (nconf->scanout_bit) - surface_type |= EGL_SCREEN_BIT_MESA; + if (nconf->scanout_bit) + surface_type |= EGL_SCREEN_BIT_MESA; #endif - - if (nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_BACK_LEFT)) surface_type |= EGL_PBUFFER_BIT; + } conf->Conformant = api_mask; conf->RenderableType = api_mask; @@ -232,11 +284,6 @@ init_config_attributes(_EGLConfig *conf, const struct native_config *nconf, } conf->Level = nconf->level; - conf->Samples = nconf->samples; - conf->SampleBuffers = 0; - - if (nconf->slow_config) - conf->ConfigCaveat = EGL_SLOW_CONFIG; if (nconf->transparent_rgb) { conf->TransparentType = EGL_TRANSPARENT_RGB; @@ -263,13 +310,9 @@ egl_g3d_init_config(_EGLDriver *drv, _EGLDisplay *dpy, int preserve_buffer, int max_swap_interval) { struct egl_g3d_config *gconf = egl_g3d_config(conf); - EGLint buffer_mask, api_mask; + EGLint buffer_mask; EGLBoolean valid; - /* skip single-buffered configs */ - if (!(nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_BACK_LEFT))) - return EGL_FALSE; - buffer_mask = 0x0; if (nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_FRONT_LEFT)) buffer_mask |= ST_ATTACHMENT_FRONT_LEFT_MASK; @@ -284,24 +327,14 @@ egl_g3d_init_config(_EGLDriver *drv, _EGLDisplay *dpy, gconf->stvis.color_format = nconf->color_format; gconf->stvis.depth_stencil_format = depth_stencil_format; gconf->stvis.accum_format = PIPE_FORMAT_NONE; - gconf->stvis.samples = nconf->samples; + gconf->stvis.samples = 0; + /* will be overridden per surface */ gconf->stvis.render_buffer = (buffer_mask & ST_ATTACHMENT_BACK_LEFT_MASK) ? ST_ATTACHMENT_BACK_LEFT : ST_ATTACHMENT_FRONT_LEFT; - api_mask = dpy->ClientAPIsMask; - /* this is required by EGL, not by OpenGL ES */ - if (nconf->window_bit && - gconf->stvis.render_buffer != ST_ATTACHMENT_BACK_LEFT) - api_mask &= ~(EGL_OPENGL_ES_BIT | EGL_OPENGL_ES2_BIT); - - if (!api_mask) { - _eglLog(_EGL_DEBUG, "no state tracker supports config 0x%x", - nconf->native_visual_id); - } - valid = init_config_attributes(&gconf->base, - nconf, api_mask, depth_stencil_format, + nconf, dpy->ClientAPIs, depth_stencil_format, preserve_buffer, max_swap_interval); if (!valid) { _eglLog(_EGL_DEBUG, "skip invalid config 0x%x", nconf->native_visual_id); @@ -341,7 +374,7 @@ egl_g3d_fill_depth_stencil_formats(_EGLDisplay *dpy, /* pick the first supported format */ for (i = 0; i < n; i++) { if (screen->is_format_supported(screen, fmt[i], - PIPE_TEXTURE_2D, 0, PIPE_BIND_DEPTH_STENCIL, 0)) { + PIPE_TEXTURE_2D, 0, PIPE_BIND_DEPTH_STENCIL)) { formats[count++] = fmt[i]; break; } @@ -405,46 +438,6 @@ egl_g3d_add_configs(_EGLDriver *drv, _EGLDisplay *dpy, EGLint id) } static void -egl_g3d_invalid_surface(struct native_display *ndpy, - struct native_surface *nsurf, - unsigned int seq_num) -{ - /* XXX not thread safe? */ - struct egl_g3d_surface *gsurf = egl_g3d_surface(nsurf->user_data); - struct egl_g3d_context *gctx; - - /* - * Some functions such as egl_g3d_copy_buffers create a temporary native - * surface. There is no gsurf associated with it. - */ - gctx = (gsurf) ? egl_g3d_context(gsurf->base.CurrentContext) : NULL; - if (gctx) - gctx->stctxi->notify_invalid_framebuffer(gctx->stctxi, gsurf->stfbi); -} - -static struct pipe_screen * -egl_g3d_new_drm_screen(struct native_display *ndpy, const char *name, int fd) -{ - _EGLDisplay *dpy = (_EGLDisplay *) ndpy->user_data; - struct egl_g3d_display *gdpy = egl_g3d_display(dpy); - return gdpy->loader->create_drm_screen(name, fd); -} - -static struct pipe_screen * -egl_g3d_new_sw_screen(struct native_display *ndpy, struct sw_winsys *ws) -{ - _EGLDisplay *dpy = (_EGLDisplay *) ndpy->user_data; - struct egl_g3d_display *gdpy = egl_g3d_display(dpy); - return gdpy->loader->create_sw_screen(ws); -} - -static struct native_event_handler egl_g3d_native_event_handler = { - egl_g3d_invalid_surface, - egl_g3d_new_drm_screen, - egl_g3d_new_sw_screen -}; - -static void egl_g3d_free_config(void *conf) { struct egl_g3d_config *gconf = egl_g3d_config((_EGLConfig *) conf); @@ -468,9 +461,6 @@ egl_g3d_terminate(_EGLDriver *drv, _EGLDisplay *dpy) _eglReleaseDisplayResources(drv, dpy); - if (gdpy->pipe) - gdpy->pipe->destroy(gdpy->pipe); - if (dpy->Configs) { _eglDestroyArray(dpy->Configs, egl_g3d_free_config); dpy->Configs = NULL; @@ -495,8 +485,7 @@ egl_g3d_terminate(_EGLDriver *drv, _EGLDisplay *dpy) } static EGLBoolean -egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy, - EGLint *major, EGLint *minor) +egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy) { struct egl_g3d_driver *gdrv = egl_g3d_driver(drv); struct egl_g3d_display *gdpy; @@ -506,6 +495,9 @@ egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy, if (!nplat) return EGL_FALSE; + if (dpy->Options.TestOnly) + return EGL_TRUE; + gdpy = CALLOC_STRUCT(egl_g3d_display); if (!gdpy) { _eglError(EGL_BAD_ALLOC, "eglInitialize"); @@ -516,20 +508,20 @@ egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy, _eglLog(_EGL_INFO, "use %s for display %p", nplat->name, dpy->PlatformDisplay); gdpy->native = nplat->create_display(dpy->PlatformDisplay, - &egl_g3d_native_event_handler, (void *) dpy); + dpy->Options.UseFallback, (void *) dpy); if (!gdpy->native) { _eglError(EGL_NOT_INITIALIZED, "eglInitialize(no usable display)"); goto fail; } if (gdpy->loader->profile_masks[ST_API_OPENGL] & ST_PROFILE_DEFAULT_MASK) - dpy->ClientAPIsMask |= EGL_OPENGL_BIT; + dpy->ClientAPIs |= EGL_OPENGL_BIT; if (gdpy->loader->profile_masks[ST_API_OPENGL] & ST_PROFILE_OPENGL_ES1_MASK) - dpy->ClientAPIsMask |= EGL_OPENGL_ES_BIT; + dpy->ClientAPIs |= EGL_OPENGL_ES_BIT; if (gdpy->loader->profile_masks[ST_API_OPENGL] & ST_PROFILE_OPENGL_ES2_MASK) - dpy->ClientAPIsMask |= EGL_OPENGL_ES2_BIT; + dpy->ClientAPIs |= EGL_OPENGL_ES2_BIT; if (gdpy->loader->profile_masks[ST_API_OPENVG] & ST_PROFILE_DEFAULT_MASK) - dpy->ClientAPIsMask |= EGL_OPENVG_BIT; + dpy->ClientAPIs |= EGL_OPENVG_BIT; gdpy->smapi = egl_g3d_create_st_manager(dpy); if (!gdpy->smapi) { @@ -563,6 +555,9 @@ egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy, dpy->Extensions.MESA_drm_image = EGL_TRUE; } + if (dpy->Platform == _EGL_PLATFORM_WAYLAND && gdpy->native->buffer) + dpy->Extensions.MESA_drm_image = EGL_TRUE; + #ifdef EGL_ANDROID_image_native_buffer if (dpy->Platform == _EGL_PLATFORM_ANDROID && gdpy->native->buffer) dpy->Extensions.ANDROID_image_native_buffer = EGL_TRUE; @@ -573,8 +568,8 @@ egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy, goto fail; } - *major = 1; - *minor = 4; + dpy->VersionMajor = 1; + dpy->VersionMinor = 4; return EGL_TRUE; @@ -599,12 +594,6 @@ egl_g3d_get_proc_address(_EGLDriver *drv, const char *procname) stapi->get_proc_address(stapi, procname) : NULL); } -static EGLint -egl_g3d_probe(_EGLDriver *drv, _EGLDisplay *dpy) -{ - return (egl_g3d_get_platform(drv, dpy->Platform)) ? 90 : 0; -} - _EGLDriver * egl_g3d_create_driver(const struct egl_g3d_loader *loader) { @@ -621,8 +610,6 @@ egl_g3d_create_driver(const struct egl_g3d_loader *loader) gdrv->base.API.Terminate = egl_g3d_terminate; gdrv->base.API.GetProcAddress = egl_g3d_get_proc_address; - gdrv->base.Probe = egl_g3d_probe; - /* to be filled by the caller */ gdrv->base.Name = NULL; gdrv->base.Unload = NULL; diff --git a/src/gallium/state_trackers/egl/common/egl_g3d.h b/src/gallium/state_trackers/egl/common/egl_g3d.h index a5850635b2..2292d611fc 100644 --- a/src/gallium/state_trackers/egl/common/egl_g3d.h +++ b/src/gallium/state_trackers/egl/common/egl_g3d.h @@ -56,7 +56,6 @@ struct egl_g3d_display { const struct egl_g3d_loader *loader; struct st_manager *smapi; - struct pipe_context *pipe; }; struct egl_g3d_context { diff --git a/src/gallium/state_trackers/egl/common/egl_g3d_api.c b/src/gallium/state_trackers/egl/common/egl_g3d_api.c index 8e53e1dccb..f1568329ec 100644 --- a/src/gallium/state_trackers/egl/common/egl_g3d_api.c +++ b/src/gallium/state_trackers/egl/common/egl_g3d_api.c @@ -158,17 +158,17 @@ egl_g3d_choose_config(_EGLDriver *drv, _EGLDisplay *dpy, const EGLint *attribs, (_EGLArrayForEach) egl_g3d_match_config, (void *) &criteria); /* perform sorting of configs */ - if (tmp_configs && tmp_size) { + if (configs && tmp_size) { _eglSortConfigs((const _EGLConfig **) tmp_configs, tmp_size, egl_g3d_compare_config, (void *) &criteria); - size = MIN2(tmp_size, size); - for (i = 0; i < size; i++) + tmp_size = MIN2(tmp_size, size); + for (i = 0; i < tmp_size; i++) configs[i] = _eglGetConfigHandle(tmp_configs[i]); } FREE(tmp_configs); - *num_configs = size; + *num_configs = tmp_size; return EGL_TRUE; } @@ -324,7 +324,8 @@ egl_g3d_create_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, } gsurf->stvis = gconf->stvis; - if (gsurf->base.RenderBuffer == EGL_SINGLE_BUFFER) + if (gsurf->base.RenderBuffer == EGL_SINGLE_BUFFER && + gconf->stvis.buffer_mask & ST_ATTACHMENT_FRONT_LEFT_MASK) gsurf->stvis.render_buffer = ST_ATTACHMENT_FRONT_LEFT; gsurf->stfbi = egl_g3d_create_st_framebuffer(&gsurf->base); @@ -402,7 +403,6 @@ egl_g3d_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, const EGLint *attribs) { struct egl_g3d_surface *gsurf; - struct pipe_resource *ptex = NULL; gsurf = create_pbuffer_surface(dpy, conf, attribs, "eglCreatePbufferSurface"); @@ -411,13 +411,6 @@ egl_g3d_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *dpy, gsurf->client_buffer_type = EGL_NONE; - if (!gsurf->stfbi->validate(gsurf->stfbi, - &gsurf->stvis.render_buffer, 1, &ptex)) { - egl_g3d_destroy_st_framebuffer(gsurf->stfbi); - FREE(gsurf); - return NULL; - } - return &gsurf->base; } @@ -477,12 +470,14 @@ egl_g3d_create_pbuffer_from_client_buffer(_EGLDriver *drv, _EGLDisplay *dpy, gsurf->client_buffer_type = buftype; gsurf->client_buffer = buffer; + /* validate now so that it fails if the client buffer is invalid */ if (!gsurf->stfbi->validate(gsurf->stfbi, &gsurf->stvis.render_buffer, 1, &ptex)) { egl_g3d_destroy_st_framebuffer(gsurf->stfbi); FREE(gsurf); return NULL; } + pipe_resource_reference(&ptex, NULL); return &gsurf->base; } @@ -533,8 +528,7 @@ egl_g3d_make_current(_EGLDriver *drv, _EGLDisplay *dpy, old_gctx = egl_g3d_context(old_ctx); if (old_gctx) { /* flush old context */ - old_gctx->stctxi->flush(old_gctx->stctxi, - PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL); + old_gctx->stctxi->flush(old_gctx->stctxi, ST_FLUSH_FRONT, NULL); } if (gctx) { @@ -611,8 +605,7 @@ egl_g3d_swap_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf) /* flush if the surface is current */ if (gctx) { - gctx->stctxi->flush(gctx->stctxi, - PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL); + gctx->stctxi->flush(gctx->stctxi, ST_FLUSH_FRONT, NULL); } return gsurf->native->present(gsurf->native, @@ -643,47 +636,36 @@ egl_g3d_copy_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf, struct egl_g3d_display *gdpy = egl_g3d_display(dpy); struct egl_g3d_surface *gsurf = egl_g3d_surface(surf); _EGLContext *ctx = _eglGetCurrentContext(); - struct egl_g3d_config *gconf; struct native_surface *nsurf; struct pipe_resource *ptex; + struct pipe_context *pipe; if (!gsurf->render_texture) return EGL_TRUE; - gconf = egl_g3d_config(egl_g3d_find_pixmap_config(dpy, target)); - if (!gconf) - return _eglError(EGL_BAD_NATIVE_PIXMAP, "eglCopyBuffers"); - - nsurf = gdpy->native->create_pixmap_surface(gdpy->native, - target, gconf->native); + nsurf = gdpy->native->create_pixmap_surface(gdpy->native, target, NULL); if (!nsurf) return _eglError(EGL_BAD_NATIVE_PIXMAP, "eglCopyBuffers"); /* flush if the surface is current */ if (ctx && ctx->DrawSurface == &gsurf->base) { struct egl_g3d_context *gctx = egl_g3d_context(ctx); - gctx->stctxi->flush(gctx->stctxi, - PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL); + gctx->stctxi->flush(gctx->stctxi, ST_FLUSH_FRONT, NULL); } - /* create a pipe context to copy surfaces */ - if (!gdpy->pipe) { - gdpy->pipe = - gdpy->native->screen->context_create(gdpy->native->screen, NULL); - if (!gdpy->pipe) - return EGL_FALSE; - } + pipe = ndpy_get_copy_context(gdpy->native); + if (!pipe) + return EGL_FALSE; ptex = get_pipe_resource(gdpy->native, nsurf, NATIVE_ATTACHMENT_FRONT_LEFT); if (ptex) { - struct pipe_resource *psrc = gsurf->render_texture; struct pipe_box src_box; + u_box_origin_2d(ptex->width0, ptex->height0, &src_box); - if (psrc) { - gdpy->pipe->resource_copy_region(gdpy->pipe, ptex, 0, 0, 0, 0, - gsurf->render_texture, 0, &src_box); - nsurf->present(nsurf, NATIVE_ATTACHMENT_FRONT_LEFT, FALSE, 0); - } + pipe->resource_copy_region(pipe, ptex, 0, 0, 0, 0, + gsurf->render_texture, 0, &src_box); + pipe->flush(pipe, NULL); + nsurf->present(nsurf, NATIVE_ATTACHMENT_FRONT_LEFT, FALSE, 0); pipe_resource_reference(&ptex, NULL); } @@ -701,10 +683,9 @@ egl_g3d_wait_client(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx) struct pipe_screen *screen = gdpy->native->screen; struct pipe_fence_handle *fence = NULL; - gctx->stctxi->flush(gctx->stctxi, - PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, &fence); + gctx->stctxi->flush(gctx->stctxi, ST_FLUSH_FRONT, &fence); if (fence) { - screen->fence_finish(screen, fence, 0); + screen->fence_finish(screen, fence, PIPE_TIMEOUT_INFINITE); screen->fence_reference(screen, &fence, NULL); } @@ -773,8 +754,7 @@ egl_g3d_bind_tex_image(_EGLDriver *drv, _EGLDisplay *dpy, /* flush properly if the surface is bound */ if (gsurf->base.CurrentContext) { gctx = egl_g3d_context(gsurf->base.CurrentContext); - gctx->stctxi->flush(gctx->stctxi, - PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL); + gctx->stctxi->flush(gctx->stctxi, ST_FLUSH_FRONT, NULL); } gctx = egl_g3d_context(es1); @@ -888,25 +868,6 @@ egl_g3d_show_screen_surface(_EGLDriver *drv, _EGLDisplay *dpy, #endif /* EGL_MESA_screen_surface */ -/** - * Find a config that supports the pixmap. - */ -_EGLConfig * -egl_g3d_find_pixmap_config(_EGLDisplay *dpy, EGLNativePixmapType pix) -{ - struct egl_g3d_display *gdpy = egl_g3d_display(dpy); - struct egl_g3d_config *gconf; - EGLint i; - - for (i = 0; i < dpy->Configs->Size; i++) { - gconf = egl_g3d_config((_EGLConfig *) dpy->Configs->Elements[i]); - if (gdpy->native->is_pixmap_supported(gdpy->native, pix, gconf->native)) - break; - } - - return (i < dpy->Configs->Size) ? &gconf->base : NULL; -} - void egl_g3d_init_driver_api(_EGLDriver *drv) { diff --git a/src/gallium/state_trackers/egl/common/egl_g3d_api.h b/src/gallium/state_trackers/egl/common/egl_g3d_api.h index d5196c12fe..17fd7958aa 100644 --- a/src/gallium/state_trackers/egl/common/egl_g3d_api.h +++ b/src/gallium/state_trackers/egl/common/egl_g3d_api.h @@ -31,7 +31,4 @@ void egl_g3d_init_driver_api(_EGLDriver *drv); -_EGLConfig * -egl_g3d_find_pixmap_config(_EGLDisplay *dpy, EGLNativePixmapType pix); - #endif /* _EGL_G3D_API_H_ */ diff --git a/src/gallium/state_trackers/egl/common/egl_g3d_image.c b/src/gallium/state_trackers/egl/common/egl_g3d_image.c index b53b121005..1d23305402 100644 --- a/src/gallium/state_trackers/egl/common/egl_g3d_image.c +++ b/src/gallium/state_trackers/egl/common/egl_g3d_image.c @@ -35,7 +35,6 @@ #include "native.h" #include "egl_g3d.h" -#include "egl_g3d_api.h" #include "egl_g3d_image.h" /* for struct winsys_handle */ @@ -53,17 +52,11 @@ static struct pipe_resource * egl_g3d_reference_native_pixmap(_EGLDisplay *dpy, EGLNativePixmapType pix) { struct egl_g3d_display *gdpy = egl_g3d_display(dpy); - struct egl_g3d_config *gconf; struct native_surface *nsurf; struct pipe_resource *textures[NUM_NATIVE_ATTACHMENTS]; enum native_attachment natt; - gconf = egl_g3d_config(egl_g3d_find_pixmap_config(dpy, pix)); - if (!gconf) - return NULL; - - nsurf = gdpy->native->create_pixmap_surface(gdpy->native, - pix, gconf->native); + nsurf = gdpy->native->create_pixmap_surface(gdpy->native, pix, NULL); if (!nsurf) return NULL; @@ -123,6 +116,7 @@ egl_g3d_create_drm_buffer(_EGLDisplay *dpy, _EGLImage *img, templ.width0 = attrs.Width; templ.height0 = attrs.Height; templ.depth0 = 1; + templ.array_size = 1; /* * XXX fix apps (e.g. wayland) and pipe drivers (e.g. i915) and remove the @@ -147,7 +141,7 @@ egl_g3d_reference_drm_buffer(_EGLDisplay *dpy, EGLint name, _EGLImageAttribs attrs; EGLint format; - if (dpy->Platform != _EGL_PLATFORM_DRM) + if (!dpy->Extensions.MESA_drm_image) return NULL; if (_eglParseImageAttribList(&attrs, dpy, attribs) != EGL_SUCCESS) @@ -236,10 +230,12 @@ egl_g3d_reference_android_native_buffer(_EGLDisplay *dpy, memset(&templ, 0, sizeof(templ)); templ.target = PIPE_TEXTURE_2D; templ.format = format; - templ.bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW; + /* assume for texturing only */ + templ.bind = PIPE_BIND_SAMPLER_VIEW; templ.width0 = buf->width; templ.height0 = buf->height; templ.depth0 = 1; + templ.array_size = 1; res = gdpy->native->buffer->import_buffer(gdpy->native, &templ, (void *) buf); @@ -385,7 +381,7 @@ egl_g3d_export_drm_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLImage *img, struct egl_g3d_image *gimg = egl_g3d_image(img); struct winsys_handle wsh; - if (dpy->Platform != _EGL_PLATFORM_DRM) + if (!dpy->Extensions.MESA_drm_image) return EGL_FALSE; /* get shared handle */ diff --git a/src/gallium/state_trackers/egl/common/egl_g3d_sync.c b/src/gallium/state_trackers/egl/common/egl_g3d_sync.c index 4e6d944c15..dd07af140a 100644 --- a/src/gallium/state_trackers/egl/common/egl_g3d_sync.c +++ b/src/gallium/state_trackers/egl/common/egl_g3d_sync.c @@ -109,7 +109,7 @@ egl_g3d_wait_fence_sync(struct egl_g3d_sync *gsync, EGLTimeKHR timeout) _eglUnlockMutex(&dpy->Mutex); /* no timed finish? */ - screen->fence_finish(screen, fence, 0x0); + screen->fence_finish(screen, fence, PIPE_TIMEOUT_INFINITE); ret = EGL_CONDITION_SATISFIED_KHR; _eglLockMutex(&dpy->Mutex); @@ -234,7 +234,7 @@ egl_g3d_client_wait_sync(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSync *sync, struct egl_g3d_context *gctx = egl_g3d_context(ctx); if (gctx) - gctx->stctxi->flush(gctx->stctxi, PIPE_FLUSH_RENDER_CACHE , NULL); + gctx->stctxi->flush(gctx->stctxi, ST_FLUSH_FRONT, NULL); } if (timeout) { diff --git a/src/gallium/state_trackers/egl/common/native.h b/src/gallium/state_trackers/egl/common/native.h index ca8cb97f71..9e9cd3fd05 100644 --- a/src/gallium/state_trackers/egl/common/native.h +++ b/src/gallium/state_trackers/egl/common/native.h @@ -126,8 +126,6 @@ struct native_config { int native_visual_id; int native_visual_type; int level; - int samples; - boolean slow_config; boolean transparent_rgb; int transparent_rgb_values[3]; }; @@ -144,6 +142,11 @@ struct native_display { struct pipe_screen *screen; /** + * Context used for copy operations. + */ + struct pipe_context *pipe; + + /** * Available for caller's use. */ void *user_data; @@ -185,7 +188,9 @@ struct native_display { const struct native_config *nconf); /** - * Create a pixmap surface. Required unless no config has pixmap_bit set. + * Create a pixmap surface. The native config may be NULL. In that case, a + * "best config" will be picked. Required unless no config has pixmap_bit + * set. */ struct native_surface *(*create_pixmap_surface)(struct native_display *ndpy, EGLNativePixmapType pix, @@ -223,11 +228,35 @@ native_attachment_mask_test(uint mask, enum native_attachment att) return !!(mask & (1 << att)); } +/** + * Get the display copy context + */ +static INLINE struct pipe_context * +ndpy_get_copy_context(struct native_display *ndpy) +{ + if (!ndpy->pipe) + ndpy->pipe = ndpy->screen->context_create(ndpy->screen, NULL); + return ndpy->pipe; +} + +/** + * Free display screen and context resources + */ +static INLINE void +ndpy_uninit(struct native_display *ndpy) +{ + if (ndpy->pipe) + ndpy->pipe->destroy(ndpy->pipe); + if (ndpy->screen) + ndpy->screen->destroy(ndpy->screen); +} + struct native_platform { const char *name; + void (*set_event_handler)(struct native_event_handler *handler); struct native_display *(*create_display)(void *dpy, - struct native_event_handler *handler, + boolean use_sw, void *user_data); }; @@ -238,6 +267,9 @@ const struct native_platform * native_get_x11_platform(void); const struct native_platform * +native_get_wayland_platform(void); + +const struct native_platform * native_get_drm_platform(void); const struct native_platform * diff --git a/src/gallium/state_trackers/egl/common/native_helper.c b/src/gallium/state_trackers/egl/common/native_helper.c index 0f2d02032b..ee18cb2025 100644 --- a/src/gallium/state_trackers/egl/common/native_helper.c +++ b/src/gallium/state_trackers/egl/common/native_helper.c @@ -3,6 +3,7 @@ * Version: 7.9 * * Copyright (C) 2010 LunarG Inc. + * Copyright (C) 2011 VMware Inc. 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"), @@ -24,6 +25,7 @@ * * Authors: * Chia-I Wu <olv@lunarg.com> + * Thomas Hellstrom <thellstrom@vmware.com> */ #include "util/u_inlines.h" @@ -34,6 +36,14 @@ #include "native_helper.h" +/** + * Number of swap fences and mask + */ + +#define EGL_SWAP_FENCES_MAX 4 +#define EGL_SWAP_FENCES_MASK 3 +#define EGL_SWAP_FENCES_DEFAULT 1 + struct resource_surface { struct pipe_screen *screen; enum pipe_format format; @@ -42,6 +52,15 @@ struct resource_surface { struct pipe_resource *resources[NUM_NATIVE_ATTACHMENTS]; uint resource_mask; uint width, height; + + /** + * Swap fences. + */ + struct pipe_fence_handle *swap_fences[EGL_SWAP_FENCES_MAX]; + unsigned int cur_fences; + unsigned int head; + unsigned int tail; + unsigned int desired_fences; }; struct resource_surface * @@ -49,11 +68,16 @@ resource_surface_create(struct pipe_screen *screen, enum pipe_format format, uint bind) { struct resource_surface *rsurf = CALLOC_STRUCT(resource_surface); + char *swap_fences = getenv("EGL_THROTTLE_FENCES"); if (rsurf) { rsurf->screen = screen; rsurf->format = format; rsurf->bind = bind; + rsurf->desired_fences = (swap_fences) ? atoi(swap_fences) : + EGL_SWAP_FENCES_DEFAULT; + if (rsurf->desired_fences > EGL_SWAP_FENCES_MAX) + rsurf->desired_fences = EGL_SWAP_FENCES_MAX; } return rsurf; @@ -143,6 +167,14 @@ resource_surface_add_resources(struct resource_surface *rsurf, return ((rsurf->resource_mask & resource_mask) == resource_mask); } +void +resource_surface_import_resource(struct resource_surface *rsurf, + enum native_attachment which, + struct pipe_resource *pres) +{ + pipe_resource_reference(&rsurf->resources[which], pres); + rsurf->resource_mask |= 1 << which; +} void resource_surface_get_resources(struct resource_surface *rsurf, @@ -217,3 +249,121 @@ resource_surface_present(struct resource_surface *rsurf, return TRUE; } + +/** + * Schedule a copy swap from the back to the front buffer using the + * native display's copy context. + */ +boolean +resource_surface_copy_swap(struct resource_surface *rsurf, + struct native_display *ndpy) +{ + struct pipe_resource *ftex; + struct pipe_resource *btex; + struct pipe_context *pipe; + struct pipe_box src_box; + boolean ret = FALSE; + + pipe = ndpy_get_copy_context(ndpy); + if (!pipe) + return FALSE; + + ftex = resource_surface_get_single_resource(rsurf, + NATIVE_ATTACHMENT_FRONT_LEFT); + if (!ftex) + goto out_no_ftex; + btex = resource_surface_get_single_resource(rsurf, + NATIVE_ATTACHMENT_BACK_LEFT); + if (!btex) + goto out_no_btex; + + u_box_origin_2d(ftex->width0, ftex->height0, &src_box); + pipe->resource_copy_region(pipe, ftex, 0, 0, 0, 0, + btex, 0, &src_box); + ret = TRUE; + + out_no_ftex: + pipe_resource_reference(&btex, NULL); + out_no_btex: + pipe_resource_reference(&ftex, NULL); + + return ret; +} + +static struct pipe_fence_handle * +swap_fences_pop_front(struct resource_surface *rsurf) +{ + struct pipe_screen *screen = rsurf->screen; + struct pipe_fence_handle *fence = NULL; + + if (rsurf->desired_fences == 0) + return NULL; + + if (rsurf->cur_fences >= rsurf->desired_fences) { + screen->fence_reference(screen, &fence, rsurf->swap_fences[rsurf->tail]); + screen->fence_reference(screen, &rsurf->swap_fences[rsurf->tail++], NULL); + rsurf->tail &= EGL_SWAP_FENCES_MASK; + --rsurf->cur_fences; + } + return fence; +} + +static void +swap_fences_push_back(struct resource_surface *rsurf, + struct pipe_fence_handle *fence) +{ + struct pipe_screen *screen = rsurf->screen; + + if (!fence || rsurf->desired_fences == 0) + return; + + while(rsurf->cur_fences == rsurf->desired_fences) + swap_fences_pop_front(rsurf); + + rsurf->cur_fences++; + screen->fence_reference(screen, &rsurf->swap_fences[rsurf->head++], + fence); + rsurf->head &= EGL_SWAP_FENCES_MASK; +} + +boolean +resource_surface_throttle(struct resource_surface *rsurf) +{ + struct pipe_screen *screen = rsurf->screen; + struct pipe_fence_handle *fence = swap_fences_pop_front(rsurf); + + if (fence) { + (void) screen->fence_finish(screen, fence, PIPE_TIMEOUT_INFINITE); + screen->fence_reference(screen, &fence, NULL); + return TRUE; + } + + return FALSE; +} + +boolean +resource_surface_flush(struct resource_surface *rsurf, + struct native_display *ndpy) +{ + struct pipe_fence_handle *fence = NULL; + struct pipe_screen *screen = rsurf->screen; + struct pipe_context *pipe= ndpy_get_copy_context(ndpy); + + if (!pipe) + return FALSE; + + pipe->flush(pipe, &fence); + if (fence == NULL) + return FALSE; + + swap_fences_push_back(rsurf, fence); + screen->fence_reference(screen, &fence, NULL); + + return TRUE; +} + +void +resource_surface_wait(struct resource_surface *rsurf) +{ + while (resource_surface_throttle(rsurf)); +} diff --git a/src/gallium/state_trackers/egl/common/native_helper.h b/src/gallium/state_trackers/egl/common/native_helper.h index d1569ac3ea..39564a0436 100644 --- a/src/gallium/state_trackers/egl/common/native_helper.h +++ b/src/gallium/state_trackers/egl/common/native_helper.h @@ -3,6 +3,7 @@ * Version: 7.9 * * Copyright (C) 2010 LunarG Inc. + * Copyright (C) 2011 VMware Inc. 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"), @@ -24,6 +25,7 @@ * * Authors: * Chia-I Wu <olv@lunarg.com> + * Thomas Hellstrom <thellstrom@vmware.com> */ #include "native.h" @@ -51,6 +53,11 @@ resource_surface_add_resources(struct resource_surface *rsurf, uint resource_mask); void +resource_surface_import_resource(struct resource_surface *rsurf, + enum native_attachment which, + struct pipe_resource *pres); + +void resource_surface_get_resources(struct resource_surface *rsurf, struct pipe_resource **resources, uint resource_mask); @@ -69,3 +76,32 @@ boolean resource_surface_present(struct resource_surface *rsurf, enum native_attachment which, void *winsys_drawable_handle); + +/** + * Perform a gallium copy blit between the back left and front left + * surfaces. Needs to be followed by a call to resource_surface_flush. + */ +boolean +resource_surface_copy_swap(struct resource_surface *rsurf, + struct native_display *ndpy); + +/** + * Throttle on outstanding rendering using the copy context. For example + * copy swaps. + */ +boolean +resource_surface_throttle(struct resource_surface *rsurf); + +/** + * Flush pending rendering using the copy context. This function saves a + * marker for upcoming throttles. + */ +boolean +resource_surface_flush(struct resource_surface *rsurf, + struct native_display *ndpy); +/** + * Wait for all rendering using the copy context to be complete. Frees all + * throttle markers saved using resource_surface_flush. + */ +void +resource_surface_wait(struct resource_surface *rsurf); diff --git a/src/gallium/state_trackers/egl/drm/modeset.c b/src/gallium/state_trackers/egl/drm/modeset.c index 0cc06caa2a..3fff954090 100644 --- a/src/gallium/state_trackers/egl/drm/modeset.c +++ b/src/gallium/state_trackers/egl/drm/modeset.c @@ -3,6 +3,7 @@ * Version: 7.9 * * Copyright (C) 2010 LunarG Inc. + * Copyright (C) 2011 VMware Inc. 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"), @@ -24,6 +25,7 @@ * * Authors: * Chia-I Wu <olv@lunarg.com> + * Thomas Hellstrom <thellstrom@vmware.com> */ #include "util/u_memory.h" @@ -131,6 +133,25 @@ drm_surface_flush_frontbuffer(struct native_surface *nsurf) } static boolean +drm_surface_copy_swap(struct native_surface *nsurf) +{ + struct drm_surface *drmsurf = drm_surface(nsurf); + struct drm_display *drmdpy = drmsurf->drmdpy; + + (void) resource_surface_throttle(drmsurf->rsurf); + if (!resource_surface_copy_swap(drmsurf->rsurf, &drmdpy->base)) + return FALSE; + + (void) resource_surface_flush(drmsurf->rsurf, &drmdpy->base); + if (!drm_surface_flush_frontbuffer(nsurf)) + return FALSE; + + drmsurf->sequence_number++; + + return TRUE; +} + +static boolean drm_surface_swap_buffers(struct native_surface *nsurf) { struct drm_surface *drmsurf = drm_surface(nsurf); @@ -139,17 +160,21 @@ drm_surface_swap_buffers(struct native_surface *nsurf) struct drm_framebuffer tmp_fb; int err; + if (!drmsurf->have_pageflip) + return drm_surface_copy_swap(nsurf); + if (!drmsurf->back_fb.buffer_id) { if (!drm_surface_init_framebuffers(&drmsurf->base, TRUE)) return FALSE; } if (drmsurf->is_shown && drmcrtc->crtc) { - err = drmModeSetCrtc(drmdpy->fd, drmcrtc->crtc->crtc_id, - drmsurf->back_fb.buffer_id, drmcrtc->crtc->x, drmcrtc->crtc->y, - drmcrtc->connectors, drmcrtc->num_connectors, &drmcrtc->crtc->mode); - if (err) - return FALSE; + err = drmModePageFlip(drmdpy->fd, drmcrtc->crtc->crtc_id, + drmsurf->back_fb.buffer_id, 0, NULL); + if (err) { + drmsurf->have_pageflip = FALSE; + return drm_surface_copy_swap(nsurf); + } } /* swap the buffers */ @@ -175,7 +200,7 @@ drm_surface_present(struct native_surface *nsurf, { boolean ret; - if (preserve || swap_interval) + if (swap_interval) return FALSE; switch (natt) { @@ -183,7 +208,10 @@ drm_surface_present(struct native_surface *nsurf, ret = drm_surface_flush_frontbuffer(nsurf); break; case NATIVE_ATTACHMENT_BACK_LEFT: - ret = drm_surface_swap_buffers(nsurf); + if (preserve) + ret = drm_surface_copy_swap(nsurf); + else + ret = drm_surface_swap_buffers(nsurf); break; default: ret = FALSE; @@ -196,7 +224,9 @@ drm_surface_present(struct native_surface *nsurf, static void drm_surface_wait(struct native_surface *nsurf) { - /* no-op */ + struct drm_surface *drmsurf = drm_surface(nsurf); + + resource_surface_wait(drmsurf->rsurf); } static void @@ -204,6 +234,7 @@ drm_surface_destroy(struct native_surface *nsurf) { struct drm_surface *drmsurf = drm_surface(nsurf); + resource_surface_wait(drmsurf->rsurf); if (drmsurf->current_crtc.crtc) drmModeFreeCrtc(drmsurf->current_crtc.crtc); @@ -236,6 +267,7 @@ drm_display_create_surface(struct native_display *ndpy, drmsurf->color_format = drmconf->base.color_format; drmsurf->width = width; drmsurf->height = height; + drmsurf->have_pageflip = TRUE; drmsurf->rsurf = resource_surface_create(drmdpy->base.screen, drmsurf->color_format, diff --git a/src/gallium/state_trackers/egl/drm/native_drm.c b/src/gallium/state_trackers/egl/drm/native_drm.c index 2441b43fd8..9863329ff4 100644 --- a/src/gallium/state_trackers/egl/drm/native_drm.c +++ b/src/gallium/state_trackers/egl/drm/native_drm.c @@ -43,7 +43,7 @@ drm_display_is_format_supported(struct native_display *ndpy, return ndpy->screen->is_format_supported(ndpy->screen, fmt, PIPE_TEXTURE_2D, 0, (is_color) ? PIPE_BIND_RENDER_TARGET : - PIPE_BIND_DEPTH_STENCIL, 0); + PIPE_BIND_DEPTH_STENCIL); } static const struct native_config ** @@ -124,8 +124,7 @@ drm_display_destroy(struct native_display *ndpy) drm_display_fini_modeset(&drmdpy->base); - if (drmdpy->base.screen) - drmdpy->base.screen->destroy(drmdpy->base.screen); + ndpy_uninit(ndpy); if (drmdpy->fd >= 0) close(drmdpy->fd); @@ -178,7 +177,7 @@ drm_display_init_screen(struct native_display *ndpy) drmFreeVersion(version); if (!drmdpy->base.screen) { - _eglLog(_EGL_WARNING, "failed to create DRM screen"); + _eglLog(_EGL_DEBUG, "failed to create DRM screen"); return FALSE; } @@ -237,9 +236,16 @@ drm_create_display(int fd, struct native_event_handler *event_handler, return &drmdpy->base; } +static struct native_event_handler *drm_event_handler; + +static void +native_set_event_handler(struct native_event_handler *event_handler) +{ + drm_event_handler = event_handler; +} + static struct native_display * -native_create_display(void *dpy, struct native_event_handler *event_handler, - void *user_data) +native_create_display(void *dpy, boolean use_sw, void *user_data) { int fd; @@ -252,11 +258,12 @@ native_create_display(void *dpy, struct native_event_handler *event_handler, if (fd < 0) return NULL; - return drm_create_display(fd, event_handler, user_data); + return drm_create_display(fd, drm_event_handler, user_data); } static const struct native_platform drm_platform = { "DRM", /* name */ + native_set_event_handler, native_create_display }; diff --git a/src/gallium/state_trackers/egl/drm/native_drm.h b/src/gallium/state_trackers/egl/drm/native_drm.h index 03c4fe01dc..7da9b45f23 100644 --- a/src/gallium/state_trackers/egl/drm/native_drm.h +++ b/src/gallium/state_trackers/egl/drm/native_drm.h @@ -91,6 +91,8 @@ struct drm_surface { boolean is_shown; struct drm_crtc current_crtc; + + boolean have_pageflip; }; struct drm_connector { diff --git a/src/gallium/state_trackers/egl/fbdev/native_fbdev.c b/src/gallium/state_trackers/egl/fbdev/native_fbdev.c index 1b5ea8bf9d..e2fde00e97 100644 --- a/src/gallium/state_trackers/egl/fbdev/native_fbdev.c +++ b/src/gallium/state_trackers/egl/fbdev/native_fbdev.c @@ -320,7 +320,7 @@ fbdev_display_destroy(struct native_display *ndpy) { struct fbdev_display *fbdpy = fbdev_display(ndpy); - fbdpy->base.screen->destroy(fbdpy->base.screen); + ndpy_uninit(&fbdpy->base); close(fbdpy->fd); FREE(fbdpy); } @@ -422,7 +422,7 @@ fbdev_display_init(struct native_display *ndpy) if (fbdpy->base.screen) { if (!fbdpy->base.screen->is_format_supported(fbdpy->base.screen, fbdpy->config.color_format, PIPE_TEXTURE_2D, 0, - PIPE_BIND_RENDER_TARGET, 0)) { + PIPE_BIND_RENDER_TARGET)) { fbdpy->base.screen->destroy(fbdpy->base.screen); fbdpy->base.screen = NULL; } @@ -459,9 +459,16 @@ fbdev_display_create(int fd, struct native_event_handler *event_handler, return &fbdpy->base; } +static struct native_event_handler *fbdev_event_handler; + +static void +native_set_event_handler(struct native_event_handler *event_handler) +{ + fbdev_event_handler = event_handler; +} + static struct native_display * -native_create_display(void *dpy, struct native_event_handler *event_handler, - void *user_data) +native_create_display(void *dpy, boolean use_sw, void *user_data) { struct native_display *ndpy; int fd; @@ -476,7 +483,7 @@ native_create_display(void *dpy, struct native_event_handler *event_handler, if (fd < 0) return NULL; - ndpy = fbdev_display_create(fd, event_handler, user_data); + ndpy = fbdev_display_create(fd, fbdev_event_handler, user_data); if (!ndpy) close(fd); @@ -485,6 +492,7 @@ native_create_display(void *dpy, struct native_event_handler *event_handler, static const struct native_platform fbdev_platform = { "FBDEV", /* name */ + native_set_event_handler, native_create_display }; diff --git a/src/gallium/state_trackers/egl/gdi/native_gdi.c b/src/gallium/state_trackers/egl/gdi/native_gdi.c index d259e6edc8..5d0045f92e 100644 --- a/src/gallium/state_trackers/egl/gdi/native_gdi.c +++ b/src/gallium/state_trackers/egl/gdi/native_gdi.c @@ -285,7 +285,7 @@ fill_color_formats(struct native_display *ndpy, enum pipe_format formats[8]) for (i = 0; i < Elements(candidates); i++) { if (screen->is_format_supported(screen, candidates[i], - PIPE_TEXTURE_2D, 0, PIPE_BIND_RENDER_TARGET, 0)) + PIPE_TEXTURE_2D, 0, PIPE_BIND_RENDER_TARGET)) formats[count++] = candidates[i]; } @@ -319,7 +319,6 @@ gdi_display_get_configs(struct native_display *ndpy, int *num_configs) nconf->color_format = formats[i]; nconf->window_bit = TRUE; - nconf->slow_config = TRUE; } gdpy->num_configs = count; @@ -364,7 +363,7 @@ gdi_display_destroy(struct native_display *ndpy) if (gdpy->configs) FREE(gdpy->configs); - gdpy->base.screen->destroy(gdpy->base.screen); + ndpy_uninit(ndpy); FREE(gdpy); } @@ -407,15 +406,23 @@ gdi_create_display(HDC hDC, struct native_event_handler *event_handler, return &gdpy->base; } +static struct native_event_handler *gdi_event_handler; + +static void +native_set_event_handler(struct native_event_handler *event_handler) +{ + gdi_event_handler = event_handler; +} + static struct native_display * -native_create_display(void *dpy, struct native_event_handler *event_handler, - void *user_data) +native_create_display(void *dpy, boolean use_sw, void *user_data) { - return gdi_create_display((HDC) dpy, event_handler, user_data); + return gdi_create_display((HDC) dpy, gdi_event_handler, user_data); } static const struct native_platform gdi_platform = { "GDI", /* name */ + native_set_event_handler, native_create_display }; diff --git a/src/gallium/state_trackers/egl/wayland/native_wayland.c b/src/gallium/state_trackers/egl/wayland/native_wayland.c new file mode 100644 index 0000000000..068c3cd7c8 --- /dev/null +++ b/src/gallium/state_trackers/egl/wayland/native_wayland.c @@ -0,0 +1,626 @@ +/* + * Mesa 3-D graphics library + * Version: 7.11 + * + * Copyright (C) 2011 Benjamin Franzke <benjaminfranzke@googlemail.com> + * + * 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 + * THE AUTHORS OR COPYRIGHT HOLDERS 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. + */ + +#include "util/u_memory.h" +#include "util/u_inlines.h" + +#include "pipe/p_compiler.h" +#include "pipe/p_screen.h" +#include "pipe/p_context.h" +#include "pipe/p_state.h" +#include "state_tracker/drm_driver.h" + +#include "egllog.h" + +#include "native_wayland.h" + +/* see get_drm_screen_name */ +#include <radeon_drm.h> +#include "radeon/drm/radeon_drm_public.h" + +#include <wayland-client.h> +#include "wayland-drm-client-protocol.h" +#include "wayland-egl-priv.h" + +#include <xf86drm.h> + +static struct native_event_handler *wayland_event_handler; + +static void +sync_callback(void *data) +{ + int *done = data; + + *done = 1; +} + +static void +force_roundtrip(struct wl_display *display) +{ + int done = 0; + + wl_display_sync_callback(display, sync_callback, &done); + wl_display_iterate(display, WL_DISPLAY_WRITABLE); + while (!done) + wl_display_iterate(display, WL_DISPLAY_READABLE); +} + +static const struct native_config ** +wayland_display_get_configs (struct native_display *ndpy, int *num_configs) +{ + struct wayland_display *display = wayland_display(ndpy); + const struct native_config **configs; + + if (!display->config) { + struct native_config *nconf; + enum pipe_format format; + display->config = CALLOC(1, sizeof(*display->config)); + if (!display->config) + return NULL; + nconf = &display->config->base; + + nconf->buffer_mask = + (1 << NATIVE_ATTACHMENT_FRONT_LEFT) | + (1 << NATIVE_ATTACHMENT_BACK_LEFT); + + format = PIPE_FORMAT_B8G8R8A8_UNORM; + + nconf->color_format = format; + nconf->window_bit = TRUE; + nconf->pixmap_bit = TRUE; + } + + configs = MALLOC(sizeof(*configs)); + if (configs) { + configs[0] = &display->config->base; + if (num_configs) + *num_configs = 1; + } + + return configs; +} + +static int +wayland_display_get_param(struct native_display *ndpy, + enum native_param_type param) +{ + int val; + + switch (param) { + case NATIVE_PARAM_USE_NATIVE_BUFFER: + case NATIVE_PARAM_PRESERVE_BUFFER: + case NATIVE_PARAM_MAX_SWAP_INTERVAL: + default: + val = 0; + break; + } + + return val; +} + +static boolean +wayland_display_is_pixmap_supported(struct native_display *ndpy, + EGLNativePixmapType pix, + const struct native_config *nconf) +{ + /* all wl_egl_pixmaps are supported */ + + return TRUE; +} + +static void +wayland_display_destroy(struct native_display *ndpy) +{ + struct wayland_display *display = wayland_display(ndpy); + + if (display->config) + FREE(display->config); + + ndpy_uninit(ndpy); + + FREE(display); +} + + +static struct wl_buffer * +wayland_create_buffer(struct wayland_surface *surface, + enum native_attachment attachment) +{ + struct wayland_display *display = surface->display; + struct pipe_resource *resource; + struct winsys_handle wsh; + uint width, height; + + resource = resource_surface_get_single_resource(surface->rsurf, attachment); + resource_surface_get_size(surface->rsurf, &width, &height); + + wsh.type = DRM_API_HANDLE_TYPE_SHARED; + display->base.screen->resource_get_handle(display->base.screen, resource, &wsh); + + pipe_resource_reference(&resource, NULL); + + return wl_drm_create_buffer(display->dpy->drm, wsh.handle, + width, height, + wsh.stride, surface->win->visual); +} + +static void +wayland_pixmap_destroy(struct wl_egl_pixmap *egl_pixmap) +{ + struct pipe_resource *resource = egl_pixmap->driver_private; + + assert(resource); + + pipe_resource_reference(&resource, NULL); + + egl_pixmap->driver_private = NULL; + egl_pixmap->destroy = NULL; + egl_pixmap->name = 0; +} + +static void +wayland_pixmap_surface_intialize(struct wayland_surface *surface) +{ + struct native_display *ndpy = &surface->display->base; + struct pipe_resource *resource; + struct winsys_handle wsh; + const enum native_attachment front_natt = NATIVE_ATTACHMENT_FRONT_LEFT; + + if (surface->pix->name > 0) + return; + + resource = resource_surface_get_single_resource(surface->rsurf, front_natt); + + wsh.type = DRM_API_HANDLE_TYPE_SHARED; + ndpy->screen->resource_get_handle(ndpy->screen, resource, &wsh); + + surface->pix->name = wsh.handle; + surface->pix->stride = wsh.stride; + surface->pix->destroy = wayland_pixmap_destroy; + surface->pix->driver_private = resource; +} + +static void +wayland_release_pending_resource(void *data) +{ + struct wayland_surface *surface = data; + + /* FIXME: print internal error */ + if (!surface->pending_resource) + return; + + pipe_resource_reference(&surface->pending_resource, NULL); +} + +static void +wayland_window_surface_handle_resize(struct wayland_surface *surface) +{ + struct wayland_display *display = surface->display; + struct pipe_resource *front_resource; + const enum native_attachment front_natt = NATIVE_ATTACHMENT_FRONT_LEFT; + int i; + + front_resource = resource_surface_get_single_resource(surface->rsurf, + front_natt); + if (resource_surface_set_size(surface->rsurf, + surface->win->width, surface->win->height)) { + + if (surface->pending_resource) + force_roundtrip(display->dpy->display); + + if (front_resource) { + surface->pending_resource = front_resource; + front_resource = NULL; + wl_display_sync_callback(display->dpy->display, + wayland_release_pending_resource, surface); + } + + for (i = 0; i < WL_BUFFER_COUNT; ++i) { + if (surface->buffer[i]) + wl_buffer_destroy(surface->buffer[i]); + surface->buffer[i] = NULL; + } + } + pipe_resource_reference(&front_resource, NULL); + + surface->dx = surface->win->dx; + surface->dy = surface->win->dy; + surface->win->dx = 0; + surface->win->dy = 0; +} + +static boolean +wayland_surface_validate(struct native_surface *nsurf, uint attachment_mask, + unsigned int *seq_num, struct pipe_resource **textures, + int *width, int *height) +{ + struct wayland_surface *surface = wayland_surface(nsurf); + + if (surface->type == WL_WINDOW_SURFACE) + wayland_window_surface_handle_resize(surface); + + if (!resource_surface_add_resources(surface->rsurf, attachment_mask | + surface->attachment_mask)) + return FALSE; + + if (textures) + resource_surface_get_resources(surface->rsurf, textures, attachment_mask); + + if (seq_num) + *seq_num = surface->sequence_number; + + resource_surface_get_size(surface->rsurf, (uint *) width, (uint *) height); + + if (surface->type == WL_PIXMAP_SURFACE) + wayland_pixmap_surface_intialize(surface); + + return TRUE; +} + +static void +wayland_frame_callback(void *data, uint32_t time) +{ + struct wayland_surface *surface = data; + + surface->block_swap_buffers = FALSE; +} + +static INLINE void +wayland_buffers_swap(struct wl_buffer **buffer, + enum wayland_buffer_type buf1, + enum wayland_buffer_type buf2) +{ + struct wl_buffer *tmp = buffer[buf1]; + buffer[buf1] = buffer[buf2]; + buffer[buf2] = tmp; +} + +static boolean +wayland_surface_swap_buffers(struct native_surface *nsurf) +{ + struct wayland_surface *surface = wayland_surface(nsurf); + struct wayland_display *display = surface->display; + + while (surface->block_swap_buffers) + wl_display_iterate(display->dpy->display, WL_DISPLAY_READABLE); + + surface->block_swap_buffers = TRUE; + wl_display_frame_callback(display->dpy->display, wayland_frame_callback, + surface); + + if (surface->type == WL_WINDOW_SURFACE) { + resource_surface_swap_buffers(surface->rsurf, + NATIVE_ATTACHMENT_FRONT_LEFT, NATIVE_ATTACHMENT_BACK_LEFT, FALSE); + + wayland_buffers_swap(surface->buffer, WL_BUFFER_FRONT, WL_BUFFER_BACK); + + if (surface->buffer[WL_BUFFER_FRONT] == NULL) + surface->buffer[WL_BUFFER_FRONT] = + wayland_create_buffer(surface, NATIVE_ATTACHMENT_FRONT_LEFT); + + wl_surface_attach(surface->win->surface, surface->buffer[WL_BUFFER_FRONT], + surface->dx, surface->dy); + + resource_surface_get_size(surface->rsurf, + (uint *) &surface->win->attached_width, + (uint *) &surface->win->attached_height); + surface->dx = 0; + surface->dy = 0; + } + + surface->sequence_number++; + wayland_event_handler->invalid_surface(&display->base, + &surface->base, surface->sequence_number); + + return TRUE; +} + +static boolean +wayland_surface_present(struct native_surface *nsurf, + enum native_attachment natt, + boolean preserve, + uint swap_interval) +{ + struct wayland_surface *surface = wayland_surface(nsurf); + uint width, height; + boolean ret; + + if (preserve || swap_interval) + return FALSE; + + switch (natt) { + case NATIVE_ATTACHMENT_FRONT_LEFT: + ret = TRUE; + break; + case NATIVE_ATTACHMENT_BACK_LEFT: + ret = wayland_surface_swap_buffers(nsurf); + break; + default: + ret = FALSE; + break; + } + + if (surface->type == WL_WINDOW_SURFACE) { + resource_surface_get_size(surface->rsurf, &width, &height); + wl_surface_damage(surface->win->surface, 0, 0, width, height); + } + + return ret; +} + +static void +wayland_surface_wait(struct native_surface *nsurf) +{ + /* no-op */ +} + +static void +wayland_surface_destroy(struct native_surface *nsurf) +{ + struct wayland_surface *surface = wayland_surface(nsurf); + enum wayland_buffer_type buffer; + + for (buffer = 0; buffer < WL_BUFFER_COUNT; ++buffer) { + if (surface->buffer[buffer]) + wl_buffer_destroy(surface->buffer[buffer]); + } + + resource_surface_destroy(surface->rsurf); + FREE(surface); +} + +static struct native_surface * +wayland_create_pixmap_surface(struct native_display *ndpy, + EGLNativePixmapType pix, + const struct native_config *nconf) +{ + struct wayland_display *display = wayland_display(ndpy); + struct wayland_config *config = wayland_config(nconf); + struct wayland_surface *surface; + struct wl_egl_pixmap *egl_pixmap = (struct wl_egl_pixmap *) pix; + enum native_attachment natt = NATIVE_ATTACHMENT_FRONT_LEFT; + + surface = CALLOC_STRUCT(wayland_surface); + if (!surface) + return NULL; + + surface->display = display; + + surface->pending_resource = NULL; + surface->type = WL_PIXMAP_SURFACE; + surface->pix = egl_pixmap; + + if (surface->pix->visual == wl_display_get_rgb_visual(display->dpy->display)) + surface->color_format = PIPE_FORMAT_B8G8R8X8_UNORM; + else + surface->color_format = PIPE_FORMAT_B8G8R8A8_UNORM; + + surface->attachment_mask = (1 << NATIVE_ATTACHMENT_FRONT_LEFT); + + surface->rsurf = resource_surface_create(display->base.screen, + surface->color_format, + PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW | + PIPE_BIND_DISPLAY_TARGET | PIPE_BIND_SCANOUT); + + if (!surface->rsurf) { + FREE(surface); + return NULL; + } + + resource_surface_set_size(surface->rsurf, + egl_pixmap->width, egl_pixmap->height); + + /* the pixmap is already allocated, so import it */ + if (surface->pix->name > 0) + resource_surface_import_resource(surface->rsurf, natt, + surface->pix->driver_private); + + surface->base.destroy = wayland_surface_destroy; + surface->base.present = wayland_surface_present; + surface->base.validate = wayland_surface_validate; + surface->base.wait = wayland_surface_wait; + + return &surface->base; +} + +static struct native_surface * +wayland_create_window_surface(struct native_display *ndpy, + EGLNativeWindowType win, + const struct native_config *nconf) +{ + struct wayland_display *display = wayland_display(ndpy); + struct wayland_config *config = wayland_config(nconf); + struct wayland_surface *surface; + + surface = CALLOC_STRUCT(wayland_surface); + if (!surface) + return NULL; + + surface->display = display; + surface->color_format = config->base.color_format; + + surface->win = (struct wl_egl_window *) win; + + surface->pending_resource = NULL; + surface->block_swap_buffers = FALSE; + surface->type = WL_WINDOW_SURFACE; + + surface->buffer[WL_BUFFER_FRONT] = NULL; + surface->buffer[WL_BUFFER_BACK] = NULL; + surface->attachment_mask = (1 << NATIVE_ATTACHMENT_FRONT_LEFT) | + (1 << NATIVE_ATTACHMENT_BACK_LEFT); + + surface->rsurf = resource_surface_create(display->base.screen, + surface->color_format, + PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW | + PIPE_BIND_DISPLAY_TARGET | PIPE_BIND_SCANOUT); + + if (!surface->rsurf) { + FREE(surface); + return NULL; + } + + surface->base.destroy = wayland_surface_destroy; + surface->base.present = wayland_surface_present; + surface->base.validate = wayland_surface_validate; + surface->base.wait = wayland_surface_wait; + + return &surface->base; +} + +static const char * +get_drm_screen_name(int fd, drmVersionPtr version) +{ + const char *name = version->name; + + if (name && !strcmp(name, "radeon")) { + int chip_id; + struct drm_radeon_info info; + + memset(&info, 0, sizeof(info)); + info.request = RADEON_INFO_DEVICE_ID; + info.value = pointer_to_intptr(&chip_id); + if (drmCommandWriteRead(fd, DRM_RADEON_INFO, &info, sizeof(info)) != 0) + return NULL; + + name = is_r3xx(chip_id) ? "r300" : "r600"; + } + + return name; +} + +static boolean +wayland_display_init_screen(struct native_display *ndpy) +{ + struct wayland_display *display = wayland_display(ndpy); + drmVersionPtr version; + const char *driver_name; + + if (display->dpy->fd == -1) + force_roundtrip(display->dpy->display); + if (display->dpy->fd == -1) + return FALSE; + + if (!display->dpy->authenticated) + force_roundtrip(display->dpy->display); + if (!display->dpy->authenticated) + return FALSE; + + version = drmGetVersion(display->dpy->fd); + if (!version) { + _eglLog(_EGL_WARNING, "invalid fd %d", display->dpy->fd); + return FALSE; + } + + /* FIXME: share this with native_drm or egl_dri2 */ + driver_name = get_drm_screen_name(display->dpy->fd, version); + + display->base.screen = + wayland_event_handler->new_drm_screen(&display->base, + driver_name, display->dpy->fd); + drmFreeVersion(version); + + if (!display->base.screen) { + _eglLog(_EGL_WARNING, "failed to create DRM screen"); + return FALSE; + } + + return TRUE; +} + + +static void +wayland_set_event_handler(struct native_event_handler *event_handler) +{ + wayland_event_handler = event_handler; +} + +static struct pipe_resource * +wayland_display_import_buffer(struct native_display *ndpy, + const struct pipe_resource *templ, + void *buf) +{ + return ndpy->screen->resource_from_handle(ndpy->screen, + templ, (struct winsys_handle *) buf); +} + +static boolean +wayland_display_export_buffer(struct native_display *ndpy, + struct pipe_resource *res, + void *buf) +{ + return ndpy->screen->resource_get_handle(ndpy->screen, + res, (struct winsys_handle *) buf); +} + +static struct native_display_buffer wayland_display_buffer = { + wayland_display_import_buffer, + wayland_display_export_buffer +}; + +static struct native_display * +wayland_display_create(void *dpy, boolean use_sw, void *user_data) +{ + struct wayland_display *display; + + display = CALLOC_STRUCT(wayland_display); + if (!display) + return NULL; + + display->base.user_data = user_data; + + display->dpy = dpy; + if (!display->dpy->display) { + wayland_display_destroy(&display->base); + return NULL; + } + + if (!wayland_display_init_screen(&display->base)) { + wayland_display_destroy(&display->base); + return NULL; + } + + display->base.destroy = wayland_display_destroy; + display->base.get_param = wayland_display_get_param; + display->base.get_configs = wayland_display_get_configs; + display->base.is_pixmap_supported = wayland_display_is_pixmap_supported; + display->base.create_window_surface = wayland_create_window_surface; + display->base.create_pixmap_surface = wayland_create_pixmap_surface; + display->base.buffer = &wayland_display_buffer; + + return &display->base; +} + +static const struct native_platform wayland_platform = { + "wayland", /* name */ + wayland_set_event_handler, + wayland_display_create +}; + +const struct native_platform * +native_get_wayland_platform(void) +{ + return &wayland_platform; +} diff --git a/src/gallium/state_trackers/egl/wayland/native_wayland.h b/src/gallium/state_trackers/egl/wayland/native_wayland.h new file mode 100644 index 0000000000..271c10dc11 --- /dev/null +++ b/src/gallium/state_trackers/egl/wayland/native_wayland.h @@ -0,0 +1,97 @@ +/* + * Mesa 3-D graphics library + * Version: 7.11 + * + * Copyright (C) 2011 Benjamin Franzke <benjaminfranzke@googlemail.com> + * + * 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 + * THE AUTHORS OR COPYRIGHT HOLDERS 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 _NATIVE_WAYLAND_H_ +#define _NATIVE_WAYLAND_H_ + +#include "pipe/p_compiler.h" +#include "pipe/p_format.h" + +#include "common/native.h" +#include "common/native_helper.h" + +#include "wayland-egl-priv.h" + +struct wayland_display { + struct native_display base; + + struct wayland_config *config; + struct wl_egl_display *dpy; +}; + +enum wayland_buffer_type { + WL_BUFFER_FRONT, + WL_BUFFER_BACK, + WL_BUFFER_COUNT +}; + +enum wayland_surface_type { + WL_WINDOW_SURFACE, + WL_PIXMAP_SURFACE, + WL_PBUFFER_SURFACE +}; + +struct wayland_surface { + struct native_surface base; + struct wayland_display *display; + + struct wl_egl_window *win; + struct wl_egl_pixmap *pix; + enum wayland_surface_type type; + int dx, dy; + struct resource_surface *rsurf; + struct pipe_resource *pending_resource; + enum pipe_format color_format; + + unsigned int sequence_number; + struct wl_buffer *buffer[WL_BUFFER_COUNT]; + unsigned int attachment_mask; + + boolean block_swap_buffers; +}; + +struct wayland_config { + struct native_config base; +}; + +static INLINE struct wayland_display * +wayland_display(const struct native_display *ndpy) +{ + return (struct wayland_display *) ndpy; +} + +static INLINE struct wayland_surface * +wayland_surface(const struct native_surface *nsurf) +{ + return (struct wayland_surface *) nsurf; +} + +static INLINE struct wayland_config * +wayland_config(const struct native_config *nconf) +{ + return (struct wayland_config *) nconf; +} + +#endif /* _NATIVE_WAYLAND_H_ */ diff --git a/src/gallium/state_trackers/egl/x11/native_dri2.c b/src/gallium/state_trackers/egl/x11/native_dri2.c index 8108ce4586..5afca67a4d 100644 --- a/src/gallium/state_trackers/egl/x11/native_dri2.c +++ b/src/gallium/state_trackers/egl/x11/native_dri2.c @@ -40,11 +40,6 @@ #ifdef GLX_DIRECT_RENDERING -enum dri2_surface_type { - DRI2_SURFACE_TYPE_WINDOW, - DRI2_SURFACE_TYPE_PIXMAP, -}; - struct dri2_display { struct native_display base; Display *dpy; @@ -66,7 +61,6 @@ struct dri2_display { struct dri2_surface { struct native_surface base; Drawable drawable; - enum dri2_surface_type type; enum pipe_format color_format; struct dri2_display *dri2dpy; @@ -439,12 +433,10 @@ dri2_surface_destroy(struct native_surface *nsurf) static struct dri2_surface * dri2_display_create_surface(struct native_display *ndpy, - enum dri2_surface_type type, Drawable drawable, - const struct native_config *nconf) + enum pipe_format color_format) { struct dri2_display *dri2dpy = dri2_display(ndpy); - struct dri2_config *dri2conf = dri2_config(nconf); struct dri2_surface *dri2surf; dri2surf = CALLOC_STRUCT(dri2_surface); @@ -452,9 +444,8 @@ dri2_display_create_surface(struct native_display *ndpy, return NULL; dri2surf->dri2dpy = dri2dpy; - dri2surf->type = type; dri2surf->drawable = drawable; - dri2surf->color_format = dri2conf->base.color_format; + dri2surf->color_format = color_format; dri2surf->base.destroy = dri2_surface_destroy; dri2surf->base.present = dri2_surface_present; @@ -480,8 +471,8 @@ dri2_display_create_window_surface(struct native_display *ndpy, { struct dri2_surface *dri2surf; - dri2surf = dri2_display_create_surface(ndpy, DRI2_SURFACE_TYPE_WINDOW, - (Drawable) win, nconf); + dri2surf = dri2_display_create_surface(ndpy, + (Drawable) win, nconf->color_format); return (dri2surf) ? &dri2surf->base : NULL; } @@ -492,8 +483,29 @@ dri2_display_create_pixmap_surface(struct native_display *ndpy, { struct dri2_surface *dri2surf; - dri2surf = dri2_display_create_surface(ndpy, DRI2_SURFACE_TYPE_PIXMAP, - (Drawable) pix, nconf); + if (!nconf) { + struct dri2_display *dri2dpy = dri2_display(ndpy); + uint depth, nconf_depth; + int i; + + depth = x11_drawable_get_depth(dri2dpy->xscr, (Drawable) pix); + for (i = 0; i < dri2dpy->num_configs; i++) { + nconf_depth = util_format_get_blocksizebits( + dri2dpy->configs[i].base.color_format); + /* simple depth match for now */ + if (depth == nconf_depth || + (depth == 24 && depth + 8 == nconf_depth)) { + nconf = &dri2dpy->configs[i].base; + break; + } + } + + if (!nconf) + return NULL; + } + + dri2surf = dri2_display_create_surface(ndpy, + (Drawable) pix, nconf->color_format); return (dri2surf) ? &dri2surf->base : NULL; } @@ -529,7 +541,7 @@ is_format_supported(struct pipe_screen *screen, { return screen->is_format_supported(screen, fmt, PIPE_TEXTURE_2D, sample_count, (is_color) ? PIPE_BIND_RENDER_TARGET : - PIPE_BIND_DEPTH_STENCIL, 0); + PIPE_BIND_DEPTH_STENCIL); } static boolean @@ -548,6 +560,10 @@ dri2_display_convert_config(struct native_display *ndpy, if (!mode->xRenderable || !mode->drawableType) return FALSE; + /* fast/slow configs are probably not relevant */ + if (mode->visualRating == GLX_SLOW_CONFIG) + return FALSE; + nconf->buffer_mask = 1 << NATIVE_ATTACHMENT_FRONT_LEFT; if (mode->doubleBufferMode) nconf->buffer_mask |= 1 << NATIVE_ATTACHMENT_BACK_LEFT; @@ -568,17 +584,33 @@ dri2_display_convert_config(struct native_display *ndpy, if (nconf->color_format == PIPE_FORMAT_NONE) return FALSE; - if (mode->drawableType & GLX_WINDOW_BIT) + if ((mode->drawableType & GLX_WINDOW_BIT) && mode->visualID) nconf->window_bit = TRUE; if (mode->drawableType & GLX_PIXMAP_BIT) nconf->pixmap_bit = TRUE; nconf->native_visual_id = mode->visualID; - nconf->native_visual_type = mode->visualType; + switch (mode->visualType) { + case GLX_TRUE_COLOR: + nconf->native_visual_type = TrueColor; + break; + case GLX_DIRECT_COLOR: + nconf->native_visual_type = DirectColor; + break; + case GLX_PSEUDO_COLOR: + nconf->native_visual_type = PseudoColor; + break; + case GLX_STATIC_COLOR: + nconf->native_visual_type = StaticColor; + break; + case GLX_GRAY_SCALE: + nconf->native_visual_type = GrayScale; + break; + case GLX_STATIC_GRAY: + nconf->native_visual_type = StaticGray; + break; + } nconf->level = mode->level; - nconf->samples = mode->samples; - - nconf->slow_config = (mode->visualRating == GLX_SLOW_CONFIG); if (mode->transparentPixel == GLX_TRANSPARENT_RGB) { nconf->transparent_rgb = TRUE; @@ -614,8 +646,17 @@ dri2_display_get_configs(struct native_display *ndpy, int *num_configs) count = 0; for (i = 0; i < num_modes; i++) { struct native_config *nconf = &dri2dpy->configs[count].base; - if (dri2_display_convert_config(&dri2dpy->base, modes, nconf)) - count++; + + if (dri2_display_convert_config(&dri2dpy->base, modes, nconf)) { + int j; + /* look for duplicates */ + for (j = 0; j < count; j++) { + if (memcmp(&dri2dpy->configs[j], nconf, sizeof(*nconf)) == 0) + break; + } + if (j == count) + count++; + } modes = modes->next; } @@ -741,7 +782,7 @@ dri2_display_init_screen(struct native_display *ndpy) dri2dpy->event_handler->new_drm_screen(&dri2dpy->base, dri2dpy->dri_driver, fd); if (!dri2dpy->base.screen) { - _eglLog(_EGL_WARNING, "failed to create DRM screen"); + _eglLog(_EGL_DEBUG, "failed to create DRM screen"); return FALSE; } @@ -758,7 +799,7 @@ dri2_display_hash_table_hash(void *key) static int dri2_display_hash_table_compare(void *key1, void *key2) { - return (key1 - key2); + return ((char *) key1 - (char *) key2); } struct native_display * diff --git a/src/gallium/state_trackers/egl/x11/native_x11.c b/src/gallium/state_trackers/egl/x11/native_x11.c index 37c8b01541..a0bcad4c73 100644 --- a/src/gallium/state_trackers/egl/x11/native_x11.c +++ b/src/gallium/state_trackers/egl/x11/native_x11.c @@ -30,25 +30,30 @@ #include "native_x11.h" +static struct native_event_handler *x11_event_handler; + +static void +native_set_event_handler(struct native_event_handler *event_handler) +{ + x11_event_handler = event_handler; +} + static struct native_display * -native_create_display(void *dpy, struct native_event_handler *event_handler, - void *user_data) +native_create_display(void *dpy, boolean use_sw, void *user_data) { struct native_display *ndpy = NULL; boolean force_sw; force_sw = debug_get_bool_option("EGL_SOFTWARE", FALSE); - if (!force_sw) { - ndpy = x11_create_dri2_display((Display *) dpy, - event_handler, user_data); - } - - if (!ndpy) { - EGLint level = (force_sw) ? _EGL_INFO : _EGL_WARNING; - _eglLog(level, "use software fallback"); + if (force_sw || use_sw) { + _eglLog(_EGL_INFO, "use software fallback"); ndpy = x11_create_ximage_display((Display *) dpy, - event_handler, user_data); + x11_event_handler, user_data); + } + else { + ndpy = x11_create_dri2_display((Display *) dpy, + x11_event_handler, user_data); } return ndpy; @@ -56,6 +61,7 @@ native_create_display(void *dpy, struct native_event_handler *event_handler, static const struct native_platform x11_platform = { "X11", /* name */ + native_set_event_handler, native_create_display }; diff --git a/src/gallium/state_trackers/egl/x11/native_ximage.c b/src/gallium/state_trackers/egl/x11/native_ximage.c index 84811fb6e1..8e32c6ff0c 100644 --- a/src/gallium/state_trackers/egl/x11/native_ximage.c +++ b/src/gallium/state_trackers/egl/x11/native_ximage.c @@ -38,11 +38,6 @@ #include "native_x11.h" #include "x11_screen.h" -enum ximage_surface_type { - XIMAGE_SURFACE_TYPE_WINDOW, - XIMAGE_SURFACE_TYPE_PIXMAP, -}; - struct ximage_display { struct native_display base; Display *dpy; @@ -60,7 +55,6 @@ struct ximage_display { struct ximage_surface { struct native_surface base; Drawable drawable; - enum ximage_surface_type type; enum pipe_format color_format; XVisualInfo visual; struct ximage_display *xdpy; @@ -245,7 +239,6 @@ ximage_surface_destroy(struct native_surface *nsurf) static struct ximage_surface * ximage_display_create_surface(struct native_display *ndpy, - enum ximage_surface_type type, Drawable drawable, const struct native_config *nconf) { @@ -258,7 +251,6 @@ ximage_display_create_surface(struct native_display *ndpy, return NULL; xsurf->xdpy = xdpy; - xsurf->type = type; xsurf->color_format = xconf->base.color_format; xsurf->drawable = drawable; @@ -297,11 +289,37 @@ ximage_display_create_window_surface(struct native_display *ndpy, { struct ximage_surface *xsurf; - xsurf = ximage_display_create_surface(ndpy, XIMAGE_SURFACE_TYPE_WINDOW, - (Drawable) win, nconf); + xsurf = ximage_display_create_surface(ndpy, (Drawable) win, nconf); return (xsurf) ? &xsurf->base : NULL; } +static enum pipe_format +get_pixmap_format(struct native_display *ndpy, EGLNativePixmapType pix) +{ + struct ximage_display *xdpy = ximage_display(ndpy); + enum pipe_format fmt; + uint depth; + + depth = x11_drawable_get_depth(xdpy->xscr, (Drawable) pix); + + switch (depth) { + case 32: + fmt = PIPE_FORMAT_B8G8R8A8_UNORM; + break; + case 24: + fmt = PIPE_FORMAT_B8G8R8X8_UNORM; + break; + case 16: + fmt = PIPE_FORMAT_B5G6R5_UNORM; + break; + default: + fmt = PIPE_FORMAT_NONE; + break; + } + + return fmt; +} + static struct native_surface * ximage_display_create_pixmap_surface(struct native_display *ndpy, EGLNativePixmapType pix, @@ -309,8 +327,26 @@ ximage_display_create_pixmap_surface(struct native_display *ndpy, { struct ximage_surface *xsurf; - xsurf = ximage_display_create_surface(ndpy, XIMAGE_SURFACE_TYPE_PIXMAP, - (Drawable) pix, nconf); + /* find the config */ + if (!nconf) { + struct ximage_display *xdpy = ximage_display(ndpy); + enum pipe_format fmt = get_pixmap_format(&xdpy->base, pix); + int i; + + if (fmt != PIPE_FORMAT_NONE) { + for (i = 0; i < xdpy->num_configs; i++) { + if (xdpy->configs[i].base.color_format == fmt) { + nconf = &xdpy->configs[i].base; + break; + } + } + } + + if (!nconf) + return NULL; + } + + xsurf = ximage_display_create_surface(ndpy, (Drawable) pix, nconf); return (xsurf) ? &xsurf->base : NULL; } @@ -384,8 +420,6 @@ ximage_display_get_configs(struct native_display *ndpy, int *num_configs) xconf->base.native_visual_type = xconf->visual->class; #endif - xconf->base.slow_config = TRUE; - count++; } @@ -408,24 +442,7 @@ ximage_display_is_pixmap_supported(struct native_display *ndpy, const struct native_config *nconf) { struct ximage_display *xdpy = ximage_display(ndpy); - enum pipe_format fmt; - uint depth; - - depth = x11_drawable_get_depth(xdpy->xscr, (Drawable) pix); - switch (depth) { - case 32: - fmt = PIPE_FORMAT_B8G8R8A8_UNORM; - break; - case 24: - fmt = PIPE_FORMAT_B8G8R8X8_UNORM; - break; - case 16: - fmt = PIPE_FORMAT_B5G6R5_UNORM; - break; - default: - fmt = PIPE_FORMAT_NONE; - break; - } + enum pipe_format fmt = get_pixmap_format(&xdpy->base, pix); return (fmt == nconf->color_format); } @@ -459,7 +476,7 @@ ximage_display_destroy(struct native_display *ndpy) if (xdpy->configs) FREE(xdpy->configs); - xdpy->base.screen->destroy(xdpy->base.screen); + ndpy_uninit(ndpy); x11_screen_destroy(xdpy->xscr); if (xdpy->own_dpy) diff --git a/src/gallium/state_trackers/glx/xlib/glx_api.c b/src/gallium/state_trackers/glx/xlib/glx_api.c index 205a7e3c19..351267bae4 100644 --- a/src/gallium/state_trackers/glx/xlib/glx_api.c +++ b/src/gallium/state_trackers/glx/xlib/glx_api.c @@ -1367,8 +1367,8 @@ glXSwapBuffers( Display *dpy, GLXDrawable drawable ) /*** GLX_MESA_copy_sub_buffer ***/ PUBLIC void -glXCopySubBufferMESA( Display *dpy, GLXDrawable drawable, - int x, int y, int width, int height ) +glXCopySubBufferMESA(Display *dpy, GLXDrawable drawable, + int x, int y, int width, int height) { XMesaBuffer buffer = XMesaFindBuffer( dpy, drawable ); if (buffer) { @@ -1718,8 +1718,8 @@ glXGetClientString( Display *dpy, int name ) PUBLIC int -glXGetFBConfigAttrib( Display *dpy, GLXFBConfig config, - int attribute, int *value ) +glXGetFBConfigAttrib(Display *dpy, GLXFBConfig config, + int attribute, int *value) { XMesaVisual v = (XMesaVisual) config; (void) dpy; @@ -1763,8 +1763,8 @@ glXGetFBConfigs( Display *dpy, int screen, int *nelements ) PUBLIC GLXFBConfig * -glXChooseFBConfig( Display *dpy, int screen, - const int *attribList, int *nitems ) +glXChooseFBConfig(Display *dpy, int screen, + const int *attribList, int *nitems) { XMesaVisual xmvis; @@ -1814,8 +1814,8 @@ glXGetVisualFromFBConfig( Display *dpy, GLXFBConfig config ) PUBLIC GLXWindow -glXCreateWindow( Display *dpy, GLXFBConfig config, Window win, - const int *attribList ) +glXCreateWindow(Display *dpy, GLXFBConfig config, Window win, + const int *attribList) { XMesaVisual xmvis = (XMesaVisual) config; XMesaBuffer xmbuf; @@ -1845,8 +1845,8 @@ glXDestroyWindow( Display *dpy, GLXWindow window ) /* XXX untested */ PUBLIC GLXPixmap -glXCreatePixmap( Display *dpy, GLXFBConfig config, Pixmap pixmap, - const int *attribList ) +glXCreatePixmap(Display *dpy, GLXFBConfig config, Pixmap pixmap, + const int *attribList) { XMesaVisual v = (XMesaVisual) config; XMesaBuffer b; @@ -1965,8 +1965,7 @@ glXDestroyPixmap( Display *dpy, GLXPixmap pixmap ) PUBLIC GLXPbuffer -glXCreatePbuffer( Display *dpy, GLXFBConfig config, - const int *attribList ) +glXCreatePbuffer(Display *dpy, GLXFBConfig config, const int *attribList) { XMesaVisual xmvis = (XMesaVisual) config; XMesaBuffer xmbuf; @@ -2038,8 +2037,8 @@ glXDestroyPbuffer( Display *dpy, GLXPbuffer pbuf ) PUBLIC void -glXQueryDrawable( Display *dpy, GLXDrawable draw, int attribute, - unsigned int *value ) +glXQueryDrawable(Display *dpy, GLXDrawable draw, int attribute, + unsigned int *value) { GLuint width, height; XMesaBuffer xmbuf = XMesaFindBuffer(dpy, draw); @@ -2085,7 +2084,7 @@ glXQueryDrawable( Display *dpy, GLXDrawable draw, int attribute, PUBLIC GLXContext glXCreateNewContext( Display *dpy, GLXFBConfig config, - int renderType, GLXContext shareList, Bool direct ) + int renderType, GLXContext shareList, Bool direct ) { GLXContext glxCtx; GLXContext shareCtx = shareList; @@ -2156,8 +2155,7 @@ glXSelectEvent( Display *dpy, GLXDrawable drawable, unsigned long mask ) PUBLIC void -glXGetSelectedEvent( Display *dpy, GLXDrawable drawable, - unsigned long *mask ) +glXGetSelectedEvent(Display *dpy, GLXDrawable drawable, unsigned long *mask) { XMesaBuffer xmbuf = XMesaFindBuffer(dpy, drawable); if (xmbuf) @@ -2209,7 +2207,8 @@ glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count) /*** GLX_SGI_make_current_read ***/ PUBLIC Bool -glXMakeCurrentReadSGI(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx) +glXMakeCurrentReadSGI(Display *dpy, GLXDrawable draw, GLXDrawable read, + GLXContext ctx) { return glXMakeContextCurrent( dpy, draw, read, ctx ); } @@ -2227,7 +2226,8 @@ glXGetCurrentReadDrawableSGI(void) #if defined(_VL_H) PUBLIC GLXVideoSourceSGIX -glXCreateGLXVideoSourceSGIX(Display *dpy, int screen, VLServer server, VLPath path, int nodeClass, VLNode drainNode) +glXCreateGLXVideoSourceSGIX(Display *dpy, int screen, VLServer server, + VLPath path, int nodeClass, VLNode drainNode) { (void) dpy; (void) screen; @@ -2273,7 +2273,8 @@ glXImportContextEXT(Display *dpy, GLXContextID contextID) } PUBLIC int -glXQueryContextInfoEXT(Display *dpy, GLXContext context, int attribute, int *value) +glXQueryContextInfoEXT(Display *dpy, GLXContext context, int attribute, + int *value) { (void) dpy; (void) context; @@ -2287,20 +2288,24 @@ glXQueryContextInfoEXT(Display *dpy, GLXContext context, int attribute, int *val /*** GLX_SGIX_fbconfig ***/ PUBLIC int -glXGetFBConfigAttribSGIX(Display *dpy, GLXFBConfigSGIX config, int attribute, int *value) +glXGetFBConfigAttribSGIX(Display *dpy, GLXFBConfigSGIX config, + int attribute, int *value) { return glXGetFBConfigAttrib(dpy, config, attribute, value); } PUBLIC GLXFBConfigSGIX * -glXChooseFBConfigSGIX(Display *dpy, int screen, int *attrib_list, int *nelements) +glXChooseFBConfigSGIX(Display *dpy, int screen, int *attrib_list, + int *nelements) { - return (GLXFBConfig *) glXChooseFBConfig(dpy, screen, attrib_list, nelements); + return (GLXFBConfig *) glXChooseFBConfig(dpy, screen, + attrib_list, nelements); } PUBLIC GLXPixmap -glXCreateGLXPixmapWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap) +glXCreateGLXPixmapWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, + Pixmap pixmap) { XMesaVisual xmvis = (XMesaVisual) config; XMesaBuffer xmbuf = XMesaCreatePixmapBuffer(xmvis, pixmap, 0); @@ -2309,7 +2314,9 @@ glXCreateGLXPixmapWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, Pixmap pi PUBLIC GLXContext -glXCreateContextWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct) +glXCreateContextWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, + int render_type, GLXContext share_list, + Bool direct) { XMesaVisual xmvis = (XMesaVisual) config; GLXContext glxCtx; @@ -2362,8 +2369,8 @@ glXGetFBConfigFromVisualSGIX(Display *dpy, XVisualInfo *vis) PUBLIC GLXPbufferSGIX glXCreateGLXPbufferSGIX(Display *dpy, GLXFBConfigSGIX config, - unsigned int width, unsigned int height, - int *attribList) + unsigned int width, unsigned int height, + int *attribList) { XMesaVisual xmvis = (XMesaVisual) config; XMesaBuffer xmbuf; @@ -2410,7 +2417,8 @@ glXDestroyGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf) PUBLIC int -glXQueryGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int *value) +glXQueryGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf, int attribute, + unsigned int *value) { const XMesaBuffer xmbuf = XMesaFindBuffer(dpy, pbuf); @@ -2454,7 +2462,8 @@ glXSelectEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long mask) PUBLIC void -glXGetSelectedEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long *mask) +glXGetSelectedEventSGIX(Display *dpy, GLXDrawable drawable, + unsigned long *mask) { XMesaBuffer xmbuf = XMesaFindBuffer(dpy, drawable); if (xmbuf) { @@ -2482,7 +2491,8 @@ glXCushionSGI(Display *dpy, Window win, float cushion) /*** GLX_SGIX_video_resize ***/ PUBLIC int -glXBindChannelToWindowSGIX(Display *dpy, int screen, int channel , Window window) +glXBindChannelToWindowSGIX(Display *dpy, int screen, int channel, + Window window) { (void) dpy; (void) screen; @@ -2492,7 +2502,8 @@ glXBindChannelToWindowSGIX(Display *dpy, int screen, int channel , Window window } PUBLIC int -glXChannelRectSGIX(Display *dpy, int screen, int channel, int x, int y, int w, int h) +glXChannelRectSGIX(Display *dpy, int screen, int channel, + int x, int y, int w, int h) { (void) dpy; (void) screen; @@ -2505,7 +2516,8 @@ glXChannelRectSGIX(Display *dpy, int screen, int channel, int x, int y, int w, i } PUBLIC int -glXQueryChannelRectSGIX(Display *dpy, int screen, int channel, int *x, int *y, int *w, int *h) +glXQueryChannelRectSGIX(Display *dpy, int screen, int channel, + int *x, int *y, int *w, int *h) { (void) dpy; (void) screen; @@ -2518,7 +2530,8 @@ glXQueryChannelRectSGIX(Display *dpy, int screen, int channel, int *x, int *y, i } PUBLIC int -glXQueryChannelDeltasSGIX(Display *dpy, int screen, int channel, int *dx, int *dy, int *dw, int *dh) +glXQueryChannelDeltasSGIX(Display *dpy, int screen, int channel, + int *dx, int *dy, int *dw, int *dh) { (void) dpy; (void) screen; @@ -2546,7 +2559,8 @@ glXChannelRectSyncSGIX(Display *dpy, int screen, int channel, GLenum synctype) #if defined(_DM_BUFFER_H_) PUBLIC Bool -glXAssociateDMPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuffer, DMparams *params, DMbuffer dmbuffer) +glXAssociateDMPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuffer, + DMparams *params, DMbuffer dmbuffer) { (void) dpy; (void) pbuffer; @@ -2593,7 +2607,8 @@ glXQueryMaxSwapBarriersSGIX(Display *dpy, int screen, int *max) /*** GLX_SUN_get_transparent_index ***/ PUBLIC Status -glXGetTransparentIndexSUN(Display *dpy, Window overlay, Window underlay, long *pTransparent) +glXGetTransparentIndexSUN(Display *dpy, Window overlay, Window underlay, + long *pTransparent) { (void) dpy; (void) overlay; diff --git a/src/gallium/state_trackers/glx/xlib/xm_api.c b/src/gallium/state_trackers/glx/xlib/xm_api.c index 7c47a25ceb..3b35cbc890 100644 --- a/src/gallium/state_trackers/glx/xlib/xm_api.c +++ b/src/gallium/state_trackers/glx/xlib/xm_api.c @@ -376,8 +376,6 @@ choose_depth_stencil_format(XMesaDisplay xmdpy, int depth, int stencil) { const enum pipe_texture_target target = PIPE_TEXTURE_2D; const unsigned tex_usage = PIPE_BIND_DEPTH_STENCIL; - const unsigned geom_flags = (PIPE_TEXTURE_GEOM_NON_SQUARE | - PIPE_TEXTURE_GEOM_NON_POWER_OF_TWO); const unsigned sample_count = 0; enum pipe_format formats[8], fmt; int count, i; @@ -403,7 +401,7 @@ choose_depth_stencil_format(XMesaDisplay xmdpy, int depth, int stencil) for (i = 0; i < count; i++) { if (xmdpy->screen->is_format_supported(xmdpy->screen, formats[i], target, sample_count, - tex_usage, geom_flags)) { + tex_usage)) { fmt = formats[i]; break; } @@ -1195,11 +1193,7 @@ void XMesaSwapBuffers( XMesaBuffer b ) XMesaContext xmctx = XMesaGetCurrentContext(); if (xmctx && xmctx->xm_buffer == b) { - xmctx->st->flush( xmctx->st, - PIPE_FLUSH_RENDER_CACHE | - PIPE_FLUSH_SWAPBUFFERS | - PIPE_FLUSH_FRAME, - NULL); + xmctx->st->flush( xmctx->st, ST_FLUSH_FRONT, NULL); } xmesa_swap_st_framebuffer(b->stfb); @@ -1225,9 +1219,10 @@ void XMesaFlush( XMesaContext c ) XMesaDisplay xmdpy = xmesa_init_display(c->xm_visual->display); struct pipe_fence_handle *fence = NULL; - c->st->flush(c->st, PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, &fence); + c->st->flush(c->st, ST_FLUSH_FRONT, &fence); if (fence) { - xmdpy->screen->fence_finish(xmdpy->screen, fence, 0); + xmdpy->screen->fence_finish(xmdpy->screen, fence, + PIPE_TIMEOUT_INFINITE); xmdpy->screen->fence_reference(xmdpy->screen, &fence, NULL); } XFlush( c->xm_visual->display ); diff --git a/src/gallium/state_trackers/python/p_context.i b/src/gallium/state_trackers/python/p_context.i index 5bdeaa8e4e..17d25ad0aa 100644 --- a/src/gallium/state_trackers/python/p_context.i +++ b/src/gallium/state_trackers/python/p_context.i @@ -268,7 +268,6 @@ struct st_context { void set_vertex_buffer(unsigned index, unsigned stride, - unsigned max_index, unsigned buffer_offset, struct pipe_resource *buffer) { @@ -277,7 +276,6 @@ struct st_context { memset(&state, 0, sizeof(state)); state.stride = stride; - state.max_index = max_index; state.buffer_offset = buffer_offset; state.buffer = buffer; @@ -352,6 +350,7 @@ struct st_context { vbuf = pipe_buffer_create(screen, PIPE_BIND_VERTEX_BUFFER, + PIPE_USAGE_STATIC, size); if(!vbuf) goto error1; @@ -360,7 +359,7 @@ struct st_context { if (!map) goto error2; memcpy(map, vertices, size); - pipe_buffer_unmap(pipe, vbuf, transfer); + pipe_buffer_unmap(pipe, transfer); cso_save_vertex_elements($self->cso); @@ -378,7 +377,6 @@ struct st_context { vbuffer.buffer = vbuf; vbuffer.stride = num_attribs * 4 * sizeof(float); /* vertex size */ vbuffer.buffer_offset = 0; - vbuffer.max_index = num_verts - 1; pipe->set_vertex_buffers(pipe, 1, &vbuffer); /* draw */ @@ -402,10 +400,10 @@ error1: void flush(unsigned flags = 0) { struct pipe_fence_handle *fence = NULL; - $self->pipe->flush($self->pipe, flags | PIPE_FLUSH_RENDER_CACHE, &fence); + $self->pipe->flush($self->pipe, &fence); if(fence) { /* TODO: allow asynchronous operation */ - $self->pipe->screen->fence_finish( $self->pipe->screen, fence, 0 ); + $self->pipe->screen->fence_finish( $self->pipe->screen, fence, PIPE_TIMEOUT_INFINITE ); $self->pipe->screen->fence_reference( $self->pipe->screen, &fence, NULL ); } } diff --git a/src/gallium/state_trackers/python/p_device.i b/src/gallium/state_trackers/python/p_device.i index d55086fefd..61f6b3bb73 100644 --- a/src/gallium/state_trackers/python/p_device.i +++ b/src/gallium/state_trackers/python/p_device.i @@ -86,8 +86,7 @@ struct st_device { int is_format_supported( enum pipe_format format, enum pipe_texture_target target, unsigned sample_count, - unsigned bind, - unsigned geom_flags ) { + unsigned bind ) { /* We can't really display surfaces with the python statetracker so mask * out that usage */ bind &= ~PIPE_BIND_DISPLAY_TARGET; @@ -96,8 +95,7 @@ struct st_device { format, target, sample_count, - bind, - geom_flags ); + bind ); } struct st_context * @@ -134,7 +132,7 @@ struct st_device { } struct pipe_resource * - buffer_create(unsigned size, unsigned bind = 0) { - return pipe_buffer_create($self->screen, bind, size); + buffer_create(unsigned size, unsigned usage, unsigned bind = 0) { + return pipe_buffer_create($self->screen, bind, usage, size); } }; diff --git a/src/gallium/state_trackers/vega/Makefile b/src/gallium/state_trackers/vega/Makefile index 7342c124c2..3e8ad49b76 100644 --- a/src/gallium/state_trackers/vega/Makefile +++ b/src/gallium/state_trackers/vega/Makefile @@ -24,23 +24,25 @@ C_SOURCES = \ api_path.c \ api_text.c \ api_transform.c \ - vgu.c \ - vg_context.c \ - vg_manager.c \ - vg_state.c \ - vg_translate.c \ - polygon.c \ - bezier.c \ - path.c \ - paint.c \ arc.c \ + bezier.c \ + handle.c \ image.c \ + mask.c \ + paint.c \ + path.c \ + polygon.c \ renderer.c \ + shader.c \ + shaders_cache.c \ stroker.c \ - mask.c \ text.c \ - shader.c \ - shaders_cache.c + vg_context.c \ + vg_manager.c \ + vg_state.c \ + vg_translate.c \ + vgu.c + GENERATED_SOURCES := api_tmp.h diff --git a/src/gallium/state_trackers/vega/SConscript b/src/gallium/state_trackers/vega/SConscript index 4900135a1c..f3732aa157 100644 --- a/src/gallium/state_trackers/vega/SConscript +++ b/src/gallium/state_trackers/vega/SConscript @@ -26,23 +26,24 @@ vega_sources = [ 'api_path.c', 'api_text.c', 'api_transform.c', - 'vgu.c', - 'vg_context.c', - 'vg_manager.c', - 'vg_state.c', - 'vg_translate.c', - 'polygon.c', - 'bezier.c', - 'path.c', - 'paint.c', 'arc.c', + 'bezier.c', + 'handle.c', 'image.c', - 'renderer.c', - 'stroker.c', 'mask.c', + 'paint.c', + 'path.c', + 'polygon.c', + 'renderer.c', 'shader.c', 'shaders_cache.c', + 'stroker.c', 'text.c', + 'vg_context.c', + 'vg_manager.c', + 'vg_state.c', + 'vg_translate.c', + 'vgu.c' ] api_tmp = env.CodeGenerate( diff --git a/src/gallium/state_trackers/vega/api_context.c b/src/gallium/state_trackers/vega/api_context.c index d6bbda5e07..19e42dd156 100644 --- a/src/gallium/state_trackers/vega/api_context.c +++ b/src/gallium/state_trackers/vega/api_context.c @@ -56,7 +56,7 @@ void vegaFlush(void) return; pipe = ctx->pipe; - pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL); + pipe->flush(pipe, NULL); vg_manager_flush_frontbuffer(ctx); } @@ -72,9 +72,10 @@ void vegaFinish(void) pipe = ctx->pipe; - pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, &fence); + pipe->flush(pipe, &fence); if (fence) { - pipe->screen->fence_finish(pipe->screen, fence, 0); + pipe->screen->fence_finish(pipe->screen, fence, + PIPE_TIMEOUT_INFINITE); pipe->screen->fence_reference(pipe->screen, &fence, NULL); } } diff --git a/src/gallium/state_trackers/vega/api_filters.c b/src/gallium/state_trackers/vega/api_filters.c index 724e38241b..6be460c495 100644 --- a/src/gallium/state_trackers/vega/api_filters.c +++ b/src/gallium/state_trackers/vega/api_filters.c @@ -29,6 +29,7 @@ #include "vg_context.h" #include "image.h" #include "api.h" +#include "handle.h" #include "renderer.h" #include "shaders_cache.h" @@ -251,8 +252,8 @@ void vegaColorMatrix(VGImage dst, VGImage src, return; } - d = (struct vg_image*)dst; - s = (struct vg_image*)src; + d = handle_to_image(dst); + s = handle_to_image(src); if (vg_image_overlaps(d, s)) { vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); @@ -293,7 +294,7 @@ void vegaConvolve(VGImage dst, VGImage src, struct vg_image *d, *s; VGint kernel_size = kernelWidth * kernelHeight; struct filter_info info; - const VGint max_kernel_size = vgGeti(VG_MAX_KERNEL_SIZE); + const VGint max_kernel_size = vegaGeti(VG_MAX_KERNEL_SIZE); if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); @@ -317,8 +318,8 @@ void vegaConvolve(VGImage dst, VGImage src, return; } - d = (struct vg_image*)dst; - s = (struct vg_image*)src; + d = handle_to_image(dst); + s = handle_to_image(src); if (vg_image_overlaps(d, s)) { vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); @@ -395,7 +396,7 @@ void vegaSeparableConvolve(VGImage dst, VGImage src, struct vg_context *ctx = vg_current_context(); VGshort *kernel; VGint i, j, idx = 0; - const VGint max_kernel_size = vgGeti(VG_MAX_SEPARABLE_KERNEL_SIZE); + const VGint max_kernel_size = vegaGeti(VG_MAX_SEPARABLE_KERNEL_SIZE); if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); @@ -425,8 +426,8 @@ void vegaSeparableConvolve(VGImage dst, VGImage src, ++idx; } } - vgConvolve(dst, src, kernelWidth, kernelHeight, shiftX, shiftY, - kernel, scale, bias, tilingMode); + vegaConvolve(dst, src, kernelWidth, kernelHeight, shiftX, shiftY, + kernel, scale, bias, tilingMode); free(kernel); } @@ -502,8 +503,8 @@ void vegaGaussianBlur(VGImage dst, VGImage src, return; } - d = (struct vg_image*)dst; - s = (struct vg_image*)src; + d = handle_to_image(dst); + s = handle_to_image(src); if (vg_image_overlaps(d, s)) { vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); @@ -599,8 +600,8 @@ void vegaLookup(VGImage dst, VGImage src, return; } - d = (struct vg_image*)dst; - s = (struct vg_image*)src; + d = handle_to_image(dst); + s = handle_to_image(src); if (vg_image_overlaps(d, s)) { vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); @@ -662,8 +663,8 @@ void vegaLookupSingle(VGImage dst, VGImage src, return; } - d = (struct vg_image*)dst; - s = (struct vg_image*)src; + d = handle_to_image(dst); + s = handle_to_image(src); if (vg_image_overlaps(d, s)) { vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); diff --git a/src/gallium/state_trackers/vega/api_images.c b/src/gallium/state_trackers/vega/api_images.c index ad95409cd0..2cb5622f81 100644 --- a/src/gallium/state_trackers/vega/api_images.c +++ b/src/gallium/state_trackers/vega/api_images.c @@ -32,6 +32,7 @@ #include "vg_translate.h" #include "api_consts.h" #include "api.h" +#include "handle.h" #include "pipe/p_context.h" #include "pipe/p_screen.h" @@ -105,12 +106,12 @@ VGImage vegaCreateImage(VGImageFormat format, vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); return VG_INVALID_HANDLE; } - if (width > vgGeti(VG_MAX_IMAGE_WIDTH) || - height > vgGeti(VG_MAX_IMAGE_HEIGHT)) { + if (width > vegaGeti(VG_MAX_IMAGE_WIDTH) || + height > vegaGeti(VG_MAX_IMAGE_HEIGHT)) { vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); return VG_INVALID_HANDLE; } - if (width * height > vgGeti(VG_MAX_IMAGE_PIXELS)) { + if (width * height > vegaGeti(VG_MAX_IMAGE_PIXELS)) { vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); return VG_INVALID_HANDLE; } @@ -122,19 +123,19 @@ VGImage vegaCreateImage(VGImageFormat format, return VG_INVALID_HANDLE; } - return (VGImage)image_create(format, width, height); + return image_to_handle(image_create(format, width, height)); } void vegaDestroyImage(VGImage image) { struct vg_context *ctx = vg_current_context(); - struct vg_image *img = (struct vg_image *)image; + struct vg_image *img = handle_to_image(image); if (image == VG_INVALID_HANDLE) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } - if (!vg_object_is_valid((void*)image, VG_OBJECT_IMAGE)) { + if (!vg_object_is_valid(image, VG_OBJECT_IMAGE)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } @@ -157,7 +158,7 @@ void vegaClearImage(VGImage image, return; } - img = (struct vg_image*)image; + img = handle_to_image(image); if (x + width < 0 || y + height < 0) return; @@ -189,7 +190,7 @@ void vegaImageSubData(VGImage image, return; } - img = (struct vg_image*)(image); + img = handle_to_image(image); image_sub_data(img, data, dataStride, dataFormat, x, y, width, height); } @@ -216,7 +217,7 @@ void vegaGetImageSubData(VGImage image, vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); return; } - img = (struct vg_image*)image; + img = handle_to_image(image); image_get_sub_data(img, data, dataStride, dataFormat, x, y, width, height); } @@ -229,8 +230,8 @@ VGImage vegaChildImage(VGImage parent, struct vg_image *p; if (parent == VG_INVALID_HANDLE || - !vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, (void*)parent) || - !vg_object_is_valid((void*)parent, VG_OBJECT_IMAGE)) { + !vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, parent) || + !vg_object_is_valid(parent, VG_OBJECT_IMAGE)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return VG_INVALID_HANDLE; } @@ -238,7 +239,7 @@ VGImage vegaChildImage(VGImage parent, vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); return VG_INVALID_HANDLE; } - p = (struct vg_image *)parent; + p = handle_to_image(parent); if (x > p->width || y > p->height) { vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); return VG_INVALID_HANDLE; @@ -248,7 +249,7 @@ VGImage vegaChildImage(VGImage parent, return VG_INVALID_HANDLE; } - return (VGImage)image_child_image(p, x, y, width, height); + return image_to_handle(image_child_image(p, x, y, width, height)); } VGImage vegaGetParent(VGImage image) @@ -261,9 +262,9 @@ VGImage vegaGetParent(VGImage image) return VG_INVALID_HANDLE; } - img = (struct vg_image*)image; + img = handle_to_image(image); if (img->parent) - return (VGImage)img->parent; + return image_to_handle(img->parent); else return image; } @@ -285,8 +286,8 @@ void vegaCopyImage(VGImage dst, VGint dx, VGint dy, return; } vg_validate_state(ctx); - image_copy((struct vg_image*)dst, dx, dy, - (struct vg_image*)src, sx, sy, + image_copy(handle_to_image(dst), dx, dy, + handle_to_image(src), sx, sy, width, height, dither); } @@ -303,7 +304,7 @@ void vegaDrawImage(VGImage image) } vg_validate_state(ctx); - image_draw((struct vg_image*)image, + image_draw(handle_to_image(image), &ctx->state.vg.image_user_to_surface_matrix); } @@ -323,7 +324,7 @@ void vegaSetPixels(VGint dx, VGint dy, vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); return; } - image_set_pixels(dx, dy, (struct vg_image*)src, sx, sy, width, + image_set_pixels(dx, dy, handle_to_image(src), sx, sy, width, height); } @@ -343,7 +344,7 @@ void vegaGetPixels(VGImage dst, VGint dx, VGint dy, return; } - img = (struct vg_image*)dst; + img = handle_to_image(dst); image_get_pixels(img, dx, dy, sx, sy, width, height); @@ -355,7 +356,6 @@ void vegaWritePixels(const void * data, VGint dataStride, VGint width, VGint height) { struct vg_context *ctx = vg_current_context(); - struct pipe_context *pipe = ctx->pipe; if (!supported_image_format(dataFormat)) { vg_set_error(ctx, VG_UNSUPPORTED_IMAGE_FORMAT_ERROR); @@ -386,8 +386,6 @@ void vegaWritePixels(const void * data, VGint dataStride, #endif image_destroy(img); } - /* make sure rendering has completed */ - pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL); } void vegaReadPixels(void * data, VGint dataStride, @@ -420,8 +418,6 @@ void vegaReadPixels(void * data, VGint dataStride, return; } - /* make sure rendering has completed */ - pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL); if (sx < 0) { xoffset = -sx; xoffset *= _vega_size_for_format(dataFormat); @@ -487,7 +483,7 @@ void vegaCopyPixels(VGint dx, VGint dy, vg_validate_state(ctx); /* make sure rendering has completed */ - vgFinish(); + vegaFinish(); vg_copy_surface(ctx, strb->surface, dx, dy, strb->surface, sx, sy, width, height); diff --git a/src/gallium/state_trackers/vega/api_masks.c b/src/gallium/state_trackers/vega/api_masks.c index beb15c33a5..cdbf0026e8 100644 --- a/src/gallium/state_trackers/vega/api_masks.c +++ b/src/gallium/state_trackers/vega/api_masks.c @@ -28,14 +28,11 @@ #include "mask.h" #include "api.h" +#include "handle.h" #include "renderer.h" #include "vg_context.h" #include "pipe/p_context.h" -#include "util/u_inlines.h" - -#include "util/u_pack_color.h" -#include "util/u_draw_quad.h" void vegaMask(VGHandle mask, VGMaskOperation operation, VGint x, VGint y, @@ -60,11 +57,11 @@ void vegaMask(VGHandle mask, VGMaskOperation operation, mask_fill(x, y, width, height, 0.f); } else if (operation == VG_FILL_MASK) { mask_fill(x, y, width, height, 1.f); - } else if (vg_object_is_valid((void*)mask, VG_OBJECT_IMAGE)) { - struct vg_image *image = (struct vg_image *)mask; + } else if (vg_object_is_valid(mask, VG_OBJECT_IMAGE)) { + struct vg_image *image = handle_to_image(mask); mask_using_image(image, operation, x, y, width, height); - } else if (vg_object_is_valid((void*)mask, VG_OBJECT_MASK)) { - struct vg_mask_layer *layer = (struct vg_mask_layer *)mask; + } else if (vg_object_is_valid(mask, VG_OBJECT_MASK)) { + struct vg_mask_layer *layer = handle_to_masklayer(mask); mask_using_layer(layer, operation, x, y, width, height); } else { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); @@ -127,14 +124,14 @@ void vegaRenderToMask(VGPath path, vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); return; } - if (!vg_object_is_valid((void*)path, VG_OBJECT_PATH)) { + if (!vg_object_is_valid(path, VG_OBJECT_PATH)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } vg_validate_state(ctx); - mask_render_to((struct path *)path, paintModes, operation); + mask_render_to(handle_to_path(path), paintModes, operation); } VGMaskLayer vegaCreateMaskLayer(VGint width, VGint height) @@ -142,13 +139,13 @@ VGMaskLayer vegaCreateMaskLayer(VGint width, VGint height) struct vg_context *ctx = vg_current_context(); if (width <= 0 || height <= 0 || - width > vgGeti(VG_MAX_IMAGE_WIDTH) || - height > vgGeti(VG_MAX_IMAGE_HEIGHT)) { + width > vegaGeti(VG_MAX_IMAGE_WIDTH) || + height > vegaGeti(VG_MAX_IMAGE_HEIGHT)) { vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); return VG_INVALID_HANDLE; } - return (VGMaskLayer)mask_layer_create(width, height); + return masklayer_to_handle(mask_layer_create(width, height)); } void vegaDestroyMaskLayer(VGMaskLayer maskLayer) @@ -160,12 +157,12 @@ void vegaDestroyMaskLayer(VGMaskLayer maskLayer) vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } - if (!vg_object_is_valid((void*)maskLayer, VG_OBJECT_MASK)) { + if (!vg_object_is_valid(maskLayer, VG_OBJECT_MASK)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } - mask = (struct vg_mask_layer *)maskLayer; + mask = handle_to_masklayer(maskLayer); mask_layer_destroy(mask); } @@ -196,12 +193,12 @@ void vegaFillMaskLayer(VGMaskLayer maskLayer, return; } - if (!vg_object_is_valid((void*)maskLayer, VG_OBJECT_MASK)) { + if (!vg_object_is_valid(maskLayer, VG_OBJECT_MASK)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } - mask = (struct vg_mask_layer*)maskLayer; + mask = handle_to_masklayer(maskLayer); if (x + width > mask_layer_width(mask) || y + height > mask_layer_height(mask)) { @@ -230,14 +227,14 @@ void vegaCopyMask(VGMaskLayer maskLayer, vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); return; } - if (!vg_object_is_valid((void*)maskLayer, VG_OBJECT_MASK)) { + if (!vg_object_is_valid(maskLayer, VG_OBJECT_MASK)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } vg_validate_state(ctx); - mask = (struct vg_mask_layer*)maskLayer; + mask = handle_to_masklayer(maskLayer); mask_copy(mask, sx, sy, dx, dy, width, height); } diff --git a/src/gallium/state_trackers/vega/api_paint.c b/src/gallium/state_trackers/vega/api_paint.c index 1411806455..2610ebe057 100644 --- a/src/gallium/state_trackers/vega/api_paint.c +++ b/src/gallium/state_trackers/vega/api_paint.c @@ -29,24 +29,24 @@ #include "vg_context.h" #include "paint.h" #include "api.h" +#include "handle.h" + VGPaint vegaCreatePaint(void) { - return (VGPaint) paint_create(vg_current_context()); + return paint_to_handle(paint_create(vg_current_context())); } void vegaDestroyPaint(VGPaint p) { struct vg_context *ctx = vg_current_context(); - struct vg_paint *paint; if (p == VG_INVALID_HANDLE) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } - paint = (struct vg_paint *)p; - paint_destroy(paint); + paint_destroy(handle_to_paint(p)); } void vegaSetPaint(VGPaint paint, VGbitfield paintModes) @@ -55,8 +55,8 @@ void vegaSetPaint(VGPaint paint, VGbitfield paintModes) if (paint == VG_INVALID_HANDLE) { /* restore the default */ - paint = (VGPaint)ctx->default_paint; - } else if (!vg_object_is_valid((void*)paint, VG_OBJECT_PAINT)) { + paint = paint_to_handle(ctx->default_paint); + } else if (!vg_object_is_valid(paint, VG_OBJECT_PAINT)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } @@ -67,11 +67,13 @@ void vegaSetPaint(VGPaint paint, VGbitfield paintModes) } if (paintModes & VG_FILL_PATH) { - ctx->state.vg.fill_paint = (struct vg_paint *)paint; + ctx->state.vg.fill_paint = handle_to_paint(paint); } if (paintModes & VG_STROKE_PATH) { - ctx->state.vg.stroke_paint = (struct vg_paint *)paint; + ctx->state.vg.stroke_paint = handle_to_paint(paint); } + + ctx->state.dirty |= PAINT_DIRTY; } VGPaint vegaGetPaint(VGPaintMode paintMode) @@ -85,11 +87,11 @@ VGPaint vegaGetPaint(VGPaintMode paintMode) } if (paintMode == VG_FILL_PATH) - paint = (VGPaint)ctx->state.vg.fill_paint; + paint = paint_to_handle(ctx->state.vg.fill_paint); else if (paintMode == VG_STROKE_PATH) - paint = (VGPaint)ctx->state.vg.stroke_paint; + paint = paint_to_handle(ctx->state.vg.stroke_paint); - if (paint == (VGPaint)ctx->default_paint) + if (paint == paint_to_handle(ctx->default_paint)) paint = VG_INVALID_HANDLE; return paint; @@ -98,20 +100,24 @@ VGPaint vegaGetPaint(VGPaintMode paintMode) void vegaSetColor(VGPaint paint, VGuint rgba) { struct vg_context *ctx = vg_current_context(); + struct vg_paint *p; if (paint == VG_INVALID_HANDLE) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } - if (!vg_object_is_valid((void*)paint, VG_OBJECT_PAINT)) { + if (!vg_object_is_valid(paint, VG_OBJECT_PAINT)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } - { - struct vg_paint *p = (struct vg_paint *)paint; - paint_set_colori(p, rgba); - } + + p = handle_to_paint(paint); + paint_set_colori(p, rgba); + + if (ctx->state.vg.fill_paint == p || + ctx->state.vg.stroke_paint == p) + ctx->state.dirty |= PAINT_DIRTY; } VGuint vegaGetColor(VGPaint paint) @@ -125,11 +131,11 @@ VGuint vegaGetColor(VGPaint paint) return rgba; } - if (!vg_object_is_valid((void*)paint, VG_OBJECT_PAINT)) { + if (!vg_object_is_valid(paint, VG_OBJECT_PAINT)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return rgba; } - p = (struct vg_paint *)paint; + p = handle_to_paint(paint); return paint_colori(p); } @@ -139,28 +145,28 @@ void vegaPaintPattern(VGPaint paint, VGImage pattern) struct vg_context *ctx = vg_current_context(); if (paint == VG_INVALID_HANDLE || - !vg_context_is_object_valid(ctx, VG_OBJECT_PAINT, (void *)paint)) { + !vg_context_is_object_valid(ctx, VG_OBJECT_PAINT, paint)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } if (pattern == VG_INVALID_HANDLE) { - paint_set_type((struct vg_paint*)paint, VG_PAINT_TYPE_COLOR); + paint_set_type(handle_to_paint(paint), VG_PAINT_TYPE_COLOR); return; } - if (!vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, (void *)pattern)) { + if (!vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, pattern)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } - if (!vg_object_is_valid((void*)paint, VG_OBJECT_PAINT) || - !vg_object_is_valid((void*)pattern, VG_OBJECT_IMAGE)) { + if (!vg_object_is_valid(paint, VG_OBJECT_PAINT) || + !vg_object_is_valid(pattern, VG_OBJECT_IMAGE)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } - paint_set_pattern((struct vg_paint*)paint, - (struct vg_image*)pattern); + paint_set_pattern(handle_to_paint(paint), + handle_to_image(pattern)); } diff --git a/src/gallium/state_trackers/vega/api_params.c b/src/gallium/state_trackers/vega/api_params.c index a73b6c3eff..aa1e5dd280 100644 --- a/src/gallium/state_trackers/vega/api_params.c +++ b/src/gallium/state_trackers/vega/api_params.c @@ -29,6 +29,7 @@ #include "vg_context.h" #include "paint.h" #include "path.h" +#include "handle.h" #include "image.h" #include "text.h" #include "matrix.h" @@ -60,7 +61,7 @@ static INLINE VGboolean count_in_bounds(VGParamType type, VGint count) else if (type == VG_STROKE_DASH_PATTERN) { return count <= VEGA_MAX_DASH_COUNT; } else { - VGint real_count = vgGetVectorSize(type); + VGint real_count = vegaGetVectorSize(type); return count == real_count; } } @@ -103,7 +104,7 @@ void vegaSetf (VGParamType type, VGfloat value) case VG_MAX_IMAGE_BYTES: case VG_MAX_GAUSSIAN_STD_DEVIATION: case VG_MAX_FLOAT: - vgSeti(type, floor(value)); + vegaSeti(type, floor(value)); return; break; case VG_STROKE_LINE_WIDTH: @@ -289,7 +290,7 @@ void vegaSetfv(VGParamType type, VGint count, case VG_FILTER_FORMAT_LINEAR: case VG_FILTER_FORMAT_PREMULTIPLIED: case VG_FILTER_CHANNEL_MASK: - vgSeti(type, floor(values[0])); + vegaSeti(type, floor(values[0])); return; break; case VG_SCISSOR_RECTS: { @@ -416,7 +417,7 @@ void vegaSetiv(VGParamType type, VGint count, case VG_FILTER_FORMAT_LINEAR: case VG_FILTER_FORMAT_PREMULTIPLIED: case VG_FILTER_CHANNEL_MASK: - vgSeti(type, values[0]); + vegaSeti(type, values[0]); return; break; case VG_SCISSOR_RECTS: { @@ -536,7 +537,7 @@ VGfloat vegaGetf(VGParamType type) case VG_FILTER_FORMAT_LINEAR: case VG_FILTER_FORMAT_PREMULTIPLIED: case VG_FILTER_CHANNEL_MASK: - return vgGeti(type); + return vegaGeti(type); break; case VG_STROKE_LINE_WIDTH: value = state->stroke.line_width.f; @@ -558,7 +559,7 @@ VGfloat vegaGetf(VGParamType type) case VG_MAX_IMAGE_PIXELS: case VG_MAX_IMAGE_BYTES: case VG_MAX_GAUSSIAN_STD_DEVIATION: - return vgGeti(type); + return vegaGeti(type); break; case VG_MAX_FLOAT: value = 1e+10;/*must be at least 1e+10*/ @@ -674,7 +675,7 @@ VGint vegaGeti(VGParamType type) break; case VG_MAX_FLOAT: { - VGfloat val = vgGetf(type); + VGfloat val = vegaGetf(type); value = float_to_int_floor(*((VGuint*)&val)); } break; @@ -765,7 +766,7 @@ void vegaGetfv(VGParamType type, VGint count, { const struct vg_state *state = current_state(); struct vg_context *ctx = vg_current_context(); - VGint real_count = vgGetVectorSize(type); + VGint real_count = vegaGetVectorSize(type); if (!values || count <= 0 || count > real_count || !is_aligned(values)) { vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); @@ -802,10 +803,10 @@ void vegaGetfv(VGParamType type, VGint count, case VG_MAX_IMAGE_PIXELS: case VG_MAX_IMAGE_BYTES: case VG_MAX_GAUSSIAN_STD_DEVIATION: - values[0] = vgGeti(type); + values[0] = vegaGeti(type); break; case VG_MAX_FLOAT: - values[0] = vgGetf(type); + values[0] = vegaGetf(type); break; case VG_SCISSOR_RECTS: { VGint i; @@ -866,7 +867,7 @@ void vegaGetiv(VGParamType type, VGint count, { const struct vg_state *state = current_state(); struct vg_context *ctx = vg_current_context(); - VGint real_count = vgGetVectorSize(type); + VGint real_count = vegaGetVectorSize(type); if (!values || count <= 0 || count > real_count || !is_aligned(values)) { vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); @@ -903,10 +904,10 @@ void vegaGetiv(VGParamType type, VGint count, case VG_MAX_IMAGE_PIXELS: case VG_MAX_IMAGE_BYTES: case VG_MAX_GAUSSIAN_STD_DEVIATION: - values[0] = vgGeti(type); + values[0] = vegaGeti(type); break; case VG_MAX_FLOAT: { - VGfloat val = vgGetf(type); + VGfloat val = vegaGetf(type); values[0] = float_to_int_floor(*((VGuint*)&val)); } break; @@ -972,9 +973,9 @@ void vegaSetParameterf(VGHandle object, VGfloat value) { struct vg_context *ctx = vg_current_context(); - void *ptr = (void*)object; + void *ptr = handle_to_pointer(object); - if (!object || object == VG_INVALID_HANDLE || !is_aligned(ptr)) { + if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } @@ -983,7 +984,7 @@ void vegaSetParameterf(VGHandle object, case VG_PAINT_TYPE: case VG_PAINT_COLOR_RAMP_SPREAD_MODE: case VG_PAINT_PATTERN_TILING_MODE: - vgSetParameteri(object, paramType, floor(value)); + vegaSetParameteri(object, paramType, floor(value)); return; break; case VG_PAINT_COLOR: @@ -994,7 +995,7 @@ void vegaSetParameterf(VGHandle object, vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); break; case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: { - struct vg_paint *p = (struct vg_paint *)object; + struct vg_paint *p = handle_to_paint(object); paint_set_color_ramp_premultiplied(p, value); } break; @@ -1026,9 +1027,9 @@ void vegaSetParameteri(VGHandle object, VGint value) { struct vg_context *ctx = vg_current_context(); - void *ptr = (void*)object; + void *ptr = handle_to_pointer(object); - if (!object || object == VG_INVALID_HANDLE || !is_aligned(ptr)) { + if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } @@ -1039,7 +1040,7 @@ void vegaSetParameteri(VGHandle object, value > VG_PAINT_TYPE_PATTERN) vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); else { - struct vg_paint *paint = (struct vg_paint *)ptr; + struct vg_paint *paint = handle_to_paint(object); paint_set_type(paint, value); } break; @@ -1055,12 +1056,12 @@ void vegaSetParameteri(VGHandle object, value > VG_COLOR_RAMP_SPREAD_REFLECT) vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); else { - struct vg_paint *paint = (struct vg_paint *)ptr; + struct vg_paint *paint = handle_to_paint(object); paint_set_spread_mode(paint, value); } break; case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: { - struct vg_paint *p = (struct vg_paint *)object; + struct vg_paint *p = handle_to_paint(object); paint_set_color_ramp_premultiplied(p, value); } break; @@ -1069,7 +1070,7 @@ void vegaSetParameteri(VGHandle object, value > VG_TILE_REFLECT) vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); else { - struct vg_paint *paint = (struct vg_paint *)ptr; + struct vg_paint *paint = handle_to_paint(object); paint_set_pattern_tiling(paint, value); } break; @@ -1102,10 +1103,10 @@ void vegaSetParameterfv(VGHandle object, const VGfloat * values) { struct vg_context *ctx = vg_current_context(); - void *ptr = (void*)object; - VGint real_count = vgGetParameterVectorSize(object, paramType); + void *ptr = handle_to_pointer(object); + VGint real_count = vegaGetParameterVectorSize(object, paramType); - if (!object || object == VG_INVALID_HANDLE || !is_aligned(ptr)) { + if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } @@ -1125,15 +1126,18 @@ void vegaSetParameterfv(VGHandle object, if (count != 1) vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); else - vgSetParameterf(object, paramType, values[0]); + vegaSetParameterf(object, paramType, values[0]); return; break; case VG_PAINT_COLOR: { if (count != 4) vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); else { - struct vg_paint *paint = (struct vg_paint *)object; + struct vg_paint *paint = handle_to_paint(object); paint_set_color(paint, values); + if (ctx->state.vg.fill_paint == paint || + ctx->state.vg.stroke_paint == paint) + ctx->state.dirty |= PAINT_DIRTY; } } break; @@ -1141,7 +1145,7 @@ void vegaSetParameterfv(VGHandle object, if (count && count < 4) vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); else { - struct vg_paint *paint = (struct vg_paint *)object; + struct vg_paint *paint = handle_to_paint(object); count = MIN2(count, VEGA_MAX_COLOR_RAMP_STOPS); paint_set_ramp_stops(paint, values, count); { @@ -1159,7 +1163,7 @@ void vegaSetParameterfv(VGHandle object, if (count != 4) vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); else { - struct vg_paint *paint = (struct vg_paint *)object; + struct vg_paint *paint = handle_to_paint(object); paint_set_linear_gradient(paint, values); { VGint vals[4]; @@ -1176,7 +1180,7 @@ void vegaSetParameterfv(VGHandle object, if (count != 5) vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); else { - struct vg_paint *paint = (struct vg_paint *)object; + struct vg_paint *paint = handle_to_paint(object); paint_set_radial_gradient(paint, values); { VGint vals[5]; @@ -1215,10 +1219,10 @@ void vegaSetParameteriv(VGHandle object, const VGint * values) { struct vg_context *ctx = vg_current_context(); - void *ptr = (void*)object; - VGint real_count = vgGetParameterVectorSize(object, paramType); + void *ptr = handle_to_pointer(object); + VGint real_count = vegaGetParameterVectorSize(object, paramType); - if (!object || object == VG_INVALID_HANDLE || !is_aligned(ptr)) { + if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } @@ -1238,15 +1242,18 @@ void vegaSetParameteriv(VGHandle object, if (count != 1) vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); else - vgSetParameteri(object, paramType, values[0]); + vegaSetParameteri(object, paramType, values[0]); return; break; case VG_PAINT_COLOR: { if (count != 4) vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); else { - struct vg_paint *paint = (struct vg_paint *)object; + struct vg_paint *paint = handle_to_paint(object); paint_set_coloriv(paint, values); + if (ctx->state.vg.fill_paint == paint || + ctx->state.vg.stroke_paint == paint) + ctx->state.dirty |= PAINT_DIRTY; } } break; @@ -1256,7 +1263,7 @@ void vegaSetParameteriv(VGHandle object, else { VGfloat *vals = 0; int i; - struct vg_paint *paint = (struct vg_paint *)object; + struct vg_paint *paint = handle_to_paint(object); if (count) { vals = malloc(sizeof(VGfloat)*count); for (i = 0; i < count; ++i) @@ -1274,7 +1281,7 @@ void vegaSetParameteriv(VGHandle object, vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); else { VGfloat vals[4]; - struct vg_paint *paint = (struct vg_paint *)object; + struct vg_paint *paint = handle_to_paint(object); vals[0] = values[0]; vals[1] = values[1]; vals[2] = values[2]; @@ -1289,7 +1296,7 @@ void vegaSetParameteriv(VGHandle object, vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); else { VGfloat vals[5]; - struct vg_paint *paint = (struct vg_paint *)object; + struct vg_paint *paint = handle_to_paint(object); vals[0] = values[0]; vals[1] = values[1]; vals[2] = values[2]; @@ -1318,9 +1325,8 @@ VGint vegaGetParameterVectorSize(VGHandle object, VGint paramType) { struct vg_context *ctx = vg_current_context(); - void *ptr = (void*)object; - if (!ptr || object == VG_INVALID_HANDLE) { + if (object == VG_INVALID_HANDLE) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return 0; } @@ -1334,7 +1340,7 @@ VGint vegaGetParameterVectorSize(VGHandle object, case VG_PAINT_COLOR: return 4; case VG_PAINT_COLOR_RAMP_STOPS: { - struct vg_paint *p = (struct vg_paint *)object; + struct vg_paint *p = handle_to_paint(object); return paint_num_ramp_stops(p); } break; @@ -1374,9 +1380,8 @@ VGfloat vegaGetParameterf(VGHandle object, VGint paramType) { struct vg_context *ctx = vg_current_context(); - void *ptr = (void*)object; - if (!ptr || object == VG_INVALID_HANDLE) { + if (object == VG_INVALID_HANDLE) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return 0; } @@ -1386,7 +1391,7 @@ VGfloat vegaGetParameterf(VGHandle object, case VG_PAINT_COLOR_RAMP_SPREAD_MODE: case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: case VG_PAINT_PATTERN_TILING_MODE: - return vgGetParameteri(object, paramType); + return vegaGetParameteri(object, paramType); break; case VG_PAINT_COLOR: case VG_PAINT_COLOR_RAMP_STOPS: @@ -1398,17 +1403,17 @@ VGfloat vegaGetParameterf(VGHandle object, case VG_PATH_FORMAT: return VG_PATH_FORMAT_STANDARD; case VG_PATH_SCALE: { - struct path *p = (struct path*)object; + struct path *p = handle_to_path(object); return path_scale(p); } case VG_PATH_BIAS: { - struct path *p = (struct path*)object; + struct path *p = handle_to_path(object); return path_bias(p); } case VG_PATH_DATATYPE: case VG_PATH_NUM_SEGMENTS: case VG_PATH_NUM_COORDS: - return vgGetParameteri(object, paramType); + return vegaGetParameteri(object, paramType); break; case VG_IMAGE_FORMAT: @@ -1416,7 +1421,7 @@ VGfloat vegaGetParameterf(VGHandle object, case VG_IMAGE_HEIGHT: #ifdef OPENVG_VERSION_1_1 case VG_FONT_NUM_GLYPHS: - return vgGetParameteri(object, paramType); + return vegaGetParameteri(object, paramType); break; #endif @@ -1431,30 +1436,29 @@ VGint vegaGetParameteri(VGHandle object, VGint paramType) { struct vg_context *ctx = vg_current_context(); - void *ptr = (void*)object; - if (!ptr || object == VG_INVALID_HANDLE) { + if (object == VG_INVALID_HANDLE) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return 0; } switch(paramType) { case VG_PAINT_TYPE: { - struct vg_paint *paint = (struct vg_paint *)ptr; + struct vg_paint *paint = handle_to_paint(object); return paint_type(paint); } break; case VG_PAINT_COLOR_RAMP_SPREAD_MODE: { - struct vg_paint *p = (struct vg_paint *)object; + struct vg_paint *p = handle_to_paint(object); return paint_spread_mode(p); } case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: { - struct vg_paint *p = (struct vg_paint *)object; + struct vg_paint *p = handle_to_paint(object); return paint_color_ramp_premultiplied(p); } break; case VG_PAINT_PATTERN_TILING_MODE: { - struct vg_paint *p = (struct vg_paint *)object; + struct vg_paint *p = handle_to_paint(object); return paint_pattern_tiling(p); } break; @@ -1469,40 +1473,40 @@ VGint vegaGetParameteri(VGHandle object, return VG_PATH_FORMAT_STANDARD; case VG_PATH_SCALE: case VG_PATH_BIAS: - return vgGetParameterf(object, paramType); + return vegaGetParameterf(object, paramType); case VG_PATH_DATATYPE: { - struct path *p = (struct path*)object; + struct path *p = handle_to_path(object); return path_datatype(p); } case VG_PATH_NUM_SEGMENTS: { - struct path *p = (struct path*)object; + struct path *p = handle_to_path(object); return path_num_segments(p); } case VG_PATH_NUM_COORDS: { - struct path *p = (struct path*)object; + struct path *p = handle_to_path(object); return path_num_coords(p); } break; case VG_IMAGE_FORMAT: { - struct vg_image *img = (struct vg_image*)object; + struct vg_image *img = handle_to_image(object); return img->format; } break; case VG_IMAGE_WIDTH: { - struct vg_image *img = (struct vg_image*)object; + struct vg_image *img = handle_to_image(object); return img->width; } break; case VG_IMAGE_HEIGHT: { - struct vg_image *img = (struct vg_image*)object; + struct vg_image *img = handle_to_image(object); return img->height; } break; #ifdef OPENVG_VERSION_1_1 case VG_FONT_NUM_GLYPHS: { - struct vg_font *font = (struct vg_font*)object; + struct vg_font *font = handle_to_font(object); return font_num_glyphs(font); } break; @@ -1521,10 +1525,9 @@ void vegaGetParameterfv(VGHandle object, VGfloat * values) { struct vg_context *ctx = vg_current_context(); - void *ptr = (void*)object; - VGint real_count = vgGetParameterVectorSize(object, paramType); + VGint real_count = vegaGetParameterVectorSize(object, paramType); - if (!ptr || object == VG_INVALID_HANDLE) { + if (object == VG_INVALID_HANDLE) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } @@ -1537,41 +1540,41 @@ void vegaGetParameterfv(VGHandle object, switch(paramType) { case VG_PAINT_TYPE: { - struct vg_paint *p = (struct vg_paint *)object; + struct vg_paint *p = handle_to_paint(object); values[0] = paint_type(p); } break; case VG_PAINT_COLOR_RAMP_SPREAD_MODE: { - struct vg_paint *p = (struct vg_paint *)object; + struct vg_paint *p = handle_to_paint(object); values[0] = paint_spread_mode(p); } break; case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: { - struct vg_paint *p = (struct vg_paint *)object; + struct vg_paint *p = handle_to_paint(object); values[0] = paint_color_ramp_premultiplied(p); } break; case VG_PAINT_PATTERN_TILING_MODE: { - values[0] = vgGetParameterf(object, paramType); + values[0] = vegaGetParameterf(object, paramType); } break; case VG_PAINT_COLOR: { - struct vg_paint *paint = (struct vg_paint *)object; + struct vg_paint *paint = handle_to_paint(object); paint_get_color(paint, values); } break; case VG_PAINT_COLOR_RAMP_STOPS: { - struct vg_paint *paint = (struct vg_paint *)object; + struct vg_paint *paint = handle_to_paint(object); paint_ramp_stops(paint, values, count); } break; case VG_PAINT_LINEAR_GRADIENT: { - struct vg_paint *paint = (struct vg_paint *)object; + struct vg_paint *paint = handle_to_paint(object); paint_linear_gradient(paint, values); } break; case VG_PAINT_RADIAL_GRADIENT: { - struct vg_paint *paint = (struct vg_paint *)object; + struct vg_paint *paint = handle_to_paint(object); paint_radial_gradient(paint, values); } break; @@ -1580,11 +1583,11 @@ void vegaGetParameterfv(VGHandle object, case VG_PATH_DATATYPE: case VG_PATH_NUM_SEGMENTS: case VG_PATH_NUM_COORDS: - values[0] = vgGetParameteri(object, paramType); + values[0] = vegaGetParameteri(object, paramType); break; case VG_PATH_SCALE: case VG_PATH_BIAS: - values[0] = vgGetParameterf(object, paramType); + values[0] = vegaGetParameterf(object, paramType); break; case VG_IMAGE_FORMAT: @@ -1592,7 +1595,7 @@ void vegaGetParameterfv(VGHandle object, case VG_IMAGE_HEIGHT: #ifdef OPENVG_VERSION_1_1 case VG_FONT_NUM_GLYPHS: - values[0] = vgGetParameteri(object, paramType); + values[0] = vegaGetParameteri(object, paramType); break; #endif @@ -1608,10 +1611,9 @@ void vegaGetParameteriv(VGHandle object, VGint * values) { struct vg_context *ctx = vg_current_context(); - void *ptr = (void*)object; - VGint real_count = vgGetParameterVectorSize(object, paramType); + VGint real_count = vegaGetParameterVectorSize(object, paramType); - if (!ptr || object == VG_INVALID_HANDLE) { + if (object || object == VG_INVALID_HANDLE) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } @@ -1629,45 +1631,45 @@ void vegaGetParameteriv(VGHandle object, case VG_PAINT_PATTERN_TILING_MODE: #ifdef OPENVG_VERSION_1_1 case VG_FONT_NUM_GLYPHS: - values[0] = vgGetParameteri(object, paramType); + values[0] = vegaGetParameteri(object, paramType); break; #endif case VG_PAINT_COLOR: { - struct vg_paint *paint = (struct vg_paint *)object; + struct vg_paint *paint = handle_to_paint(object); paint_get_coloriv(paint, values); } break; case VG_PAINT_COLOR_RAMP_STOPS: { - struct vg_paint *paint = (struct vg_paint *)object; + struct vg_paint *paint = handle_to_paint(object); paint_ramp_stopsi(paint, values, count); } break; case VG_PAINT_LINEAR_GRADIENT: { - struct vg_paint *paint = (struct vg_paint *)object; + struct vg_paint *paint = handle_to_paint(object); paint_linear_gradienti(paint, values); } break; case VG_PAINT_RADIAL_GRADIENT: { - struct vg_paint *paint = (struct vg_paint *)object; + struct vg_paint *paint = handle_to_paint(object); paint_radial_gradienti(paint, values); } break; case VG_PATH_SCALE: case VG_PATH_BIAS: - values[0] = vgGetParameterf(object, paramType); + values[0] = vegaGetParameterf(object, paramType); break; case VG_PATH_FORMAT: case VG_PATH_DATATYPE: case VG_PATH_NUM_SEGMENTS: case VG_PATH_NUM_COORDS: - values[0] = vgGetParameteri(object, paramType); + values[0] = vegaGetParameteri(object, paramType); break; case VG_IMAGE_FORMAT: case VG_IMAGE_WIDTH: case VG_IMAGE_HEIGHT: - values[0] = vgGetParameteri(object, paramType); + values[0] = vegaGetParameteri(object, paramType); break; default: diff --git a/src/gallium/state_trackers/vega/api_path.c b/src/gallium/state_trackers/vega/api_path.c index fe57b7671d..ab6ce95894 100644 --- a/src/gallium/state_trackers/vega/api_path.c +++ b/src/gallium/state_trackers/vega/api_path.c @@ -27,6 +27,7 @@ #include "VG/openvg.h" #include "vg_context.h" +#include "handle.h" #include "path.h" #include "api.h" @@ -55,9 +56,9 @@ VGPath vegaCreatePath(VGint pathFormat, return VG_INVALID_HANDLE; } - return (VGPath)path_create(datatype, scale, bias, - segmentCapacityHint, coordCapacityHint, - capabilities); + return path_to_handle(path_create(datatype, scale, bias, + segmentCapacityHint, coordCapacityHint, + capabilities)); } void vegaClearPath(VGPath path, VGbitfield capabilities) @@ -70,7 +71,7 @@ void vegaClearPath(VGPath path, VGbitfield capabilities) return; } - p = (struct path *)path; + p = handle_to_path(path); path_clear(p, capabilities); } @@ -84,7 +85,7 @@ void vegaDestroyPath(VGPath p) return; } - path = (struct path *)p; + path = handle_to_path(p); path_destroy(path); } @@ -100,7 +101,7 @@ void vegaRemovePathCapabilities(VGPath path, return; } - p = (struct path*)path; + p = handle_to_path(path); current = path_capabilities(p); path_set_capabilities(p, (current & (~(capabilities & VG_PATH_CAPABILITY_ALL)))); @@ -115,7 +116,7 @@ VGbitfield vegaGetPathCapabilities(VGPath path) vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return 0; } - p = (struct path*)path; + p = handle_to_path(path); return path_capabilities(p); } @@ -128,8 +129,8 @@ void vegaAppendPath(VGPath dstPath, VGPath srcPath) vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } - src = (struct path *)srcPath; - dst = (struct path *)dstPath; + src = handle_to_path(srcPath); + dst = handle_to_path(dstPath); if (!(path_capabilities(src) & VG_PATH_CAPABILITY_APPEND_FROM) || !(path_capabilities(dst) & VG_PATH_CAPABILITY_APPEND_TO)) { @@ -167,9 +168,9 @@ void vegaAppendPathData(VGPath dstPath, } } - p = (struct path*)dstPath; + p = handle_to_path(dstPath); - if (!pathData || !is_aligned_to(pathData, path_datatype_size(p))) { + if (!p || !is_aligned_to(p, path_datatype_size(p))) { vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); return; } @@ -199,7 +200,7 @@ void vegaModifyPathCoords(VGPath dstPath, return; } - p = (struct path *)dstPath; + p = handle_to_path(dstPath); if (!pathData || !is_aligned_to(pathData, path_datatype_size(p))) { vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); @@ -226,8 +227,8 @@ void vegaTransformPath(VGPath dstPath, VGPath srcPath) vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } - src = (struct path *)srcPath; - dst = (struct path *)dstPath; + src = handle_to_path(srcPath); + dst = handle_to_path(dstPath); if (!(path_capabilities(src) & VG_PATH_CAPABILITY_TRANSFORM_FROM) || !(path_capabilities(dst) & VG_PATH_CAPABILITY_TRANSFORM_TO)) { @@ -251,9 +252,9 @@ VGboolean vegaInterpolatePath(VGPath dstPath, vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return VG_FALSE; } - dst = (struct path *)dstPath; - start = (struct path *)startPath; - end = (struct path *)endPath; + dst = handle_to_path(dstPath); + start = handle_to_path(startPath); + end = handle_to_path(endPath); if (!(path_capabilities(dst) & VG_PATH_CAPABILITY_INTERPOLATE_TO) || !(path_capabilities(start) & VG_PATH_CAPABILITY_INTERPOLATE_FROM) || @@ -285,7 +286,7 @@ VGfloat vegaPathLength(VGPath path, vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); return -1; } - p = (struct path*)path; + p = handle_to_path(path); if (!(path_capabilities(p) & VG_PATH_CAPABILITY_PATH_LENGTH)) { vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR); @@ -330,7 +331,7 @@ void vegaPointAlongPath(VGPath path, return; } - p = (struct path*)path; + p = handle_to_path(path); caps = path_capabilities(p); if (!(caps & VG_PATH_CAPABILITY_POINT_ALONG_PATH) || @@ -385,7 +386,7 @@ void vegaPathBounds(VGPath path, return; } - p = (struct path*)path; + p = handle_to_path(path); caps = path_capabilities(p); if (!(caps & VG_PATH_CAPABILITY_PATH_BOUNDS)) { @@ -422,7 +423,7 @@ void vegaPathTransformedBounds(VGPath path, return; } - p = (struct path*)path; + p = handle_to_path(path); caps = path_capabilities(p); if (!(caps & VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS)) { @@ -466,6 +467,7 @@ void vegaPathTransformedBounds(VGPath path, void vegaDrawPath(VGPath path, VGbitfield paintModes) { struct vg_context *ctx = vg_current_context(); + struct path *p = handle_to_path(path); if (path == VG_INVALID_HANDLE) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); @@ -477,9 +479,9 @@ void vegaDrawPath(VGPath path, VGbitfield paintModes) return; } - if (path_is_empty((struct path*)path)) + if (path_is_empty(p)) return; - path_render((struct path*)path, paintModes, + path_render(p, paintModes, &ctx->state.vg.path_user_to_surface_matrix); } diff --git a/src/gallium/state_trackers/vega/api_text.c b/src/gallium/state_trackers/vega/api_text.c index 7c6b479409..824c763040 100644 --- a/src/gallium/state_trackers/vega/api_text.c +++ b/src/gallium/state_trackers/vega/api_text.c @@ -29,6 +29,7 @@ #include "vg_context.h" #include "text.h" #include "api.h" +#include "handle.h" #include "util/u_memory.h" @@ -43,19 +44,19 @@ VGFont vegaCreateFont(VGint glyphCapacityHint) return VG_INVALID_HANDLE; } - return (VGFont) font_create(glyphCapacityHint); + return font_to_handle(font_create(glyphCapacityHint)); } void vegaDestroyFont(VGFont f) { - struct vg_font *font = (struct vg_font *)f; + struct vg_font *font = handle_to_font(f); struct vg_context *ctx = vg_current_context(); if (f == VG_INVALID_HANDLE) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } - if (!vg_object_is_valid((void *) font, VG_OBJECT_FONT)) { + if (!vg_object_is_valid(f, VG_OBJECT_FONT)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } @@ -75,7 +76,7 @@ void vegaSetGlyphToPath(VGFont font, struct vg_font *f; if (font == VG_INVALID_HANDLE || - !vg_context_is_object_valid(ctx, VG_OBJECT_FONT, (void *)font)) { + !vg_context_is_object_valid(ctx, VG_OBJECT_FONT, font)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } @@ -85,13 +86,13 @@ void vegaSetGlyphToPath(VGFont font, return; } if (path != VG_INVALID_HANDLE && - !vg_context_is_object_valid(ctx, VG_OBJECT_PATH, (void *)path)) { + !vg_context_is_object_valid(ctx, VG_OBJECT_PATH, path)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } - pathObj = (struct path*) path; - f = (struct vg_font*) font; + pathObj = handle_to_path(path); + f = handle_to_font(font); font_set_glyph_to_path(f, glyphIndex, pathObj, isHinted, glyphOrigin, escapement); @@ -108,7 +109,7 @@ void vegaSetGlyphToImage(VGFont font, struct vg_font *f; if (font == VG_INVALID_HANDLE || - !vg_context_is_object_valid(ctx, VG_OBJECT_FONT, (void *)font)) { + !vg_context_is_object_valid(ctx, VG_OBJECT_FONT, font)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } @@ -118,13 +119,13 @@ void vegaSetGlyphToImage(VGFont font, return; } if (image != VG_INVALID_HANDLE && - !vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, (void *)image)) { + !vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, image)) { vg_set_error(ctx, VG_BAD_HANDLE_ERROR); return; } - img_obj = (struct vg_image*)image; - f = (struct vg_font*)font; + img_obj = handle_to_image(image); + f = handle_to_font(font); font_set_glyph_to_image(f, glyphIndex, img_obj, glyphOrigin, escapement); } @@ -140,7 +141,7 @@ void vegaClearGlyph(VGFont font, return; } - f = (struct vg_font*) font; + f = handle_to_font(font); font_clear_glyph(f, glyphIndex); } @@ -161,7 +162,7 @@ void vegaDrawGlyph(VGFont font, vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); return; } - f = (struct vg_font*)font; + f = handle_to_font(font); font_draw_glyph(f, glyphIndex, paintModes, allowAutoHinting); } @@ -199,7 +200,7 @@ void vegaDrawGlyphs(VGFont font, return; } - f = (struct vg_font*)font; + f = handle_to_font(font); font_draw_glyphs(f, glyphCount, glyphIndices, adjustments_x, adjustments_y, paintModes, allowAutoHinting); diff --git a/src/gallium/state_trackers/vega/handle.c b/src/gallium/state_trackers/vega/handle.c new file mode 100644 index 0000000000..11eedd923e --- /dev/null +++ b/src/gallium/state_trackers/vega/handle.c @@ -0,0 +1,93 @@ +/************************************************************************** + * + * Copyright 2010 VMware, Inc. 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 VMWARE 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. + * + **************************************************************************/ + + +#include "handle.h" +#include "util/u_hash.h" +#include "util/u_hash_table.h" + + +/** + * Hash keys are 32-bit VGHandles + */ + +struct util_hash_table *handle_hash = NULL; + + +static unsigned next_handle = 1; + + +static unsigned +hash_func(void *key) +{ + /* XXX this kind of ugly */ + intptr_t ip = pointer_to_intptr(key); + return (unsigned) (ip & 0xffffffff); +} + + +static int +compare(void *key1, void *key2) +{ + if (key1 < key2) + return -1; + else if (key1 > key2) + return +1; + else + return 0; +} + + +void +init_handles(void) +{ + if (!handle_hash) + handle_hash = util_hash_table_create(hash_func, compare); +} + + +void +free_handles(void) +{ + /* XXX destroy */ +} + + +VGHandle +create_handle(void *object) +{ + VGHandle h = next_handle++; + util_hash_table_set(handle_hash, intptr_to_pointer(h), object); + return h; +} + + +void +destroy_handle(VGHandle h) +{ + util_hash_table_remove(handle_hash, intptr_to_pointer(h)); +} + diff --git a/src/gallium/state_trackers/vega/handle.h b/src/gallium/state_trackers/vega/handle.h new file mode 100644 index 0000000000..9ed326d509 --- /dev/null +++ b/src/gallium/state_trackers/vega/handle.h @@ -0,0 +1,171 @@ +/************************************************************************** + * + * Copyright 2010 VMware, Inc. 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 VMWARE 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. + * + **************************************************************************/ + + +/** + * Convert opaque VG object handles into pointers and vice versa. + * XXX This is not yet 64-bit safe! All VG handles are 32 bits in size. + */ + + +#ifndef HANDLE_H +#define HANDLE_H + +#include "pipe/p_compiler.h" +#include "util/u_hash_table.h" +#include "util/u_pointer.h" + +#include "VG/openvg.h" +#include "vg_context.h" + + +extern struct util_hash_table *handle_hash; + + +struct vg_mask_layer; +struct vg_font; +struct vg_image; +struct vg_paint; +struct path; + + +extern void +init_handles(void); + + +extern void +free_handles(void); + + +extern VGHandle +create_handle(void *object); + + +extern void +destroy_handle(VGHandle h); + + +static INLINE VGHandle +object_to_handle(struct vg_object *obj) +{ + return obj ? obj->handle : VG_INVALID_HANDLE; +} + + +static INLINE VGHandle +image_to_handle(struct vg_image *img) +{ + /* vg_image is derived from vg_object */ + return object_to_handle((struct vg_object *) img); +} + + +static INLINE VGHandle +masklayer_to_handle(struct vg_mask_layer *mask) +{ + /* vg_object is derived from vg_object */ + return object_to_handle((struct vg_object *) mask); +} + + +static INLINE VGHandle +font_to_handle(struct vg_font *font) +{ + return object_to_handle((struct vg_object *) font); +} + + +static INLINE VGHandle +paint_to_handle(struct vg_paint *paint) +{ + return object_to_handle((struct vg_object *) paint); +} + + +static INLINE VGHandle +path_to_handle(struct path *path) +{ + return object_to_handle((struct vg_object *) path); +} + + +static INLINE void * +handle_to_pointer(VGHandle h) +{ + void *v = util_hash_table_get(handle_hash, intptr_to_pointer(h)); +#ifdef DEBUG + if (v) { + struct vg_object *obj = (struct vg_object *) v; + assert(obj->handle == h); + } +#endif + return v; +} + + +static INLINE struct vg_font * +handle_to_font(VGHandle h) +{ + return (struct vg_font *) handle_to_pointer(h); +} + + +static INLINE struct vg_image * +handle_to_image(VGHandle h) +{ + return (struct vg_image *) handle_to_pointer(h); +} + + +static INLINE struct vg_mask_layer * +handle_to_masklayer(VGHandle h) +{ + return (struct vg_mask_layer *) handle_to_pointer(h); +} + + +static INLINE struct vg_object * +handle_to_object(VGHandle h) +{ + return (struct vg_object *) handle_to_pointer(h); +} + + +static INLINE struct vg_paint * +handle_to_paint(VGHandle h) +{ + return (struct vg_paint *) handle_to_pointer(h); +} + + +static INLINE struct path * +handle_to_path(VGHandle h) +{ + return (struct path *) handle_to_pointer(h); +} + + +#endif /* HANDLE_H */ diff --git a/src/gallium/state_trackers/vega/image.c b/src/gallium/state_trackers/vega/image.c index 318ea94bdf..44480876b6 100644 --- a/src/gallium/state_trackers/vega/image.c +++ b/src/gallium/state_trackers/vega/image.c @@ -257,7 +257,7 @@ struct vg_image * image_create(VGImageFormat format, image->sampler.normalized_coords = 1; assert(screen->is_format_supported(screen, pformat, PIPE_TEXTURE_2D, - 0, PIPE_BIND_SAMPLER_VIEW, 0)); + 0, PIPE_BIND_SAMPLER_VIEW)); memset(&pt, 0, sizeof(pt)); pt.target = PIPE_TEXTURE_2D; @@ -349,6 +349,8 @@ void image_destroy(struct vg_image *img) array_destroy(img->children_array); } + vg_free_object(&img->base); + pipe_sampler_view_reference(&img->sampler_view, NULL); FREE(img); } @@ -516,8 +518,6 @@ void image_copy(struct vg_image *dst, VGint dx, VGint dy, vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); return; } - /* make sure rendering has completed */ - ctx->pipe->flush(ctx->pipe, PIPE_FLUSH_RENDER_CACHE, NULL); vg_copy_texture(ctx, dst->sampler_view->texture, dst->x + dx, dst->y + dy, src->sampler_view, src->x + sx, src->y + sy, width, height); } @@ -567,9 +567,6 @@ void image_set_pixels(VGint dx, VGint dy, struct pipe_surface *surf, surf_tmpl; struct st_renderbuffer *strb = ctx->draw_buffer->strb; - /* make sure rendering has completed */ - pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL); - memset(&surf_tmpl, 0, sizeof(surf_tmpl)); u_surface_default_template(&surf_tmpl, image_texture(src), 0 /* no bind flag - not a surface*/); @@ -593,9 +590,6 @@ void image_get_pixels(struct vg_image *dst, VGint dx, VGint dy, /* flip the y coordinates */ /*dy = dst->height - dy - height;*/ - /* make sure rendering has completed */ - pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL); - memset(&surf_tmpl, 0, sizeof(surf_tmpl)); u_surface_default_template(&surf_tmpl, image_texture(dst), PIPE_BIND_RENDER_TARGET); diff --git a/src/gallium/state_trackers/vega/mask.c b/src/gallium/state_trackers/vega/mask.c index dfd0600e44..10590e29cd 100644 --- a/src/gallium/state_trackers/vega/mask.c +++ b/src/gallium/state_trackers/vega/mask.c @@ -111,8 +111,6 @@ static void read_alpha_mask(void * data, VGint dataStride, VGubyte *dst = (VGubyte *)data; VGint xoffset = 0, yoffset = 0; - /* make sure rendering has completed */ - pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL); if (sx < 0) { xoffset = -sx; xoffset *= _vega_size_for_format(dataFormat); diff --git a/src/gallium/state_trackers/vega/paint.c b/src/gallium/state_trackers/vega/paint.c index 2db8cbcf7c..6e5348a1ff 100644 --- a/src/gallium/state_trackers/vega/paint.c +++ b/src/gallium/state_trackers/vega/paint.c @@ -748,3 +748,10 @@ void paint_fill_constant_buffer(struct vg_paint *paint, abort(); } } + +VGboolean paint_is_opaque(struct vg_paint *paint) +{ + /* TODO add other paint types and make sure PAINT_DIRTY gets set */ + return (paint->type == VG_PAINT_TYPE_COLOR && + floatsEqual(paint->solid.color[3], 1.0f)); +} diff --git a/src/gallium/state_trackers/vega/paint.h b/src/gallium/state_trackers/vega/paint.h index 3de3bbe12e..e5357763b8 100644 --- a/src/gallium/state_trackers/vega/paint.h +++ b/src/gallium/state_trackers/vega/paint.h @@ -118,5 +118,6 @@ void paint_fill_constant_buffer(struct vg_paint *paint, const struct matrix *mat, void *buffer); +VGboolean paint_is_opaque(struct vg_paint *paint); #endif diff --git a/src/gallium/state_trackers/vega/polygon.c b/src/gallium/state_trackers/vega/polygon.c index a491de27fa..bcc5cb272c 100644 --- a/src/gallium/state_trackers/vega/polygon.c +++ b/src/gallium/state_trackers/vega/polygon.c @@ -303,7 +303,6 @@ void polygon_fill(struct polygon *poly, struct vg_context *ctx) vbuffer.buffer = poly->vbuf; vbuffer.stride = COMPONENTS * sizeof(float); /* vertex size */ vbuffer.buffer_offset = 0; - vbuffer.max_index = poly->num_verts - 1; renderer_polygon_stencil_begin(ctx->renderer, &velement, ctx->state.vg.fill_rule, VG_FALSE); @@ -354,7 +353,6 @@ void polygon_array_fill(struct polygon_array *polyarray, struct vg_context *ctx) polygon_prepare_buffer(ctx, poly); vbuffer.buffer = poly->vbuf; - vbuffer.max_index = poly->num_verts - 1; renderer_polygon_stencil(ctx->renderer, &vbuffer, PIPE_PRIM_TRIANGLE_FAN, 0, (VGuint) poly->num_verts); diff --git a/src/gallium/state_trackers/vega/renderer.c b/src/gallium/state_trackers/vega/renderer.c index 7871c516c4..5715073e2d 100644 --- a/src/gallium/state_trackers/vega/renderer.c +++ b/src/gallium/state_trackers/vega/renderer.c @@ -28,7 +28,7 @@ #include "renderer.h" #include "vg_context.h" -#include "image.h" +#include "paint.h" /* for paint_is_opaque */ #include "pipe/p_context.h" #include "pipe/p_state.h" @@ -140,7 +140,7 @@ static VGboolean renderer_can_support(struct renderer *renderer, struct pipe_screen *screen = renderer->pipe->screen; return screen->is_format_supported(screen, - res->format, res->target, 0, bindings, 0); + res->format, res->target, 0, bindings); } /** @@ -174,6 +174,7 @@ static void renderer_set_mvp(struct renderer *renderer, pipe_resource_reference(&cbuf, NULL); cbuf = pipe_buffer_create(renderer->pipe->screen, PIPE_BIND_CONSTANT_BUFFER, + PIPE_USAGE_STATIC, sizeof(consts)); if (cbuf) { pipe_buffer_write(renderer->pipe, cbuf, @@ -474,7 +475,8 @@ static void renderer_set_custom_fs(struct renderer *renderer, pipe_resource_reference(&cbuf, NULL); cbuf = pipe_buffer_create(renderer->pipe->screen, - PIPE_BIND_CONSTANT_BUFFER, const_buffer_len); + PIPE_BIND_CONSTANT_BUFFER, PIPE_USAGE_STATIC, + const_buffer_len); pipe_buffer_write(renderer->pipe, cbuf, 0, const_buffer_len, const_buffer); renderer->pipe->set_constant_buffer(renderer->pipe, @@ -572,7 +574,7 @@ static void renderer_quad_draw(struct renderer *r) sizeof(r->vertices), PIPE_BIND_VERTEX_BUFFER); if (buf) { - util_draw_vertex_buffer(r->pipe, buf, 0, + util_draw_vertex_buffer(r->pipe, r->cso, buf, 0, PIPE_PRIM_TRIANGLE_FAN, Elements(r->vertices), /* verts */ Elements(r->vertices[0])); /* attribs/vert */ @@ -1050,7 +1052,7 @@ void renderer_polygon_stencil(struct renderer *renderer, { assert(renderer->state == RENDERER_STATE_POLYGON_STENCIL); - renderer->pipe->set_vertex_buffers(renderer->pipe, 1, vbuf); + cso_set_vertex_buffers(renderer->cso, 1, vbuf); if (!renderer->u.polygon_stencil.manual_two_sides) { util_draw_arrays(renderer->pipe, mode, start, count); @@ -1290,7 +1292,11 @@ static void renderer_validate_blend(struct renderer *renderer, blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO; break; case VG_BLEND_SRC_OVER: - if (!util_format_has_alpha(fb_format)) { + if (paint_is_opaque(state->fill_paint) && + paint_is_opaque(state->stroke_paint)) { + /* no blending */ + } + else if (!util_format_has_alpha(fb_format)) { blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_SRC_ALPHA; blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE; blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_INV_SRC_ALPHA; @@ -1457,11 +1463,11 @@ void renderer_copy_surface(struct renderer *ctx, } assert(screen->is_format_supported(screen, src->format, PIPE_TEXTURE_2D, - 0, PIPE_BIND_SAMPLER_VIEW, 0)); + 0, PIPE_BIND_SAMPLER_VIEW)); assert(screen->is_format_supported(screen, dst->format, PIPE_TEXTURE_2D, - 0, PIPE_BIND_SAMPLER_VIEW, 0)); + 0, PIPE_BIND_SAMPLER_VIEW)); assert(screen->is_format_supported(screen, dst->format, PIPE_TEXTURE_2D, - 0, PIPE_BIND_RENDER_TARGET, 0)); + 0, PIPE_BIND_RENDER_TARGET)); /* * XXX for now we're always creating a temporary texture. diff --git a/src/gallium/state_trackers/vega/shader.c b/src/gallium/state_trackers/vega/shader.c index 0ed721376c..bee6d84001 100644 --- a/src/gallium/state_trackers/vega/shader.c +++ b/src/gallium/state_trackers/vega/shader.c @@ -34,9 +34,7 @@ #include "renderer.h" #include "pipe/p_context.h" -#include "pipe/p_screen.h" #include "pipe/p_state.h" -#include "util/u_inlines.h" #include "util/u_memory.h" #include "util/u_math.h" #include "util/u_format.h" @@ -136,6 +134,8 @@ static VGboolean blend_use_shader(struct vg_context *ctx) switch (ctx->state.vg.blend_mode) { case VG_BLEND_SRC_OVER: advanced_blending = + (!paint_is_opaque(ctx->state.vg.fill_paint) || + !paint_is_opaque(ctx->state.vg.stroke_paint)) && util_format_has_alpha(ctx->draw_buffer->strb->format); break; case VG_BLEND_DST_OVER: diff --git a/src/gallium/state_trackers/vega/text.c b/src/gallium/state_trackers/vega/text.c index 01ff602f58..6714ee9ad3 100644 --- a/src/gallium/state_trackers/vega/text.c +++ b/src/gallium/state_trackers/vega/text.c @@ -30,7 +30,6 @@ #include "text.h" #include "image.h" #include "path.h" -#include "api.h" #ifdef OPENVG_VERSION_1_1 diff --git a/src/gallium/state_trackers/vega/vg_context.c b/src/gallium/state_trackers/vega/vg_context.c index 0844012cc3..c2ab56455b 100644 --- a/src/gallium/state_trackers/vega/vg_context.c +++ b/src/gallium/state_trackers/vega/vg_context.c @@ -30,17 +30,16 @@ #include "renderer.h" #include "shaders_cache.h" #include "shader.h" -#include "asm_util.h" #include "vg_manager.h" #include "api.h" #include "mask.h" +#include "handle.h" #include "pipe/p_context.h" #include "util/u_inlines.h" #include "cso_cache/cso_context.h" -#include "util/u_simple_shaders.h" #include "util/u_memory.h" #include "util/u_blit.h" #include "util/u_sampler.h" @@ -70,7 +69,7 @@ choose_depth_stencil_format(struct vg_context *ctx) for (fmt = formats; *fmt != PIPE_FORMAT_NONE; fmt++) { if (screen->is_format_supported(screen, *fmt, - PIPE_TEXTURE_2D, 0, PIPE_BIND_DEPTH_STENCIL, 0)) + PIPE_TEXTURE_2D, 0, PIPE_BIND_DEPTH_STENCIL)) break; } @@ -184,17 +183,26 @@ void vg_init_object(struct vg_object *obj, struct vg_context *ctx, enum vg_objec { obj->type = type; obj->ctx = ctx; + obj->handle = create_handle(obj); +} + +/** free object resources, but not the object itself */ +void vg_free_object(struct vg_object *obj) +{ + obj->type = 0; + obj->ctx = NULL; + destroy_handle(obj->handle); } VGboolean vg_context_is_object_valid(struct vg_context *ctx, enum vg_object_type type, - void *ptr) + VGHandle object) { if (ctx) { struct cso_hash *hash = ctx->owned_objects[type]; if (!hash) return VG_FALSE; - return cso_hash_contains(hash, (unsigned)(long)ptr); + return cso_hash_contains(hash, (unsigned)(long)object); } return VG_FALSE; } @@ -400,8 +408,9 @@ void vg_validate_state(struct vg_context *ctx) if (vg_context_update_depth_stencil_rb(ctx, stfb->width, stfb->height)) ctx->state.dirty |= DEPTH_STENCIL_DIRTY; - /* blend state depends on fb format */ - if (ctx->state.dirty & FRAMEBUFFER_DIRTY) + /* blend state depends on fb format and paint color */ + if ((ctx->state.dirty & FRAMEBUFFER_DIRTY) || + (ctx->state.dirty & PAINT_DIRTY)) ctx->state.dirty |= BLEND_DIRTY; renderer_validate(ctx->renderer, ctx->state.dirty, @@ -414,10 +423,10 @@ void vg_validate_state(struct vg_context *ctx) shader_set_color_transform(ctx->shader, ctx->state.vg.color_transform); } -VGboolean vg_object_is_valid(void *ptr, enum vg_object_type type) +VGboolean vg_object_is_valid(VGHandle object, enum vg_object_type type) { - struct vg_object *obj = ptr; - if (ptr && is_aligned(obj) && obj->type == type) + struct vg_object *obj = handle_to_object(object); + if (obj && is_aligned(obj) && obj->type == type) return VG_TRUE; else return VG_FALSE; diff --git a/src/gallium/state_trackers/vega/vg_context.h b/src/gallium/state_trackers/vega/vg_context.h index d616a20a3d..71491a5aa2 100644 --- a/src/gallium/state_trackers/vega/vg_context.h +++ b/src/gallium/state_trackers/vega/vg_context.h @@ -81,10 +81,12 @@ enum dirty_state { BLEND_DIRTY = 1 << 0, FRAMEBUFFER_DIRTY = 1 << 1, DEPTH_STENCIL_DIRTY = 1 << 2, + PAINT_DIRTY = 1 << 3, ALL_DIRTY = BLEND_DIRTY | FRAMEBUFFER_DIRTY | - DEPTH_STENCIL_DIRTY + DEPTH_STENCIL_DIRTY | + PAINT_DIRTY }; struct vg_context @@ -129,12 +131,21 @@ struct vg_context struct blit_state *blit; }; + +/** + * Base class for VG objects like paths, images, fonts. + */ struct vg_object { enum vg_object_type type; + VGHandle handle; struct vg_context *ctx; }; + + void vg_init_object(struct vg_object *obj, struct vg_context *ctx, enum vg_object_type type); -VGboolean vg_object_is_valid(void *ptr, enum vg_object_type type); +void vg_free_object(struct vg_object *obj); + +VGboolean vg_object_is_valid(VGHandle object, enum vg_object_type type); struct vg_context *vg_create_context(struct pipe_context *pipe, const void *visual, @@ -145,7 +156,7 @@ void vg_set_current_context(struct vg_context *ctx); VGboolean vg_context_is_object_valid(struct vg_context *ctx, enum vg_object_type type, - void *ptr); + VGHandle object); void vg_context_add_object(struct vg_context *ctx, enum vg_object_type type, void *ptr); diff --git a/src/gallium/state_trackers/vega/vg_manager.c b/src/gallium/state_trackers/vega/vg_manager.c index de935768b2..eeea68677d 100644 --- a/src/gallium/state_trackers/vega/vg_manager.c +++ b/src/gallium/state_trackers/vega/vg_manager.c @@ -33,15 +33,14 @@ #include "pipe/p_screen.h" #include "util/u_memory.h" #include "util/u_inlines.h" -#include "util/u_sampler.h" #include "util/u_box.h" #include "util/u_surface.h" #include "vg_api.h" #include "vg_manager.h" #include "vg_context.h" -#include "image.h" #include "api.h" +#include "handle.h" static boolean vg_context_update_color_rb(struct vg_context *ctx, struct pipe_resource *pt) @@ -143,8 +142,8 @@ vg_context_flush(struct st_context_iface *stctxi, unsigned flags, struct pipe_fence_handle **fence) { struct vg_context *ctx = (struct vg_context *) stctxi; - ctx->pipe->flush(ctx->pipe, flags, fence); - if (flags & PIPE_FLUSH_RENDER_CACHE) + ctx->pipe->flush(ctx->pipe, fence); + if (flags & ST_FLUSH_FRONT) vg_manager_flush_frontbuffer(ctx); } @@ -174,6 +173,9 @@ vg_api_create_context(struct st_api *stapi, struct st_manager *smapi, if (attribs->major > 1 || (attribs->major == 1 && attribs->minor > 0)) return NULL; + /* for VGHandle / pointer lookups */ + init_handles(); + pipe = smapi->screen->context_create(smapi->screen, NULL); if (!pipe) return NULL; diff --git a/src/gallium/state_trackers/vega/vgu.c b/src/gallium/state_trackers/vega/vgu.c index 7dc51c5599..4206a91e00 100644 --- a/src/gallium/state_trackers/vega/vgu.c +++ b/src/gallium/state_trackers/vega/vgu.c @@ -29,6 +29,7 @@ #include "matrix.h" #include "path.h" +#include "handle.h" #include "util/u_debug.h" #include "util/u_pointer.h" @@ -36,16 +37,6 @@ #include <math.h> #include <assert.h> -static VGboolean is_aligned_to(const void *ptr, VGbyte alignment) -{ - void *aligned = align_pointer(ptr, alignment); - return (ptr == aligned) ? VG_TRUE : VG_FALSE; -} - -static VGboolean is_aligned(const void *ptr) -{ - return is_aligned_to(ptr, 4); -} static void vgu_append_float_coords(VGPath path, const VGubyte *cmds, @@ -54,7 +45,7 @@ static void vgu_append_float_coords(VGPath path, VGint num_coords) { VGubyte common_data[40 * sizeof(VGfloat)]; - struct path *p = (struct path *)path; + struct path *p = handle_to_path(path); vg_float_to_datatype(path_datatype(p), common_data, coords, num_coords); vgAppendPathData(path, num_cmds, cmds, common_data); diff --git a/src/gallium/state_trackers/wgl/SConscript b/src/gallium/state_trackers/wgl/SConscript index 1b7597de44..7cb953ba74 100644 --- a/src/gallium/state_trackers/wgl/SConscript +++ b/src/gallium/state_trackers/wgl/SConscript @@ -15,6 +15,9 @@ env.AppendUnique(CPPDEFINES = [ 'BUILD_GL32', # declare gl* as __declspec(dllexport) in Mesa headers 'WIN32_LEAN_AND_MEAN', # http://msdn2.microsoft.com/en-us/library/6dwk3a1z.aspx ]) +if not env['gles']: + # prevent _glapi_* from being declared __declspec(dllimport) + env.Append(CPPDEFINES = ['_GLAPI_NO_EXPORTS']) sources = [ 'stw_context.c', diff --git a/src/gallium/state_trackers/wgl/stw_context.c b/src/gallium/state_trackers/wgl/stw_context.c index cd4f3c8b3e..5608d4f4ce 100644 --- a/src/gallium/state_trackers/wgl/stw_context.c +++ b/src/gallium/state_trackers/wgl/stw_context.c @@ -277,7 +277,7 @@ stw_make_current( return TRUE; } } else { - curctx->st->flush(curctx->st, PIPE_FLUSH_RENDER_CACHE, NULL); + curctx->st->flush(curctx->st, ST_FLUSH_FRONT, NULL); } } @@ -351,11 +351,7 @@ stw_flush_current_locked( struct stw_framebuffer *fb ) struct stw_context *ctx = stw_current_context(); if (ctx && ctx->current_framebuffer == fb) { - ctx->st->flush(ctx->st, - PIPE_FLUSH_RENDER_CACHE | - PIPE_FLUSH_SWAPBUFFERS | - PIPE_FLUSH_FRAME, - NULL); + ctx->st->flush(ctx->st, ST_FLUSH_FRONT, NULL); } } diff --git a/src/gallium/state_trackers/wgl/stw_device.c b/src/gallium/state_trackers/wgl/stw_device.c index c4822d4d8a..e65e71dc15 100644 --- a/src/gallium/state_trackers/wgl/stw_device.c +++ b/src/gallium/state_trackers/wgl/stw_device.c @@ -41,8 +41,6 @@ #include "stw_framebuffer.h" #include "stw_st.h" -extern _glthread_Mutex OneTimeLock; - struct stw_device *stw_dev = NULL; @@ -50,7 +48,19 @@ static int stw_get_param(struct st_manager *smapi, enum st_manager_param param) { - return 0; + switch (param) { + case ST_MANAGER_BROKEN_INVALIDATE: + /* + * Force framebuffer validation on glViewport. + * + * Certain applications, like Rhinoceros 4, uses glReadPixels + * exclusively (never uses SwapBuffers), so framebuffers never get + * resized unless we check on glViewport. + */ + return 1; + default: + return 0; + } } boolean @@ -74,8 +84,6 @@ stw_init(const struct stw_winsys *stw_winsys) stw_dev->stw_winsys = stw_winsys; - _glthread_INIT_MUTEX(OneTimeLock); - stw_dev->stapi = stw_st_create_api(); stw_dev->smapi = CALLOC_STRUCT(st_manager); if (!stw_dev->stapi || !stw_dev->smapi) @@ -168,9 +176,10 @@ stw_cleanup(void) stw_dev->screen->destroy(stw_dev->screen); - _glthread_DESTROY_MUTEX(OneTimeLock); - + /* glapi is statically linked: we can call the local destroy function. */ +#ifdef _GLAPI_NO_EXPORTS _glapi_destroy_multithread(); +#endif #ifdef DEBUG debug_memory_end(stw_dev->memdbg_no); diff --git a/src/gallium/state_trackers/wgl/stw_pixelformat.c b/src/gallium/state_trackers/wgl/stw_pixelformat.c index 5ede1d4322..333f50c25f 100644 --- a/src/gallium/state_trackers/wgl/stw_pixelformat.c +++ b/src/gallium/state_trackers/wgl/stw_pixelformat.c @@ -225,7 +225,7 @@ stw_pixelformat_init( void ) if(!screen->is_format_supported(screen, color->format, PIPE_TEXTURE_2D, 0, PIPE_BIND_RENDER_TARGET | - PIPE_BIND_DISPLAY_TARGET, 0)) + PIPE_BIND_DISPLAY_TARGET)) continue; for(k = 0; k < Elements(stw_pf_doublebuffer); ++k) { @@ -235,7 +235,7 @@ stw_pixelformat_init( void ) const struct stw_pf_depth_info *depth = &stw_pf_depth_stencil[l]; if(!screen->is_format_supported(screen, depth->format, PIPE_TEXTURE_2D, - 0, PIPE_BIND_DEPTH_STENCIL, 0)) + 0, PIPE_BIND_DEPTH_STENCIL)) continue; stw_pixelformat_add( stw_dev, color, depth, 0, doublebuffer, samples ); diff --git a/src/gallium/state_trackers/xorg/xorg_crtc.c b/src/gallium/state_trackers/xorg/xorg_crtc.c index 28e30e09ff..d751ac1870 100644 --- a/src/gallium/state_trackers/xorg/xorg_crtc.c +++ b/src/gallium/state_trackers/xorg/xorg_crtc.c @@ -133,6 +133,14 @@ crtc_set_mode_major(xf86CrtcPtr crtc, DisplayModePtr mode, if (ret) return FALSE; + /* Only set gamma when needed, to avoid unneeded delays. */ +#if defined(XF86_CRTC_VERSION) && XF86_CRTC_VERSION >= 3 + if (!crtc->active && crtc->version >= 3) + crtc->funcs->gamma_set(crtc, crtc->gamma_red, crtc->gamma_green, + crtc->gamma_blue, crtc->gamma_size); + crtc->active = TRUE; +#endif + crtc->x = x; crtc->y = y; crtc->mode = *mode; @@ -145,7 +153,10 @@ static void crtc_gamma_set(xf86CrtcPtr crtc, CARD16 * red, CARD16 * green, CARD16 * blue, int size) { - /* XXX: hockup */ + modesettingPtr ms = modesettingPTR(crtc->scrn); + struct crtc_private *crtcp = crtc->driver_private; + + drmModeCrtcSetGamma(ms->fd, crtcp->drm_crtc->crtc_id, size, red, green, blue); } #if 0 /* Implement and enable to enable rotation and reflection. */ diff --git a/src/gallium/state_trackers/xorg/xorg_dri2.c b/src/gallium/state_trackers/xorg/xorg_dri2.c index 17c34b7eac..6f2c52eabb 100644 --- a/src/gallium/state_trackers/xorg/xorg_dri2.c +++ b/src/gallium/state_trackers/xorg/xorg_dri2.c @@ -336,7 +336,7 @@ dri2_copy_region(DrawablePtr pDraw, RegionPtr pRegion, /* pixmap glXWaitX */ if (pSrcBuffer->attachment == DRI2BufferFrontLeft && pDestBuffer->attachment == DRI2BufferFakeFrontLeft) { - ms->ctx->flush(ms->ctx, PIPE_FLUSH_SWAPBUFFERS, NULL); + ms->ctx->flush(ms->ctx, NULL); return; } /* pixmap glXWaitGL */ @@ -362,7 +362,8 @@ dri2_copy_region(DrawablePtr pDraw, RegionPtr pRegion, if (extents->x1 == 0 && extents->y1 == 0 && extents->x2 == pDraw->width && extents->y2 == pDraw->height) { - ms->screen->fence_finish(ms->screen, dst_priv->fence, 0); + ms->screen->fence_finish(ms->screen, dst_priv->fence, + PIPE_TIMEOUT_INFINITE); ms->screen->fence_reference(ms->screen, &dst_priv->fence, NULL); } } @@ -388,7 +389,7 @@ dri2_copy_region(DrawablePtr pDraw, RegionPtr pRegion, FreeScratchGC(gc); - ms->ctx->flush(ms->ctx, PIPE_FLUSH_SWAPBUFFERS, + ms->ctx->flush(ms->ctx, (pDestBuffer->attachment == DRI2BufferFrontLeft && ms->swapThrottling) ? &dst_priv->fence : NULL); @@ -451,12 +452,12 @@ xorg_dri2_init(ScreenPtr pScreen) ms->screen->is_format_supported(ms->screen, PIPE_FORMAT_Z24X8_UNORM, PIPE_TEXTURE_2D, 0, - PIPE_BIND_DEPTH_STENCIL, 0); + PIPE_BIND_DEPTH_STENCIL); ms->ds_depth_bits_last = ms->screen->is_format_supported(ms->screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED, PIPE_TEXTURE_2D, 0, - PIPE_BIND_DEPTH_STENCIL, 0); + PIPE_BIND_DEPTH_STENCIL); return DRI2ScreenInit(pScreen, &dri2info); } diff --git a/src/gallium/state_trackers/xorg/xorg_driver.c b/src/gallium/state_trackers/xorg/xorg_driver.c index 66685ecec6..19e9bf8465 100644 --- a/src/gallium/state_trackers/xorg/xorg_driver.c +++ b/src/gallium/state_trackers/xorg/xorg_driver.c @@ -44,6 +44,7 @@ #include "xf86Crtc.h" #include "miscstruct.h" #include "dixstruct.h" +#include "xf86cmap.h" #include "xf86xv.h" #include "xorgVersion.h" #ifndef XSERVER_LIBPCIACCESS @@ -333,7 +334,8 @@ drv_cleanup_fences(ScrnInfoPtr pScrn) for (i = 0; i < XORG_NR_FENCES; i++) { if (ms->fence[i]) { - ms->screen->fence_finish(ms->screen, ms->fence[i], 0); + ms->screen->fence_finish(ms->screen, ms->fence[i], + PIPE_TIMEOUT_INFINITE); ms->screen->fence_reference(ms->screen, &ms->fence[i], NULL); } } @@ -414,6 +416,7 @@ drv_pre_init(ScrnInfoPtr pScrn, int flags) return FALSE; switch (pScrn->depth) { + case 8: case 15: case 16: case 24: @@ -545,7 +548,7 @@ void xorg_flush(ScreenPtr pScreen) if (ms->ctx) { int j; - ms->ctx->flush(ms->ctx, PIPE_FLUSH_RENDER_CACHE, + ms->ctx->flush(ms->ctx, ms->dirtyThrottling ? &ms->fence[XORG_NR_FENCES-1] : NULL); @@ -553,7 +556,8 @@ void xorg_flush(ScreenPtr pScreen) if (ms->dirtyThrottling) { if (ms->fence[0]) ms->ctx->screen->fence_finish(ms->ctx->screen, - ms->fence[0], 0); + ms->fence[0], + PIPE_TIMEOUT_INFINITE); /* The amount of rendering generated by a block handler can be * quite small. Let us get a fair way ahead of hardware before @@ -677,6 +681,65 @@ drv_set_master(ScrnInfoPtr pScrn) } +static void drv_load_palette(ScrnInfoPtr pScrn, int numColors, + int *indices, LOCO *colors, VisualPtr pVisual) +{ + xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn); + modesettingPtr ms = modesettingPTR(pScrn); + int index, j, i; + int c; + + switch(pScrn->depth) { + case 15: + for (i = 0; i < numColors; i++) { + index = indices[i]; + for (j = 0; j < 8; j++) { + ms->lut_r[index * 8 + j] = colors[index].red << 8; + ms->lut_g[index * 8 + j] = colors[index].green << 8; + ms->lut_b[index * 8 + j] = colors[index].blue << 8; + } + } + break; + case 16: + for (i = 0; i < numColors; i++) { + index = indices[i]; + + if (index < 32) { + for (j = 0; j < 8; j++) { + ms->lut_r[index * 8 + j] = colors[index].red << 8; + ms->lut_b[index * 8 + j] = colors[index].blue << 8; + } + } + + for (j = 0; j < 4; j++) { + ms->lut_g[index * 4 + j] = colors[index].green << 8; + } + } + break; + default: + for (i = 0; i < numColors; i++) { + index = indices[i]; + ms->lut_r[index] = colors[index].red << 8; + ms->lut_g[index] = colors[index].green << 8; + ms->lut_b[index] = colors[index].blue << 8; + } + break; + } + + for (c = 0; c < xf86_config->num_crtc; c++) { + xf86CrtcPtr crtc = xf86_config->crtc[c]; + + /* Make the change through RandR */ +#ifdef RANDR_12_INTERFACE + if (crtc->randr_crtc) + RRCrtcGammaSet(crtc->randr_crtc, ms->lut_r, ms->lut_g, ms->lut_b); + else +#endif + crtc->funcs->gamma_set(crtc, ms->lut_r, ms->lut_g, ms->lut_b, 256); + } +} + + static Bool drv_screen_init(int scrnIndex, ScreenPtr pScreen, int argc, char **argv) { @@ -816,6 +879,10 @@ drv_screen_init(int scrnIndex, ScreenPtr pScreen, int argc, char **argv) if (!miCreateDefColormap(pScreen)) return FALSE; + if (!xf86HandleColormaps(pScreen, 256, 8, drv_load_palette, NULL, + CMAP_PALETTED_TRUECOLOR | + CMAP_RELOAD_ON_MODE_SWITCH)) + return FALSE; xf86DPMSInit(pScreen, xf86DPMSSet, 0); diff --git a/src/gallium/state_trackers/xorg/xorg_exa.c b/src/gallium/state_trackers/xorg/xorg_exa.c index 718a345393..e7d6a93e5c 100644 --- a/src/gallium/state_trackers/xorg/xorg_exa.c +++ b/src/gallium/state_trackers/xorg/xorg_exa.c @@ -349,7 +349,7 @@ ExaPrepareSolid(PixmapPtr pPixmap, int alu, Pixel planeMask, Pixel fg) if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format, priv->tex->target, 0, - PIPE_BIND_RENDER_TARGET, 0)) { + PIPE_BIND_RENDER_TARGET)) { XORG_FALLBACK("format %s", util_format_name(priv->tex->format)); } @@ -430,12 +430,12 @@ ExaPrepareCopy(PixmapPtr pSrcPixmap, PixmapPtr pDstPixmap, int xdir, if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format, priv->tex->target, 0, - PIPE_BIND_RENDER_TARGET, 0)) + PIPE_BIND_RENDER_TARGET)) XORG_FALLBACK("pDst format %s", util_format_name(priv->tex->format)); if (!exa->scrn->is_format_supported(exa->scrn, src_priv->tex->format, src_priv->tex->target, 0, - PIPE_BIND_SAMPLER_VIEW, 0)) + PIPE_BIND_SAMPLER_VIEW)) XORG_FALLBACK("pSrc format %s", util_format_name(src_priv->tex->format)); exa->copy.src = src_priv; @@ -630,7 +630,7 @@ ExaPrepareComposite(int op, PicturePtr pSrcPicture, if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format, priv->tex->target, 0, - PIPE_BIND_RENDER_TARGET, 0)) + PIPE_BIND_RENDER_TARGET)) XORG_FALLBACK("pDst format: %s", util_format_name(priv->tex->format)); if (priv->picture_format != pDstPicture->format) @@ -645,7 +645,7 @@ ExaPrepareComposite(int op, PicturePtr pSrcPicture, if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format, priv->tex->target, 0, - PIPE_BIND_SAMPLER_VIEW, 0)) + PIPE_BIND_SAMPLER_VIEW)) XORG_FALLBACK("pSrc format: %s", util_format_name(priv->tex->format)); if (!picture_check_formats(priv, pSrcPicture)) @@ -662,7 +662,7 @@ ExaPrepareComposite(int op, PicturePtr pSrcPicture, if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format, priv->tex->target, 0, - PIPE_BIND_SAMPLER_VIEW, 0)) + PIPE_BIND_SAMPLER_VIEW)) XORG_FALLBACK("pMask format: %s", util_format_name(priv->tex->format)); if (!picture_check_formats(priv, pMaskPicture)) @@ -1072,19 +1072,20 @@ xorg_gpu_surface(struct pipe_context *pipe, struct exa_pixmap_priv *priv) } -void xorg_exa_flush(struct exa_context *exa, uint pipeFlushFlags, +void xorg_exa_flush(struct exa_context *exa, struct pipe_fence_handle **fence) { - exa->pipe->flush(exa->pipe, pipeFlushFlags, fence); + exa->pipe->flush(exa->pipe, fence); } void xorg_exa_finish(struct exa_context *exa) { struct pipe_fence_handle *fence = NULL; - xorg_exa_flush(exa, PIPE_FLUSH_RENDER_CACHE, &fence); + xorg_exa_flush(exa, &fence); - exa->pipe->screen->fence_finish(exa->pipe->screen, fence, 0); + exa->pipe->screen->fence_finish(exa->pipe->screen, fence, + PIPE_TIMEOUT_INFINITE); exa->pipe->screen->fence_reference(exa->pipe->screen, &fence, NULL); } diff --git a/src/gallium/state_trackers/xorg/xorg_exa.h b/src/gallium/state_trackers/xorg/xorg_exa.h index 1f78f60be7..30b6f0ce46 100644 --- a/src/gallium/state_trackers/xorg/xorg_exa.h +++ b/src/gallium/state_trackers/xorg/xorg_exa.h @@ -74,7 +74,7 @@ do { \ struct pipe_surface * xorg_gpu_surface(struct pipe_context *pipe, struct exa_pixmap_priv *priv); -void xorg_exa_flush(struct exa_context *exa, uint pipeFlushFlags, +void xorg_exa_flush(struct exa_context *exa, struct pipe_fence_handle **fence); void xorg_exa_finish(struct exa_context *exa); diff --git a/src/gallium/state_trackers/xorg/xorg_renderer.c b/src/gallium/state_trackers/xorg/xorg_renderer.c index a3d7c5a70e..6b799af90c 100644 --- a/src/gallium/state_trackers/xorg/xorg_renderer.c +++ b/src/gallium/state_trackers/xorg/xorg_renderer.c @@ -73,7 +73,7 @@ renderer_draw(struct xorg_renderer *r) if (buf) { cso_set_vertex_elements(r->cso, r->attrs_per_vertex, r->velems); - util_draw_vertex_buffer(pipe, buf, 0, + util_draw_vertex_buffer(pipe, r->cso, buf, 0, PIPE_PRIM_QUADS, num_verts, /* verts */ r->attrs_per_vertex); /* attribs/vert */ @@ -429,6 +429,7 @@ void renderer_set_constants(struct xorg_renderer *r, pipe_resource_reference(cbuf, NULL); *cbuf = pipe_buffer_create(r->pipe->screen, PIPE_BIND_CONSTANT_BUFFER, + PIPE_USAGE_STATIC, param_bytes); if (*cbuf) { @@ -449,8 +450,7 @@ void renderer_copy_prepare(struct xorg_renderer *r, assert(screen->is_format_supported(screen, dst_surface->format, PIPE_TEXTURE_2D, 0, - PIPE_BIND_RENDER_TARGET, - 0)); + PIPE_BIND_RENDER_TARGET)); (void) screen; @@ -518,14 +518,10 @@ renderer_clone_texture(struct xorg_renderer *r, struct pipe_resource *pt; struct pipe_resource templ; - if (pipe->is_resource_referenced(pipe, src, 0, 0) & - PIPE_REFERENCED_FOR_WRITE) - pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL); - /* the coming in texture should already have that invariance */ debug_assert(screen->is_format_supported(screen, src->format, PIPE_TEXTURE_2D, 0, - PIPE_BIND_SAMPLER_VIEW, 0)); + PIPE_BIND_SAMPLER_VIEW)); format = src->format; @@ -616,7 +612,7 @@ void renderer_draw_yuv(struct xorg_renderer *r, cso_set_vertex_elements(r->cso, num_attribs, r->velems); - util_draw_vertex_buffer(pipe, buf, 0, + util_draw_vertex_buffer(pipe, r->cso, buf, 0, PIPE_PRIM_QUADS, 4, /* verts */ num_attribs); /* attribs/vert */ diff --git a/src/gallium/state_trackers/xorg/xorg_tracker.h b/src/gallium/state_trackers/xorg/xorg_tracker.h index 56397b8fea..664e8c7573 100644 --- a/src/gallium/state_trackers/xorg/xorg_tracker.h +++ b/src/gallium/state_trackers/xorg/xorg_tracker.h @@ -129,6 +129,7 @@ typedef struct _modesettingRec /* kms */ struct kms_driver *kms; struct kms_bo *root_bo; + uint16_t lut_r[256], lut_g[256], lut_b[256]; /* gallium */ struct pipe_screen *screen; diff --git a/src/gallium/state_trackers/xorg/xorg_xv.c b/src/gallium/state_trackers/xorg/xorg_xv.c index c72ba9ef8d..234574b968 100644 --- a/src/gallium/state_trackers/xorg/xorg_xv.c +++ b/src/gallium/state_trackers/xorg/xorg_xv.c @@ -461,20 +461,6 @@ bind_shaders(struct xorg_xv_port_priv *port) cso_set_fragment_shader_handle(port->r->cso, shader.fs); } -static INLINE void -conditional_flush(struct pipe_context *pipe, struct pipe_resource **tex, - int num) -{ - int i; - for (i = 0; i < num; ++i) { - if (tex[i] && pipe->is_resource_referenced(pipe, tex[i], 0, 0) & - PIPE_REFERENCED_FOR_WRITE) { - pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL); - return; - } - } -} - static void bind_samplers(struct xorg_xv_port_priv *port) { @@ -485,8 +471,6 @@ bind_samplers(struct xorg_xv_port_priv *port) memset(&sampler, 0, sizeof(struct pipe_sampler_state)); - conditional_flush(port->r->pipe, dst, 3); - sampler.wrap_s = PIPE_TEX_WRAP_CLAMP; sampler.wrap_t = PIPE_TEX_WRAP_CLAMP; sampler.min_img_filter = PIPE_TEX_FILTER_LINEAR; |