diff options
Diffstat (limited to 'src/gallium/state_trackers')
47 files changed, 1488 insertions, 277 deletions
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 2ff24e17d41..2e45f3f43e9 100644 --- a/src/gallium/state_trackers/d3d1x/dxgi/src/dxgi_native.cpp +++ b/src/gallium/state_trackers/d3d1x/dxgi/src/dxgi_native.cpp @@ -794,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); diff --git a/src/gallium/state_trackers/d3d1x/gd3d11/d3d11_context.h b/src/gallium/state_trackers/d3d1x/gd3d11/d3d11_context.h index e1ba6c184fd..542d6591293 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; } } diff --git a/src/gallium/state_trackers/dri/common/dri_context.c b/src/gallium/state_trackers/dri/common/dri_context.c index 3d5d24e692c..fc68ee13eaa 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); + stapi->make_current(stapi, NULL, NULL, NULL); + draw->context = NULL; + read->context = NULL; } } @@ -169,17 +175,23 @@ dri_make_current(__DRIcontext * cPriv, ++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 060748622c9..28a33ac7d07 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; diff --git a/src/gallium/state_trackers/dri/common/dri_drawable.h b/src/gallium/state_trackers/dri/common/dri_drawable.h index 2ff6b713293..7f1aa512ca1 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 f6e22c74b4e..69c2e7e9ec8 100644 --- a/src/gallium/state_trackers/dri/common/dri_screen.c +++ b/src/gallium/state_trackers/dri/common/dri_screen.c @@ -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 a9d05a80fbd..0181588096d 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,91 @@ 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; + 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; + + 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 +459,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; @@ -601,6 +687,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 00000000000..1cd8dbbda22 --- /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/egl/Makefile b/src/gallium/state_trackers/egl/Makefile index 8cfcef968ed..98167cceeb3 100644 --- a/src/gallium/state_trackers/egl/Makefile +++ b/src/gallium/state_trackers/egl/Makefile @@ -23,6 +23,13 @@ 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 \ + $(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 +52,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 +98,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/common/egl_g3d.c b/src/gallium/state_trackers/egl/common/egl_g3d.c index 9024f945b8c..6107df48822 100644 --- a/src/gallium/state_trackers/egl/common/egl_g3d.c +++ b/src/gallium/state_trackers/egl/common/egl_g3d.c @@ -102,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"; @@ -546,6 +552,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; + if (egl_g3d_add_configs(drv, dpy, 1) == 1) { _eglError(EGL_NOT_INITIALIZED, "eglInitialize(unable to add configs)"); goto fail; 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 78c035a2af0..81ce7ab45c7 100644 --- a/src/gallium/state_trackers/egl/common/egl_g3d_image.c +++ b/src/gallium/state_trackers/egl/common/egl_g3d_image.c @@ -135,7 +135,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) @@ -295,7 +295,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/native.h b/src/gallium/state_trackers/egl/common/native.h index 6461b5edbdf..42889075a39 100644 --- a/src/gallium/state_trackers/egl/common/native.h +++ b/src/gallium/state_trackers/egl/common/native.h @@ -239,6 +239,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 0f2d02032b5..a9d8f32e007 100644 --- a/src/gallium/state_trackers/egl/common/native_helper.c +++ b/src/gallium/state_trackers/egl/common/native_helper.c @@ -143,6 +143,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, diff --git a/src/gallium/state_trackers/egl/common/native_helper.h b/src/gallium/state_trackers/egl/common/native_helper.h index d1569ac3ea6..03995de19ae 100644 --- a/src/gallium/state_trackers/egl/common/native_helper.h +++ b/src/gallium/state_trackers/egl/common/native_helper.h @@ -51,6 +51,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); diff --git a/src/gallium/state_trackers/egl/drm/native_drm.c b/src/gallium/state_trackers/egl/drm/native_drm.c index 14c134ea1ad..6932f30a6a4 100644 --- a/src/gallium/state_trackers/egl/drm/native_drm.c +++ b/src/gallium/state_trackers/egl/drm/native_drm.c @@ -178,7 +178,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; } 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 00000000000..d4d5f9c2ebb --- /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 <[email protected]> + * + * 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-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); + + if (display->base.screen) + display->base.screen->destroy(display->base.screen); + + 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 00000000000..271c10dc113 --- /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 <[email protected]> + * + * 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 c82e2da863b..b18c3132c57 100644 --- a/src/gallium/state_trackers/egl/x11/native_dri2.c +++ b/src/gallium/state_trackers/egl/x11/native_dri2.c @@ -782,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; } diff --git a/src/gallium/state_trackers/python/p_context.i b/src/gallium/state_trackers/python/p_context.i index d694651eef7..b30050bf6d4 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; @@ -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 */ diff --git a/src/gallium/state_trackers/python/p_device.i b/src/gallium/state_trackers/python/p_device.i index d55086fefd5..cc67da937cd 100644 --- a/src/gallium/state_trackers/python/p_device.i +++ b/src/gallium/state_trackers/python/p_device.i @@ -134,7 +134,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 7342c124c28..3e8ad49b767 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 4900135a1c5..f3732aa1577 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_filters.c b/src/gallium/state_trackers/vega/api_filters.c index 724e38241b5..6be460c495c 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 ad95409cd00..b993ba62c26 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); @@ -487,7 +488,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 d96afe66387..cdbf0026e89 100644 --- a/src/gallium/state_trackers/vega/api_masks.c +++ b/src/gallium/state_trackers/vega/api_masks.c @@ -28,6 +28,7 @@ #include "mask.h" #include "api.h" +#include "handle.h" #include "renderer.h" #include "vg_context.h" @@ -56,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); @@ -123,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) @@ -138,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) @@ -156,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); } @@ -192,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)) { @@ -226,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 1411806455c..2610ebe0576 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 a73b6c3effe..aa1e5dd280a 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 fe57b7671d9..ab6ce958945 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 7c6b4794099..824c7630403 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 00000000000..11eedd923ed --- /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 00000000000..9ed326d5098 --- /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 318ea94bdfb..73351b671f9 100644 --- a/src/gallium/state_trackers/vega/image.c +++ b/src/gallium/state_trackers/vega/image.c @@ -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); } diff --git a/src/gallium/state_trackers/vega/paint.c b/src/gallium/state_trackers/vega/paint.c index 2db8cbcf7c8..6e5348a1ff2 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 3de3bbe12ed..e5357763b89 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 a491de27fa6..bcc5cb272ca 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 e42bad76492..9de2cb1014d 100644 --- a/src/gallium/state_trackers/vega/renderer.c +++ b/src/gallium/state_trackers/vega/renderer.c @@ -28,6 +28,7 @@ #include "renderer.h" #include "vg_context.h" +#include "paint.h" /* for paint_is_opaque */ #include "pipe/p_context.h" #include "pipe/p_state.h" @@ -173,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, @@ -473,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, @@ -571,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 */ @@ -1049,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); @@ -1289,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; diff --git a/src/gallium/state_trackers/vega/shader.c b/src/gallium/state_trackers/vega/shader.c index 2a6bae8a630..bee6d84001d 100644 --- a/src/gallium/state_trackers/vega/shader.c +++ b/src/gallium/state_trackers/vega/shader.c @@ -134,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/vg_context.c b/src/gallium/state_trackers/vega/vg_context.c index f36f55d6c89..83b42609e03 100644 --- a/src/gallium/state_trackers/vega/vg_context.c +++ b/src/gallium/state_trackers/vega/vg_context.c @@ -33,6 +33,7 @@ #include "vg_manager.h" #include "api.h" #include "mask.h" +#include "handle.h" #include "pipe/p_context.h" #include "util/u_inlines.h" @@ -182,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; } @@ -398,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, @@ -412,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 d616a20a3d9..71491a5aa22 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 ec713b7fb1d..44d2996bb45 100644 --- a/src/gallium/state_trackers/vega/vg_manager.c +++ b/src/gallium/state_trackers/vega/vg_manager.c @@ -40,6 +40,7 @@ #include "vg_manager.h" #include "vg_context.h" #include "api.h" +#include "handle.h" static boolean vg_context_update_color_rb(struct vg_context *ctx, struct pipe_resource *pt) @@ -172,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 7dc51c5599c..4206a91e006 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 1b7597de440..7cb953ba742 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_device.c b/src/gallium/state_trackers/wgl/stw_device.c index c4822d4d8aa..4ece4e4979a 100644 --- a/src/gallium/state_trackers/wgl/stw_device.c +++ b/src/gallium/state_trackers/wgl/stw_device.c @@ -170,7 +170,10 @@ stw_cleanup(void) _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/xorg/xorg_crtc.c b/src/gallium/state_trackers/xorg/xorg_crtc.c index 71f7b8c21d0..d751ac18704 100644 --- a/src/gallium/state_trackers/xorg/xorg_crtc.c +++ b/src/gallium/state_trackers/xorg/xorg_crtc.c @@ -135,14 +135,12 @@ crtc_set_mode_major(xf86CrtcPtr crtc, DisplayModePtr mode, /* Only set gamma when needed, to avoid unneeded delays. */ #if defined(XF86_CRTC_VERSION) && XF86_CRTC_VERSION >= 3 - if (!crtc->active) -#endif + if (!crtc->active && crtc->version >= 3) crtc->funcs->gamma_set(crtc, crtc->gamma_red, crtc->gamma_green, crtc->gamma_blue, crtc->gamma_size); - -#if defined(XF86_CRTC_VERSION) && XF86_CRTC_VERSION >= 3 crtc->active = TRUE; #endif + crtc->x = x; crtc->y = y; crtc->mode = *mode; diff --git a/src/gallium/state_trackers/xorg/xorg_renderer.c b/src/gallium/state_trackers/xorg/xorg_renderer.c index a3d7c5a70e2..3b3ae455c0b 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) { @@ -616,7 +617,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/xvmc/subpicture.c b/src/gallium/state_trackers/xorg/xvmc/subpicture.c index 4a835c04d8a..78de154bdd7 100644 --- a/src/gallium/state_trackers/xorg/xvmc/subpicture.c +++ b/src/gallium/state_trackers/xorg/xvmc/subpicture.c @@ -14,7 +14,7 @@ * 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. @@ -176,6 +176,7 @@ Status XvMCCreateSubpicture(Display *dpy, XvMCContext *context, XvMCSubpicture * template.height0 = util_next_power_of_two(height); } template.depth0 = 1; + template.array_size = 1; template.usage = PIPE_USAGE_DYNAMIC; template.bind = PIPE_BIND_SAMPLER_VIEW; template.flags = 0; @@ -222,7 +223,7 @@ Status XvMCClearSubpicture(Display *dpy, XvMCSubpicture *subpicture, short x, sh if (!subpicture) return XvMCBadSubpicture; - + /* Convert color to float */ util_format_read_4f(PIPE_FORMAT_B8G8R8A8_UNORM, color_f, 1, diff --git a/src/gallium/state_trackers/xorg/xvmc/surface.c b/src/gallium/state_trackers/xorg/xvmc/surface.c index d7285a478fb..c90ad409c10 100644 --- a/src/gallium/state_trackers/xorg/xvmc/surface.c +++ b/src/gallium/state_trackers/xorg/xvmc/surface.c @@ -122,6 +122,7 @@ CreateOrResizeBackBuffer(struct vl_context *vctx, unsigned int width, unsigned i template.width0 = width; template.height0 = height; template.depth0 = 1; + template.array_size = 1; template.usage = PIPE_USAGE_DEFAULT; template.bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_DISPLAY_TARGET | PIPE_BIND_BLIT_SOURCE; template.flags = 0; @@ -240,6 +241,7 @@ Status XvMCCreateSurface(Display *dpy, XvMCContext *context, XvMCSurface *surfac template.height0 = util_next_power_of_two(context->height); } template.depth0 = 1; + template.array_size = 1; template.usage = PIPE_USAGE_DEFAULT; template.bind = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET; template.flags = 0; |