st/vega: Remove.

OpenVG API seems to have dwindled away.  The code
would still be interesting if we wanted to implement NV_path_rendering
but given the trend of the next gen graphics APIs, it seems
unlikely that this becomes ARB or core.

v2: Remove a few "openvg" references left, per Emil Velikov.

Reviewed-by: Emil Velikov <[email protected]>

v3: Update release notes.

59 files changed, 0 insertions, 20527 deletions

diff --git a/src/gallium/state_trackers/vega/.gitignore b/src/gallium/state_trackers/vega/.gitignore
deleted file mode 100644
index c452229f7f4..00000000000
--- a/src/gallium/state_trackers/vega/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-api_tmp.h
diff --git a/src/gallium/state_trackers/vega/Makefile.am b/src/gallium/state_trackers/vega/Makefile.am
deleted file mode 100644
index 8985a4e4f4a..00000000000
--- a/src/gallium/state_trackers/vega/Makefile.am
+++ /dev/null
@@ -1,42 +0,0 @@
-# Copyright © 2012 Intel Corporation
-#
-# 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 (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
-# 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 Makefile.sources
-include $(top_srcdir)/src/gallium/Automake.inc
-
-AM_CFLAGS = $(GALLIUM_CFLAGS)
-AM_CPPFLAGS = \
-	-I$(top_srcdir)/include \
-	-I$(top_srcdir)/src/mapi
-
-noinst_LTLIBRARIES = libvega.la
-
-libvega_la_SOURCES = $(C_SOURCES)
-
-BUILT_SOURCES = api_tmp.h
-CLEANFILES = api_tmp.h
-
-api_tmp.h: $(top_srcdir)/src/mapi/vgapi/vgapi.csv $(top_srcdir)/src/mapi/mapi_abi.py
-	$(AM_V_GEN) $(PYTHON2) $(PYTHON_FLAGS) $(top_srcdir)/src/mapi/mapi_abi.py \
-			--printer vgapi --mode app $< > $@
-
-EXTRA_DIST = SConscript
diff --git a/src/gallium/state_trackers/vega/Makefile.sources b/src/gallium/state_trackers/vega/Makefile.sources
deleted file mode 100644
index 116a771629f..00000000000
--- a/src/gallium/state_trackers/vega/Makefile.sources
+++ /dev/null
@@ -1,56 +0,0 @@
-C_SOURCES := \
-	api.c \
-	api.h \
-	api_consts.h \
-	api_context.c \
-	api_filters.c \
-	api_images.c \
-	api_masks.c \
-	api_misc.c \
-	api_paint.c \
-	api_params.c \
-	api_path.c \
-	api_text.c \
-	api_transform.c \
-	arc.c \
-	arc.h \
-	asm_fill.h \
-	asm_filters.h \
-	asm_util.h \
-	bezier.c \
-	bezier.h \
-	handle.c \
-	handle.h \
-	image.c \
-	image.h \
-	mask.c \
-	mask.h \
-	matrix.h \
-	paint.c \
-	paint.h \
-	path.c \
-	path.h \
-	path_utils.h \
-	polygon.c \
-	polygon.h \
-	renderer.c \
-	renderer.h \
-	shader.c \
-	shader.h \
-	shaders_cache.c \
-	shaders_cache.h \
-	stroker.c \
-	stroker.h \
-	text.c \
-	text.h \
-	util_array.h \
-	vg_api.h \
-	vg_context.c \
-	vg_context.h \
-	vg_manager.c \
-	vg_manager.h \
-	vg_state.c \
-	vg_state.h \
-	vg_translate.c \
-	vg_translate.h \
-	vgu.c
diff --git a/src/gallium/state_trackers/vega/SConscript b/src/gallium/state_trackers/vega/SConscript
deleted file mode 100644
index 29d5498c6c4..00000000000
--- a/src/gallium/state_trackers/vega/SConscript
+++ /dev/null
@@ -1,30 +0,0 @@
-#######################################################################
-# SConscript for vega state_tracker
-
-Import('*')
-
-from sys import executable as python_cmd
-
-env = env.Clone()
-
-env.Append(CPPPATH = [
-    '#/src/mapi',
-    Dir('.'),
-])
-env.Append(CPPDEFINES = [
-    'KHRONOS_DLL_EXPORTS',
-])
-
-api_tmp, = env.CodeGenerate(
-        target = 'api_tmp.h',
-        script = '#src/mapi/mapi_abi.py',
-        source = '#src/mapi/vgapi/vgapi.csv',
-        command = python_cmd + ' $SCRIPT --printer vgapi --mode app $SOURCE > $TARGET'
-)
-
-st_vega = env.ConvenienceLibrary(
-    target = 'st_vega',
-    source = env.ParseSourceList('Makefile.sources', 'C_SOURCES')
-)
-
-Export('st_vega')
diff --git a/src/gallium/state_trackers/vega/api.c b/src/gallium/state_trackers/vega/api.c
deleted file mode 100644
index 06b1e7b95af..00000000000
--- a/src/gallium/state_trackers/vega/api.c
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Mesa 3-D graphics library
- *
- * Copyright (C) 2010 LunarG Inc.
- *
- * 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.
- *
- * Authors:
- *    Chia-I Wu <[email protected]>
- */
-
-#include "mapi.h"
-
-/* define vega_spec and vega_procs for use with mapi */
-#define API_TMP_DEFINE_SPEC
-#include "api.h"
-
-static void api_init(void)
-{
-   static boolean initialized = FALSE;
-   if (!initialized) {
-      mapi_init(vega_spec);
-      initialized = TRUE;
-   }
-}
-
-struct mapi_table *api_create_dispatch(void)
-{
-   struct mapi_table *tbl;
-
-   api_init();
-
-   tbl = mapi_table_create();
-   if (tbl)
-      mapi_table_fill(tbl, vega_procs);
-
-   return tbl;
-}
-
-void api_destroy_dispatch(struct mapi_table *tbl)
-{
-   mapi_table_destroy(tbl);
-}
-
-void api_make_dispatch_current(const struct mapi_table *tbl)
-{
-   mapi_table_make_current(tbl);
-}
-
-mapi_proc api_get_proc_address(const char *proc_name)
-{
-   if (!proc_name || proc_name[0] != 'v' || proc_name[1] != 'g')
-      return NULL;
-   proc_name += 2;
-
-   api_init();
-   return mapi_get_proc_address(proc_name);
-}
diff --git a/src/gallium/state_trackers/vega/api.h b/src/gallium/state_trackers/vega/api.h
deleted file mode 100644
index 3226450ac33..00000000000
--- a/src/gallium/state_trackers/vega/api.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Mesa 3-D graphics library
- *
- * Copyright (C) 2010 LunarG Inc.
- *
- * 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.
- *
- * Authors:
- *    Chia-I Wu <[email protected]>
- */
-
-#ifndef API_H
-#define API_H
-
-#include "VG/openvg.h"
-#include "VG/vgext.h"
-#include "vg_manager.h"
-
-#include "api_tmp.h"
-
-struct mapi_table;
-
-struct mapi_table *api_create_dispatch(void);
-
-void api_destroy_dispatch(struct mapi_table *tbl);
-
-void api_make_dispatch_current(const struct mapi_table *tbl);
-
-st_proc_t api_get_proc_address(const char *proc_name);
-
-#endif /* API_H */
diff --git a/src/gallium/state_trackers/vega/api_consts.h b/src/gallium/state_trackers/vega/api_consts.h
deleted file mode 100644
index e1b48d4a46c..00000000000
--- a/src/gallium/state_trackers/vega/api_consts.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef API_CONSTS_H
-#define API_CONSTS_H
-
-/*must be at least 32*/
-#define VEGA_MAX_SCISSOR_RECTS 32
-
-/*must be at least 16*/
-#define VEGA_MAX_DASH_COUNT 32
-
-/*must be at least 7*/
-#define VEGA_MAX_KERNEL_SIZE 7
-
-/*must be at least 15*/
-#define VEGA_MAX_SEPARABLE_KERNEL_SIZE 15
-
-/*must be at least 32*/
-#define VEGA_MAX_COLOR_RAMP_STOPS 256
-
-#define VEGA_MAX_IMAGE_WIDTH 2048
-
-#define VEGA_MAX_IMAGE_HEIGHT 2048
-
-#define VEGA_MAX_IMAGE_PIXELS (2048*2048)
-
-#define VEGA_MAX_IMAGE_BYTES (2048*2048 * 4)
-
-/*must be at least 128*/
-#define VEGA_MAX_GAUSSIAN_STD_DEVIATION 128
-
-#endif
diff --git a/src/gallium/state_trackers/vega/api_context.c b/src/gallium/state_trackers/vega/api_context.c
deleted file mode 100644
index 055277cd76e..00000000000
--- a/src/gallium/state_trackers/vega/api_context.c
+++ /dev/null
@@ -1,81 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "VG/openvg.h"
-
-#include "vg_manager.h"
-#include "vg_context.h"
-#include "api.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_screen.h"
-
-VGErrorCode vegaGetError(void)
-{
-   struct vg_context *ctx = vg_current_context();
-   VGErrorCode error = VG_NO_CONTEXT_ERROR;
-
-   if (!ctx)
-      return error;
-
-   error = ctx->_error;
-   ctx->_error = VG_NO_ERROR;
-
-   return error;
-}
-
-void vegaFlush(void)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct pipe_context *pipe;
-
-   if (!ctx)
-      return;
-
-   pipe = ctx->pipe;
-   pipe->flush(pipe, NULL, 0);
-
-   vg_manager_flush_frontbuffer(ctx);
-}
-
-void vegaFinish(void)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct pipe_fence_handle *fence = NULL;
-   struct pipe_context *pipe;
-
-   if (!ctx)
-      return;
-
-   pipe = ctx->pipe;
-
-   pipe->flush(pipe, &fence, 0);
-   if (fence) {
-      pipe->screen->fence_finish(pipe->screen, fence,
-                                 PIPE_TIMEOUT_INFINITE);
-      pipe->screen->fence_reference(pipe->screen, &fence, NULL);
-   }
-}
diff --git a/src/gallium/state_trackers/vega/api_filters.c b/src/gallium/state_trackers/vega/api_filters.c
deleted file mode 100644
index 480ced16c51..00000000000
--- a/src/gallium/state_trackers/vega/api_filters.c
+++ /dev/null
@@ -1,705 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "VG/openvg.h"
-
-#include "vg_context.h"
-#include "image.h"
-#include "api.h"
-#include "handle.h"
-#include "renderer.h"
-#include "shaders_cache.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_state.h"
-#include "util/u_inlines.h"
-#include "pipe/p_screen.h"
-
-#include "util/u_format.h"
-#include "util/u_sampler.h"
-#include "util/u_string.h"
-
-#include "asm_filters.h"
-
-
-struct filter_info {
-   struct vg_image *dst;
-   struct vg_image *src;
-   struct vg_shader * (*setup_shader)(struct vg_context *, void *);
-   void *user_data;
-   const void *const_buffer;
-   VGint const_buffer_len;
-   VGTilingMode tiling_mode;
-   struct pipe_sampler_view *extra_texture_view;
-};
-
-static INLINE struct pipe_resource *create_texture_1d(struct vg_context *ctx,
-                                                     const VGuint *color_data,
-                                                     const VGint color_data_len)
-{
-   struct pipe_context *pipe = ctx->pipe;
-   struct pipe_screen *screen = pipe->screen;
-   struct pipe_resource *tex = 0;
-   struct pipe_resource templ;
-
-   memset(&templ, 0, sizeof(templ));
-   templ.target = PIPE_TEXTURE_1D;
-   templ.format = PIPE_FORMAT_B8G8R8A8_UNORM;
-   templ.last_level = 0;
-   templ.width0 = color_data_len;
-   templ.height0 = 1;
-   templ.depth0 = 1;
-   templ.array_size = 1;
-   templ.bind = PIPE_BIND_SAMPLER_VIEW;
-
-   tex = screen->resource_create(screen, &templ);
-
-   { /* upload color_data */
-      struct pipe_transfer *transfer;
-      void *map =
-         pipe_transfer_map(pipe, tex,
-                           0, 0,
-                           PIPE_TRANSFER_READ_WRITE ,
-                           0, 0, tex->width0, tex->height0,
-                           &transfer);
-      memcpy(map, color_data, sizeof(VGint)*color_data_len);
-      pipe->transfer_unmap(pipe, transfer);
-   }
-
-   return tex;
-}
-
-static INLINE struct pipe_sampler_view *create_texture_1d_view(struct vg_context *ctx,
-                                                               const VGuint *color_data,
-                                                               const VGint color_data_len)
-{
-   struct pipe_context *pipe = ctx->pipe;
-   struct pipe_resource *texture;
-   struct pipe_sampler_view view_templ;
-   struct pipe_sampler_view *view;
-
-   texture = create_texture_1d(ctx, color_data, color_data_len);
-
-   if (!texture)
-      return NULL;
-
-   u_sampler_view_default_template(&view_templ, texture, texture->format);
-   view = pipe->create_sampler_view(pipe, texture, &view_templ);
-   /* want the texture to go away if the view is freed */
-   pipe_resource_reference(&texture, NULL);
-
-   return view;
-}
-
-static struct vg_shader * setup_color_matrix(struct vg_context *ctx, void *user_data)
-{
-   struct vg_shader *shader =
-      shader_create_from_text(ctx->pipe, color_matrix_asm, 200,
-         PIPE_SHADER_FRAGMENT);
-   return shader;
-}
-
-static struct vg_shader * setup_convolution(struct vg_context *ctx, void *user_data)
-{
-   char buffer[1024];
-   VGint num_consts = (VGint)(long)(user_data);
-   struct vg_shader *shader;
-
-   util_snprintf(buffer, 1023, convolution_asm, num_consts, num_consts / 2 + 1);
-
-   shader = shader_create_from_text(ctx->pipe, buffer, 200,
-                                    PIPE_SHADER_FRAGMENT);
-
-   return shader;
-}
-
-static struct vg_shader * setup_lookup(struct vg_context *ctx, void *user_data)
-{
-   struct vg_shader *shader =
-      shader_create_from_text(ctx->pipe, lookup_asm,
-                              200, PIPE_SHADER_FRAGMENT);
-
-   return shader;
-}
-
-
-static struct vg_shader * setup_lookup_single(struct vg_context *ctx, void *user_data)
-{
-   char buffer[1024];
-   VGImageChannel channel = (VGImageChannel)(user_data);
-   struct vg_shader *shader;
-
-   switch(channel) {
-   case VG_RED:
-      util_snprintf(buffer, 1023, lookup_single_asm, "xxxx");
-      break;
-   case VG_GREEN:
-      util_snprintf(buffer, 1023, lookup_single_asm, "yyyy");
-      break;
-   case VG_BLUE:
-      util_snprintf(buffer, 1023, lookup_single_asm, "zzzz");
-      break;
-   case VG_ALPHA:
-      util_snprintf(buffer, 1023, lookup_single_asm, "wwww");
-      break;
-   default:
-      debug_assert(!"Unknown color channel");
-   }
-
-   shader = shader_create_from_text(ctx->pipe, buffer, 200,
-                                    PIPE_SHADER_FRAGMENT);
-
-   return shader;
-}
-
-static void execute_filter(struct vg_context *ctx,
-                           struct filter_info *info)
-{
-   struct vg_shader *shader;
-   const struct pipe_sampler_state *samplers[2];
-   struct pipe_sampler_view *views[2];
-   struct pipe_sampler_state sampler;
-   uint tex_wrap;
-
-   memset(&sampler, 0, sizeof(sampler));
-   sampler.min_img_filter = PIPE_TEX_FILTER_LINEAR;
-   sampler.mag_img_filter = PIPE_TEX_FILTER_LINEAR;
-   sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
-   sampler.normalized_coords = 1;
-
-   switch (info->tiling_mode) {
-   case VG_TILE_FILL:
-      tex_wrap = PIPE_TEX_WRAP_CLAMP_TO_BORDER;
-      /* copy border color */
-      memcpy(sampler.border_color.f, ctx->state.vg.tile_fill_color,
-            sizeof(sampler.border_color));
-      break;
-   case VG_TILE_PAD:
-      tex_wrap = PIPE_TEX_WRAP_CLAMP_TO_EDGE;;
-      break;
-   case VG_TILE_REPEAT:
-      tex_wrap = PIPE_TEX_WRAP_REPEAT;;
-      break;
-   case VG_TILE_REFLECT:
-      tex_wrap = PIPE_TEX_WRAP_MIRROR_REPEAT;
-      break;
-   default:
-      debug_assert(!"Unknown tiling mode");
-      tex_wrap = 0;
-      break;
-   }
-
-   sampler.wrap_s = tex_wrap;
-   sampler.wrap_t = tex_wrap;
-   sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-
-   samplers[0] = samplers[1] = &sampler;
-   views[0] = info->src->sampler_view;
-   views[1] = info->extra_texture_view;
-
-   shader = info->setup_shader(ctx, info->user_data);
-
-   if (renderer_filter_begin(ctx->renderer,
-            info->dst->sampler_view->texture, VG_TRUE,
-            ctx->state.vg.filter_channel_mask,
-            samplers, views, (info->extra_texture_view) ? 2 : 1,
-            shader->driver, info->const_buffer, info->const_buffer_len)) {
-      renderer_filter(ctx->renderer,
-            info->dst->x, info->dst->y, info->dst->width, info->dst->height,
-            info->src->x, info->src->y, info->src->width, info->src->height);
-      renderer_filter_end(ctx->renderer);
-   }
-
-   vg_shader_destroy(ctx, shader);
-}
-
-void vegaColorMatrix(VGImage dst, VGImage src,
-                     const VGfloat * matrix)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_image *d, *s;
-   struct filter_info info;
-
-   if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   if (!matrix || !is_aligned(matrix)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   d = handle_to_image(dst);
-   s = handle_to_image(src);
-
-   if (vg_image_overlaps(d, s)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   info.dst = d;
-   info.src = s;
-   info.setup_shader = &setup_color_matrix;
-   info.user_data = NULL;
-   info.const_buffer = matrix;
-   info.const_buffer_len = 20 * sizeof(VGfloat);
-   info.tiling_mode = VG_TILE_PAD;
-   info.extra_texture_view = NULL;
-   execute_filter(ctx, &info);
-}
-
-static VGfloat texture_offset(VGfloat width, VGint kernelSize, VGint current, VGint shift)
-{
-   VGfloat diff = (VGfloat) (current - shift);
-
-   return diff / width;
-}
-
-void vegaConvolve(VGImage dst, VGImage src,
-                  VGint kernelWidth, VGint kernelHeight,
-                  VGint shiftX, VGint shiftY,
-                  const VGshort * kernel,
-                  VGfloat scale,
-                  VGfloat bias,
-                  VGTilingMode tilingMode)
-{
-   struct vg_context *ctx = vg_current_context();
-   VGfloat *buffer;
-   VGint buffer_len;
-   VGint i, j;
-   VGint idx = 0;
-   struct vg_image *d, *s;
-   VGint kernel_size = kernelWidth * kernelHeight;
-   struct filter_info info;
-   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);
-      return;
-   }
-
-   if (kernelWidth <= 0 || kernelHeight <= 0 ||
-      kernelWidth > max_kernel_size || kernelHeight > max_kernel_size) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   if (!kernel || !is_aligned_to(kernel, 2)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   if (tilingMode < VG_TILE_FILL ||
-       tilingMode > VG_TILE_REFLECT) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   d = handle_to_image(dst);
-   s = handle_to_image(src);
-
-   if (vg_image_overlaps(d, s)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   vg_validate_state(ctx);
-
-   buffer_len = 8 + 2 * 4 * kernel_size;
-   buffer = malloc(buffer_len * sizeof(VGfloat));
-
-   buffer[0] = 0.f;
-   buffer[1] = 1.f;
-   buffer[2] = 2.f; /*unused*/
-   buffer[3] = 4.f; /*unused*/
-
-   buffer[4] = (VGfloat) (kernelWidth * kernelHeight);
-   buffer[5] = scale;
-   buffer[6] = bias;
-   buffer[7] = 0.f;
-
-   idx = 8;
-   for (j = 0; j < kernelHeight; ++j) {
-      for (i = 0; i < kernelWidth; ++i) {
-         VGint index = j * kernelWidth + i;
-         VGfloat x, y;
-
-         x = (VGfloat) texture_offset(s->width, kernelWidth, i, shiftX);
-         y = (VGfloat) texture_offset(s->height, kernelHeight, j, shiftY);
-
-         buffer[idx + index*4 + 0] = x;
-         buffer[idx + index*4 + 1] = y;
-         buffer[idx + index*4 + 2] = 0.f;
-         buffer[idx + index*4 + 3] = 0.f;
-      }
-   }
-   idx += kernel_size * 4;
-
-   for (j = 0; j < kernelHeight; ++j) {
-      for (i = 0; i < kernelWidth; ++i) {
-         /* transpose the kernel */
-         VGint index = j * kernelWidth + i;
-         VGint kindex = (kernelWidth - i - 1) * kernelHeight + (kernelHeight - j - 1);
-         buffer[idx + index*4 + 0] = kernel[kindex];
-         buffer[idx + index*4 + 1] = kernel[kindex];
-         buffer[idx + index*4 + 2] = kernel[kindex];
-         buffer[idx + index*4 + 3] = kernel[kindex];
-      }
-   }
-
-   info.dst = d;
-   info.src = s;
-   info.setup_shader = &setup_convolution;
-   info.user_data = (void*)(long)(buffer_len/4);
-   info.const_buffer = buffer;
-   info.const_buffer_len = buffer_len * sizeof(VGfloat);
-   info.tiling_mode = tilingMode;
-   info.extra_texture_view = NULL;
-   execute_filter(ctx, &info);
-
-   free(buffer);
-}
-
-void vegaSeparableConvolve(VGImage dst, VGImage src,
-                           VGint kernelWidth,
-                           VGint kernelHeight,
-                           VGint shiftX, VGint shiftY,
-                           const VGshort * kernelX,
-                           const VGshort * kernelY,
-                           VGfloat scale,
-                           VGfloat bias,
-                           VGTilingMode tilingMode)
-{
-   struct vg_context *ctx = vg_current_context();
-   VGshort *kernel;
-   VGint i, j, idx = 0;
-   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);
-      return;
-   }
-
-   if (kernelWidth <= 0 || kernelHeight <= 0 ||
-       kernelWidth > max_kernel_size || kernelHeight > max_kernel_size) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   if (!kernelX || !kernelY ||
-       !is_aligned_to(kernelX, 2) || !is_aligned_to(kernelY, 2)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   if (tilingMode < VG_TILE_FILL ||
-       tilingMode > VG_TILE_REFLECT) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   kernel = malloc(sizeof(VGshort)*kernelWidth*kernelHeight);
-   for (i = 0; i < kernelWidth; ++i) {
-      for (j = 0; j < kernelHeight; ++j) {
-         kernel[idx] = kernelX[i] * kernelY[j];
-         ++idx;
-      }
-   }
-   vegaConvolve(dst, src, kernelWidth, kernelHeight, shiftX, shiftY,
-                kernel, scale, bias, tilingMode);
-   free(kernel);
-}
-
-static INLINE VGfloat compute_gaussian_componenet(VGfloat x, VGfloat y,
-                                                  VGfloat stdDeviationX,
-                                                  VGfloat stdDeviationY)
-{
-   VGfloat mult = 1 / ( 2 * M_PI * stdDeviationX * stdDeviationY);
-   VGfloat e = exp( - ( pow(x, 2)/(2*pow(stdDeviationX, 2)) +
-                        pow(y, 2)/(2*pow(stdDeviationY, 2)) ) );
-   return mult * e;
-}
-
-static INLINE VGint compute_kernel_size(VGfloat deviation)
-{
-   VGint size = ceil(2.146 * deviation);
-   if (size > 11)
-      return 11;
-   return size;
-}
-
-static void compute_gaussian_kernel(VGfloat *kernel,
-                                    VGint width, VGint height,
-                                    VGfloat stdDeviationX,
-                                    VGfloat stdDeviationY)
-{
-   VGint i, j;
-   VGfloat scale = 0.0f;
-
-   for (j = 0; j < height; ++j) {
-      for (i = 0; i < width; ++i) {
-         VGint idx =  (height - j -1) * width + (width - i -1);
-         kernel[idx] = compute_gaussian_componenet(i-(ceil(width/2))-1,
-                                                   j-ceil(height/2)-1,
-                                                   stdDeviationX, stdDeviationY);
-         scale += kernel[idx];
-      }
-   }
-
-   for (j = 0; j < height; ++j) {
-      for (i = 0; i < width; ++i) {
-         VGint idx = j * width + i;
-         kernel[idx] /= scale;
-      }
-   }
-}
-
-void vegaGaussianBlur(VGImage dst, VGImage src,
-                      VGfloat stdDeviationX,
-                      VGfloat stdDeviationY,
-                      VGTilingMode tilingMode)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_image *d, *s;
-   VGfloat *buffer, *kernel;
-   VGint kernel_width, kernel_height, kernel_size;
-   VGint buffer_len;
-   VGint idx, i, j;
-   struct filter_info info;
-
-   if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   if (stdDeviationX <= 0 || stdDeviationY <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   if (tilingMode < VG_TILE_FILL ||
-       tilingMode > VG_TILE_REFLECT) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   d = handle_to_image(dst);
-   s = handle_to_image(src);
-
-   if (vg_image_overlaps(d, s)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   kernel_width = compute_kernel_size(stdDeviationX);
-   kernel_height = compute_kernel_size(stdDeviationY);
-   kernel_size = kernel_width * kernel_height;
-   kernel = malloc(sizeof(VGfloat)*kernel_size);
-   compute_gaussian_kernel(kernel, kernel_width, kernel_height,
-                           stdDeviationX, stdDeviationY);
-
-   buffer_len = 8 + 2 * 4 * kernel_size;
-   buffer = malloc(buffer_len * sizeof(VGfloat));
-
-   buffer[0] = 0.f;
-   buffer[1] = 1.f;
-   buffer[2] = 2.f; /*unused*/
-   buffer[3] = 4.f; /*unused*/
-
-   buffer[4] = kernel_width * kernel_height;
-   buffer[5] = 1.f;/*scale*/
-   buffer[6] = 0.f;/*bias*/
-   buffer[7] = 0.f;
-
-   idx = 8;
-   for (j = 0; j < kernel_height; ++j) {
-      for (i = 0; i < kernel_width; ++i) {
-         VGint index = j * kernel_width + i;
-         VGfloat x, y;
-
-         x = texture_offset(s->width, kernel_width, i, kernel_width/2);
-         y = texture_offset(s->height, kernel_height, j, kernel_height/2);
-
-         buffer[idx + index*4 + 0] = x;
-         buffer[idx + index*4 + 1] = y;
-         buffer[idx + index*4 + 2] = 0.f;
-         buffer[idx + index*4 + 3] = 0.f;
-      }
-   }
-   idx += kernel_size * 4;
-
-   for (j = 0; j < kernel_height; ++j) {
-      for (i = 0; i < kernel_width; ++i) {
-         /* transpose the kernel */
-         VGint index = j * kernel_width + i;
-         VGint kindex = (kernel_width - i - 1) * kernel_height + (kernel_height - j - 1);
-         buffer[idx + index*4 + 0] = kernel[kindex];
-         buffer[idx + index*4 + 1] = kernel[kindex];
-         buffer[idx + index*4 + 2] = kernel[kindex];
-         buffer[idx + index*4 + 3] = kernel[kindex];
-      }
-   }
-
-   info.dst = d;
-   info.src = s;
-   info.setup_shader = &setup_convolution;
-   info.user_data = (void*)(long)(buffer_len/4);
-   info.const_buffer = buffer;
-   info.const_buffer_len = buffer_len * sizeof(VGfloat);
-   info.tiling_mode = tilingMode;
-   info.extra_texture_view = NULL;
-   execute_filter(ctx, &info);
-
-   free(buffer);
-   free(kernel);
-}
-
-void vegaLookup(VGImage dst, VGImage src,
-                const VGubyte * redLUT,
-                const VGubyte * greenLUT,
-                const VGubyte * blueLUT,
-                const VGubyte * alphaLUT,
-                VGboolean outputLinear,
-                VGboolean outputPremultiplied)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_image *d, *s;
-   VGuint color_data[256];
-   VGint i;
-   struct pipe_sampler_view *lut_texture_view;
-   VGfloat buffer[4];
-   struct filter_info info;
-
-   if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   if (!redLUT || !greenLUT || !blueLUT || !alphaLUT) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   d = handle_to_image(dst);
-   s = handle_to_image(src);
-
-   if (vg_image_overlaps(d, s)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   for (i = 0; i < 256; ++i) {
-      color_data[i] = blueLUT[i] << 24 | greenLUT[i] << 16 |
-                      redLUT[i]  <<  8 | alphaLUT[i];
-   }
-   lut_texture_view = create_texture_1d_view(ctx, color_data, 255);
-
-   buffer[0] = 0.f;
-   buffer[1] = 0.f;
-   buffer[2] = 1.f;
-   buffer[3] = 1.f;
-
-   info.dst = d;
-   info.src = s;
-   info.setup_shader = &setup_lookup;
-   info.user_data = NULL;
-   info.const_buffer = buffer;
-   info.const_buffer_len = 4 * sizeof(VGfloat);
-   info.tiling_mode = VG_TILE_PAD;
-   info.extra_texture_view = lut_texture_view;
-
-   execute_filter(ctx, &info);
-
-   pipe_sampler_view_reference(&lut_texture_view, NULL);
-}
-
-void vegaLookupSingle(VGImage dst, VGImage src,
-                      const VGuint * lookupTable,
-                      VGImageChannel sourceChannel,
-                      VGboolean outputLinear,
-                      VGboolean outputPremultiplied)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_image *d, *s;
-   struct pipe_sampler_view *lut_texture_view;
-   VGfloat buffer[4];
-   struct filter_info info;
-   VGuint color_data[256];
-   VGint i;
-
-   if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   if (!lookupTable || !is_aligned(lookupTable)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   if (sourceChannel != VG_RED && sourceChannel != VG_GREEN &&
-       sourceChannel != VG_BLUE && sourceChannel != VG_ALPHA) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   d = handle_to_image(dst);
-   s = handle_to_image(src);
-
-   if (vg_image_overlaps(d, s)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   vg_validate_state(ctx);
-
-   for (i = 0; i < 256; ++i) {
-      VGuint rgba = lookupTable[i];
-      VGubyte blue, green, red, alpha;
-      red   = (rgba & 0xff000000)>>24;
-      green = (rgba & 0x00ff0000)>>16;
-      blue  = (rgba & 0x0000ff00)>> 8;
-      alpha = (rgba & 0x000000ff)>> 0;
-      color_data[i] = blue << 24 | green << 16 |
-                      red  <<  8 | alpha;
-   }
-   lut_texture_view = create_texture_1d_view(ctx, color_data, 256);
-
-   buffer[0] = 0.f;
-   buffer[1] = 0.f;
-   buffer[2] = 1.f;
-   buffer[3] = 1.f;
-
-   info.dst = d;
-   info.src = s;
-   info.setup_shader = &setup_lookup_single;
-   info.user_data = (void*)sourceChannel;
-   info.const_buffer = buffer;
-   info.const_buffer_len = 4 * sizeof(VGfloat);
-   info.tiling_mode = VG_TILE_PAD;
-   info.extra_texture_view = lut_texture_view;
-
-   execute_filter(ctx, &info);
-
-   pipe_sampler_view_reference(&lut_texture_view, NULL);
-}
diff --git a/src/gallium/state_trackers/vega/api_images.c b/src/gallium/state_trackers/vega/api_images.c
deleted file mode 100644
index 300868c252c..00000000000
--- a/src/gallium/state_trackers/vega/api_images.c
+++ /dev/null
@@ -1,492 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "image.h"
-
-#include "VG/openvg.h"
-
-#include "vg_context.h"
-#include "vg_translate.h"
-#include "api_consts.h"
-#include "api.h"
-#include "handle.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_screen.h"
-#include "util/u_inlines.h"
-#include "util/u_tile.h"
-#include "util/u_math.h"
-
-static INLINE VGboolean supported_image_format(VGImageFormat format)
-{
-   switch(format) {
-   case VG_sRGBX_8888:
-   case VG_sRGBA_8888:
-   case VG_sRGBA_8888_PRE:
-   case VG_sRGB_565:
-   case VG_sRGBA_5551:
-   case VG_sRGBA_4444:
-   case VG_sL_8:
-   case VG_lRGBX_8888:
-   case VG_lRGBA_8888:
-   case VG_lRGBA_8888_PRE:
-   case VG_lL_8:
-   case VG_A_8:
-   case VG_BW_1:
-#ifdef OPENVG_VERSION_1_1
-   case VG_A_1:
-   case VG_A_4:
-#endif
-   case VG_sXRGB_8888:
-   case VG_sARGB_8888:
-   case VG_sARGB_8888_PRE:
-   case VG_sARGB_1555:
-   case VG_sARGB_4444:
-   case VG_lXRGB_8888:
-   case VG_lARGB_8888:
-   case VG_lARGB_8888_PRE:
-   case VG_sBGRX_8888:
-   case VG_sBGRA_8888:
-   case VG_sBGRA_8888_PRE:
-   case VG_sBGR_565:
-   case VG_sBGRA_5551:
-   case VG_sBGRA_4444:
-   case VG_lBGRX_8888:
-   case VG_lBGRA_8888:
-   case VG_lBGRA_8888_PRE:
-   case VG_sXBGR_8888:
-   case VG_sABGR_8888:
-   case VG_sABGR_8888_PRE:
-   case VG_sABGR_1555:
-   case VG_sABGR_4444:
-   case VG_lXBGR_8888:
-   case VG_lABGR_8888:
-   case VG_lABGR_8888_PRE:
-      return VG_TRUE;
-   default:
-      return VG_FALSE;
-   }
-   return VG_FALSE;
-}
-
-VGImage vegaCreateImage(VGImageFormat format,
-                        VGint width, VGint height,
-                        VGbitfield allowedQuality)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   if (!supported_image_format(format)) {
-      vg_set_error(ctx, VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);
-      return VG_INVALID_HANDLE;
-   }
-   if (width <= 0 || height <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return VG_INVALID_HANDLE;
-   }
-   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 > vegaGeti(VG_MAX_IMAGE_PIXELS)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return VG_INVALID_HANDLE;
-   }
-
-   if (!(allowedQuality & ((VG_IMAGE_QUALITY_NONANTIALIASED |
-                           VG_IMAGE_QUALITY_FASTER |
-                           VG_IMAGE_QUALITY_BETTER)))) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return VG_INVALID_HANDLE;
-   }
-
-   return image_to_handle(image_create(format, width, height));
-}
-
-void vegaDestroyImage(VGImage image)
-{
-   struct vg_context *ctx = vg_current_context();
-   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(image, VG_OBJECT_IMAGE)) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   image_destroy(img);
-}
-
-void vegaClearImage(VGImage image,
-                    VGint x, VGint y,
-                    VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_image *img;
-
-   if (image == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   if (width <= 0 || height <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   img = handle_to_image(image);
-
-   if (x + width < 0 || y + height < 0)
-      return;
-
-   image_clear(img, x, y, width, height);
-
-}
-
-void vegaImageSubData(VGImage image,
-                      const void * data,
-                      VGint dataStride,
-                      VGImageFormat dataFormat,
-                      VGint x, VGint y,
-                      VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_image *img;
-
-   if (image == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   if (!supported_image_format(dataFormat)) {
-      vg_set_error(ctx, VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);
-      return;
-   }
-   if (width <= 0 || height <= 0 || !data || !is_aligned(data)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   img = handle_to_image(image);
-   image_sub_data(img, data, dataStride, dataFormat,
-                  x, y, width, height);
-}
-
-void vegaGetImageSubData(VGImage image,
-                         void * data,
-                         VGint dataStride,
-                         VGImageFormat dataFormat,
-                         VGint x, VGint y,
-                         VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_image *img;
-
-   if (image == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   if (!supported_image_format(dataFormat)) {
-      vg_set_error(ctx, VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);
-      return;
-   }
-   if (width <= 0 || height <= 0 || !data || !is_aligned(data)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   img = handle_to_image(image);
-   image_get_sub_data(img, data, dataStride, dataFormat,
-                      x, y, width, height);
-}
-
-VGImage vegaChildImage(VGImage parent,
-                       VGint x, VGint y,
-                       VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_image *p;
-
-   if (parent == VG_INVALID_HANDLE ||
-       !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;
-   }
-   if (width <= 0 || height <= 0 || x < 0 || y < 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return VG_INVALID_HANDLE;
-   }
-   p = handle_to_image(parent);
-   if (x > p->width  || y > p->height) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return VG_INVALID_HANDLE;
-   }
-   if (x + width > p->width  || y + height > p->height) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return VG_INVALID_HANDLE;
-   }
-
-   return image_to_handle(image_child_image(p, x, y, width, height));
-}
-
-VGImage vegaGetParent(VGImage image)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_image *img;
-
-   if (image == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return VG_INVALID_HANDLE;
-   }
-
-   img = handle_to_image(image);
-   if (img->parent)
-      return image_to_handle(img->parent);
-   else
-      return image;
-}
-
-void vegaCopyImage(VGImage dst, VGint dx, VGint dy,
-                   VGImage src, VGint sx, VGint sy,
-                   VGint width, VGint height,
-                   VGboolean dither)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   if (src == VG_INVALID_HANDLE || dst == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   if (width <= 0 || height <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   vg_validate_state(ctx);
-   image_copy(handle_to_image(dst), dx, dy,
-              handle_to_image(src), sx, sy,
-              width, height, dither);
-}
-
-void vegaDrawImage(VGImage image)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   if (!ctx)
-      return;
-
-   if (image == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   vg_validate_state(ctx);
-   image_draw(handle_to_image(image),
-         &ctx->state.vg.image_user_to_surface_matrix);
-}
-
-void vegaSetPixels(VGint dx, VGint dy,
-                   VGImage src, VGint sx, VGint sy,
-                   VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   vg_validate_state(ctx);
-
-   if (src == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   if (width <= 0 || height <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   image_set_pixels(dx, dy, handle_to_image(src), sx, sy, width,
-                    height);
-}
-
-void vegaGetPixels(VGImage dst, VGint dx, VGint dy,
-                   VGint sx, VGint sy,
-                   VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_image *img;
-
-   if (dst == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   if (width <= 0 || height <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   img = handle_to_image(dst);
-
-   image_get_pixels(img, dx, dy,
-                    sx, sy, width, height);
-}
-
-void vegaWritePixels(const void * data, VGint dataStride,
-                     VGImageFormat dataFormat,
-                     VGint dx, VGint dy,
-                     VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   if (!supported_image_format(dataFormat)) {
-      vg_set_error(ctx, VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);
-      return;
-   }
-   if (!data || !is_aligned(data)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   if (width <= 0 || height <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   vg_validate_state(ctx);
-   {
-      struct vg_image *img = image_create(dataFormat, width, height);
-      image_sub_data(img, data, dataStride, dataFormat, 0, 0,
-                     width, height);
-#if 0
-      struct matrix *matrix = &ctx->state.vg.image_user_to_surface_matrix;
-      matrix_translate(matrix, dx, dy);
-      image_draw(img);
-      matrix_translate(matrix, -dx, -dy);
-#else
-      /* this looks like a better approach */
-      image_set_pixels(dx, dy, img, 0, 0, width, height);
-#endif
-      image_destroy(img);
-   }
-}
-
-void vegaReadPixels(void * data, VGint dataStride,
-                    VGImageFormat dataFormat,
-                    VGint sx, VGint sy,
-                    VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct pipe_context *pipe = ctx->pipe;
-
-   struct st_framebuffer *stfb = ctx->draw_buffer;
-   struct st_renderbuffer *strb = stfb->strb;
-
-   VGfloat temp[VEGA_MAX_IMAGE_WIDTH][4];
-   VGfloat *df = (VGfloat*)temp;
-   VGint i;
-   VGubyte *dst = (VGubyte *)data;
-   VGint xoffset = 0, yoffset = 0;
-
-   if (!supported_image_format(dataFormat)) {
-      vg_set_error(ctx, VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);
-      return;
-   }
-   if (!data || !is_aligned(data)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   if (width <= 0 || height <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   if (sx < 0) {
-      xoffset = -sx;
-      xoffset *= _vega_size_for_format(dataFormat);
-      width += sx;
-      sx = 0;
-   }
-   if (sy < 0) {
-      yoffset = -sy;
-      yoffset *= dataStride;
-      height += sy;
-      sy = 0;
-   }
-
-   if (sx + width > stfb->width || sy + height > stfb->height) {
-      width = stfb->width - sx;
-      height = stfb->height - sy;
-      /* nothing to read */
-      if (width <= 0 || height <= 0)
-         return;
-   }
-
-   {
-      VGint y = (stfb->height - sy) - 1, yStep = -1;
-      struct pipe_transfer *transfer;
-      void *map;
-
-      map = pipe_transfer_map(pipe, strb->texture,  0, 0,
-                              PIPE_TRANSFER_READ,
-                              0, 0, sx + width, stfb->height - sy,
-                              &transfer);
-
-      /* Do a row at a time to flip image data vertically */
-      for (i = 0; i < height; i++) {
-#if 0
-         debug_printf("%d-%d  == %d\n", sy, height, y);
-#endif
-         pipe_get_tile_rgba(transfer, map, sx, y, width, 1, df);
-         y += yStep;
-         _vega_pack_rgba_span_float(ctx, width, temp, dataFormat,
-                                    dst + yoffset + xoffset);
-         dst += dataStride;
-      }
-
-      pipe->transfer_unmap(pipe, transfer);
-   }
-}
-
-void vegaCopyPixels(VGint dx, VGint dy,
-                    VGint sx, VGint sy,
-                    VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct st_framebuffer *stfb = ctx->draw_buffer;
-   struct st_renderbuffer *strb = stfb->strb;
-
-   if (width <= 0 || height <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   /* do nothing if we copy from outside the fb */
-   if (dx >= (VGint)stfb->width || dy >= (VGint)stfb->height ||
-       sx >= (VGint)stfb->width || sy >= (VGint)stfb->height)
-      return;
-
-   vg_validate_state(ctx);
-   /* make sure rendering has completed */
-   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
deleted file mode 100644
index 48dc8445c02..00000000000
--- a/src/gallium/state_trackers/vega/api_masks.c
+++ /dev/null
@@ -1,246 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "VG/openvg.h"
-
-#include "mask.h"
-#include "api.h"
-#include "handle.h"
-#include "renderer.h"
-
-#include "vg_context.h"
-#include "pipe/p_context.h"
-
-void vegaMask(VGHandle mask, VGMaskOperation operation,
-              VGint x, VGint y,
-              VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   if (width <=0 || height <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   if (operation < VG_CLEAR_MASK || operation > VG_SUBTRACT_MASK) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-
-   vg_validate_state(ctx);
-
-   if (operation == VG_CLEAR_MASK) {
-      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(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(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);
-   }
-}
-
-void vegaClear(VGint x, VGint y,
-               VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct st_framebuffer *stfb = ctx->draw_buffer;
-
-   if (width <= 0 || height <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   vg_validate_state(ctx);
-#if 0
-   debug_printf("Clear [%d, %d, %d, %d] with [%f, %f, %f, %f]\n",
-                x, y, width, height,
-                ctx->state.vg.clear_color[0],
-                ctx->state.vg.clear_color[1],
-                ctx->state.vg.clear_color[2],
-                ctx->state.vg.clear_color[3]);
-#endif
-
-   /* check for a whole surface clear */
-   if (!ctx->state.vg.scissoring &&
-       (x == 0 && y == 0 && width == stfb->width && height == stfb->height)) {
-      union pipe_color_union clear_color;
-      clear_color.f[0] = ctx->state.vg.clear_color[0];
-      clear_color.f[1] = ctx->state.vg.clear_color[1];
-      clear_color.f[2] = ctx->state.vg.clear_color[2];
-      clear_color.f[3] = ctx->state.vg.clear_color[3];
-      ctx->pipe->clear(ctx->pipe, PIPE_CLEAR_COLOR0 | PIPE_CLEAR_DEPTHSTENCIL,
-                       &clear_color, 1., 0);
-   } else if (renderer_clear_begin(ctx->renderer)) {
-      /* XXX verify coord round-off */
-      renderer_clear(ctx->renderer, x, y, width, height, ctx->state.vg.clear_color);
-      renderer_clear_end(ctx->renderer);
-   }
-}
-
-
-#ifdef OPENVG_VERSION_1_1
-
-
-void vegaRenderToMask(VGPath path,
-                      VGbitfield paintModes,
-                      VGMaskOperation operation)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   if (path == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   if (!paintModes || (paintModes&(~(VG_STROKE_PATH|VG_FILL_PATH)))) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   if (operation < VG_CLEAR_MASK ||
-       operation > VG_SUBTRACT_MASK) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   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(handle_to_path(path), paintModes, operation);
-}
-
-VGMaskLayer vegaCreateMaskLayer(VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   if (width <= 0 || height <= 0 ||
-       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 masklayer_to_handle(mask_layer_create(width, height));
-}
-
-void vegaDestroyMaskLayer(VGMaskLayer maskLayer)
-{
-   struct vg_mask_layer *mask = 0;
-   struct vg_context *ctx = vg_current_context();
-
-   if (maskLayer == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   if (!vg_object_is_valid(maskLayer, VG_OBJECT_MASK)) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   mask = handle_to_masklayer(maskLayer);
-   mask_layer_destroy(mask);
-}
-
-void vegaFillMaskLayer(VGMaskLayer maskLayer,
-                       VGint x, VGint y,
-                       VGint width, VGint height,
-                       VGfloat value)
-{
-   struct vg_mask_layer *mask = 0;
-   struct vg_context *ctx = vg_current_context();
-
-   if (maskLayer == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   if (value < 0 || value > 1) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   if (width <= 0 || height <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   if (x < 0 || y < 0 || (x + width) < 0 || (y + height) < 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   if (!vg_object_is_valid(maskLayer, VG_OBJECT_MASK)) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   mask = handle_to_masklayer(maskLayer);
-
-   if (x + width > mask_layer_width(mask) ||
-       y + height > mask_layer_height(mask)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   vg_validate_state(ctx);
-
-   mask_layer_fill(mask, x, y, width, height, value);
-}
-
-void vegaCopyMask(VGMaskLayer maskLayer,
-                  VGint sx, VGint sy,
-                  VGint dx, VGint dy,
-                  VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_mask_layer *mask = 0;
-
-   if (maskLayer == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   if (width <= 0 || height <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   if (!vg_object_is_valid(maskLayer, VG_OBJECT_MASK)) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   vg_validate_state(ctx);
-
-   mask = handle_to_masklayer(maskLayer);
-   mask_copy(mask, sx, sy, dx, dy, width, height);
-}
-
-#endif
diff --git a/src/gallium/state_trackers/vega/api_misc.c b/src/gallium/state_trackers/vega/api_misc.c
deleted file mode 100644
index e274e6a2981..00000000000
--- a/src/gallium/state_trackers/vega/api_misc.c
+++ /dev/null
@@ -1,84 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "VG/openvg.h"
-
-#include "vg_context.h"
-#include "api.h"
-
-/* Hardware Queries */
-VGHardwareQueryResult vegaHardwareQuery(VGHardwareQueryType key,
-                                        VGint setting)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   if (key < VG_IMAGE_FORMAT_QUERY ||
-       key > VG_PATH_DATATYPE_QUERY) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return VG_HARDWARE_UNACCELERATED;
-   }
-
-   if (key == VG_IMAGE_FORMAT_QUERY) {
-      if (setting < VG_sRGBX_8888 ||
-          setting > VG_lABGR_8888_PRE) {
-         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-         return VG_HARDWARE_UNACCELERATED;
-      }
-   } else if (key == VG_PATH_DATATYPE_QUERY) {
-      if (setting < VG_PATH_DATATYPE_S_8 ||
-          setting > VG_PATH_DATATYPE_F) {
-         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-         return VG_HARDWARE_UNACCELERATED;
-      }
-   }
-   /* we're supposed to accelerate everything */
-   return VG_HARDWARE_ACCELERATED;
-}
-
-/* Renderer and Extension Information */
-const VGubyte *vegaGetString(VGStringID name)
-{
-   struct vg_context *ctx = vg_current_context();
-   static const VGubyte *vendor = (VGubyte *)"Mesa Project";
-   static const VGubyte *renderer = (VGubyte *)"Vega OpenVG 1.1";
-   static const VGubyte *version = (VGubyte *)"1.1";
-
-   if (!ctx)
-      return NULL;
-
-   switch(name) {
-   case VG_VENDOR:
-      return vendor;
-   case VG_RENDERER:
-      return renderer;
-   case VG_VERSION:
-      return version;
-   case VG_EXTENSIONS:
-      return NULL;
-   default:
-      return NULL;
-   }
-}
diff --git a/src/gallium/state_trackers/vega/api_paint.c b/src/gallium/state_trackers/vega/api_paint.c
deleted file mode 100644
index 2610ebe0576..00000000000
--- a/src/gallium/state_trackers/vega/api_paint.c
+++ /dev/null
@@ -1,172 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "VG/openvg.h"
-
-#include "vg_context.h"
-#include "paint.h"
-#include "api.h"
-#include "handle.h"
-
-
-VGPaint vegaCreatePaint(void)
-{
-   return paint_to_handle(paint_create(vg_current_context()));
-}
-
-void vegaDestroyPaint(VGPaint p)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   if (p == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   paint_destroy(handle_to_paint(p));
-}
-
-void vegaSetPaint(VGPaint paint, VGbitfield paintModes)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   if (paint == VG_INVALID_HANDLE) {
-      /* restore the default */
-      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;
-   }
-
-   if (!(paintModes & ((VG_FILL_PATH|VG_STROKE_PATH)))) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   if (paintModes & VG_FILL_PATH) {
-      ctx->state.vg.fill_paint = handle_to_paint(paint);
-   }
-   if (paintModes & VG_STROKE_PATH) {
-      ctx->state.vg.stroke_paint = handle_to_paint(paint);
-   }
-
-   ctx->state.dirty |= PAINT_DIRTY;
-}
-
-VGPaint vegaGetPaint(VGPaintMode paintMode)
-{
-   struct vg_context *ctx = vg_current_context();
-   VGPaint paint = VG_INVALID_HANDLE;
-
-   if (paintMode < VG_STROKE_PATH || paintMode > VG_FILL_PATH) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return VG_INVALID_HANDLE;
-   }
-
-   if (paintMode == VG_FILL_PATH)
-      paint = paint_to_handle(ctx->state.vg.fill_paint);
-   else if (paintMode == VG_STROKE_PATH)
-      paint = paint_to_handle(ctx->state.vg.stroke_paint);
-
-   if (paint == paint_to_handle(ctx->default_paint))
-      paint = VG_INVALID_HANDLE;
-
-   return paint;
-}
-
-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(paint, VG_OBJECT_PAINT)) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   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)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_paint *p;
-   VGuint rgba = 0;
-
-   if (paint == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return rgba;
-   }
-
-   if (!vg_object_is_valid(paint, VG_OBJECT_PAINT)) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return rgba;
-   }
-   p = handle_to_paint(paint);
-
-   return paint_colori(p);
-}
-
-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, paint)) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   if (pattern == VG_INVALID_HANDLE) {
-      paint_set_type(handle_to_paint(paint), VG_PAINT_TYPE_COLOR);
-      return;
-   }
-
-   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(paint, VG_OBJECT_PAINT) ||
-       !vg_object_is_valid(pattern, VG_OBJECT_IMAGE)) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   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
deleted file mode 100644
index aa1e5dd280a..00000000000
--- a/src/gallium/state_trackers/vega/api_params.c
+++ /dev/null
@@ -1,1679 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "VG/openvg.h"
-
-#include "vg_context.h"
-#include "paint.h"
-#include "path.h"
-#include "handle.h"
-#include "image.h"
-#include "text.h"
-#include "matrix.h"
-#include "api_consts.h"
-#include "api.h"
-
-#include "pipe/p_compiler.h"
-#include "util/u_pointer.h"
-#include "util/u_math.h"
-
-#include <math.h>
-
-static INLINE struct vg_state *current_state()
-{
-   struct vg_context *ctx = vg_current_context();
-   if (!ctx)
-      return 0;
-   else
-      return &ctx->state.vg;
-}
-
-static INLINE VGboolean count_in_bounds(VGParamType type, VGint count)
-{
-   if (count < 0)
-      return VG_FALSE;
-
-   if (type == VG_SCISSOR_RECTS)
-      return (!(count % 4) && (count >= 0 || count <= VEGA_MAX_SCISSOR_RECTS * 4));
-   else if (type == VG_STROKE_DASH_PATTERN) {
-      return count <= VEGA_MAX_DASH_COUNT;
-   } else {
-      VGint real_count = vegaGetVectorSize(type);
-      return count == real_count;
-   }
-}
-
-void vegaSetf (VGParamType type, VGfloat value)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_state *state = current_state();
-   VGErrorCode error = VG_NO_ERROR;
-
-   switch(type) {
-   case VG_MATRIX_MODE:
-   case VG_FILL_RULE:
-   case VG_IMAGE_QUALITY:
-   case VG_RENDERING_QUALITY:
-   case VG_BLEND_MODE:
-   case VG_IMAGE_MODE:
-#ifdef OPENVG_VERSION_1_1
-   case VG_COLOR_TRANSFORM:
-#endif
-   case VG_STROKE_CAP_STYLE:
-   case VG_STROKE_JOIN_STYLE:
-   case VG_STROKE_DASH_PHASE_RESET:
-   case VG_MASKING:
-   case VG_SCISSORING:
-   case VG_PIXEL_LAYOUT:
-   case VG_SCREEN_LAYOUT:
-   case VG_FILTER_FORMAT_LINEAR:
-   case VG_FILTER_FORMAT_PREMULTIPLIED:
-   case VG_FILTER_CHANNEL_MASK:
-
-   case VG_MAX_SCISSOR_RECTS:
-   case VG_MAX_DASH_COUNT:
-   case VG_MAX_KERNEL_SIZE:
-   case VG_MAX_SEPARABLE_KERNEL_SIZE:
-   case VG_MAX_COLOR_RAMP_STOPS:
-   case VG_MAX_IMAGE_WIDTH:
-   case VG_MAX_IMAGE_HEIGHT:
-   case VG_MAX_IMAGE_PIXELS:
-   case VG_MAX_IMAGE_BYTES:
-   case VG_MAX_GAUSSIAN_STD_DEVIATION:
-   case VG_MAX_FLOAT:
-      vegaSeti(type, floor(value));
-      return;
-      break;
-   case VG_STROKE_LINE_WIDTH:
-      state->stroke.line_width.f = value;
-      state->stroke.line_width.i = float_to_int_floor(*((VGuint*)(&value)));
-      break;
-   case VG_STROKE_MITER_LIMIT:
-      state->stroke.miter_limit.f = value;
-      state->stroke.miter_limit.i = float_to_int_floor(*((VGuint*)(&value)));
-      break;
-   case VG_STROKE_DASH_PHASE:
-      state->stroke.dash_phase.f = value;
-      state->stroke.dash_phase.i = float_to_int_floor(*((VGuint*)(&value)));
-      break;
-   default:
-      error = VG_ILLEGAL_ARGUMENT_ERROR;
-      break;
-   }
-   vg_set_error(ctx, error);
-}
-
-void vegaSeti (VGParamType type, VGint value)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_state *state = current_state();
-   VGErrorCode error = VG_NO_ERROR;
-
-   switch(type) {
-   case VG_MATRIX_MODE:
-      if (value < VG_MATRIX_PATH_USER_TO_SURFACE ||
-#ifdef OPENVG_VERSION_1_1
-          value > VG_MATRIX_GLYPH_USER_TO_SURFACE)
-#else
-          value > VG_MATRIX_STROKE_PAINT_TO_USER)
-#endif
-         error = VG_ILLEGAL_ARGUMENT_ERROR;
-      else
-         state->matrix_mode = value;
-      break;
-   case VG_FILL_RULE:
-      if (value < VG_EVEN_ODD ||
-          value > VG_NON_ZERO)
-         error = VG_ILLEGAL_ARGUMENT_ERROR;
-      else
-         state->fill_rule = value;
-      break;
-   case VG_IMAGE_QUALITY:
-      state->image_quality = value;
-      break;
-   case VG_RENDERING_QUALITY:
-      if (value < VG_RENDERING_QUALITY_NONANTIALIASED ||
-          value > VG_RENDERING_QUALITY_BETTER)
-         error = VG_ILLEGAL_ARGUMENT_ERROR;
-      else
-         state->rendering_quality = value;
-      break;
-   case VG_BLEND_MODE:
-      if (value < VG_BLEND_SRC ||
-          value > VG_BLEND_ADDITIVE)
-         error = VG_ILLEGAL_ARGUMENT_ERROR;
-      else {
-         ctx->state.dirty |= BLEND_DIRTY;
-         state->blend_mode = value;
-      }
-      break;
-   case VG_IMAGE_MODE:
-      if (value < VG_DRAW_IMAGE_NORMAL ||
-          value > VG_DRAW_IMAGE_STENCIL)
-         error = VG_ILLEGAL_ARGUMENT_ERROR;
-      else
-         state->image_mode = value;
-      break;
-#ifdef OPENVG_VERSION_1_1
-   case VG_COLOR_TRANSFORM:
-      state->color_transform = value;
-#endif
-      break;
-   case VG_STROKE_LINE_WIDTH:
-      state->stroke.line_width.f = value;
-      state->stroke.line_width.i = value;
-      break;
-   case VG_STROKE_CAP_STYLE:
-      if (value < VG_CAP_BUTT ||
-          value > VG_CAP_SQUARE)
-         error = VG_ILLEGAL_ARGUMENT_ERROR;
-      else
-         state->stroke.cap_style = value;
-      break;
-   case VG_STROKE_JOIN_STYLE:
-      if (value < VG_JOIN_MITER ||
-          value > VG_JOIN_BEVEL)
-         error = VG_ILLEGAL_ARGUMENT_ERROR;
-      else
-         state->stroke.join_style = value;
-      break;
-   case VG_STROKE_MITER_LIMIT:
-      state->stroke.miter_limit.f = value;
-      state->stroke.miter_limit.i = value;
-      break;
-   case VG_STROKE_DASH_PHASE:
-      state->stroke.dash_phase.f = value;
-      state->stroke.dash_phase.i = value;
-      break;
-   case VG_STROKE_DASH_PHASE_RESET:
-      state->stroke.dash_phase_reset = value;
-      break;
-   case VG_MASKING:
-      state->masking = value;
-      break;
-   case VG_SCISSORING:
-      state->scissoring = value;
-      ctx->state.dirty |= DEPTH_STENCIL_DIRTY;
-      break;
-   case VG_PIXEL_LAYOUT:
-      if (value < VG_PIXEL_LAYOUT_UNKNOWN ||
-          value > VG_PIXEL_LAYOUT_BGR_HORIZONTAL)
-         error = VG_ILLEGAL_ARGUMENT_ERROR;
-      else
-         state->pixel_layout = value;
-      break;
-   case VG_SCREEN_LAYOUT:
-      /* read only ignore */
-      break;
-   case VG_FILTER_FORMAT_LINEAR:
-      state->filter_format_linear = value;
-      break;
-   case VG_FILTER_FORMAT_PREMULTIPLIED:
-      state->filter_format_premultiplied = value;
-      break;
-   case VG_FILTER_CHANNEL_MASK:
-      state->filter_channel_mask = value;
-      break;
-
-   case VG_MAX_SCISSOR_RECTS:
-   case VG_MAX_DASH_COUNT:
-   case VG_MAX_KERNEL_SIZE:
-   case VG_MAX_SEPARABLE_KERNEL_SIZE:
-   case VG_MAX_COLOR_RAMP_STOPS:
-   case VG_MAX_IMAGE_WIDTH:
-   case VG_MAX_IMAGE_HEIGHT:
-   case VG_MAX_IMAGE_PIXELS:
-   case VG_MAX_IMAGE_BYTES:
-   case VG_MAX_GAUSSIAN_STD_DEVIATION:
-   case VG_MAX_FLOAT:
-      /* read only ignore */
-      break;
-   default:
-      error = VG_ILLEGAL_ARGUMENT_ERROR;
-      break;
-   }
-   vg_set_error(ctx, error);
-}
-
-void vegaSetfv(VGParamType type, VGint count,
-               const VGfloat * values)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_state *state = current_state();
-   VGErrorCode error = VG_NO_ERROR;
-
-   if ((count && !values) || !count_in_bounds(type, count) || !is_aligned(values)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   switch(type) {
-   case VG_MATRIX_MODE:
-   case VG_FILL_RULE:
-   case VG_IMAGE_QUALITY:
-   case VG_RENDERING_QUALITY:
-   case VG_BLEND_MODE:
-   case VG_IMAGE_MODE:
-#ifdef OPENVG_VERSION_1_1
-   case VG_COLOR_TRANSFORM:
-#endif
-   case VG_STROKE_CAP_STYLE:
-   case VG_STROKE_JOIN_STYLE:
-   case VG_STROKE_DASH_PHASE_RESET:
-   case VG_MASKING:
-   case VG_SCISSORING:
-   case VG_PIXEL_LAYOUT:
-   case VG_SCREEN_LAYOUT:
-   case VG_FILTER_FORMAT_LINEAR:
-   case VG_FILTER_FORMAT_PREMULTIPLIED:
-   case VG_FILTER_CHANNEL_MASK:
-      vegaSeti(type, floor(values[0]));
-      return;
-      break;
-   case VG_SCISSOR_RECTS: {
-      VGint i;
-      VGuint *x = (VGuint*)values;
-      for (i = 0; i < count; ++i) {
-         state->scissor_rects[i].f =  values[i];
-         state->scissor_rects[i].i =  float_to_int_floor(x[i]);
-      }
-      state->scissor_rects_num = count / 4;
-      ctx->state.dirty |= DEPTH_STENCIL_DIRTY;
-   }
-      break;
-#ifdef OPENVG_VERSION_1_1
-   case VG_COLOR_TRANSFORM_VALUES: {
-      VGint i;
-      for (i = 0; i < count; ++i) {
-         state->color_transform_values[i] =  values[i];
-      }
-   }
-      break;
-#endif
-   case VG_STROKE_LINE_WIDTH:
-      state->stroke.line_width.f = values[0];
-      state->stroke.line_width.i = float_to_int_floor(*((VGuint*)(values)));
-      break;
-   case VG_STROKE_MITER_LIMIT:
-      state->stroke.miter_limit.f = values[0];
-      state->stroke.miter_limit.i = float_to_int_floor(*((VGuint*)(values)));
-      break;
-   case VG_STROKE_DASH_PATTERN: {
-      int i;
-      for (i = 0; i < count; ++i) {
-         state->stroke.dash_pattern[i].f = values[i];
-         state->stroke.dash_pattern[i].i =
-            float_to_int_floor(*((VGuint*)(values + i)));
-      }
-      state->stroke.dash_pattern_num = count;
-   }
-      break;
-   case VG_STROKE_DASH_PHASE:
-      state->stroke.dash_phase.f = values[0];
-      state->stroke.dash_phase.i = float_to_int_floor(*((VGuint*)(values)));
-      break;
-   case VG_TILE_FILL_COLOR:
-      state->tile_fill_color[0] = values[0];
-      state->tile_fill_color[1] = values[1];
-      state->tile_fill_color[2] = values[2];
-      state->tile_fill_color[3] = values[3];
-
-      state->tile_fill_colori[0] = float_to_int_floor(*((VGuint*)(values + 0)));
-      state->tile_fill_colori[1] = float_to_int_floor(*((VGuint*)(values + 1)));
-      state->tile_fill_colori[2] = float_to_int_floor(*((VGuint*)(values + 2)));
-      state->tile_fill_colori[3] = float_to_int_floor(*((VGuint*)(values + 3)));
-      break;
-   case VG_CLEAR_COLOR:
-      state->clear_color[0] = values[0];
-      state->clear_color[1] = values[1];
-      state->clear_color[2] = values[2];
-      state->clear_color[3] = values[3];
-
-      state->clear_colori[0] = float_to_int_floor(*((VGuint*)(values + 0)));
-      state->clear_colori[1] = float_to_int_floor(*((VGuint*)(values + 1)));
-      state->clear_colori[2] = float_to_int_floor(*((VGuint*)(values + 2)));
-      state->clear_colori[3] = float_to_int_floor(*((VGuint*)(values + 3)));
-      break;
-#ifdef OPENVG_VERSION_1_1
-   case VG_GLYPH_ORIGIN:
-      state->glyph_origin[0].f = values[0];
-      state->glyph_origin[1].f = values[1];
-
-      state->glyph_origin[0].i = float_to_int_floor(*((VGuint*)(values + 0)));
-      state->glyph_origin[1].i = float_to_int_floor(*((VGuint*)(values + 1)));
-      break;
-#endif
-
-   case VG_MAX_SCISSOR_RECTS:
-   case VG_MAX_DASH_COUNT:
-   case VG_MAX_KERNEL_SIZE:
-   case VG_MAX_SEPARABLE_KERNEL_SIZE:
-   case VG_MAX_COLOR_RAMP_STOPS:
-   case VG_MAX_IMAGE_WIDTH:
-   case VG_MAX_IMAGE_HEIGHT:
-   case VG_MAX_IMAGE_PIXELS:
-   case VG_MAX_IMAGE_BYTES:
-   case VG_MAX_GAUSSIAN_STD_DEVIATION:
-   case VG_MAX_FLOAT:
-      break;
-   default:
-      error = VG_ILLEGAL_ARGUMENT_ERROR;
-      break;
-   }
-   vg_set_error(ctx, error);
-}
-
-void vegaSetiv(VGParamType type, VGint count,
-               const VGint * values)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_state *state = current_state();
-
-   if ((count && !values) || !count_in_bounds(type, count) || !is_aligned(values)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   switch(type) {
-   case VG_MATRIX_MODE:
-   case VG_FILL_RULE:
-   case VG_IMAGE_QUALITY:
-   case VG_RENDERING_QUALITY:
-   case VG_BLEND_MODE:
-   case VG_IMAGE_MODE:
-#ifdef OPENVG_VERSION_1_1
-   case VG_COLOR_TRANSFORM:
-#endif
-   case VG_STROKE_CAP_STYLE:
-   case VG_STROKE_JOIN_STYLE:
-   case VG_STROKE_DASH_PHASE_RESET:
-   case VG_MASKING:
-   case VG_SCISSORING:
-   case VG_PIXEL_LAYOUT:
-   case VG_SCREEN_LAYOUT:
-   case VG_FILTER_FORMAT_LINEAR:
-   case VG_FILTER_FORMAT_PREMULTIPLIED:
-   case VG_FILTER_CHANNEL_MASK:
-      vegaSeti(type, values[0]);
-      return;
-      break;
-   case VG_SCISSOR_RECTS: {
-      VGint i;
-      for (i = 0; i < count; ++i) {
-         state->scissor_rects[i].i =  values[i];
-         state->scissor_rects[i].f =  values[i];
-      }
-      state->scissor_rects_num = count / 4;
-      ctx->state.dirty |= DEPTH_STENCIL_DIRTY;
-   }
-      break;
-#ifdef OPENVG_VERSION_1_1
-   case VG_COLOR_TRANSFORM_VALUES: {
-      VGint i;
-      for (i = 0; i < count; ++i) {
-         state->color_transform_values[i] =  values[i];
-      }
-   }
-      break;
-#endif
-   case VG_STROKE_LINE_WIDTH:
-      state->stroke.line_width.f = values[0];
-      state->stroke.line_width.i = values[0];
-      break;
-   case VG_STROKE_MITER_LIMIT:
-      state->stroke.miter_limit.f = values[0];
-      state->stroke.miter_limit.i = values[0];
-      break;
-   case VG_STROKE_DASH_PATTERN: {
-      int i;
-      for (i = 0; i < count; ++i) {
-         state->stroke.dash_pattern[i].f = values[i];
-         state->stroke.dash_pattern[i].i = values[i];
-      }
-      state->stroke.dash_pattern_num = count;
-   }
-      break;
-   case VG_STROKE_DASH_PHASE:
-      state->stroke.dash_phase.f = values[0];
-      state->stroke.dash_phase.i = values[0];
-      break;
-   case VG_TILE_FILL_COLOR:
-      state->tile_fill_color[0] = values[0];
-      state->tile_fill_color[1] = values[1];
-      state->tile_fill_color[2] = values[2];
-      state->tile_fill_color[3] = values[3];
-
-      state->tile_fill_colori[0] = values[0];
-      state->tile_fill_colori[1] = values[1];
-      state->tile_fill_colori[2] = values[2];
-      state->tile_fill_colori[3] = values[3];
-      break;
-   case VG_CLEAR_COLOR:
-      state->clear_color[0] = values[0];
-      state->clear_color[1] = values[1];
-      state->clear_color[2] = values[2];
-      state->clear_color[3] = values[3];
-
-      state->clear_colori[0] = values[0];
-      state->clear_colori[1] = values[1];
-      state->clear_colori[2] = values[2];
-      state->clear_colori[3] = values[3];
-      break;
-#ifdef OPENVG_VERSION_1_1
-   case VG_GLYPH_ORIGIN:
-      state->glyph_origin[0].f = values[0];
-      state->glyph_origin[1].f = values[1];
-      state->glyph_origin[0].i = values[0];
-      state->glyph_origin[1].i = values[1];
-      break;
-#endif
-
-   case VG_MAX_SCISSOR_RECTS:
-   case VG_MAX_DASH_COUNT:
-   case VG_MAX_KERNEL_SIZE:
-   case VG_MAX_SEPARABLE_KERNEL_SIZE:
-   case VG_MAX_COLOR_RAMP_STOPS:
-   case VG_MAX_IMAGE_WIDTH:
-   case VG_MAX_IMAGE_HEIGHT:
-   case VG_MAX_IMAGE_PIXELS:
-   case VG_MAX_IMAGE_BYTES:
-   case VG_MAX_GAUSSIAN_STD_DEVIATION:
-   case VG_MAX_FLOAT:
-      break;
-
-   default:
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      break;
-   }
-}
-
-VGfloat vegaGetf(VGParamType type)
-{
-   struct vg_context *ctx = vg_current_context();
-   const struct vg_state *state = current_state();
-   VGErrorCode error = VG_NO_ERROR;
-   VGfloat value = 0.0f;
-
-   switch(type) {
-   case VG_MATRIX_MODE:
-   case VG_FILL_RULE:
-   case VG_IMAGE_QUALITY:
-   case VG_RENDERING_QUALITY:
-   case VG_BLEND_MODE:
-   case VG_IMAGE_MODE:
-#ifdef OPENVG_VERSION_1_1
-   case VG_COLOR_TRANSFORM:
-#endif
-   case VG_STROKE_CAP_STYLE:
-   case VG_STROKE_JOIN_STYLE:
-   case VG_STROKE_DASH_PHASE_RESET:
-   case VG_MASKING:
-   case VG_SCISSORING:
-   case VG_PIXEL_LAYOUT:
-   case VG_SCREEN_LAYOUT:
-   case VG_FILTER_FORMAT_LINEAR:
-   case VG_FILTER_FORMAT_PREMULTIPLIED:
-   case VG_FILTER_CHANNEL_MASK:
-      return vegaGeti(type);
-      break;
-   case VG_STROKE_LINE_WIDTH:
-      value = state->stroke.line_width.f;
-      break;
-   case VG_STROKE_MITER_LIMIT:
-      value = state->stroke.miter_limit.f;
-      break;
-   case VG_STROKE_DASH_PHASE:
-      value = state->stroke.dash_phase.f;
-      break;
-
-   case VG_MAX_SCISSOR_RECTS:
-   case VG_MAX_DASH_COUNT:
-   case VG_MAX_KERNEL_SIZE:
-   case VG_MAX_SEPARABLE_KERNEL_SIZE:
-   case VG_MAX_COLOR_RAMP_STOPS:
-   case VG_MAX_IMAGE_WIDTH:
-   case VG_MAX_IMAGE_HEIGHT:
-   case VG_MAX_IMAGE_PIXELS:
-   case VG_MAX_IMAGE_BYTES:
-   case VG_MAX_GAUSSIAN_STD_DEVIATION:
-      return vegaGeti(type);
-      break;
-   case VG_MAX_FLOAT:
-      value = 1e+10;/*must be at least 1e+10*/
-      break;
-   default:
-      error = VG_ILLEGAL_ARGUMENT_ERROR;
-      break;
-   }
-   vg_set_error(ctx, error);
-   return value;
-}
-
-VGint vegaGeti(VGParamType type)
-{
-   const struct vg_state *state = current_state();
-   struct vg_context *ctx = vg_current_context();
-   VGErrorCode error = VG_NO_ERROR;
-   VGint value = 0;
-
-   switch(type) {
-   case VG_MATRIX_MODE:
-      value = state->matrix_mode;
-      break;
-   case VG_FILL_RULE:
-      value = state->fill_rule;
-      break;
-   case VG_IMAGE_QUALITY:
-      value = state->image_quality;
-      break;
-   case VG_RENDERING_QUALITY:
-      value = state->rendering_quality;
-      break;
-   case VG_BLEND_MODE:
-      value = state->blend_mode;
-      break;
-   case VG_IMAGE_MODE:
-      value = state->image_mode;
-      break;
-#ifdef OPENVG_VERSION_1_1
-   case VG_COLOR_TRANSFORM:
-      value = state->color_transform;
-      break;
-#endif
-   case VG_STROKE_LINE_WIDTH:
-      value = state->stroke.line_width.i;
-      break;
-   case VG_STROKE_CAP_STYLE:
-      value = state->stroke.cap_style;
-      break;
-   case VG_STROKE_JOIN_STYLE:
-      value = state->stroke.join_style;
-      break;
-   case VG_STROKE_MITER_LIMIT:
-      value = state->stroke.miter_limit.i;
-      break;
-   case VG_STROKE_DASH_PHASE:
-      value = state->stroke.dash_phase.i;
-      break;
-   case VG_STROKE_DASH_PHASE_RESET:
-      value = state->stroke.dash_phase_reset;
-      break;
-   case VG_MASKING:
-      value = state->masking;
-      break;
-   case VG_SCISSORING:
-      value = state->scissoring;
-      break;
-   case VG_PIXEL_LAYOUT:
-      value = state->pixel_layout;
-      break;
-   case VG_SCREEN_LAYOUT:
-      value = state->screen_layout;
-      break;
-   case VG_FILTER_FORMAT_LINEAR:
-      value = state->filter_format_linear;
-      break;
-   case VG_FILTER_FORMAT_PREMULTIPLIED:
-      value = state->filter_format_premultiplied;
-      break;
-   case VG_FILTER_CHANNEL_MASK:
-      value = state->filter_channel_mask;
-      break;
-
-   case VG_MAX_SCISSOR_RECTS:
-      value = 32; /*must be at least 32*/
-      break;
-   case VG_MAX_DASH_COUNT:
-      value = 16; /*must be at least 16*/
-      break;
-   case VG_MAX_KERNEL_SIZE:
-      value = 7; /*must be at least 7*/
-      break;
-   case VG_MAX_SEPARABLE_KERNEL_SIZE:
-      value = 15; /*must be at least 15*/
-      break;
-   case VG_MAX_COLOR_RAMP_STOPS:
-      value = 256; /*must be at least 32*/
-      break;
-   case VG_MAX_IMAGE_WIDTH:
-      value = 2048;
-      break;
-   case VG_MAX_IMAGE_HEIGHT:
-      value = 2048;
-      break;
-   case VG_MAX_IMAGE_PIXELS:
-      value = 2048*2048;
-      break;
-   case VG_MAX_IMAGE_BYTES:
-      value = 2048*2048 * 4;
-      break;
-   case VG_MAX_GAUSSIAN_STD_DEVIATION:
-      value = 128; /*must be at least 128*/
-      break;
-
-   case VG_MAX_FLOAT: {
-      VGfloat val = vegaGetf(type);
-      value = float_to_int_floor(*((VGuint*)&val));
-   }
-      break;
-   default:
-      error = VG_ILLEGAL_ARGUMENT_ERROR;
-      break;
-   }
-   vg_set_error(ctx, error);
-   return value;
-}
-
-VGint vegaGetVectorSize(VGParamType type)
-{
-   struct vg_context *ctx = vg_current_context();
-   const struct vg_state *state = current_state();
-   switch(type) {
-   case VG_MATRIX_MODE:
-   case VG_FILL_RULE:
-   case VG_IMAGE_QUALITY:
-   case VG_RENDERING_QUALITY:
-   case VG_BLEND_MODE:
-   case VG_IMAGE_MODE:
-      return 1;
-   case VG_SCISSOR_RECTS:
-      return state->scissor_rects_num * 4;
-#ifdef OPENVG_VERSION_1_1
-   case VG_COLOR_TRANSFORM:
-      return 1;
-   case VG_COLOR_TRANSFORM_VALUES:
-      return 8;
-#endif
-   case VG_STROKE_LINE_WIDTH:
-   case VG_STROKE_CAP_STYLE:
-   case VG_STROKE_JOIN_STYLE:
-   case VG_STROKE_MITER_LIMIT:
-      return 1;
-   case VG_STROKE_DASH_PATTERN:
-      return state->stroke.dash_pattern_num;
-   case VG_STROKE_DASH_PHASE:
-      return 1;
-   case VG_STROKE_DASH_PHASE_RESET:
-      return 1;
-   case VG_TILE_FILL_COLOR:
-      return 4;
-   case VG_CLEAR_COLOR:
-      return 4;
-#ifdef OPENVG_VERSION_1_1
-   case VG_GLYPH_ORIGIN:
-      return 2;
-#endif
-   case VG_MASKING:
-      return 1;
-   case VG_SCISSORING:
-      return 1;
-   case VG_PIXEL_LAYOUT:
-      return 1;
-   case VG_SCREEN_LAYOUT:
-      return 1;
-   case VG_FILTER_FORMAT_LINEAR:
-      return 1;
-   case VG_FILTER_FORMAT_PREMULTIPLIED:
-      return 1;
-   case VG_FILTER_CHANNEL_MASK:
-      return 1;
-
-   case VG_MAX_COLOR_RAMP_STOPS:
-      return 1;
-   case VG_MAX_SCISSOR_RECTS:
-   case VG_MAX_DASH_COUNT:
-   case VG_MAX_KERNEL_SIZE:
-   case VG_MAX_SEPARABLE_KERNEL_SIZE:
-   case VG_MAX_IMAGE_WIDTH:
-   case VG_MAX_IMAGE_HEIGHT:
-   case VG_MAX_IMAGE_PIXELS:
-   case VG_MAX_IMAGE_BYTES:
-   case VG_MAX_FLOAT:
-   case VG_MAX_GAUSSIAN_STD_DEVIATION:
-      return 1;
-   default:
-      if (ctx)
-         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return 0;
-   }
-}
-
-void vegaGetfv(VGParamType type, VGint count,
-               VGfloat * values)
-{
-   const struct vg_state *state = current_state();
-   struct vg_context *ctx = vg_current_context();
-   VGint real_count = vegaGetVectorSize(type);
-
-   if (!values || count <= 0 || count > real_count || !is_aligned(values)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   switch(type) {
-   case VG_MATRIX_MODE:
-   case VG_FILL_RULE:
-   case VG_IMAGE_QUALITY:
-   case VG_RENDERING_QUALITY:
-   case VG_BLEND_MODE:
-   case VG_IMAGE_MODE:
-#ifdef OPENVG_VERSION_1_1
-   case VG_COLOR_TRANSFORM:
-#endif
-   case VG_STROKE_CAP_STYLE:
-   case VG_STROKE_JOIN_STYLE:
-   case VG_STROKE_DASH_PHASE_RESET:
-   case VG_MASKING:
-   case VG_SCISSORING:
-   case VG_PIXEL_LAYOUT:
-   case VG_SCREEN_LAYOUT:
-   case VG_FILTER_FORMAT_LINEAR:
-   case VG_FILTER_FORMAT_PREMULTIPLIED:
-   case VG_FILTER_CHANNEL_MASK:
-   case VG_MAX_SCISSOR_RECTS:
-   case VG_MAX_DASH_COUNT:
-   case VG_MAX_KERNEL_SIZE:
-   case VG_MAX_SEPARABLE_KERNEL_SIZE:
-   case VG_MAX_COLOR_RAMP_STOPS:
-   case VG_MAX_IMAGE_WIDTH:
-   case VG_MAX_IMAGE_HEIGHT:
-   case VG_MAX_IMAGE_PIXELS:
-   case VG_MAX_IMAGE_BYTES:
-   case VG_MAX_GAUSSIAN_STD_DEVIATION:
-      values[0] = vegaGeti(type);
-      break;
-   case VG_MAX_FLOAT:
-      values[0] = vegaGetf(type);
-      break;
-   case VG_SCISSOR_RECTS: {
-      VGint i;
-      for (i = 0; i < count; ++i) {
-         values[i] = state->scissor_rects[i].f;
-      }
-   }
-      break;
-#ifdef OPENVG_VERSION_1_1
-   case VG_COLOR_TRANSFORM_VALUES: {
-      memcpy(values, state->color_transform_values,
-             sizeof(VGfloat) * count);
-   }
-      break;
-#endif
-   case VG_STROKE_LINE_WIDTH:
-      values[0] = state->stroke.line_width.f;
-      break;
-   case VG_STROKE_MITER_LIMIT:
-      values[0] = state->stroke.miter_limit.f;
-      break;
-   case VG_STROKE_DASH_PATTERN: {
-      VGint i;
-      for (i = 0; i < count; ++i) {
-         values[i] = state->stroke.dash_pattern[i].f;
-      }
-   }
-      break;
-   case VG_STROKE_DASH_PHASE:
-      values[0] = state->stroke.dash_phase.f;
-      break;
-   case VG_TILE_FILL_COLOR:
-      values[0] = state->tile_fill_color[0];
-      values[1] = state->tile_fill_color[1];
-      values[2] = state->tile_fill_color[2];
-      values[3] = state->tile_fill_color[3];
-      break;
-   case VG_CLEAR_COLOR:
-      values[0] = state->clear_color[0];
-      values[1] = state->clear_color[1];
-      values[2] = state->clear_color[2];
-      values[3] = state->clear_color[3];
-      break;
-#ifdef OPENVG_VERSION_1_1
-   case VG_GLYPH_ORIGIN:
-      values[0] = state->glyph_origin[0].f;
-      values[1] = state->glyph_origin[1].f;
-      break;
-#endif
-   default:
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      break;
-   }
-}
-
-void vegaGetiv(VGParamType type, VGint count,
-               VGint * values)
-{
-   const struct vg_state *state = current_state();
-   struct vg_context *ctx = vg_current_context();
-   VGint real_count = vegaGetVectorSize(type);
-
-   if (!values || count <= 0 || count > real_count || !is_aligned(values)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   switch(type) {
-   case VG_MATRIX_MODE:
-   case VG_FILL_RULE:
-   case VG_IMAGE_QUALITY:
-   case VG_RENDERING_QUALITY:
-   case VG_BLEND_MODE:
-   case VG_IMAGE_MODE:
-#ifdef OPENVG_VERSION_1_1
-   case VG_COLOR_TRANSFORM:
-#endif
-   case VG_STROKE_CAP_STYLE:
-   case VG_STROKE_JOIN_STYLE:
-   case VG_STROKE_DASH_PHASE_RESET:
-   case VG_MASKING:
-   case VG_SCISSORING:
-   case VG_PIXEL_LAYOUT:
-   case VG_SCREEN_LAYOUT:
-   case VG_FILTER_FORMAT_LINEAR:
-   case VG_FILTER_FORMAT_PREMULTIPLIED:
-   case VG_FILTER_CHANNEL_MASK:
-   case VG_MAX_SCISSOR_RECTS:
-   case VG_MAX_DASH_COUNT:
-   case VG_MAX_KERNEL_SIZE:
-   case VG_MAX_SEPARABLE_KERNEL_SIZE:
-   case VG_MAX_COLOR_RAMP_STOPS:
-   case VG_MAX_IMAGE_WIDTH:
-   case VG_MAX_IMAGE_HEIGHT:
-   case VG_MAX_IMAGE_PIXELS:
-   case VG_MAX_IMAGE_BYTES:
-   case VG_MAX_GAUSSIAN_STD_DEVIATION:
-      values[0] = vegaGeti(type);
-      break;
-   case VG_MAX_FLOAT: {
-      VGfloat val = vegaGetf(type);
-      values[0] = float_to_int_floor(*((VGuint*)&val));
-   }
-      break;
-   case VG_SCISSOR_RECTS: {
-      VGint i;
-      for (i = 0; i < count; ++i) {
-         values[i] = state->scissor_rects[i].i;
-      }
-   }
-      break;
-#ifdef OPENVG_VERSION_1_1
-   case VG_COLOR_TRANSFORM_VALUES: {
-      VGint i;
-      VGuint *x = (VGuint*)state->color_transform_values;
-      for (i = 0; i < count; ++i) {
-         values[i] = float_to_int_floor(x[i]);
-      }
-   }
-      break;
-#endif
-   case VG_STROKE_LINE_WIDTH:
-      values[0] = state->stroke.line_width.i;
-      break;
-   case VG_STROKE_MITER_LIMIT:
-      values[0] = state->stroke.miter_limit.i;
-      break;
-   case VG_STROKE_DASH_PATTERN: {
-      VGint i;
-      for (i = 0; i < count; ++i) {
-         values[i] = state->stroke.dash_pattern[i].i;
-      }
-   }
-      break;
-   case VG_STROKE_DASH_PHASE:
-      values[0] = state->stroke.dash_phase.i;
-      break;
-   case VG_TILE_FILL_COLOR:
-      values[0] = state->tile_fill_colori[0];
-      values[1] = state->tile_fill_colori[1];
-      values[2] = state->tile_fill_colori[2];
-      values[3] = state->tile_fill_colori[3];
-      break;
-   case VG_CLEAR_COLOR:
-      values[0] = state->clear_colori[0];
-      values[1] = state->clear_colori[1];
-      values[2] = state->clear_colori[2];
-      values[3] = state->clear_colori[3];
-      break;
-#ifdef OPENVG_VERSION_1_1
-   case VG_GLYPH_ORIGIN:
-      values[0] = state->glyph_origin[0].i;
-      values[1] = state->glyph_origin[1].i;
-      break;
-#endif
-   default:
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      break;
-   }
-}
-
-void vegaSetParameterf(VGHandle object,
-                       VGint paramType,
-                       VGfloat value)
-{
-   struct vg_context *ctx = vg_current_context();
-   void *ptr = handle_to_pointer(object);
-
-   if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   switch(paramType) {
-   case VG_PAINT_TYPE:
-   case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
-   case VG_PAINT_PATTERN_TILING_MODE:
-      vegaSetParameteri(object, paramType, floor(value));
-      return;
-      break;
-   case VG_PAINT_COLOR:
-   case VG_PAINT_COLOR_RAMP_STOPS:
-   case VG_PAINT_LINEAR_GRADIENT:
-   case VG_PAINT_RADIAL_GRADIENT:
-      /* it's an error if paramType refers to a vector parameter */
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      break;
-   case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: {
-      struct vg_paint *p = handle_to_paint(object);
-      paint_set_color_ramp_premultiplied(p, value);
-   }
-      break;
-
-   case VG_PATH_DATATYPE:
-   case VG_PATH_FORMAT:
-   case VG_PATH_SCALE:
-   case VG_PATH_BIAS:
-   case VG_PATH_NUM_SEGMENTS:
-   case VG_PATH_NUM_COORDS:
-
-   case VG_IMAGE_FORMAT:
-   case VG_IMAGE_WIDTH:
-   case VG_IMAGE_HEIGHT:
-
-#ifdef OPENVG_VERSION_1_1
-   case VG_FONT_NUM_GLYPHS:
-      /* read only don't produce an error */
-      break;
-#endif
-   default:
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      break;
-   }
-}
-
-void vegaSetParameteri(VGHandle object,
-                       VGint paramType,
-                       VGint value)
-{
-   struct vg_context *ctx = vg_current_context();
-   void *ptr = handle_to_pointer(object);
-
-   if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   switch(paramType) {
-   case VG_PAINT_TYPE:
-      if (value < VG_PAINT_TYPE_COLOR ||
-          value > VG_PAINT_TYPE_PATTERN)
-         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      else {
-         struct vg_paint *paint = handle_to_paint(object);
-         paint_set_type(paint, value);
-      }
-      break;
-   case VG_PAINT_COLOR:
-   case VG_PAINT_COLOR_RAMP_STOPS:
-   case VG_PAINT_LINEAR_GRADIENT:
-   case VG_PAINT_RADIAL_GRADIENT:
-      /* it's an error if paramType refers to a vector parameter */
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      break;
-   case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
-      if (value < VG_COLOR_RAMP_SPREAD_PAD ||
-          value > VG_COLOR_RAMP_SPREAD_REFLECT)
-         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      else {
-         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 = handle_to_paint(object);
-      paint_set_color_ramp_premultiplied(p, value);
-   }
-      break;
-   case VG_PAINT_PATTERN_TILING_MODE:
-      if (value < VG_TILE_FILL ||
-          value > VG_TILE_REFLECT)
-         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      else {
-         struct vg_paint *paint = handle_to_paint(object);
-         paint_set_pattern_tiling(paint, value);
-      }
-      break;
-
-   case VG_PATH_DATATYPE:
-   case VG_PATH_FORMAT:
-   case VG_PATH_SCALE:
-   case VG_PATH_BIAS:
-   case VG_PATH_NUM_SEGMENTS:
-   case VG_PATH_NUM_COORDS:
-
-   case VG_IMAGE_FORMAT:
-   case VG_IMAGE_WIDTH:
-   case VG_IMAGE_HEIGHT:
-
-#ifdef OPENVG_VERSION_1_1
-   case VG_FONT_NUM_GLYPHS:
-      /* read only don't produce an error */
-      break;
-#endif
-   default:
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-}
-
-void vegaSetParameterfv(VGHandle object,
-                        VGint paramType,
-                        VGint count,
-                        const VGfloat * values)
-{
-   struct vg_context *ctx = vg_current_context();
-   void *ptr = handle_to_pointer(object);
-   VGint real_count = vegaGetParameterVectorSize(object, paramType);
-
-   if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   if (count < 0 || count < real_count ||
-       (values == NULL && count != 0) ||
-       !is_aligned(values)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   switch(paramType) {
-   case VG_PAINT_TYPE:
-   case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
-   case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:
-   case VG_PAINT_PATTERN_TILING_MODE:
-      if (count != 1)
-         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      else
-         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 = 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;
-   case VG_PAINT_COLOR_RAMP_STOPS: {
-      if (count && count < 4)
-         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      else {
-         struct vg_paint *paint = handle_to_paint(object);
-         count = MIN2(count, VEGA_MAX_COLOR_RAMP_STOPS);
-         paint_set_ramp_stops(paint, values, count);
-         {
-            VGint stopsi[VEGA_MAX_COLOR_RAMP_STOPS];
-            int i = 0;
-            for (i = 0; i < count; ++i) {
-               stopsi[i] = float_to_int_floor(*((VGuint*)(values + i)));
-            }
-            paint_set_ramp_stopsi(paint, stopsi, count);
-         }
-      }
-   }
-      break;
-   case VG_PAINT_LINEAR_GRADIENT: {
-      if (count != 4)
-         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      else {
-         struct vg_paint *paint = handle_to_paint(object);
-         paint_set_linear_gradient(paint, values);
-         {
-            VGint vals[4];
-            vals[0] = FLT_TO_INT(values[0]);
-            vals[1] = FLT_TO_INT(values[1]);
-            vals[2] = FLT_TO_INT(values[2]);
-            vals[3] = FLT_TO_INT(values[3]);
-            paint_set_linear_gradienti(paint, vals);
-         }
-      }
-   }
-      break;
-   case VG_PAINT_RADIAL_GRADIENT: {
-      if (count != 5)
-         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      else {
-         struct vg_paint *paint = handle_to_paint(object);
-         paint_set_radial_gradient(paint, values);
-         {
-            VGint vals[5];
-            vals[0] = FLT_TO_INT(values[0]);
-            vals[1] = FLT_TO_INT(values[1]);
-            vals[2] = FLT_TO_INT(values[2]);
-            vals[3] = FLT_TO_INT(values[3]);
-            vals[4] = FLT_TO_INT(values[4]);
-            paint_set_radial_gradienti(paint, vals);
-         }
-      }
-   }
-      break;
-
-   case VG_PATH_DATATYPE:
-   case VG_PATH_FORMAT:
-   case VG_PATH_SCALE:
-   case VG_PATH_BIAS:
-   case VG_PATH_NUM_SEGMENTS:
-   case VG_PATH_NUM_COORDS:
-
-#ifdef OPENVG_VERSION_1_1
-   case VG_FONT_NUM_GLYPHS:
-      /* read only don't produce an error */
-      break;
-#endif
-   default:
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-}
-
-void vegaSetParameteriv(VGHandle object,
-                        VGint paramType,
-                        VGint count,
-                        const VGint * values)
-{
-   struct vg_context *ctx = vg_current_context();
-   void *ptr = handle_to_pointer(object);
-   VGint real_count = vegaGetParameterVectorSize(object, paramType);
-
-   if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   if (count < 0 || count < real_count ||
-       (values == NULL && count != 0) ||
-       !is_aligned(values)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   switch(paramType) {
-   case VG_PAINT_TYPE:
-   case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
-   case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:
-   case VG_PAINT_PATTERN_TILING_MODE:
-      if (count != 1)
-         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      else
-         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 = 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;
-   case VG_PAINT_COLOR_RAMP_STOPS: {
-      if ((count % 5))
-         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      else {
-         VGfloat *vals = 0;
-         int i;
-         struct vg_paint *paint = handle_to_paint(object);
-         if (count) {
-            vals = malloc(sizeof(VGfloat)*count);
-            for (i = 0; i < count; ++i)
-               vals[i] = values[i];
-         }
-
-         paint_set_ramp_stopsi(paint, values, count);
-         paint_set_ramp_stops(paint, vals, count);
-         free(vals);
-      }
-   }
-      break;
-   case VG_PAINT_LINEAR_GRADIENT: {
-      if (count != 4)
-         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      else {
-         VGfloat vals[4];
-         struct vg_paint *paint = handle_to_paint(object);
-         vals[0] = values[0];
-         vals[1] = values[1];
-         vals[2] = values[2];
-         vals[3] = values[3];
-         paint_set_linear_gradient(paint, vals);
-         paint_set_linear_gradienti(paint, values);
-      }
-   }
-      break;
-   case VG_PAINT_RADIAL_GRADIENT: {
-      if (count != 5)
-         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      else {
-         VGfloat vals[5];
-         struct vg_paint *paint = handle_to_paint(object);
-         vals[0] = values[0];
-         vals[1] = values[1];
-         vals[2] = values[2];
-         vals[3] = values[3];
-         vals[4] = values[4];
-         paint_set_radial_gradient(paint, vals);
-         paint_set_radial_gradienti(paint, values);
-      }
-   }
-      break;
-   case VG_PATH_DATATYPE:
-   case VG_PATH_FORMAT:
-   case VG_PATH_SCALE:
-   case VG_PATH_BIAS:
-   case VG_PATH_NUM_SEGMENTS:
-   case VG_PATH_NUM_COORDS:
-      /* read only don't produce an error */
-      break;
-   default:
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-}
-
-VGint vegaGetParameterVectorSize(VGHandle object,
-                                 VGint paramType)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   if (object == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return 0;
-   }
-
-   switch(paramType) {
-   case VG_PAINT_TYPE:
-   case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
-   case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:
-   case VG_PAINT_PATTERN_TILING_MODE:
-      return 1;
-   case VG_PAINT_COLOR:
-      return 4;
-   case VG_PAINT_COLOR_RAMP_STOPS: {
-      struct vg_paint *p = handle_to_paint(object);
-      return paint_num_ramp_stops(p);
-   }
-      break;
-   case VG_PAINT_LINEAR_GRADIENT:
-      return 4;
-   case VG_PAINT_RADIAL_GRADIENT:
-      return 5;
-
-
-   case VG_PATH_FORMAT:
-   case VG_PATH_DATATYPE:
-   case VG_PATH_SCALE:
-   case VG_PATH_BIAS:
-   case VG_PATH_NUM_SEGMENTS:
-   case VG_PATH_NUM_COORDS:
-      return 1;
-
-   case VG_IMAGE_FORMAT:
-   case VG_IMAGE_WIDTH:
-   case VG_IMAGE_HEIGHT:
-      return 1;
-
-#ifdef OPENVG_VERSION_1_1
-   case VG_FONT_NUM_GLYPHS:
-      return 1;
-#endif
-
-   default:
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      break;
-   }
-   return 0;
-}
-
-
-VGfloat vegaGetParameterf(VGHandle object,
-                          VGint paramType)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   if (object == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return 0;
-   }
-
-   switch(paramType) {
-   case VG_PAINT_TYPE:
-   case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
-   case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:
-   case VG_PAINT_PATTERN_TILING_MODE:
-      return vegaGetParameteri(object, paramType);
-      break;
-   case VG_PAINT_COLOR:
-   case VG_PAINT_COLOR_RAMP_STOPS:
-   case VG_PAINT_LINEAR_GRADIENT:
-   case VG_PAINT_RADIAL_GRADIENT:
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      break;
-
-   case VG_PATH_FORMAT:
-      return VG_PATH_FORMAT_STANDARD;
-   case VG_PATH_SCALE: {
-      struct path *p = handle_to_path(object);
-      return path_scale(p);
-   }
-   case VG_PATH_BIAS: {
-      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 vegaGetParameteri(object, paramType);
-      break;
-
-   case VG_IMAGE_FORMAT:
-   case VG_IMAGE_WIDTH:
-   case VG_IMAGE_HEIGHT:
-#ifdef OPENVG_VERSION_1_1
-   case VG_FONT_NUM_GLYPHS: 
-      return vegaGetParameteri(object, paramType);
-      break;
-#endif
-
-   default:
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      break;
-   }
-   return 0;
-}
-
-VGint vegaGetParameteri(VGHandle object,
-                        VGint paramType)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   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 = handle_to_paint(object);
-         return paint_type(paint);
-   }
-      break;
-   case VG_PAINT_COLOR_RAMP_SPREAD_MODE: {
-      struct vg_paint *p = handle_to_paint(object);
-      return paint_spread_mode(p);
-   }
-   case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: {
-      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 = handle_to_paint(object);
-      return paint_pattern_tiling(p);
-   }
-      break;
-   case VG_PAINT_COLOR:
-   case VG_PAINT_COLOR_RAMP_STOPS:
-   case VG_PAINT_LINEAR_GRADIENT:
-   case VG_PAINT_RADIAL_GRADIENT:
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      break;
-
-   case VG_PATH_FORMAT:
-      return VG_PATH_FORMAT_STANDARD;
-   case VG_PATH_SCALE:
-   case VG_PATH_BIAS:
-      return vegaGetParameterf(object, paramType);
-   case VG_PATH_DATATYPE: {
-      struct path *p = handle_to_path(object);
-      return path_datatype(p);
-   }
-   case VG_PATH_NUM_SEGMENTS: {
-      struct path *p = handle_to_path(object);
-      return path_num_segments(p);
-   }
-   case VG_PATH_NUM_COORDS: {
-      struct path *p = handle_to_path(object);
-      return path_num_coords(p);
-   }
-      break;
-
-   case VG_IMAGE_FORMAT: {
-      struct vg_image *img = handle_to_image(object);
-      return img->format;
-   }
-      break;
-   case VG_IMAGE_WIDTH: {
-      struct vg_image *img = handle_to_image(object);
-      return img->width;
-   }
-      break;
-   case VG_IMAGE_HEIGHT: {
-      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 = handle_to_font(object);
-      return font_num_glyphs(font);
-   }
-      break;
-#endif
-
-   default:
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      break;
-   }
-   return 0;
-}
-
-void vegaGetParameterfv(VGHandle object,
-                        VGint paramType,
-                        VGint count,
-                        VGfloat * values)
-{
-   struct vg_context *ctx = vg_current_context();
-   VGint real_count = vegaGetParameterVectorSize(object, paramType);
-
-   if (object == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   if (!values || count <= 0 || count > real_count ||
-       !is_aligned(values)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   switch(paramType) {
-   case VG_PAINT_TYPE: {
-      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 = handle_to_paint(object);
-      values[0] = paint_spread_mode(p);
-   }
-      break;
-   case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: {
-      struct vg_paint *p = handle_to_paint(object);
-      values[0] = paint_color_ramp_premultiplied(p);
-   }
-      break;
-   case VG_PAINT_PATTERN_TILING_MODE: {
-      values[0] = vegaGetParameterf(object, paramType);
-   }
-      break;
-   case VG_PAINT_COLOR: {
-      struct vg_paint *paint = handle_to_paint(object);
-      paint_get_color(paint, values);
-   }
-      break;
-   case VG_PAINT_COLOR_RAMP_STOPS: {
-      struct vg_paint *paint = handle_to_paint(object);
-      paint_ramp_stops(paint, values, count);
-   }
-      break;
-   case VG_PAINT_LINEAR_GRADIENT: {
-      struct vg_paint *paint = handle_to_paint(object);
-      paint_linear_gradient(paint, values);
-   }
-      break;
-   case VG_PAINT_RADIAL_GRADIENT: {
-      struct vg_paint *paint = handle_to_paint(object);
-      paint_radial_gradient(paint, values);
-   }
-      break;
-
-   case VG_PATH_FORMAT:
-   case VG_PATH_DATATYPE:
-   case VG_PATH_NUM_SEGMENTS:
-   case VG_PATH_NUM_COORDS:
-      values[0] = vegaGetParameteri(object, paramType);
-      break;
-   case VG_PATH_SCALE:
-   case VG_PATH_BIAS:
-      values[0] = vegaGetParameterf(object, paramType);
-      break;
-
-   case VG_IMAGE_FORMAT:
-   case VG_IMAGE_WIDTH:
-   case VG_IMAGE_HEIGHT:
-#ifdef OPENVG_VERSION_1_1
-   case VG_FONT_NUM_GLYPHS:
-      values[0] = vegaGetParameteri(object, paramType);
-      break;
-#endif
-
-   default:
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      break;
-   }
-}
-
-void vegaGetParameteriv(VGHandle object,
-                        VGint paramType,
-                        VGint count,
-                        VGint * values)
-{
-   struct vg_context *ctx = vg_current_context();
-   VGint real_count = vegaGetParameterVectorSize(object, paramType);
-
-   if (object || object == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   if (!values || count <= 0 || count > real_count ||
-       !is_aligned(values)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   switch(paramType) {
-   case VG_PAINT_TYPE:
-   case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
-   case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:
-   case VG_PAINT_PATTERN_TILING_MODE:
-#ifdef OPENVG_VERSION_1_1
-   case VG_FONT_NUM_GLYPHS:
-      values[0] = vegaGetParameteri(object, paramType);
-      break;
-#endif
-   case VG_PAINT_COLOR: {
-      struct vg_paint *paint = handle_to_paint(object);
-      paint_get_coloriv(paint, values);
-   }
-      break;
-   case VG_PAINT_COLOR_RAMP_STOPS: {
-      struct vg_paint *paint = handle_to_paint(object);
-      paint_ramp_stopsi(paint, values, count);
-   }
-      break;
-   case VG_PAINT_LINEAR_GRADIENT: {
-      struct vg_paint *paint = handle_to_paint(object);
-      paint_linear_gradienti(paint, values);
-   }
-      break;
-   case VG_PAINT_RADIAL_GRADIENT: {
-      struct vg_paint *paint = handle_to_paint(object);
-      paint_radial_gradienti(paint, values);
-   }
-      break;
-
-   case VG_PATH_SCALE:
-   case VG_PATH_BIAS:
-      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] = vegaGetParameteri(object, paramType);
-      break;
-
-   case VG_IMAGE_FORMAT:
-   case VG_IMAGE_WIDTH:
-   case VG_IMAGE_HEIGHT:
-      values[0] = vegaGetParameteri(object, paramType);
-      break;
-
-   default:
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      break;
-   }
-}
diff --git a/src/gallium/state_trackers/vega/api_path.c b/src/gallium/state_trackers/vega/api_path.c
deleted file mode 100644
index ab6ce958945..00000000000
--- a/src/gallium/state_trackers/vega/api_path.c
+++ /dev/null
@@ -1,487 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "VG/openvg.h"
-
-#include "vg_context.h"
-#include "handle.h"
-#include "path.h"
-#include "api.h"
-
-#include "pipe/p_context.h"
-
-VGPath vegaCreatePath(VGint pathFormat,
-                      VGPathDatatype datatype,
-                      VGfloat scale, VGfloat bias,
-                      VGint segmentCapacityHint,
-                      VGint coordCapacityHint,
-                      VGbitfield capabilities)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   if (pathFormat != VG_PATH_FORMAT_STANDARD) {
-      vg_set_error(ctx, VG_UNSUPPORTED_PATH_FORMAT_ERROR);
-      return VG_INVALID_HANDLE;
-   }
-   if (datatype < VG_PATH_DATATYPE_S_8 ||
-       datatype > VG_PATH_DATATYPE_F) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return VG_INVALID_HANDLE;
-   }
-   if (!scale) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return VG_INVALID_HANDLE;
-   }
-
-   return path_to_handle(path_create(datatype, scale, bias,
-                                     segmentCapacityHint, coordCapacityHint,
-                                     capabilities));
-}
-
-void vegaClearPath(VGPath path, VGbitfield capabilities)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct path *p = 0;
-
-   if (path == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   p = handle_to_path(path);
-   path_clear(p, capabilities);
-}
-
-void vegaDestroyPath(VGPath p)
-{
-   struct path *path = 0;
-   struct vg_context *ctx = vg_current_context();
-
-   if (p == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   path = handle_to_path(p);
-   path_destroy(path);
-}
-
-void vegaRemovePathCapabilities(VGPath path,
-                                VGbitfield capabilities)
-{
-   struct vg_context *ctx = vg_current_context();
-   VGbitfield current;
-   struct path *p;
-
-   if (path == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   p = handle_to_path(path);
-   current = path_capabilities(p);
-   path_set_capabilities(p, (current &
-                             (~(capabilities & VG_PATH_CAPABILITY_ALL))));
-}
-
-VGbitfield vegaGetPathCapabilities(VGPath path)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct path *p = 0;
-
-   if (path == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return 0;
-   }
-   p = handle_to_path(path);
-   return path_capabilities(p);
-}
-
-void vegaAppendPath(VGPath dstPath, VGPath srcPath)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct path *src, *dst;
-
-   if (dstPath == VG_INVALID_HANDLE || srcPath == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   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)) {
-      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
-      return;
-   }
-   path_append_path(dst, src);
-}
-
-void vegaAppendPathData(VGPath dstPath,
-                        VGint numSegments,
-                        const VGubyte * pathSegments,
-                        const void * pathData)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct path *p = 0;
-   VGint i;
-
-   if (dstPath == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   if (!pathSegments) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   if (numSegments <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   for (i = 0; i < numSegments; ++i) {
-      if (pathSegments[i] > VG_LCWARC_TO_REL) {
-         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-         return;
-      }
-   }
-
-   p = handle_to_path(dstPath);
-
-   if (!p || !is_aligned_to(p, path_datatype_size(p))) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   if (!(path_capabilities(p)&VG_PATH_CAPABILITY_APPEND_TO)) {
-      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
-      return;
-   }
-
-   path_append_data(p, numSegments, pathSegments, pathData);
-}
-
-void vegaModifyPathCoords(VGPath dstPath,
-                          VGint startIndex,
-                          VGint numSegments,
-                          const void * pathData)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct path *p = 0;
-
-   if (dstPath == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   if (startIndex < 0 || numSegments <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   p = handle_to_path(dstPath);
-
-   if (!pathData || !is_aligned_to(pathData, path_datatype_size(p))) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   if (startIndex + numSegments > path_num_segments(p)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   if (!(path_capabilities(p)&VG_PATH_CAPABILITY_MODIFY)) {
-      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
-      return;
-   }
-   path_modify_coords(p, startIndex, numSegments, pathData);
-}
-
-void vegaTransformPath(VGPath dstPath, VGPath srcPath)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct path *src = 0, *dst = 0;
-
-   if (dstPath == VG_INVALID_HANDLE || srcPath == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   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)) {
-      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
-      return;
-   }
-   path_transform(dst, src);
-}
-
-VGboolean vegaInterpolatePath(VGPath dstPath,
-                              VGPath startPath,
-                              VGPath endPath,
-                              VGfloat amount)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct path *start = 0, *dst = 0, *end = 0;
-
-   if (dstPath == VG_INVALID_HANDLE ||
-       startPath == VG_INVALID_HANDLE ||
-       endPath == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return VG_FALSE;
-   }
-   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) ||
-       !(path_capabilities(end) & VG_PATH_CAPABILITY_INTERPOLATE_FROM)) {
-      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
-      return VG_FALSE;
-   }
-
-   return path_interpolate(dst,
-                           start, end, amount);
-}
-
-VGfloat vegaPathLength(VGPath path,
-                       VGint startSegment,
-                       VGint numSegments)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct path *p = 0;
-
-   if (path == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return -1;
-   }
-   if (startSegment < 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return -1;
-   }
-   if (numSegments <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return -1;
-   }
-   p = handle_to_path(path);
-
-   if (!(path_capabilities(p) & VG_PATH_CAPABILITY_PATH_LENGTH)) {
-      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
-      return -1;
-   }
-   if (startSegment + numSegments > path_num_segments(p)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return -1;
-   }
-
-   return path_length(p, startSegment, numSegments);
-}
-
-void vegaPointAlongPath(VGPath path,
-                        VGint startSegment,
-                        VGint numSegments,
-                        VGfloat distance,
-                        VGfloat * x, VGfloat * y,
-                        VGfloat * tangentX,
-                        VGfloat * tangentY)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct path *p = 0;
-   VGbitfield caps;
-
-   if (path == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   if (startSegment < 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   if (numSegments <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   if (!is_aligned(x) || !is_aligned(y) ||
-       !is_aligned(tangentX) || !is_aligned(tangentY)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   p = handle_to_path(path);
-
-   caps = path_capabilities(p);
-   if (!(caps & VG_PATH_CAPABILITY_POINT_ALONG_PATH) ||
-       !(caps & VG_PATH_CAPABILITY_TANGENT_ALONG_PATH)) {
-      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
-      return;
-   }
-
-   if (startSegment + numSegments > path_num_segments(p)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   {
-      VGfloat point[2], normal[2];
-      path_point(p, startSegment, numSegments, distance,
-                 point, normal);
-      if (x)
-         *x = point[0];
-      if (y)
-         *y = point[1];
-      if (tangentX)
-         *tangentX = -normal[1];
-      if (tangentY)
-         *tangentY = normal[0];
-   }
-}
-
-void vegaPathBounds(VGPath path,
-                    VGfloat * minX,
-                    VGfloat * minY,
-                    VGfloat * width,
-                    VGfloat * height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct path *p = 0;
-   VGbitfield caps;
-
-   if (path == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   if (!minX || !minY || !width || !height) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   if (!is_aligned(minX) || !is_aligned(minY) ||
-       !is_aligned(width) || !is_aligned(height)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   p = handle_to_path(path);
-
-   caps = path_capabilities(p);
-   if (!(caps & VG_PATH_CAPABILITY_PATH_BOUNDS)) {
-      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
-      return;
-   }
-
-   path_bounding_rect(p, minX, minY, width, height);
-}
-
-void vegaPathTransformedBounds(VGPath path,
-                               VGfloat * minX,
-                               VGfloat * minY,
-                               VGfloat * width,
-                               VGfloat * height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct path *p = 0;
-   VGbitfield caps;
-
-   if (path == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   if (!minX || !minY || !width || !height) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   if (!is_aligned(minX) || !is_aligned(minY) ||
-       !is_aligned(width) || !is_aligned(height)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   p = handle_to_path(path);
-
-   caps = path_capabilities(p);
-   if (!(caps & VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS)) {
-      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
-      return;
-   }
-
-#if 0
-   /* faster, but seems to have precision problems... */
-   path_bounding_rect(p, minX, minY, width, height);
-   if (*width > 0 && *height > 0) {
-      VGfloat pts[] = {*minX,          *minY,
-                       *minX + *width, *minY,
-                       *minX + *width, *minY + *height,
-                       *minX,          *minY + *height};
-      struct matrix *matrix = &ctx->state.vg.path_user_to_surface_matrix;
-      VGfloat maxX, maxY;
-      matrix_map_point(matrix, pts[0], pts[1], pts + 0, pts + 1);
-      matrix_map_point(matrix, pts[2], pts[3], pts + 2, pts + 3);
-      matrix_map_point(matrix, pts[4], pts[5], pts + 4, pts + 5);
-      matrix_map_point(matrix, pts[6], pts[7], pts + 6, pts + 7);
-      *minX = MIN2(pts[0], MIN2(pts[2], MIN2(pts[4], pts[6])));
-      *minY = MIN2(pts[1], MIN2(pts[3], MIN2(pts[5], pts[7])));
-      maxX = MAX2(pts[0], MAX2(pts[2], MAX2(pts[4], pts[6])));
-      maxY = MAX2(pts[1], MAX2(pts[3], MAX2(pts[5], pts[7])));
-      *width  = maxX - *minX;
-      *height = maxY - *minY;
-   }
-#else
-   {
-      struct path *dst = path_create(VG_PATH_DATATYPE_F, 1.0, 0,
-                                     0, 0, VG_PATH_CAPABILITY_ALL);
-      path_transform(dst, p);
-      path_bounding_rect(dst, minX, minY, width, height);
-      path_destroy(dst);
-   }
-#endif
-}
-
-
-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);
-      return;
-   }
-
-   if (!(paintModes & (VG_STROKE_PATH | VG_FILL_PATH))) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   if (path_is_empty(p))
-      return;
-   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
deleted file mode 100644
index 824c7630403..00000000000
--- a/src/gallium/state_trackers/vega/api_text.c
+++ /dev/null
@@ -1,209 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "VG/openvg.h"
-
-#include "vg_context.h"
-#include "text.h"
-#include "api.h"
-#include "handle.h"
-
-#include "util/u_memory.h"
-
-#ifdef OPENVG_VERSION_1_1
-
-VGFont vegaCreateFont(VGint glyphCapacityHint)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   if (glyphCapacityHint < 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return VG_INVALID_HANDLE;
-   }
-
-   return font_to_handle(font_create(glyphCapacityHint));
-}
-
-void vegaDestroyFont(VGFont 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(f, VG_OBJECT_FONT)) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   font_destroy(font);
-}
-
-void vegaSetGlyphToPath(VGFont font,
-                        VGuint glyphIndex,
-                        VGPath path,
-                        VGboolean isHinted,
-                        const VGfloat glyphOrigin[2],
-                        const VGfloat escapement[2])
-{
-   struct vg_context *ctx = vg_current_context();
-   struct path *pathObj;
-   struct vg_font *f;
-
-   if (font == VG_INVALID_HANDLE ||
-       !vg_context_is_object_valid(ctx, VG_OBJECT_FONT, font)) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   if (!glyphOrigin || !escapement ||
-       !is_aligned(glyphOrigin) || !is_aligned(escapement)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   if (path != VG_INVALID_HANDLE &&
-       !vg_context_is_object_valid(ctx, VG_OBJECT_PATH, path)) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   pathObj = handle_to_path(path);
-   f = handle_to_font(font);
-
-   font_set_glyph_to_path(f, glyphIndex, pathObj,
-         isHinted, glyphOrigin, escapement);
-}
-
-void vegaSetGlyphToImage(VGFont font,
-                         VGuint glyphIndex,
-                         VGImage image,
-                         const VGfloat glyphOrigin[2],
-                         const VGfloat escapement[2])
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_image *img_obj;
-   struct vg_font *f;
-
-   if (font == VG_INVALID_HANDLE ||
-       !vg_context_is_object_valid(ctx, VG_OBJECT_FONT, font)) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   if (!glyphOrigin || !escapement ||
-       !is_aligned(glyphOrigin) || !is_aligned(escapement)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   if (image != VG_INVALID_HANDLE &&
-       !vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, image)) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   img_obj = handle_to_image(image);
-   f = handle_to_font(font);
-
-   font_set_glyph_to_image(f, glyphIndex, img_obj, glyphOrigin, escapement);
-}
-
-void vegaClearGlyph(VGFont font,
-                    VGuint glyphIndex)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_font *f;
-
-   if (font == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-
-   f = handle_to_font(font);
-
-   font_clear_glyph(f, glyphIndex);
-}
-
-void vegaDrawGlyph(VGFont font,
-                   VGuint glyphIndex,
-                   VGbitfield paintModes,
-                   VGboolean allowAutoHinting)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_font *f;
-
-   if (font == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   if (paintModes & (~(VG_STROKE_PATH|VG_FILL_PATH))) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   f = handle_to_font(font);
-
-   font_draw_glyph(f, glyphIndex, paintModes, allowAutoHinting);
-}
-
-void vegaDrawGlyphs(VGFont font,
-                    VGint glyphCount,
-                    const VGuint *glyphIndices,
-                    const VGfloat *adjustments_x,
-                    const VGfloat *adjustments_y,
-                    VGbitfield paintModes,
-                    VGboolean allowAutoHinting)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_font *f;
-
-   if (font == VG_INVALID_HANDLE) {
-      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
-      return;
-   }
-   if (glyphCount <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   if (!glyphIndices || !is_aligned(glyphIndices)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   if ((adjustments_x && !is_aligned(adjustments_x)) ||
-       (adjustments_y && !is_aligned(adjustments_y))) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   if (paintModes & (~(VG_STROKE_PATH|VG_FILL_PATH))) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   f = handle_to_font(font);
-
-   font_draw_glyphs(f, glyphCount, glyphIndices,
-         adjustments_x, adjustments_y, paintModes, allowAutoHinting);
-}
-
-#endif /* OPENVG_VERSION_1_1 */
diff --git a/src/gallium/state_trackers/vega/api_transform.c b/src/gallium/state_trackers/vega/api_transform.c
deleted file mode 100644
index 0a40fc69b95..00000000000
--- a/src/gallium/state_trackers/vega/api_transform.c
+++ /dev/null
@@ -1,129 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "VG/openvg.h"
-
-#include "vg_context.h"
-
-#include "matrix.h"
-#include "api.h"
-
-void vegaLoadIdentity(void)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct  matrix *mat = vg_state_matrix(&ctx->state.vg);
-   matrix_load_identity(mat);
-}
-
-void vegaLoadMatrix(const VGfloat * m)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct  matrix *mat;
-
-   if (!ctx)
-      return;
-
-   if (!m || !is_aligned(m)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   mat = vg_state_matrix(&ctx->state.vg);
-   matrix_init(mat, m);
-   if (!matrix_is_affine(mat)) {
-      if (ctx->state.vg.matrix_mode != VG_MATRIX_IMAGE_USER_TO_SURFACE) {
-         matrix_make_affine(mat);
-      }
-   }
-}
-
-void vegaGetMatrix(VGfloat * m)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct matrix *mat;
-
-   if (!ctx)
-      return;
-
-   if (!m || !is_aligned(m)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   mat = vg_state_matrix(&ctx->state.vg);
-   memcpy(m, mat->m, sizeof(VGfloat)*9);
-}
-
-void vegaMultMatrix(const VGfloat * m)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct matrix *dst, src;
-
-   if (!ctx)
-      return;
-
-   if (!m || !is_aligned(m)) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   matrix_init(&src, m);
-   dst = vg_state_matrix(&ctx->state.vg);
-   if (!matrix_is_affine(&src)) {
-      if (ctx->state.vg.matrix_mode != VG_MATRIX_IMAGE_USER_TO_SURFACE) {
-         matrix_make_affine(&src);
-      }
-   }
-   matrix_mult(dst, &src);
-
-}
-
-void vegaTranslate(VGfloat tx, VGfloat ty)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct matrix *dst = vg_state_matrix(&ctx->state.vg);
-   matrix_translate(dst, tx, ty);
-}
-
-void vegaScale(VGfloat sx, VGfloat sy)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct matrix *dst = vg_state_matrix(&ctx->state.vg);
-   matrix_scale(dst, sx, sy);
-}
-
-void vegaShear(VGfloat shx, VGfloat shy)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct matrix *dst = vg_state_matrix(&ctx->state.vg);
-   matrix_shear(dst, shx, shy);
-}
-
-void vegaRotate(VGfloat angle)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct matrix *dst = vg_state_matrix(&ctx->state.vg);
-   matrix_rotate(dst, angle);
-}
diff --git a/src/gallium/state_trackers/vega/arc.c b/src/gallium/state_trackers/vega/arc.c
deleted file mode 100644
index 65a985fbbbf..00000000000
--- a/src/gallium/state_trackers/vega/arc.c
+++ /dev/null
@@ -1,709 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "arc.h"
-
-#include "matrix.h"
-#include "bezier.h"
-#include "polygon.h"
-#include "stroker.h"
-#include "path.h"
-
-#include "util/u_debug.h"
-#include "util/u_math.h"
-
-#ifndef M_PI
-#define M_PI 3.14159265358979323846
-#endif
-
-#define DEBUG_ARCS 0
-
-static const VGfloat two_pi = M_PI * 2;
-
-
-static const double coeffs3Low[2][4][4] = {
-   {
-      {  3.85268,   -21.229,      -0.330434,    0.0127842  },
-      { -1.61486,     0.706564,    0.225945,    0.263682   },
-      { -0.910164,    0.388383,    0.00551445,  0.00671814 },
-      { -0.630184,    0.192402,    0.0098871,   0.0102527  }
-   },
-   {
-      { -0.162211,    9.94329,     0.13723,     0.0124084  },
-      { -0.253135,    0.00187735,  0.0230286,   0.01264    },
-      { -0.0695069,  -0.0437594,   0.0120636,   0.0163087  },
-      { -0.0328856,  -0.00926032, -0.00173573,  0.00527385 }
-   }
-};
-
-/* coefficients for error estimation
-   while using cubic Bézier curves for approximation
-   1/4 <= b/a <= 1 */
-static const double coeffs3High[2][4][4] = {
-   {
-      {  0.0899116, -19.2349,     -4.11711,     0.183362   },
-      {  0.138148,   -1.45804,     1.32044,     1.38474    },
-      {  0.230903,   -0.450262,    0.219963,    0.414038   },
-      {  0.0590565,  -0.101062,    0.0430592,   0.0204699  }
-   },
-   {
-      {  0.0164649,   9.89394,     0.0919496,   0.00760802 },
-      {  0.0191603,  -0.0322058,   0.0134667,  -0.0825018  },
-      {  0.0156192,  -0.017535,    0.00326508, -0.228157   },
-      { -0.0236752,   0.0405821,  -0.0173086,   0.176187   }
-   }
-};
-
-/* safety factor to convert the "best" error approximation
-   into a "max bound" error */
-static const double safety3[] = {
-   0.001, 4.98, 0.207, 0.0067
-};
-
-/* The code below is from the OpenVG 1.1 Spec
- * Section 18.4 */
-
-/* Given: Points (x0, y0) and (x1, y1)
- * Return: TRUE if a solution exists, FALSE otherwise
- *         Circle centers are written to (cx0, cy0) and (cx1, cy1)
- */
-static VGboolean
-find_unit_circles(double x0, double y0, double x1, double y1,
-                  double *cx0, double *cy0,
-                  double *cx1, double *cy1)
-{
-   /* Compute differences and averages */
-   double dx = x0 - x1;
-   double dy = y0 - y1;
-   double xm = (x0 + x1)/2;
-   double ym = (y0 + y1)/2;
-   double dsq, disc, s, sdx, sdy;
-
-   /* Solve for intersecting unit circles */
-   dsq = dx*dx + dy*dy;
-   if (dsq == 0.0) return VG_FALSE; /* Points are coincident */
-   disc = 1.0/dsq - 1.0/4.0;
-
-   /* the precision we care about here is around float so if we're
-    * around the float defined zero then make it official to avoid
-    * precision problems later on */
-   if (floatIsZero(disc))
-      disc = 0.0;
-
-   if (disc < 0.0) return VG_FALSE; /* Points are too far apart */
-   s = sqrt(disc);
-   sdx = s*dx;
-   sdy = s*dy;
-   *cx0 = xm + sdy;
-   *cy0 = ym - sdx;
-   *cx1 = xm - sdy;
-   *cy1 = ym + sdx;
-   return VG_TRUE;
-}
-
-
-/* Given:  Ellipse parameters rh, rv, rot (in degrees),
- *         endpoints (x0, y0) and (x1, y1)
- * Return: TRUE if a solution exists, FALSE otherwise
- *         Ellipse centers are written to (cx0, cy0) and (cx1, cy1)
- */
-static VGboolean
-find_ellipses(double rh, double rv, double rot,
-              double x0, double y0, double x1, double y1,
-              double *cx0, double *cy0, double *cx1, double *cy1)
-{
-   double COS, SIN, x0p, y0p, x1p, y1p, pcx0, pcy0, pcx1, pcy1;
-   /* Convert rotation angle from degrees to radians */
-   rot *= M_PI/180.0;
-   /* Pre-compute rotation matrix entries */
-   COS = cos(rot); SIN = sin(rot);
-   /* Transform (x0, y0) and (x1, y1) into unit space */
-   /* using (inverse) rotate, followed by (inverse) scale   */
-   x0p = (x0*COS + y0*SIN)/rh;
-   y0p = (-x0*SIN + y0*COS)/rv;
-   x1p = (x1*COS + y1*SIN)/rh;
-   y1p = (-x1*SIN + y1*COS)/rv;
-   if (!find_unit_circles(x0p, y0p, x1p, y1p,
-                          &pcx0, &pcy0, &pcx1, &pcy1)) {
-      return VG_FALSE;
-   }
-   /* Transform back to original coordinate space */
-   /* using (forward) scale followed by (forward) rotate */
-   pcx0 *= rh; pcy0 *= rv;
-   pcx1 *= rh; pcy1 *= rv;
-   *cx0 = pcx0*COS - pcy0*SIN;
-   *cy0 = pcx0*SIN + pcy0*COS;
-   *cx1 = pcx1*COS - pcy1*SIN;
-   *cy1 = pcx1*SIN + pcy1*COS;
-   return VG_TRUE;
-}
-
-static INLINE VGboolean
-try_to_fix_radii(struct arc *arc)
-{
-   double COS, SIN, rot, x0p, y0p, x1p, y1p;
-   double dx, dy, dsq, scale;
-
-   /* Convert rotation angle from degrees to radians */
-   rot = DEGREES_TO_RADIANS(arc->theta);
-
-   /* Pre-compute rotation matrix entries */
-   COS = cos(rot); SIN = sin(rot);
-
-   /* Transform (x0, y0) and (x1, y1) into unit space */
-   /* using (inverse) rotate, followed by (inverse) scale   */
-   x0p = (arc->x1*COS + arc->y1*SIN)/arc->a;
-   y0p = (-arc->x1*SIN + arc->y1*COS)/arc->b;
-   x1p = (arc->x2*COS + arc->y2*SIN)/arc->a;
-   y1p = (-arc->x2*SIN + arc->y2*COS)/arc->b;
-   /* Compute differences and averages */
-   dx = x0p - x1p;
-   dy = y0p - y1p;
-
-   dsq = dx*dx + dy*dy;
-#if 0
-   if (dsq <= 0.001) {
-      debug_printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaaaaa\n");
-   }
-#endif
-   scale = 1/(2/sqrt(dsq));
-   arc->a *= scale;
-   arc->b *= scale;
-   return VG_TRUE;
-}
-
-static INLINE double vector_normalize(double *v)
-{
-   double sq = v[0] * v[0] + v[1] * v[1];
-   return sqrt(sq);
-}
-static INLINE double vector_orientation(double *v)
-{
-   double norm = vector_normalize(v);
-   double cosa = v[0] / norm;
-   double sina = v[1] / norm;
-   return (sina>=0 ? acos(cosa) : 2*M_PI - acos(cosa));
-}
-static INLINE double vector_dot(double *v0,
-                                double *v1)
-{
-   return v0[0] * v1[0] + v0[1] * v1[1];
-}
-
-static INLINE double vector_angles(double *v0,
-                                   double *v1)
-{
-   double dot = vector_dot(v0, v1);
-   double norm0 = vector_normalize(v0);
-   double norm1 = vector_normalize(v1);
-
-   return acos(dot / (norm0 * norm1));
-}
-
-static VGboolean find_angles(struct arc *arc)
-{
-   double vec0[2], vec1[2];
-   double lambda1, lambda2;
-   double angle;
-   struct matrix matrix;
-
-   if (floatIsZero(arc->a) || floatIsZero(arc->b)) {
-      return VG_FALSE;
-   }
-   /* map the points to an identity circle */
-   matrix_load_identity(&matrix);
-   matrix_scale(&matrix, 1.f, arc->a/arc->b);
-   matrix_rotate(&matrix, -arc->theta);
-   matrix_map_point(&matrix,
-                    arc->x1, arc->y1,
-                    &arc->x1, &arc->y1);
-   matrix_map_point(&matrix,
-                    arc->x2, arc->y2,
-                    &arc->x2, &arc->y2);
-   matrix_map_point(&matrix,
-                    arc->cx, arc->cy,
-                    &arc->cx, &arc->cy);
-
-#if DEBUG_ARCS
-   debug_printf("Matrix 3 [%f, %f, %f| %f, %f, %f| %f, %f, %f]\n",
-                matrix.m[0], matrix.m[1], matrix.m[2],
-                matrix.m[3], matrix.m[4], matrix.m[5],
-                matrix.m[6], matrix.m[7], matrix.m[8]);
-   debug_printf("Endpoints [%f, %f], [%f, %f]\n",
-                arc->x1, arc->y1, arc->x2, arc->y2);
-#endif
-
-   vec0[0] = arc->x1 - arc->cx;
-   vec0[1] = arc->y1 - arc->cy;
-   vec1[0] = arc->x2 - arc->cx;
-   vec1[1] = arc->y2 - arc->cy;
-
-#if DEBUG_ARCS
-   debug_printf("Vec is [%f, %f], [%f, %f], [%f, %f]\n",
-                vec0[0], vec0[1], vec1[0], vec1[1], arc->cx, arc->cy);
-#endif
-
-   lambda1 = vector_orientation(vec0);
-
-   if (isnan(lambda1))
-      lambda1 = 0.f;
-
-   if (arc->type == VG_SCWARC_TO ||
-       arc->type == VG_SCCWARC_TO)
-      angle = vector_angles(vec0, vec1);
-   else if (arc->type == VG_LCWARC_TO ||
-            arc->type == VG_LCCWARC_TO) {
-      angle = 2*M_PI - vector_angles(vec0, vec1);
-   } else
-      abort();
-
-   if (isnan(angle))
-      angle = M_PI;
-
-
-   if (arc->type == VG_SCWARC_TO ||
-       arc->type == VG_LCWARC_TO)
-      lambda2 = lambda1 - angle;
-   else
-      lambda2 = lambda1 + angle;
-
-#if DEBUG_ARCS
-   debug_printf("Angle is %f and (%f, %f)\n", angle, lambda1, lambda2);
-#endif
-
-#if 0
-   arc->eta1 = atan2(sin(lambda1) / arc->b,
-                     cos(lambda1) / arc->a);
-   arc->eta2 = atan2(sin(lambda2) / arc->b,
-                     cos(lambda2) / arc->a);
-
-   /* make sure we have eta1 <= eta2 <= eta1 + 2 PI */
-   arc->eta2 -= two_pi * floor((arc->eta2 - arc->eta1) / two_pi);
-
-   /* the preceding correction fails if we have exactly et2 - eta1 = 2 PI
-      it reduces the interval to zero length */
-   if ((lambda2 - lambda1 > M_PI) && (arc->eta2 - arc->eta1 < M_PI)) {
-      arc->eta2 += 2 * M_PI;
-   }
-#else
-   arc->eta1 = lambda1;
-   arc->eta2 = lambda2;
-#endif
-
-   return VG_TRUE;
-}
-
-#if DEBUG_ARCS
-static void check_endpoints(struct arc *arc)
-{
-   double x1, y1, x2, y2;
-
-   double a_cos_eta1 = arc->a * cos(arc->eta1);
-   double b_sin_eta1 = arc->b * sin(arc->eta1);
-   x1 = arc->cx + a_cos_eta1 * arc->cos_theta -
-        b_sin_eta1 * arc->sin_theta;
-   y1 = arc->cy + a_cos_eta1 * arc->sin_theta +
-        b_sin_eta1 * arc->cos_theta;
-
-   double a_cos_eta2 = arc->a * cos(arc->eta2);
-   double b_sin_eta2 = arc->b * sin(arc->eta2);
-   x2 = arc->cx + a_cos_eta2 * arc->cos_theta -
-        b_sin_eta2 * arc->sin_theta;
-   y2 = arc->cy + a_cos_eta2 * arc->sin_theta +
-        b_sin_eta2 * arc->cos_theta;
-
-   debug_printf("Computed (%f, %f), (%f, %f)\n",
-                x1, y1, x2, y2);
-   debug_printf("Real     (%f, %f), (%f, %f)\n",
-                arc->x1, arc->y1,
-                arc->x2, arc->y2);
-}
-#endif
-
-void arc_init(struct arc *arc,
-              VGPathSegment type,
-              VGfloat x1, VGfloat y1,
-              VGfloat x2, VGfloat y2,
-              VGfloat rh, VGfloat rv,
-              VGfloat rot)
-{
-   assert(type == VG_SCCWARC_TO ||
-          type == VG_SCWARC_TO ||
-          type == VG_LCCWARC_TO ||
-          type == VG_LCWARC_TO);
-   arc->type = type;
-   arc->x1  = x1;
-   arc->y1  = y1;
-   arc->x2  = x2;
-   arc->y2  = y2;
-   arc->a   = rh;
-   arc->b   = rv;
-   arc->theta = rot;
-   arc->cos_theta = cos(arc->theta);
-   arc->sin_theta = sin(arc->theta);
-   {
-      double cx0, cy0, cx1, cy1;
-      double cx, cy;
-      arc->is_valid =  find_ellipses(rh, rv, rot, x1, y1, x2, y2,
-                                     &cx0, &cy0, &cx1, &cy1);
-
-      if (!arc->is_valid && try_to_fix_radii(arc)) {
-         rh = arc->a;
-         rv = arc->b;
-         arc->is_valid =
-            find_ellipses(rh, rv, rot, x1, y1, x2, y2,
-                          &cx0, &cy0, &cx1, &cy1);
-      }
-
-      if (type == VG_SCWARC_TO ||
-          type == VG_LCCWARC_TO) {
-         cx = cx1;
-         cy = cy1;
-      } else {
-         cx = cx0;
-         cy = cy0;
-      }
-#if DEBUG_ARCS
-      debug_printf("Centers are : (%f, %f) , (%f, %f). Real (%f, %f)\n",
-                   cx0, cy0, cx1, cy1, cx, cy);
-#endif
-      arc->cx = cx;
-      arc->cy = cy;
-      if (arc->is_valid) {
-         arc->is_valid = find_angles(arc);
-#if DEBUG_ARCS
-         check_endpoints(arc);
-#endif
-         /* remap a few points. find_angles requires
-          * rot in angles, the rest of the code
-          * will need them in radians. and find_angles
-          * modifies the center to match an identity
-          * circle so lets reset it */
-         arc->theta = DEGREES_TO_RADIANS(rot);
-         arc->cos_theta = cos(arc->theta);
-         arc->sin_theta = sin(arc->theta);
-         arc->cx = cx;
-         arc->cy = cy;
-      }
-   }
-}
-
-static INLINE double rational_function(double x, const double *c)
-{
-   return (x * (x * c[0] + c[1]) + c[2]) / (x + c[3]);
-}
-
-static double estimate_error(struct arc *arc,
-                             double etaA, double etaB)
-{
-   double eta  = 0.5 * (etaA + etaB);
-
-   double x    = arc->b / arc->a;
-   double dEta = etaB - etaA;
-   double cos2 = cos(2 * eta);
-   double cos4 = cos(4 * eta);
-   double cos6 = cos(6 * eta);
-   double c0, c1;
-
-   /* select the right coeficients set according to degree and b/a */
-   const double (*coeffs)[4][4];
-   const double *safety;
-   coeffs = (x < 0.25) ? coeffs3Low : coeffs3High;
-   safety = safety3;
-
-   c0 = rational_function(x, coeffs[0][0])
-        + cos2 * rational_function(x, coeffs[0][1])
-        + cos4 * rational_function(x, coeffs[0][2])
-        + cos6 * rational_function(x, coeffs[0][3]);
-
-   c1 = rational_function(x, coeffs[1][0])
-        + cos2 * rational_function(x, coeffs[1][1])
-        + cos4 * rational_function(x, coeffs[1][2])
-        + cos6 * rational_function(x, coeffs[1][3]);
-
-   return rational_function(x, safety) * arc->a * exp(c0 + c1 * dEta);
-}
-
-struct arc_cb {
-   void (*move)(struct arc_cb *cb, VGfloat x, VGfloat y);
-   void (*point)(struct arc_cb *cb, VGfloat x, VGfloat y);
-   void (*bezier)(struct arc_cb *cb, struct bezier *bezier);
-
-   void *user_data;
-};
-
-static void cb_null_move(struct arc_cb *cb, VGfloat x, VGfloat y)
-{
-}
-
-static void polygon_point(struct arc_cb *cb, VGfloat x, VGfloat y)
-{
-   struct polygon *poly = (struct polygon*)cb->user_data;
-   polygon_vertex_append(poly, x, y);
-}
-
-static void polygon_bezier(struct arc_cb *cb, struct bezier *bezier)
-{
-   struct polygon *poly = (struct polygon*)cb->user_data;
-   bezier_add_to_polygon(bezier, poly);
-}
-
-static void stroke_point(struct arc_cb *cb, VGfloat x, VGfloat y)
-{
-   struct stroker *stroker = (struct stroker*)cb->user_data;
-   stroker_line_to(stroker, x, y);
-}
-
-static void stroke_curve(struct arc_cb *cb, struct bezier *bezier)
-{
-   struct stroker *stroker = (struct stroker*)cb->user_data;
-   stroker_curve_to(stroker,
-                    bezier->x2, bezier->y2,
-                    bezier->x3, bezier->y3,
-                    bezier->x4, bezier->y4);
-}
-
-static void stroke_emit_point(struct arc_cb *cb, VGfloat x, VGfloat y)
-{
-   struct stroker *stroker = (struct stroker*)cb->user_data;
-   stroker_emit_line_to(stroker, x, y);
-}
-
-static void stroke_emit_curve(struct arc_cb *cb, struct bezier *bezier)
-{
-   struct stroker *stroker = (struct stroker*)cb->user_data;
-   stroker_emit_curve_to(stroker,
-                         bezier->x2, bezier->y2,
-                         bezier->x3, bezier->y3,
-                         bezier->x4, bezier->y4);
-}
-
-static void arc_path_move(struct arc_cb *cb, VGfloat x, VGfloat y)
-{
-   struct path *path = (struct path*)cb->user_data;
-   path_move_to(path, x, y);
-}
-
-static void arc_path_point(struct arc_cb *cb, VGfloat x, VGfloat y)
-{
-   struct path *path = (struct path*)cb->user_data;
-   path_line_to(path, x, y);
-}
-
-static void arc_path_bezier(struct arc_cb *cb, struct bezier *bezier)
-{
-   struct path *path = (struct path*)cb->user_data;
-   path_cubic_to(path,
-                 bezier->x2, bezier->y2,
-                 bezier->x3, bezier->y3,
-                 bezier->x4, bezier->y4);
-}
-
-static INLINE int num_beziers_needed(struct arc *arc)
-{
-   double threshold = 0.05;
-   VGboolean found = VG_FALSE;
-   int n = 1;
-   double min_eta, max_eta;
-
-   min_eta = MIN2(arc->eta1, arc->eta2);
-   max_eta = MAX2(arc->eta1, arc->eta2);
-
-   while ((! found) && (n < 1024)) {
-      double d_eta = (max_eta - min_eta) / n;
-      if (d_eta <= 0.5 * M_PI) {
-         double eta_b = min_eta;
-         int i;
-         found = VG_TRUE;
-         for (i = 0; found && (i < n); ++i) {
-            double etaA = eta_b;
-            eta_b += d_eta;
-            found = (estimate_error(arc, etaA, eta_b) <= threshold);
-         }
-      }
-      n = n << 1;
-   }
-
-   return n;
-}
-
-static void arc_to_beziers(struct arc *arc,
-                           struct arc_cb cb,
-                           struct matrix *matrix)
-{
-   int i;
-   int n = 1;
-   double d_eta, eta_b, cos_eta_b,
-      sin_eta_b, a_cos_eta_b, b_sin_eta_b, a_sin_eta_b,
-      b_cos_eta_b, x_b, y_b, x_b_dot, y_b_dot, lx, ly;
-   double t, alpha;
-
-   { /* always move to the start of the arc */
-      VGfloat x = arc->x1;
-      VGfloat y = arc->y1;
-      matrix_map_point(matrix, x, y, &x, &y);
-      cb.move(&cb, x, y);
-   }
-
-   if (!arc->is_valid) {
-      VGfloat x = arc->x2;
-      VGfloat y = arc->y2;
-      matrix_map_point(matrix, x, y, &x, &y);
-      cb.point(&cb, x, y);
-      return;
-   }
-
-   /* find the number of Bézier curves needed */
-   n = num_beziers_needed(arc);
-
-   d_eta = (arc->eta2 - arc->eta1) / n;
-   eta_b = arc->eta1;
-
-   cos_eta_b  = cos(eta_b);
-   sin_eta_b  = sin(eta_b);
-   a_cos_eta_b = arc->a * cos_eta_b;
-   b_sin_eta_b = arc->b * sin_eta_b;
-   a_sin_eta_b = arc->a * sin_eta_b;
-   b_cos_eta_b = arc->b * cos_eta_b;
-   x_b       = arc->cx + a_cos_eta_b * arc->cos_theta -
-               b_sin_eta_b * arc->sin_theta;
-   y_b       = arc->cy + a_cos_eta_b * arc->sin_theta +
-               b_sin_eta_b * arc->cos_theta;
-   x_b_dot    = -a_sin_eta_b * arc->cos_theta -
-                b_cos_eta_b * arc->sin_theta;
-   y_b_dot    = -a_sin_eta_b * arc->sin_theta +
-                b_cos_eta_b * arc->cos_theta;
-
-   {
-      VGfloat x = x_b, y = y_b;
-      matrix_map_point(matrix, x, y, &x, &y);
-      cb.point(&cb, x, y);
-   }
-   lx = x_b;
-   ly = y_b;
-
-   t     = tan(0.5 * d_eta);
-   alpha = sin(d_eta) * (sqrt(4 + 3 * t * t) - 1) / 3;
-
-   for (i = 0; i < n; ++i) {
-      struct bezier bezier;
-      double xA    = x_b;
-      double yA    = y_b;
-      double xADot = x_b_dot;
-      double yADot = y_b_dot;
-
-      eta_b    += d_eta;
-      cos_eta_b  = cos(eta_b);
-      sin_eta_b  = sin(eta_b);
-      a_cos_eta_b = arc->a * cos_eta_b;
-      b_sin_eta_b = arc->b * sin_eta_b;
-      a_sin_eta_b = arc->a * sin_eta_b;
-      b_cos_eta_b = arc->b * cos_eta_b;
-      x_b       = arc->cx + a_cos_eta_b * arc->cos_theta -
-                  b_sin_eta_b * arc->sin_theta;
-      y_b       = arc->cy + a_cos_eta_b * arc->sin_theta +
-                  b_sin_eta_b * arc->cos_theta;
-      x_b_dot    = -a_sin_eta_b * arc->cos_theta -
-                   b_cos_eta_b * arc->sin_theta;
-      y_b_dot    = -a_sin_eta_b * arc->sin_theta +
-                   b_cos_eta_b * arc->cos_theta;
-
-      bezier_init(&bezier,
-                  lx, ly,
-                  (float) (xA + alpha * xADot), (float) (yA + alpha * yADot),
-                  (float) (x_b - alpha * x_b_dot), (float) (y_b - alpha * y_b_dot),
-                  (float) x_b,                   (float) y_b);
-#if 0
-      debug_printf("%d) Bezier (%f, %f), (%f, %f), (%f, %f), (%f, %f)\n",
-                   i,
-                   bezier.x1, bezier.y1,
-                   bezier.x2, bezier.y2,
-                   bezier.x3, bezier.y3,
-                   bezier.x4, bezier.y4);
-#endif
-      bezier_transform(&bezier, matrix);
-      cb.bezier(&cb, &bezier);
-      lx = x_b;
-      ly = y_b;
-   }
-}
-
-
-void arc_add_to_polygon(struct arc *arc,
-                        struct polygon *poly,
-                        struct matrix *matrix)
-{
-   struct arc_cb cb;
-
-   cb.move = cb_null_move;
-   cb.point = polygon_point;
-   cb.bezier = polygon_bezier;
-   cb.user_data = poly;
-
-   arc_to_beziers(arc, cb, matrix);
-}
-
-void arc_stroke_cb(struct arc *arc,
-                   struct stroker *stroke,
-                   struct matrix *matrix)
-{
-   struct arc_cb cb;
-
-   cb.move = cb_null_move;
-   cb.point = stroke_point;
-   cb.bezier = stroke_curve;
-   cb.user_data = stroke;
-
-   arc_to_beziers(arc, cb, matrix);
-}
-
-void arc_stroker_emit(struct arc *arc,
-                      struct stroker *stroker,
-                      struct matrix *matrix)
-{
-   struct arc_cb cb;
-
-   cb.move = cb_null_move;
-   cb.point = stroke_emit_point;
-   cb.bezier = stroke_emit_curve;
-   cb.user_data = stroker;
-
-   arc_to_beziers(arc, cb, matrix);
-}
-
-void arc_to_path(struct arc *arc,
-                 struct path *path,
-                 struct matrix *matrix)
-{
-   struct arc_cb cb;
-
-   cb.move = arc_path_move;
-   cb.point = arc_path_point;
-   cb.bezier = arc_path_bezier;
-   cb.user_data = path;
-
-   arc_to_beziers(arc, cb, matrix);
-}
diff --git a/src/gallium/state_trackers/vega/arc.h b/src/gallium/state_trackers/vega/arc.h
deleted file mode 100644
index 3205cd5021d..00000000000
--- a/src/gallium/state_trackers/vega/arc.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef ARC_H
-#define ARC_H
-
-#include "VG/openvg.h"
-
-struct polygon;
-struct matrix;
-struct stroker;
-struct path;
-
-struct arc {
-   VGPathSegment type;
-
-   VGfloat cx, cy;
-
-   VGfloat a, b;
-
-   VGfloat theta;
-   VGfloat cos_theta, sin_theta;
-
-   VGfloat eta1;
-   VGfloat eta2;
-
-   VGfloat x1, y1, x2, y2;
-
-   VGboolean is_valid;
-};
-
-void arc_init(struct arc *arc,
-              VGPathSegment type,
-              VGfloat x1, VGfloat y1,
-              VGfloat x2, VGfloat y2,
-              VGfloat rh, VGfloat rv,
-              VGfloat rot);
-
-void arc_add_to_polygon(struct arc *arc,
-                        struct polygon *poly,
-                        struct matrix *matrix);
-
-
-void arc_to_path(struct arc *arc,
-                 struct path *p,
-                 struct matrix *matrix);
-
-void arc_stroke_cb(struct arc *arc,
-                   struct stroker *stroke,
-                   struct matrix *matrix);
-
-void arc_stroker_emit(struct arc *arc,
-                      struct stroker *stroke,
-                      struct matrix *matrix);
-
-
-#endif
diff --git a/src/gallium/state_trackers/vega/asm_fill.h b/src/gallium/state_trackers/vega/asm_fill.h
deleted file mode 100644
index 77e6a14fe99..00000000000
--- a/src/gallium/state_trackers/vega/asm_fill.h
+++ /dev/null
@@ -1,693 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef ASM_FILL_H
-#define ASM_FILL_H
-
-#include "tgsi/tgsi_ureg.h"
-
-typedef void (* ureg_func)( struct ureg_program *ureg,
-                            struct ureg_dst *out,
-                            struct ureg_src *in,
-                            struct ureg_src *sampler,
-                            struct ureg_dst *temp,
-                            struct ureg_src *constant);
-
-static INLINE void
-solid_fill( struct ureg_program *ureg,
-            struct ureg_dst *out,
-            struct ureg_src *in,
-            struct ureg_src *sampler,
-            struct ureg_dst *temp,
-            struct ureg_src *constant)
-{
-   ureg_MOV(ureg, *out, constant[2]);
-}
-
-/**
- * Perform frag-coord-to-paint-coord transform.  The transformation is in
- * CONST[4..6].
- */
-#define PAINT_TRANSFORM                                                 \
-   ureg_MOV(ureg, ureg_writemask(temp[0], TGSI_WRITEMASK_XY), in[0]);   \
-   ureg_MOV(ureg,                                                       \
-            ureg_writemask(temp[0], TGSI_WRITEMASK_Z),                  \
-            ureg_scalar(constant[3], TGSI_SWIZZLE_Y));                  \
-   ureg_DP3(ureg, temp[1], constant[4], ureg_src(temp[0]));             \
-   ureg_DP3(ureg, temp[2], constant[5], ureg_src(temp[0]));             \
-   ureg_DP3(ureg, temp[3], constant[6], ureg_src(temp[0]));             \
-   ureg_RCP(ureg, temp[3], ureg_src(temp[3]));                          \
-   ureg_MUL(ureg, temp[1], ureg_src(temp[1]), ureg_src(temp[3]));       \
-   ureg_MUL(ureg, temp[2], ureg_src(temp[2]), ureg_src(temp[3]));       \
-   ureg_MOV(ureg,                                                       \
-            ureg_writemask(temp[4], TGSI_WRITEMASK_X),                  \
-            ureg_src(temp[1]));                                         \
-   ureg_MOV(ureg,                                                       \
-            ureg_writemask(temp[4], TGSI_WRITEMASK_Y),                  \
-            ureg_src(temp[2]));
-
-static INLINE void
-linear_grad( struct ureg_program *ureg,
-             struct ureg_dst *out,
-             struct ureg_src *in,
-             struct ureg_src *sampler,
-             struct ureg_dst *temp,
-             struct ureg_src *constant)
-{
-   PAINT_TRANSFORM
-
-   /* grad = DP2((x, y), CONST[2].xy) * CONST[2].z */
-   ureg_MUL(ureg, temp[0],
-            ureg_scalar(constant[2], TGSI_SWIZZLE_Y),
-            ureg_scalar(ureg_src(temp[4]), TGSI_SWIZZLE_Y));
-   ureg_MAD(ureg, temp[1],
-            ureg_scalar(constant[2], TGSI_SWIZZLE_X),
-            ureg_scalar(ureg_src(temp[4]), TGSI_SWIZZLE_X),
-            ureg_src(temp[0]));
-   ureg_MUL(ureg, temp[2], ureg_src(temp[1]),
-            ureg_scalar(constant[2], TGSI_SWIZZLE_Z));
-
-   ureg_TEX(ureg, *out, TGSI_TEXTURE_1D, ureg_src(temp[2]), sampler[0]);
-}
-
-static INLINE void
-radial_grad( struct ureg_program *ureg,
-             struct ureg_dst *out,
-             struct ureg_src *in,
-             struct ureg_src *sampler,
-             struct ureg_dst *temp,
-             struct ureg_src *constant)
-{
-   PAINT_TRANSFORM
-
-   /*
-    * Calculate (sqrt(B^2 + AC) - B) / A, where
-    *
-    *   A is CONST[2].z,
-    *   B is DP2((x, y), CONST[2].xy), and
-    *   C is DP2((x, y), (x, y)).
-    */
-
-   /* B and C */
-   ureg_DP2(ureg, temp[0], ureg_src(temp[4]), constant[2]);
-   ureg_DP2(ureg, temp[1], ureg_src(temp[4]), ureg_src(temp[4]));
-
-   /* the square root */
-   ureg_MUL(ureg, temp[2], ureg_src(temp[0]), ureg_src(temp[0]));
-   ureg_MAD(ureg, temp[3], ureg_src(temp[1]),
-         ureg_scalar(constant[2], TGSI_SWIZZLE_Z), ureg_src(temp[2]));
-   ureg_RSQ(ureg, temp[3], ureg_src(temp[3]));
-   ureg_RCP(ureg, temp[3], ureg_src(temp[3]));
-
-   ureg_SUB(ureg, temp[3], ureg_src(temp[3]), ureg_src(temp[0]));
-   ureg_RCP(ureg, temp[0], ureg_scalar(constant[2], TGSI_SWIZZLE_Z));
-   ureg_MUL(ureg, temp[0], ureg_src(temp[0]), ureg_src(temp[3]));
-
-   ureg_TEX(ureg, *out, TGSI_TEXTURE_1D, ureg_src(temp[0]), sampler[0]);
-}
-
-
-static INLINE void
-pattern( struct ureg_program *ureg,
-         struct ureg_dst     *out,
-         struct ureg_src     *in,
-         struct ureg_src     *sampler,
-         struct ureg_dst     *temp,
-         struct ureg_src     *constant)
-{
-   PAINT_TRANSFORM
-
-   /* (s, t) = (x / tex_width, y / tex_height) */
-   ureg_RCP(ureg, temp[0],
-            ureg_swizzle(constant[3],
-                         TGSI_SWIZZLE_Z,
-                         TGSI_SWIZZLE_W,
-                         TGSI_SWIZZLE_Z,
-                         TGSI_SWIZZLE_W));
-   ureg_MOV(ureg, temp[1], ureg_src(temp[4]));
-   ureg_MUL(ureg,
-            ureg_writemask(temp[1], TGSI_WRITEMASK_X),
-            ureg_src(temp[1]),
-            ureg_src(temp[0]));
-   ureg_MUL(ureg,
-            ureg_writemask(temp[1], TGSI_WRITEMASK_Y),
-            ureg_src(temp[1]),
-            ureg_src(temp[0]));
-
-   ureg_TEX(ureg, *out, TGSI_TEXTURE_2D, ureg_src(temp[1]), sampler[0]);
-}
-
-static INLINE void
-paint_degenerate( struct ureg_program *ureg,
-                  struct ureg_dst *out,
-                  struct ureg_src *in,
-                  struct ureg_src *sampler,
-                  struct ureg_dst *temp,
-                  struct ureg_src *constant)
-{
-   /* CONST[3].y is 1.0f */
-   ureg_MOV(ureg, temp[1], ureg_scalar(constant[3], TGSI_SWIZZLE_Y));
-   ureg_TEX(ureg, *out, TGSI_TEXTURE_1D, ureg_src(temp[1]), sampler[0]);
-}
-
-static INLINE void
-image_normal( struct ureg_program *ureg,
-              struct ureg_dst *out,
-              struct ureg_src *in,
-              struct ureg_src *sampler,
-              struct ureg_dst *temp,
-              struct ureg_src *constant)
-{
-   /* store and pass image color in TEMP[1] */
-   ureg_TEX(ureg, temp[1], TGSI_TEXTURE_2D, in[1], sampler[3]);
-   ureg_MOV(ureg, *out, ureg_src(temp[1]));
-}
-
-
-static INLINE void
-image_multiply( struct ureg_program *ureg,
-                struct ureg_dst *out,
-                struct ureg_src *in,
-                struct ureg_src *sampler,
-                struct ureg_dst *temp,
-                struct ureg_src *constant)
-{
-   /* store and pass image color in TEMP[1] */
-   ureg_TEX(ureg, temp[1], TGSI_TEXTURE_2D, in[1], sampler[3]);
-   ureg_MUL(ureg, *out, ureg_src(temp[0]), ureg_src(temp[1]));
-}
-
-
-static INLINE void
-image_stencil( struct ureg_program *ureg,
-               struct ureg_dst *out,
-               struct ureg_src *in,
-               struct ureg_src *sampler,
-               struct ureg_dst *temp,
-               struct ureg_src *constant)
-{
-   /* store and pass image color in TEMP[1] */
-   ureg_TEX(ureg, temp[1], TGSI_TEXTURE_2D, in[1], sampler[3]);
-   ureg_MOV(ureg, *out, ureg_src(temp[0]));
-}
-
-static INLINE void
-color_transform( struct ureg_program *ureg,
-                 struct ureg_dst *out,
-                 struct ureg_src *in,
-                 struct ureg_src *sampler,
-                 struct ureg_dst *temp,
-                 struct ureg_src *constant)
-{
-   /* note that TEMP[1] may already be used for image color */
-
-   ureg_MAD(ureg, temp[2], ureg_src(temp[0]), constant[0], constant[1]);
-   /* clamp to [0.0f, 1.0f] */
-   ureg_CLAMP(ureg, temp[2],
-              ureg_src(temp[2]),
-              ureg_scalar(constant[3], TGSI_SWIZZLE_X),
-              ureg_scalar(constant[3], TGSI_SWIZZLE_Y));
-   ureg_MOV(ureg, *out, ureg_src(temp[2]));
-}
-
-static INLINE void
-alpha_normal( struct ureg_program *ureg,
-              struct ureg_dst *out,
-              struct ureg_src *in,
-              struct ureg_src *sampler,
-              struct ureg_dst *temp,
-              struct ureg_src *constant)
-{
-   /* save per-channel alpha in TEMP[1] */
-   ureg_MOV(ureg, temp[1], ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_W));
-
-   ureg_MOV(ureg, *out, ureg_src(temp[0]));
-}
-
-static INLINE void
-alpha_per_channel( struct ureg_program *ureg,
-                   struct ureg_dst *out,
-                   struct ureg_src *in,
-                   struct ureg_src *sampler,
-                   struct ureg_dst *temp,
-                   struct ureg_src *constant)
-{
-   /* save per-channel alpha in TEMP[1] */
-   ureg_MUL(ureg,
-            ureg_writemask(temp[1], TGSI_WRITEMASK_W),
-            ureg_src(temp[0]),
-            ureg_src(temp[1]));
-   ureg_MUL(ureg,
-            ureg_writemask(temp[1], TGSI_WRITEMASK_XYZ),
-            ureg_src(temp[1]),
-            ureg_scalar(ureg_src(temp[1]), TGSI_SWIZZLE_W));
-
-   /* update alpha */
-   ureg_MOV(ureg,
-            ureg_writemask(temp[0], TGSI_WRITEMASK_W),
-            ureg_src(temp[1]));
-   ureg_MOV(ureg, *out, ureg_src(temp[0]));
-}
-
-/**
- * Premultiply src and dst.
- */
-static INLINE void
-blend_premultiply( struct ureg_program *ureg,
-                   struct ureg_src src,
-                   struct ureg_src src_channel_alpha,
-                   struct ureg_src dst)
-{
-   /* premultiply src */
-   ureg_MUL(ureg,
-            ureg_writemask(ureg_dst(src), TGSI_WRITEMASK_XYZ),
-            src,
-            src_channel_alpha);
-   /* premultiply dst */
-   ureg_MUL(ureg,
-            ureg_writemask(ureg_dst(dst), TGSI_WRITEMASK_XYZ),
-            dst,
-            ureg_scalar(dst, TGSI_SWIZZLE_W));
-}
-
-/**
- * Unpremultiply src.
- */
-static INLINE void
-blend_unpremultiply( struct ureg_program *ureg,
-                     struct ureg_src src,
-                     struct ureg_src one,
-                     struct ureg_dst temp[1])
-{
-   /* replace 0.0f by 1.0f before calculating reciprocal */
-   ureg_CMP(ureg,
-            temp[0],
-            ureg_negate(ureg_scalar(src, TGSI_SWIZZLE_W)),
-            ureg_scalar(src, TGSI_SWIZZLE_W),
-            one);
-   ureg_RCP(ureg, temp[0], ureg_src(temp[0]));
-
-   ureg_MUL(ureg,
-            ureg_writemask(ureg_dst(src), TGSI_WRITEMASK_XYZ),
-            src,
-            ureg_src(temp[0]));
-}
-
-/**
- * Emit instructions for the specified blend mode.  Colors will be
- * unpremultiplied.  Two temporary registers are required.
- *
- * The output is written back to src.
- */
-static INLINE void
-blend_generic(struct ureg_program *ureg,
-              VGBlendMode mode,
-              struct ureg_src src,
-              struct ureg_src src_channel_alpha,
-              struct ureg_src dst,
-              struct ureg_src one,
-              struct ureg_dst temp[2])
-{
-   struct ureg_dst out;
-
-   blend_premultiply(ureg, src, src_channel_alpha, dst);
-
-   /* blend in-place */
-   out = ureg_dst(src);
-
-   switch (mode) {
-   case VG_BLEND_SRC:
-      ureg_MOV(ureg, out, src);
-      break;
-   case VG_BLEND_SRC_OVER:
-      /* RGBA_out = RGBA_src + (1 - A_src) * RGBA_dst */
-      ureg_SUB(ureg, temp[0], one, src_channel_alpha);
-      ureg_MAD(ureg, out, ureg_src(temp[0]), dst, src);
-      break;
-   case VG_BLEND_DST_OVER:
-      /* RGBA_out = RGBA_dst + (1 - A_dst) * RGBA_src */
-      ureg_SUB(ureg, temp[0], one, ureg_scalar(dst, TGSI_SWIZZLE_W));
-      ureg_MAD(ureg, out, ureg_src(temp[0]), src, dst);
-      break;
-   case VG_BLEND_SRC_IN:
-      ureg_MUL(ureg, out, src, ureg_scalar(dst, TGSI_SWIZZLE_W));
-      break;
-   case VG_BLEND_DST_IN:
-      ureg_MUL(ureg, out, dst, src_channel_alpha);
-      break;
-   case VG_BLEND_MULTIPLY:
-      /*
-       * RGB_out = (1 - A_dst) * RGB_src + (1 - A_src) * RGB_dst +
-       *           RGB_src * RGB_dst
-       */
-      ureg_MAD(ureg, temp[0],
-            ureg_scalar(dst, TGSI_SWIZZLE_W), ureg_negate(src), src);
-      ureg_MAD(ureg, temp[1],
-            src_channel_alpha, ureg_negate(dst), dst);
-      ureg_MAD(ureg, temp[0], src, dst, ureg_src(temp[0]));
-      ureg_ADD(ureg, out, ureg_src(temp[0]), ureg_src(temp[1]));
-      /* alpha is src over */
-      ureg_ADD(ureg, ureg_writemask(out, TGSI_WRITEMASK_W),
-            src, ureg_src(temp[1]));
-      break;
-   case VG_BLEND_SCREEN:
-      /* RGBA_out = RGBA_src + (1 - RGBA_src) * RGBA_dst */
-      ureg_SUB(ureg, temp[0], one, src);
-      ureg_MAD(ureg, out, ureg_src(temp[0]), dst, src);
-      break;
-   case VG_BLEND_DARKEN:
-   case VG_BLEND_LIGHTEN:
-      /* src over */
-      ureg_SUB(ureg, temp[0], one, src_channel_alpha);
-      ureg_MAD(ureg, temp[0], ureg_src(temp[0]), dst, src);
-      /* dst over */
-      ureg_SUB(ureg, temp[1], one, ureg_scalar(dst, TGSI_SWIZZLE_W));
-      ureg_MAD(ureg, temp[1], ureg_src(temp[1]), src, dst);
-      /* take min/max for colors */
-      if (mode == VG_BLEND_DARKEN) {
-         ureg_MIN(ureg, ureg_writemask(out, TGSI_WRITEMASK_XYZ),
-               ureg_src(temp[0]), ureg_src(temp[1]));
-      }
-      else {
-         ureg_MAX(ureg, ureg_writemask(out, TGSI_WRITEMASK_XYZ),
-               ureg_src(temp[0]), ureg_src(temp[1]));
-      }
-      break;
-   case VG_BLEND_ADDITIVE:
-      /* RGBA_out = RGBA_src + RGBA_dst */
-      ureg_ADD(ureg, temp[0], src, dst);
-      ureg_MIN(ureg, out, ureg_src(temp[0]), one);
-      break;
-   default:
-      assert(0);
-      break;
-   }
-
-   blend_unpremultiply(ureg, src, one, temp);
-}
-
-#define BLEND_GENERIC(mode) \
-   do { \
-      ureg_TEX(ureg, temp[2], TGSI_TEXTURE_2D, in[0], sampler[2]);         \
-      blend_generic(ureg, (mode), ureg_src(temp[0]), ureg_src(temp[1]),    \
-                    ureg_src(temp[2]),                                     \
-                    ureg_scalar(constant[3], TGSI_SWIZZLE_Y), temp + 3);   \
-      ureg_MOV(ureg, *out, ureg_src(temp[0]));                             \
-   } while (0)
-
-static INLINE void
-blend_src( struct ureg_program *ureg,
-           struct ureg_dst *out,
-           struct ureg_src *in,
-           struct ureg_src *sampler,
-           struct ureg_dst *temp,
-           struct ureg_src *constant)
-{
-   BLEND_GENERIC(VG_BLEND_SRC);
-}
-
-static INLINE void
-blend_src_over( struct ureg_program *ureg,
-                struct ureg_dst *out,
-                struct ureg_src *in,
-                struct ureg_src *sampler,
-                struct ureg_dst *temp,
-                struct ureg_src *constant)
-{
-   BLEND_GENERIC(VG_BLEND_SRC_OVER);
-}
-
-static INLINE void
-blend_dst_over( struct ureg_program *ureg,
-                struct ureg_dst *out,
-                struct ureg_src *in,
-                struct ureg_src *sampler,
-                struct ureg_dst *temp,
-                struct ureg_src *constant)
-{
-   BLEND_GENERIC(VG_BLEND_DST_OVER);
-}
-
-static INLINE void
-blend_src_in( struct ureg_program *ureg,
-              struct ureg_dst *out,
-              struct ureg_src *in,
-              struct ureg_src *sampler,
-              struct ureg_dst *temp,
-              struct ureg_src *constant)
-{
-   BLEND_GENERIC(VG_BLEND_SRC_IN);
-}
-
-static INLINE void
-blend_dst_in( struct ureg_program *ureg,
-              struct ureg_dst *out,
-              struct ureg_src *in,
-              struct ureg_src *sampler,
-              struct ureg_dst *temp,
-              struct ureg_src *constant)
-{
-   BLEND_GENERIC(VG_BLEND_DST_IN);
-}
-
-static INLINE void
-blend_multiply( struct ureg_program *ureg,
-                struct ureg_dst *out,
-                struct ureg_src *in,
-                struct ureg_src *sampler,
-                struct ureg_dst *temp,
-                struct ureg_src *constant)
-{
-   BLEND_GENERIC(VG_BLEND_MULTIPLY);
-}
-
-static INLINE void
-blend_screen( struct ureg_program *ureg,
-              struct ureg_dst     *out,
-              struct ureg_src     *in,
-              struct ureg_src     *sampler,
-              struct ureg_dst     *temp,
-              struct ureg_src     *constant)
-{
-   BLEND_GENERIC(VG_BLEND_SCREEN);
-}
-
-static INLINE void
-blend_darken( struct ureg_program *ureg,
-              struct ureg_dst     *out,
-              struct ureg_src     *in,
-              struct ureg_src     *sampler,
-              struct ureg_dst     *temp,
-              struct ureg_src     *constant)
-{
-   BLEND_GENERIC(VG_BLEND_DARKEN);
-}
-
-static INLINE void
-blend_lighten( struct ureg_program *ureg,
-               struct ureg_dst     *out,
-               struct ureg_src     *in,
-               struct ureg_src     *sampler,
-               struct ureg_dst *temp,
-               struct ureg_src     *constant)
-{
-   BLEND_GENERIC(VG_BLEND_LIGHTEN);
-}
-
-static INLINE void
-blend_additive( struct ureg_program *ureg,
-                struct ureg_dst *out,
-                struct ureg_src *in,
-                struct ureg_src *sampler,
-                struct ureg_dst *temp,
-                struct ureg_src *constant)
-{
-   BLEND_GENERIC(VG_BLEND_ADDITIVE);
-}
-
-static INLINE void
-mask( struct ureg_program *ureg,
-      struct ureg_dst *out,
-      struct ureg_src *in,
-      struct ureg_src *sampler,
-      struct ureg_dst *temp,
-      struct ureg_src *constant)
-{
-   ureg_TEX(ureg, temp[1], TGSI_TEXTURE_2D, in[0], sampler[1]);
-   ureg_MUL(ureg, ureg_writemask(temp[0], TGSI_WRITEMASK_W),
-            ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_W),
-            ureg_scalar(ureg_src(temp[1]), TGSI_SWIZZLE_W));
-   ureg_MOV(ureg, *out, ureg_src(temp[0]));
-}
-
-static INLINE void
-premultiply( struct ureg_program *ureg,
-                struct ureg_dst *out,
-                struct ureg_src *in,
-                struct ureg_src *sampler,
-                struct ureg_dst *temp,
-                struct ureg_src *constant)
-{
-   ureg_MUL(ureg,
-            ureg_writemask(temp[0], TGSI_WRITEMASK_XYZ),
-            ureg_src(temp[0]),
-            ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_W));
-}
-
-static INLINE void
-unpremultiply( struct ureg_program *ureg,
-                struct ureg_dst *out,
-                struct ureg_src *in,
-                struct ureg_src *sampler,
-                struct ureg_dst *temp,
-                struct ureg_src *constant)
-{
-   ureg_TEX(ureg, temp[0], TGSI_TEXTURE_2D, in[0], sampler[1]);
-}
-
-
-static INLINE void
-color_bw( struct ureg_program *ureg,
-                struct ureg_dst *out,
-                struct ureg_src *in,
-                struct ureg_src *sampler,
-                struct ureg_dst *temp,
-                struct ureg_src *constant)
-{
-   ureg_ADD(ureg, temp[1],
-            ureg_scalar(constant[3], TGSI_SWIZZLE_Y),
-            ureg_scalar(constant[3], TGSI_SWIZZLE_Y));
-   ureg_RCP(ureg, temp[2], ureg_src(temp[1]));
-   ureg_ADD(ureg, temp[1],
-            ureg_scalar(constant[3], TGSI_SWIZZLE_Y),
-            ureg_src(temp[2]));
-   ureg_ADD(ureg, ureg_writemask(temp[2], TGSI_WRITEMASK_X),
-            ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_X),
-            ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_Y));
-   ureg_ADD(ureg, ureg_writemask(temp[2], TGSI_WRITEMASK_X),
-            ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_Z),
-            ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_X));
-   ureg_SGE(ureg,
-            ureg_writemask(temp[0], TGSI_WRITEMASK_XYZ),
-            ureg_scalar(ureg_src(temp[2]), TGSI_SWIZZLE_X),
-            ureg_src(temp[1]));
-  ureg_SGE(ureg,
-           ureg_writemask(temp[0], TGSI_WRITEMASK_W),
-           ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_W),
-           ureg_scalar(ureg_src(temp[2]), TGSI_SWIZZLE_Y));
-  ureg_MOV(ureg, *out, ureg_src(temp[0]));
-}
-
-
-struct shader_asm_info {
-   VGint id;
-   ureg_func func;
-
-   VGboolean needs_position;
-
-   VGint start_const;
-   VGint num_consts;
-
-   VGint start_sampler;
-   VGint num_samplers;
-
-   VGint start_temp;
-   VGint num_temps;
-};
-
-
-/* paint types */
-static const struct shader_asm_info shaders_paint_asm[] = {
-   {VEGA_SOLID_FILL_SHADER, solid_fill,
-    VG_FALSE, 2, 1, 0, 0, 0, 0},
-   {VEGA_LINEAR_GRADIENT_SHADER, linear_grad,
-    VG_TRUE,  2, 5, 0, 1, 0, 5},
-   {VEGA_RADIAL_GRADIENT_SHADER, radial_grad,
-    VG_TRUE,  2, 5, 0, 1, 0, 5},
-   {VEGA_PATTERN_SHADER, pattern,
-    VG_TRUE,  3, 4, 0, 1, 0, 5},
-   {VEGA_PAINT_DEGENERATE_SHADER, paint_degenerate,
-    VG_FALSE,  3, 1, 0, 1, 0, 2}
-};
-
-/* image draw modes */
-static const struct shader_asm_info shaders_image_asm[] = {
-   {VEGA_IMAGE_NORMAL_SHADER, image_normal,
-    VG_TRUE,  0, 0, 3, 1, 0, 2},
-   {VEGA_IMAGE_MULTIPLY_SHADER, image_multiply,
-    VG_TRUE,  0, 0, 3, 1, 0, 2},
-   {VEGA_IMAGE_STENCIL_SHADER, image_stencil,
-    VG_TRUE,  0, 0, 3, 1, 0, 2}
-};
-
-static const struct shader_asm_info shaders_color_transform_asm[] = {
-   {VEGA_COLOR_TRANSFORM_SHADER, color_transform,
-    VG_FALSE, 0, 4, 0, 0, 0, 3}
-};
-
-static const struct shader_asm_info shaders_alpha_asm[] = {
-   {VEGA_ALPHA_NORMAL_SHADER, alpha_normal,
-    VG_FALSE, 0, 0, 0, 0, 0, 2},
-   {VEGA_ALPHA_PER_CHANNEL_SHADER, alpha_per_channel,
-    VG_FALSE, 0, 0, 0, 0, 0, 2}
-};
-
-/* extra blend modes */
-static const struct shader_asm_info shaders_blend_asm[] = {
-#define BLEND_ASM_INFO(id, func) { (id), (func), VG_TRUE, 3, 1, 2, 1, 0, 5 }
-   BLEND_ASM_INFO(VEGA_BLEND_SRC_SHADER, blend_src),
-   BLEND_ASM_INFO(VEGA_BLEND_SRC_OVER_SHADER, blend_src_over),
-   BLEND_ASM_INFO(VEGA_BLEND_DST_OVER_SHADER, blend_dst_over),
-   BLEND_ASM_INFO(VEGA_BLEND_SRC_IN_SHADER, blend_src_in),
-   BLEND_ASM_INFO(VEGA_BLEND_DST_IN_SHADER, blend_dst_in),
-   BLEND_ASM_INFO(VEGA_BLEND_MULTIPLY_SHADER, blend_multiply),
-   BLEND_ASM_INFO(VEGA_BLEND_SCREEN_SHADER, blend_screen),
-   BLEND_ASM_INFO(VEGA_BLEND_DARKEN_SHADER, blend_darken),
-   BLEND_ASM_INFO(VEGA_BLEND_LIGHTEN_SHADER, blend_lighten),
-   BLEND_ASM_INFO(VEGA_BLEND_ADDITIVE_SHADER, blend_additive)
-#undef BLEND_ASM_INFO
-};
-
-static const struct shader_asm_info shaders_mask_asm[] = {
-   {VEGA_MASK_SHADER, mask,
-    VG_TRUE,  0, 0, 1, 1, 0, 2}
-};
-
-/* premultiply */
-static const struct shader_asm_info shaders_premultiply_asm[] = {
-   {VEGA_PREMULTIPLY_SHADER, premultiply,
-    VG_FALSE,  0, 0, 0, 0, 0, 1},
-   {VEGA_UNPREMULTIPLY_SHADER, unpremultiply,
-    VG_FALSE,  0, 0, 0, 0, 0, 1},
-};
-
-/* color transform to black and white */
-static const struct shader_asm_info shaders_bw_asm[] = {
-   {VEGA_BW_SHADER, color_bw,
-    VG_FALSE,  3, 1, 0, 0, 0, 3},
-};
-
-#endif
diff --git a/src/gallium/state_trackers/vega/asm_filters.h b/src/gallium/state_trackers/vega/asm_filters.h
deleted file mode 100644
index 60bed197e28..00000000000
--- a/src/gallium/state_trackers/vega/asm_filters.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef ASM_FILTERS_H
-#define ASM_FILTERS_H
-
-static const char color_matrix_asm[] =
-   "FRAG\n"
-   "DCL IN[0], GENERIC[0], PERSPECTIVE\n"
-   "DCL OUT[0], COLOR, CONSTANT\n"
-   "DCL CONST[0..4], CONSTANT\n"
-   "DCL TEMP[0..4], CONSTANT\n"
-   "DCL SAMP[0], CONSTANT\n"
-   "TEX TEMP[0], IN[0], SAMP[0], 2D\n"
-   "MOV TEMP[1], TEMP[0].xxxx\n"
-   "MOV TEMP[2], TEMP[0].yyyy\n"
-   "MOV TEMP[3], TEMP[0].zzzz\n"
-   "MOV TEMP[4], TEMP[0].wwww\n"
-   "MUL TEMP[1], TEMP[1], CONST[0]\n"
-   "MUL TEMP[2], TEMP[2], CONST[1]\n"
-   "MUL TEMP[3], TEMP[3], CONST[2]\n"
-   "MUL TEMP[4], TEMP[4], CONST[3]\n"
-   "ADD TEMP[0], TEMP[1], CONST[4]\n"
-   "ADD TEMP[0], TEMP[0], TEMP[2]\n"
-   "ADD TEMP[0], TEMP[0], TEMP[3]\n"
-   "ADD TEMP[0], TEMP[0], TEMP[4]\n"
-   "MOV OUT[0], TEMP[0]\n"
-   "END\n";
-
-static const char convolution_asm[] =
-   "FRAG\n"
-   "DCL IN[0], GENERIC[0], PERSPECTIVE\n"
-   "DCL OUT[0], COLOR, CONSTANT\n"
-   "DCL TEMP[0..4], CONSTANT\n"
-   "DCL ADDR[0], CONSTANT\n"
-   "DCL CONST[0..%d], CONSTANT\n"
-   "DCL SAMP[0], CONSTANT\n"
-   "0: MOV TEMP[0], CONST[0].xxxx\n"
-   "1: MOV TEMP[1], CONST[0].xxxx\n"
-   "2: BGNLOOP :14\n"
-   "3: SGE TEMP[0].z, TEMP[0].yyyy, CONST[1].xxxx\n"
-   "4: IF TEMP[0].zzzz :7\n"
-   "5: BRK\n"
-   "6: ENDIF\n"
-   "7: ARL ADDR[0].x, TEMP[0].yyyy\n"
-   "8: MOV TEMP[3], CONST[ADDR[0]+2]\n"
-   "9: ADD TEMP[4].xy, IN[0], TEMP[3]\n"
-   "10: TEX TEMP[2], TEMP[4], SAMP[0], 2D\n"
-   "11: MOV TEMP[3], CONST[ADDR[0]+%d]\n"
-   "12: MAD TEMP[1], TEMP[2], TEMP[3], TEMP[1]\n"
-   "13: ADD TEMP[0].y, TEMP[0].yyyy, CONST[0].yyyy\n"
-   "14: ENDLOOP :2\n"
-   "15: MAD OUT[0], TEMP[1], CONST[1].yyyy, CONST[1].zzzz\n"
-   "16: END\n";
-
-
-static const char lookup_asm[] =
-   "FRAG\n"
-   "DCL IN[0], GENERIC[0], PERSPECTIVE\n"
-   "DCL OUT[0], COLOR, CONSTANT\n"
-   "DCL TEMP[0..2], CONSTANT\n"
-   "DCL CONST[0], CONSTANT\n"
-   "DCL SAMP[0..1], CONSTANT\n"
-   "TEX TEMP[0], IN[0], SAMP[0], 2D\n"
-   "MOV TEMP[1], TEMP[0]\n"
-   /* do red */
-   "TEX TEMP[2], TEMP[1].xxxx, SAMP[1], 1D\n"
-   "MOV TEMP[0].x, TEMP[2].xxxx\n"
-   /* do blue */
-   "TEX TEMP[2], TEMP[1].yyyy, SAMP[1], 1D\n"
-   "MOV TEMP[0].y, TEMP[2].yyyy\n"
-   /* do green */
-   "TEX TEMP[2], TEMP[1].zzzz, SAMP[1], 1D\n"
-   "MOV TEMP[0].z, TEMP[2].zzzz\n"
-   /* do alpha */
-   "TEX TEMP[2], TEMP[1].wwww, SAMP[1], 1D\n"
-   "MOV TEMP[0].w, TEMP[2].wwww\n"
-   "MOV OUT[0], TEMP[0]\n"
-   "END\n";
-
-
-static const char lookup_single_asm[] =
-   "FRAG\n"
-   "DCL IN[0], GENERIC[0], PERSPECTIVE\n"
-   "DCL OUT[0], COLOR, CONSTANT\n"
-   "DCL TEMP[0..2], CONSTANT\n"
-   "DCL CONST[0], CONSTANT\n"
-   "DCL SAMP[0..1], CONSTANT\n"
-   "TEX TEMP[0], IN[0], SAMP[0], 2D\n"
-   "TEX TEMP[1], TEMP[0].%s, SAMP[1], 1D\n"
-   "MOV OUT[0], TEMP[1]\n"
-   "END\n";
-
-#endif
diff --git a/src/gallium/state_trackers/vega/asm_util.h b/src/gallium/state_trackers/vega/asm_util.h
deleted file mode 100644
index ae1842a62cd..00000000000
--- a/src/gallium/state_trackers/vega/asm_util.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef ASM_UTIL_H
-#define ASM_UTIL_H
-
-/* μnew = μmask */
-static const char set_mask_asm[] =
-   "FRAG\n"
-   "DCL IN[0], GENERIC[0], PERSPECTIVE\n"
-   "DCL SAMP[0], CONSTANT\n"
-   "DCL OUT[0], COLOR, CONSTANT\n"
-   "0: TEX OUT[0], IN[0], SAMP[0], 2D\n"/*umask*/
-   "1: END\n";
-
-/* μnew = 1 – (1 – μmask)*(1 – μprev) */
-static const char union_mask_asm[] =
-   "FRAG\n"
-   "DCL IN[0], GENERIC[0], PERSPECTIVE\n"
-   "DCL IN[1], POSITION, LINEAR\n"
-   "DCL CONST[0], CONSTANT\n"
-   "DCL SAMP[0..1], CONSTANT\n"
-   "DCL TEMP[0..3], CONSTANT\n"
-   "DCL OUT[0], COLOR, CONSTANT\n"
-   "0: TEX TEMP[1], IN[0], SAMP[0], 2D\n"/*umask*/
-   "1: TEX TEMP[0], IN[1], SAMP[1], 2D\n"/*uprev*/
-   "2: SUB TEMP[2], CONST[0], TEMP[0]\n"
-   "3: SUB TEMP[3], CONST[0], TEMP[1]\n"
-   "4: MUL TEMP[0].w, TEMP[2].wwww, TEMP[3].wwww\n"
-   "5: SUB OUT[0], CONST[0], TEMP[0]\n"
-   "6: END\n";
-
-/* μnew = μmask *μprev */
-static const char intersect_mask_asm[] =
-   "FRAG\n"
-   "DCL IN[0], GENERIC[0], PERSPECTIVE\n"
-   "DCL IN[1], POSITION, LINEAR\n"
-   "DCL CONST[0], CONSTANT\n"
-   "DCL SAMP[0..1], CONSTANT\n"
-   "DCL TEMP[0..1], CONSTANT\n"
-   "DCL OUT[0], COLOR, CONSTANT\n"
-   "0: TEX TEMP[0], IN[1], SAMP[1], 2D\n"/*uprev*/
-   "1: TEX TEMP[1], IN[0], SAMP[0], 2D\n"/*umask*/
-   "2: MUL OUT[0], TEMP[0].wwww, TEMP[1].wwww\n"
-   "3: END\n";
-
-/* μnew = μprev*(1 – μmask) */
-static const char subtract_mask_asm[] =
-   "FRAG\n"
-   "DCL IN[0], GENERIC[0], PERSPECTIVE\n"
-   "DCL IN[1], POSITION, LINEAR\n"
-   "DCL CONST[0], CONSTANT\n"
-   "DCL SAMP[0..1], CONSTANT\n"
-   "DCL TEMP[0..2], CONSTANT\n"
-   "DCL OUT[0], COLOR, CONSTANT\n"
-   "0: TEX TEMP[1], IN[0], SAMP[0], 2D\n"/*umask*/
-   "1: TEX TEMP[0], IN[1], SAMP[1], 2D\n"/*uprev*/
-   "2: SUB TEMP[2], CONST[0], TEMP[1]\n"
-   "3: MUL OUT[0], TEMP[2].wwww, TEMP[0].wwww\n"
-   "4: END\n";
-
-#endif
diff --git a/src/gallium/state_trackers/vega/bezier.c b/src/gallium/state_trackers/vega/bezier.c
deleted file mode 100644
index 5769e8ea868..00000000000
--- a/src/gallium/state_trackers/vega/bezier.c
+++ /dev/null
@@ -1,706 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "bezier.h"
-
-#include "matrix.h"
-#include "polygon.h"
-
-#include "pipe/p_compiler.h"
-#include "util/u_debug.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <assert.h>
-#include <math.h>
-
-static const float flatness = 0.5;
-
-
-static INLINE void split_left(struct bezier *bez, VGfloat t, struct bezier* left)
-{
-    left->x1 = bez->x1;
-    left->y1 = bez->y1;
-
-    left->x2 = bez->x1 + t * (bez->x2 - bez->x1);
-    left->y2 = bez->y1 + t * (bez->y2 - bez->y1);
-
-    left->x3 = bez->x2 + t * (bez->x3 - bez->x2);
-    left->y3 = bez->y2 + t * (bez->y3 - bez->y2);
-
-    bez->x3 = bez->x3 + t * (bez->x4 - bez->x3);
-    bez->y3 = bez->y3 + t * (bez->y4 - bez->y3);
-
-    bez->x2 = left->x3 + t * (bez->x3 - left->x3);
-    bez->y2 = left->y3 + t * (bez->y3 - left->y3);
-
-    left->x3 = left->x2 + t * (left->x3 - left->x2);
-    left->y3 = left->y2 + t * (left->y3 - left->y2);
-
-    left->x4 = bez->x1 = left->x3 + t * (bez->x2 - left->x3);
-    left->y4 = bez->y1 = left->y3 + t * (bez->y2 - left->y3);
-}
-
-static INLINE void split(struct bezier *bez,
-                         struct bezier *first_half,
-                         struct bezier *second_half)
-{
-   double c         = (bez->x2 + bez->x3) * 0.5;
-   first_half->x2  = (bez->x1 + bez->x2) * 0.5;
-   second_half->x3 = (bez->x3 + bez->x4) * 0.5;
-   first_half->x1  = bez->x1;
-   second_half->x4 = bez->x4;
-   first_half->x3  = (first_half->x2 + c) * 0.5;
-   second_half->x2 = (second_half->x3 + c) * 0.5;
-   first_half->x4  = second_half->x1 =
-                     (first_half->x3 + second_half->x2) * 0.5;
-
-   c = (bez->y2 + bez->y3) / 2;
-   first_half->y2  = (bez->y1 + bez->y2) * 0.5;
-   second_half->y3 = (bez->y3 + bez->y4) * 0.5;
-   first_half->y1  = bez->y1;
-   second_half->y4 = bez->y4;
-   first_half->y3  = (first_half->y2 + c) * 0.5;
-   second_half->y2 = (second_half->y3 + c) * 0.5;
-   first_half->y4  = second_half->y1 =
-                     (first_half->y3 + second_half->y2) * 0.5;
-}
-
-struct polygon * bezier_to_polygon(struct bezier *bez)
-{
-   struct polygon *poly = polygon_create(64);
-   polygon_vertex_append(poly, bez->x1, bez->y1);
-   bezier_add_to_polygon(bez, poly);
-   return poly;
-}
-
-void bezier_add_to_polygon(const struct bezier *bez,
-                           struct polygon *poly)
-{
-   struct bezier beziers[32];
-   struct bezier *b;
-
-   beziers[0] = *bez;
-   b = beziers;
-
-   while (b >= beziers) {
-      double y4y1 = b->y4 - b->y1;
-      double x4x1 = b->x4 - b->x1;
-      double l = ABS(x4x1) + ABS(y4y1);
-      double d;
-      if (l > 1.f) {
-         d = ABS((x4x1)*(b->y1 - b->y2) - (y4y1)*(b->x1 - b->x2))
-             + ABS((x4x1)*(b->y1 - b->y3) - (y4y1)*(b->x1 - b->x3));
-      } else {
-         d = ABS(b->x1 - b->x2) + ABS(b->y1 - b->y2) +
-             ABS(b->x1 - b->x3) + ABS(b->y1 - b->y3);
-         l = 1.;
-      }
-      if (d < flatness*l || b == beziers + 31) {
-         /* good enough, we pop it off and add the endpoint */
-         polygon_vertex_append(poly, b->x4, b->y4);
-         --b;
-      } else {
-         /* split, second half of the bezier goes lower into the stack */
-         split(b, b+1, b);
-         ++b;
-      }
-   }
-}
-
-static void add_if_close(struct bezier *bez, VGfloat *length, VGfloat error)
-{
-   struct bezier left, right;     /* bez poly splits */
-   VGfloat len = 0.0;        /* arc length */
-   VGfloat chord;            /* chord length */
-
-   len = len + line_length(bez->x1, bez->y1, bez->x2, bez->y2);
-   len = len + line_length(bez->x2, bez->y2, bez->x3, bez->y3);
-   len = len + line_length(bez->x3, bez->y3, bez->x4, bez->y4);
-
-   chord = line_length(bez->x1, bez->y1, bez->x4, bez->y4);
-
-   if ((len-chord) > error) {
-      split(bez, &left, &right);                 /* split in two */
-      add_if_close(&left, length, error);       /* try left side */
-      add_if_close(&right, length, error);      /* try right side */
-      return;
-   }
-
-   *length = *length + len;
-
-   return;
-}
-
-float bezier_length(struct bezier *bez, float error)
-{
-   VGfloat length = 0.f;
-
-   add_if_close(bez, &length, error);
-   return length;
-}
-
-void bezier_init(struct bezier *bez,
-                 float x1, float y1,
-                 float x2, float y2,
-                 float x3, float y3,
-                 float x4, float y4)
-{
-   bez->x1 = x1;
-   bez->y1 = y1;
-   bez->x2 = x2;
-   bez->y2 = y2;
-   bez->x3 = x3;
-   bez->y3 = y3;
-   bez->x4 = x4;
-   bez->y4 = y4;
-#if 0
-   debug_printf("bezier in [%f, %f, %f, %f, %f, %f]\n",
-                x1, y1, x2, y2, x3, y3, x4, y4);
-#endif
-}
-
-
-static INLINE void bezier_init2v(struct bezier *bez,
-                                 float *pt1,
-                                 float *pt2,
-                                 float *pt3,
-                                 float *pt4)
-{
-   bez->x1 = pt1[0];
-   bez->y1 = pt1[1];
-
-   bez->x2 = pt2[0];
-   bez->y2 = pt2[1];
-
-   bez->x3 = pt3[0];
-   bez->y3 = pt3[1];
-
-   bez->x4 = pt4[0];
-   bez->y4 = pt4[1];
-}
-
-
-void bezier_transform(struct bezier *bez,
-                      struct matrix *matrix)
-{
-   assert(matrix_is_affine(matrix));
-   matrix_map_point(matrix, bez->x1, bez->y1, &bez->x1, &bez->y1);
-   matrix_map_point(matrix, bez->x2, bez->y2, &bez->x2, &bez->y2);
-   matrix_map_point(matrix, bez->x3, bez->y3, &bez->x3, &bez->y3);
-   matrix_map_point(matrix, bez->x4, bez->y4, &bez->x4, &bez->y4);
-}
-
-static INLINE void bezier_point_at(const struct bezier *bez, float t, float *pt)
-{
-   float a, b, c, d;
-   float m_t;
-   m_t = 1. - t;
-   b = m_t * m_t;
-   c = t * t;
-   d = c * t;
-   a = b * m_t;
-   b *= 3. * t;
-   c *= 3. * m_t;
-   pt[0] = a*bez->x1 + b*bez->x2 + c*bez->x3 + d*bez->x4;
-   pt[1] = a*bez->y1 + b*bez->y2 + c*bez->y3 + d*bez->y4;
-}
-
-static INLINE void bezier_normal_at(const struct bezier *bez, float t, float *norm)
-{
-   float m_t = 1. - t;
-   float a = m_t * m_t;
-   float b = t * m_t;
-   float c = t * t;
-
-   norm[0] =  (bez->y2-bez->y1) * a + (bez->y3-bez->y2) * b + (bez->y4-bez->y3) * c;
-   norm[1] = -(bez->x2-bez->x1) * a - (bez->x3-bez->x2) * b - (bez->x4-bez->x3) * c;
-}
-
-enum shift_result {
-   Ok,
-   Discard,
-   Split,
-   Circle
-};
-
-static enum shift_result good_offset(const struct bezier *b1,
-                                     const struct bezier *b2,
-                                     float offset, float threshold)
-{
-   const float o2 = offset*offset;
-   const float max_dist_line = threshold*offset*offset;
-   const float max_dist_normal = threshold*offset;
-   const float spacing = 0.25;
-   float i;
-   for (i = spacing; i < 0.99; i += spacing) {
-      float p1[2],p2[2], d, l;
-      float normal[2];
-      bezier_point_at(b1, i, p1);
-      bezier_point_at(b2, i, p2);
-      d = (p1[0] - p2[0])*(p1[0] - p2[0]) + (p1[1] - p2[1])*(p1[1] - p2[1]);
-      if (ABS(d - o2) > max_dist_line)
-         return Split;
-
-      bezier_normal_at(b1, i, normal);
-      l = ABS(normal[0]) + ABS(normal[1]);
-      if (l != 0.) {
-         d = ABS(normal[0]*(p1[1] - p2[1]) - normal[1]*(p1[0] - p2[0]) ) / l;
-         if (d > max_dist_normal)
-            return Split;
-      }
-   }
-   return Ok;
-}
-
-static INLINE void shift_line_by_normal(float *l, float offset)
-{
-   float norm[4];
-   float tx, ty;
-
-   line_normal(l, norm);
-   line_normalize(norm);
-
-   tx = (norm[2] - norm[0]) * offset;
-   ty = (norm[3] - norm[1]) * offset;
-   l[0] += tx; l[1] += ty;
-   l[2] += tx; l[3] += ty;
-}
-
-static INLINE VGboolean is_bezier_line(float (*points)[2], int count)
-{
-   float dx13 = points[2][0] - points[0][0];
-   float dy13 = points[2][1] - points[0][1];
-
-   float dx12 = points[1][0] - points[0][0];
-   float dy12 = points[1][1] - points[0][1];
-
-   debug_assert(count > 2);
-
-   if (count == 3) {
-      return floatsEqual(dx12 * dy13, dx13 * dy12);
-   } else if (count == 4) {
-      float dx14 = points[3][0] - points[0][0];
-      float dy14 = points[3][1] - points[0][1];
-
-      return (floatsEqual(dx12 * dy13, dx13 * dy12) &&
-              floatsEqual(dx12 * dy14, dx14 * dy12));
-   }
-
-   return VG_FALSE;
-}
-
-static INLINE void compute_pt_normal(float *pt1, float *pt2, float *res)
-{
-   float line[4];
-   float normal[4];
-   line[0] = 0.f; line[1] = 0.f;
-   line[2] = pt2[0] - pt1[0];
-   line[3] = pt2[1] - pt1[1];
-   line_normal(line, normal);
-   line_normalize(normal);
-
-   res[0] = normal[2];
-   res[1] = normal[3];
-}
-
-static enum shift_result shift(const struct bezier *orig,
-                               struct bezier *shifted,
-                               float offset, float threshold)
-{
-   int i;
-   int map[4];
-   VGboolean p1_p2_equal = (orig->x1 == orig->x2 && orig->y1 == orig->y2);
-   VGboolean p2_p3_equal = (orig->x2 == orig->x3 && orig->y2 == orig->y3);
-   VGboolean p3_p4_equal = (orig->x3 == orig->x4 && orig->y3 == orig->y4);
-
-   float points[4][2];
-   int np = 0;
-   float bounds[4];
-   float points_shifted[4][2];
-   float prev_normal[2];
-
-   points[np][0] = orig->x1;
-   points[np][1] = orig->y1;
-   map[0] = 0;
-   ++np;
-   if (!p1_p2_equal) {
-      points[np][0] = orig->x2;
-      points[np][1] = orig->y2;
-      ++np;
-   }
-   map[1] = np - 1;
-   if (!p2_p3_equal) {
-      points[np][0] = orig->x3;
-      points[np][1] = orig->y3;
-      ++np;
-   }
-   map[2] = np - 1;
-   if (!p3_p4_equal) {
-      points[np][0] = orig->x4;
-      points[np][1] = orig->y4;
-      ++np;
-   }
-   map[3] = np - 1;
-   if (np == 1)
-      return Discard;
-
-   /* We need to specialcase lines of 3 or 4 points due to numerical
-      instability in intersection code below */
-   if (np > 2 && is_bezier_line(points, np)) {
-      float l[4] = { points[0][0], points[0][1],
-                     points[np-1][0], points[np-1][1] };
-      float ctrl1[2], ctrl2[2];
-      if (floatsEqual(points[0][0], points[np-1][0]) &&
-          floatsEqual(points[0][1], points[np-1][1]))
-         return Discard;
-
-      shift_line_by_normal(l, offset);
-      line_point_at(l, 0.33, ctrl1);
-      line_point_at(l, 0.66, ctrl2);
-      bezier_init(shifted, l[0], l[1],
-                  ctrl1[0], ctrl1[1], ctrl2[0], ctrl2[1],
-                  l[2], l[3]);
-      return Ok;
-   }
-
-   bezier_bounds(orig, bounds);
-   if (np == 4 && bounds[2] < .1*offset && bounds[3] < .1*offset) {
-      float l = (orig->x1 - orig->x2)*(orig->x1 - orig->x2) +
-                (orig->y1 - orig->y2)*(orig->y1 - orig->y1) *
-                (orig->x3 - orig->x4)*(orig->x3 - orig->x4) +
-                (orig->y3 - orig->y4)*(orig->y3 - orig->y4);
-      float dot = (orig->x1 - orig->x2)*(orig->x3 - orig->x4) +
-                  (orig->y1 - orig->y2)*(orig->y3 - orig->y4);
-      if (dot < 0 && dot*dot < 0.8*l)
-         /* the points are close and reverse dirction. Approximate the whole
-            thing by a semi circle */
-         return Circle;
-   }
-
-   compute_pt_normal(points[0], points[1], prev_normal);
-
-   points_shifted[0][0] = points[0][0] + offset * prev_normal[0];
-   points_shifted[0][1] = points[0][1] + offset * prev_normal[1];
-
-   for (i = 1; i < np - 1; ++i) {
-      float normal_sum[2], r;
-      float next_normal[2];
-      compute_pt_normal(points[i], points[i + 1], next_normal);
-
-      normal_sum[0] = prev_normal[0] + next_normal[0];
-      normal_sum[1] = prev_normal[1] + next_normal[1];
-
-      r = 1.0 + prev_normal[0] * next_normal[0]
-          + prev_normal[1] * next_normal[1];
-
-      if (floatsEqual(r + 1, 1)) {
-         points_shifted[i][0] = points[i][0] + offset * prev_normal[0];
-         points_shifted[i][1] = points[i][1] + offset * prev_normal[1];
-      } else {
-         float k = offset / r;
-         points_shifted[i][0] = points[i][0] + k * normal_sum[0];
-         points_shifted[i][1] = points[i][1] + k * normal_sum[1];
-      }
-
-      prev_normal[0] = next_normal[0];
-      prev_normal[1] = next_normal[1];
-   }
-
-   points_shifted[np - 1][0] = points[np - 1][0] + offset * prev_normal[0];
-   points_shifted[np - 1][1] = points[np - 1][1] + offset * prev_normal[1];
-
-   bezier_init2v(shifted,
-                 points_shifted[map[0]], points_shifted[map[1]],
-                 points_shifted[map[2]], points_shifted[map[3]]);
-
-   return good_offset(orig, shifted, offset, threshold);
-}
-
-static VGboolean make_circle(const struct bezier *b, float offset, struct bezier *o)
-{
-   float normals[3][2];
-   float dist;
-   float angles[2];
-   float sign = 1.f;
-   int i;
-   float circle[3][2];
-
-   normals[0][0] = b->y2 - b->y1;
-   normals[0][1] = b->x1 - b->x2;
-   dist = sqrt(normals[0][0]*normals[0][0] + normals[0][1]*normals[0][1]);
-   if (floatsEqual(dist + 1, 1.f))
-      return VG_FALSE;
-   normals[0][0] /= dist;
-   normals[0][1] /= dist;
-
-   normals[2][0] = b->y4 - b->y3;
-   normals[2][1] = b->x3 - b->x4;
-   dist = sqrt(normals[2][0]*normals[2][0] + normals[2][1]*normals[2][1]);
-   if (floatsEqual(dist + 1, 1.f))
-      return VG_FALSE;
-   normals[2][0] /= dist;
-   normals[2][1] /= dist;
-
-   normals[1][0] = b->x1 - b->x2 - b->x3 + b->x4;
-   normals[1][1] = b->y1 - b->y2 - b->y3 + b->y4;
-   dist = -1*sqrt(normals[1][0]*normals[1][0] + normals[1][1]*normals[1][1]);
-   normals[1][0] /= dist;
-   normals[1][1] /= dist;
-
-   for (i = 0; i < 2; ++i) {
-      float cos_a = normals[i][0]*normals[i+1][0] + normals[i][1]*normals[i+1][1];
-      if (cos_a > 1.)
-         cos_a = 1.;
-      if (cos_a < -1.)
-         cos_a = -1;
-      angles[i] = acos(cos_a)/M_PI;
-   }
-
-   if (angles[0] + angles[1] > 1.) {
-      /* more than 180 degrees */
-      normals[1][0] = -normals[1][0];
-      normals[1][1] = -normals[1][1];
-      angles[0] = 1. - angles[0];
-      angles[1] = 1. - angles[1];
-      sign = -1.;
-   }
-
-   circle[0][0] = b->x1 + normals[0][0]*offset;
-   circle[0][1] = b->y1 + normals[0][1]*offset;
-
-   circle[1][0] = 0.5*(b->x1 + b->x4) + normals[1][0]*offset;
-   circle[1][1] = 0.5*(b->y1 + b->y4) + normals[1][1]*offset;
-
-   circle[2][0] = b->x4 + normals[2][0]*offset;
-   circle[2][1] = b->y4 + normals[2][1]*offset;
-
-   for (i = 0; i < 2; ++i) {
-      float kappa = 2.*KAPPA * sign * offset * angles[i];
-
-      o->x1 = circle[i][0];
-      o->y1 = circle[i][1];
-      o->x2 = circle[i][0] - normals[i][1]*kappa;
-      o->y2 = circle[i][1] + normals[i][0]*kappa;
-      o->x3 = circle[i+1][0] + normals[i+1][1]*kappa;
-      o->y3 = circle[i+1][1] - normals[i+1][0]*kappa;
-      o->x4 = circle[i+1][0];
-      o->y4 = circle[i+1][1];
-
-      ++o;
-   }
-   return VG_TRUE;
-}
-
-int bezier_translate_by_normal(struct bezier *bez,
-                               struct bezier *curves,
-                               int max_curves,
-                               float normal_len,
-                               float threshold)
-{
-   struct bezier beziers[10];
-   struct bezier *b, *o;
-
-   /* fixme: this should really be floatsEqual */
-   if (bez->x1 == bez->x2 && bez->x1 == bez->x3 && bez->x1 == bez->x4 &&
-       bez->y1 == bez->y2 && bez->y1 == bez->y3 && bez->y1 == bez->y4)
-      return 0;
-
-   --max_curves;
-redo:
-   beziers[0] = *bez;
-   b = beziers;
-   o = curves;
-
-   while (b >= beziers) {
-      int stack_segments = b - beziers + 1;
-      enum shift_result res;
-      if ((stack_segments == 10) || (o - curves == max_curves - stack_segments)) {
-         threshold *= 1.5;
-         if (threshold > 2.)
-            goto give_up;
-         goto redo;
-      }
-      res = shift(b, o, normal_len, threshold);
-      if (res == Discard) {
-         --b;
-      } else if (res == Ok) {
-         ++o;
-         --b;
-         continue;
-      } else if (res == Circle && max_curves - (o - curves) >= 2) {
-         /* add semi circle */
-         if (make_circle(b, normal_len, o))
-            o += 2;
-         --b;
-      } else {
-         split(b, b+1, b);
-         ++b;
-      }
-   }
-
-give_up:
-   while (b >= beziers) {
-      enum shift_result res = shift(b, o, normal_len, threshold);
-
-      /* if res isn't Ok or Split then *o is undefined */
-      if (res == Ok || res == Split)
-         ++o;
-
-      --b;
-   }
-
-   debug_assert(o - curves <= max_curves);
-   return o - curves;
-}
-
-void bezier_bounds(const struct bezier *bez,
-                   float *bounds/*x/y/width/height*/)
-{
-   float xmin = bez->x1;
-   float xmax = bez->x1;
-   float ymin = bez->y1;
-   float ymax = bez->y1;
-
-   if (bez->x2 < xmin)
-      xmin = bez->x2;
-   else if (bez->x2 > xmax)
-      xmax = bez->x2;
-   if (bez->x3 < xmin)
-      xmin = bez->x3;
-   else if (bez->x3 > xmax)
-      xmax = bez->x3;
-   if (bez->x4 < xmin)
-      xmin = bez->x4;
-   else if (bez->x4 > xmax)
-      xmax = bez->x4;
-
-   if (bez->y2 < ymin)
-      ymin = bez->y2;
-   else if (bez->y2 > ymax)
-      ymax = bez->y2;
-   if (bez->y3 < ymin)
-      ymin = bez->y3;
-   else if (bez->y3 > ymax)
-      ymax = bez->y3;
-   if (bez->y4 < ymin)
-      ymin = bez->y4;
-   else if (bez->y4 > ymax)
-      ymax = bez->y4;
-
-   bounds[0] = xmin; /* x */
-   bounds[1] = ymin; /* y */
-   bounds[2] = xmax - xmin; /* width */
-   bounds[3] = ymax - ymin; /* height */
-}
-
-void bezier_start_tangent(const struct bezier *bez,
-                          float *tangent)
-{
-   tangent[0] = bez->x1;
-   tangent[1] = bez->y1;
-   tangent[2] = bez->x2;
-   tangent[3] = bez->y2;
-
-   if (null_line(tangent)) {
-      tangent[0] = bez->x1;
-      tangent[1] = bez->y1;
-      tangent[2] = bez->x3;
-      tangent[3] = bez->y3;
-   }
-   if (null_line(tangent)) {
-      tangent[0] = bez->x1;
-      tangent[1] = bez->y1;
-      tangent[2] = bez->x4;
-      tangent[3] = bez->y4;
-   }
-}
-
-
-static INLINE VGfloat bezier_t_at_length(struct bezier *bez,
-                                         VGfloat at_length,
-                                         VGfloat error)
-{
-   VGfloat len = bezier_length(bez, error);
-   VGfloat t   = 1.0;
-   VGfloat last_bigger = 1.;
-
-   if (at_length > len || floatsEqual(at_length, len))
-      return t;
-
-   if (floatIsZero(at_length))
-      return 0.f;
-
-   t *= 0.5;
-   while (1) {
-      struct bezier right = *bez;
-      struct bezier left;
-      VGfloat tmp_len;
-      split_left(&right, t, &left);
-      tmp_len = bezier_length(&left, error);
-      if (ABS(tmp_len - at_length) < error)
-         break;
-
-      if (tmp_len < at_length) {
-         t += (last_bigger - t)*.5;
-      } else {
-         last_bigger = t;
-         t -= t*.5;
-      }
-   }
-   return t;
-}
-
-void bezier_point_at_length(struct bezier *bez,
-                            float length,
-                            float *point,
-                            float *normal)
-{
-   /* ~0.000001 seems to be required to pass G2080x tests */
-   VGfloat t = bezier_t_at_length(bez, length, 0.000001);
-   bezier_point_at(bez, t, point);
-   bezier_normal_at(bez, t, normal);
-   vector_unit(normal);
-}
-
-void bezier_point_at_t(struct bezier *bez, float t,
-                       float *point, float *normal)
-{
-   bezier_point_at(bez, t, point);
-   bezier_normal_at(bez, t, normal);
-   vector_unit(normal);
-}
-
-void bezier_exact_bounds(const struct bezier *bez,
-                         float *bounds/*x/y/width/height*/)
-{
-   struct polygon *poly = polygon_create(64);
-   polygon_vertex_append(poly, bez->x1, bez->y1);
-   bezier_add_to_polygon(bez, poly);
-   polygon_bounding_rect(poly, bounds);
-   polygon_destroy(poly);
-}
-
diff --git a/src/gallium/state_trackers/vega/bezier.h b/src/gallium/state_trackers/vega/bezier.h
deleted file mode 100644
index e06666051ca..00000000000
--- a/src/gallium/state_trackers/vega/bezier.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef BEZIER_H
-#define BEZIER_H
-
-struct polygon;
-struct matrix;
-
-struct bezier {
-    float x1, y1;
-    float x2, y2;
-    float x3, y3;
-    float x4, y4;
-};
-
-
-#define BEZIER_DEFAULT_ERROR 0.01
-
-/* kappa as being l of a circle with r = 1, we can emulate any
- * circle of radius r by using the formula
- * l = r . kappa
- * More at:
- * http://www.whizkidtech.redprince.net/bezier/circle/ */
-#define KAPPA 0.5522847498
-
-void bezier_init(struct bezier *bez,
-                 float x1, float y1,
-                 float x2, float y2,
-                 float x3, float y3,
-                 float x4, float y4);
-
-struct polygon *bezier_to_polygon(struct bezier *bez);
-void bezier_add_to_polygon(const struct bezier *bez,
-                           struct polygon *poly);
-float bezier_length(struct bezier *bez, float error);
-void bezier_transform(struct bezier *bez,
-                      struct matrix *mat);
-
-int bezier_translate_by_normal(struct bezier *b,
-                               struct bezier *curves,
-                               int max_curves,
-                               float normal_len,
-                               float threshold);
-void bezier_bounds(const struct bezier *bez,
-                   float *bounds/*x/y/width/height*/);
-void bezier_exact_bounds(const struct bezier *bez,
-                         float *bounds/*x/y/width/height*/);
-
-void bezier_start_tangent(const struct bezier *bez,
-                          float *tangent);
-
-void bezier_point_at_length(struct bezier *bez, float length,
-                            float *point, float *normal);
-void bezier_point_at_t(struct bezier *bez, float t,
-                       float *point, float *normal);
-
-#endif
diff --git a/src/gallium/state_trackers/vega/handle.c b/src/gallium/state_trackers/vega/handle.c
deleted file mode 100644
index 11eedd923ed..00000000000
--- a/src/gallium/state_trackers/vega/handle.c
+++ /dev/null
@@ -1,93 +0,0 @@
-/**************************************************************************
- *
- * 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
deleted file mode 100644
index 75f2ee875b7..00000000000
--- a/src/gallium/state_trackers/vega/handle.h
+++ /dev/null
@@ -1,172 +0,0 @@
-/**************************************************************************
- *
- * 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_debug.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
deleted file mode 100644
index 4434550c629..00000000000
--- a/src/gallium/state_trackers/vega/image.c
+++ /dev/null
@@ -1,653 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "image.h"
-
-#include "vg_translate.h"
-#include "vg_context.h"
-#include "matrix.h"
-#include "renderer.h"
-#include "util_array.h"
-#include "api_consts.h"
-#include "shader.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_screen.h"
-#include "util/u_inlines.h"
-#include "util/u_format.h"
-#include "util/u_tile.h"
-#include "util/u_memory.h"
-#include "util/u_math.h"
-#include "util/u_sampler.h"
-#include "util/u_surface.h"
-
-static enum pipe_format vg_format_to_pipe(VGImageFormat format)
-{
-   switch(format) {
-   case VG_sRGB_565:
-      return PIPE_FORMAT_B5G6R5_UNORM;
-   case VG_sRGBA_5551:
-      return PIPE_FORMAT_B5G5R5A1_UNORM;
-   case VG_sRGBA_4444:
-      return PIPE_FORMAT_B4G4R4A4_UNORM;
-   case VG_sL_8:
-   case VG_lL_8:
-      return PIPE_FORMAT_L8_UNORM;
-   case VG_BW_1:
-      return PIPE_FORMAT_B8G8R8A8_UNORM;
-   case VG_A_8:
-      return PIPE_FORMAT_A8_UNORM;
-#ifdef OPENVG_VERSION_1_1
-   case VG_A_1:
-   case VG_A_4:
-      return PIPE_FORMAT_A8_UNORM;
-#endif
-   default:
-      return PIPE_FORMAT_B8G8R8A8_UNORM;
-   }
-}
-
-static INLINE void vg_sync_size(VGfloat *src_loc, VGfloat *dst_loc)
-{
-   src_loc[2] = MIN2(src_loc[2], dst_loc[2]);
-   src_loc[3] = MIN2(src_loc[3], dst_loc[3]);
-   dst_loc[2] = src_loc[2];
-   dst_loc[3] = src_loc[3];
-}
-
-static void vg_get_copy_coords(VGfloat *src_loc,
-                               VGfloat src_width, VGfloat src_height,
-                               VGfloat *dst_loc,
-                               VGfloat dst_width, VGfloat dst_height)
-{
-   VGfloat dst_bounds[4], src_bounds[4];
-   VGfloat src_shift[4], dst_shift[4], shift[4];
-
-   dst_bounds[0] = 0.f;
-   dst_bounds[1] = 0.f;
-   dst_bounds[2] = dst_width;
-   dst_bounds[3] = dst_height;
-
-   src_bounds[0] = 0.f;
-   src_bounds[1] = 0.f;
-   src_bounds[2] = src_width;
-   src_bounds[3] = src_height;
-
-   vg_bound_rect(src_loc, src_bounds, src_shift);
-   vg_bound_rect(dst_loc, dst_bounds, dst_shift);
-   shift[0] = src_shift[0] - dst_shift[0];
-   shift[1] = src_shift[1] - dst_shift[1];
-
-   if (shift[0] < 0)
-      vg_shift_rectx(src_loc, src_bounds, -shift[0]);
-   else
-      vg_shift_rectx(dst_loc, dst_bounds, shift[0]);
-
-   if (shift[1] < 0)
-      vg_shift_recty(src_loc, src_bounds, -shift[1]);
-   else
-      vg_shift_recty(dst_loc, dst_bounds, shift[1]);
-
-   vg_sync_size(src_loc, dst_loc);
-}
-
-static void vg_copy_texture(struct vg_context *ctx,
-                            struct pipe_resource *dst, VGint dx, VGint dy,
-                            struct pipe_sampler_view *src, VGint sx, VGint sy,
-                            VGint width, VGint height)
-{
-   VGfloat dst_loc[4], src_loc[4];
-
-   dst_loc[0] = dx;
-   dst_loc[1] = dy;
-   dst_loc[2] = width;
-   dst_loc[3] = height;
-
-   src_loc[0] = sx;
-   src_loc[1] = sy;
-   src_loc[2] = width;
-   src_loc[3] = height;
-
-   vg_get_copy_coords(src_loc, src->texture->width0, src->texture->height0,
-                      dst_loc, dst->width0, dst->height0);
-
-   if (src_loc[2] >= 0 && src_loc[3] >= 0 &&
-       dst_loc[2] >= 0 && dst_loc[3] >= 0) {
-      struct pipe_surface *surf, surf_tmpl;
-
-      /* get the destination surface */
-      u_surface_default_template(&surf_tmpl, dst);
-      surf = ctx->pipe->create_surface(ctx->pipe, dst, &surf_tmpl);
-      if (surf && renderer_copy_begin(ctx->renderer, surf, VG_TRUE, src)) {
-         renderer_copy(ctx->renderer,
-               dst_loc[0], dst_loc[1], dst_loc[2], dst_loc[3],
-               src_loc[0], src_loc[1], src_loc[2], src_loc[3]);
-         renderer_copy_end(ctx->renderer);
-      }
-
-      pipe_surface_reference(&surf, NULL);
-   }
-}
-
-void vg_copy_surface(struct vg_context *ctx,
-                     struct pipe_surface *dst, VGint dx, VGint dy,
-                     struct pipe_surface *src, VGint sx, VGint sy,
-                     VGint width, VGint height)
-{
-   VGfloat dst_loc[4], src_loc[4];
-
-   dst_loc[0] = dx;
-   dst_loc[1] = dy;
-   dst_loc[2] = width;
-   dst_loc[3] = height;
-
-   src_loc[0] = sx;
-   src_loc[1] = sy;
-   src_loc[2] = width;
-   src_loc[3] = height;
-
-   vg_get_copy_coords(src_loc, src->width, src->height,
-                      dst_loc, dst->width, dst->height);
-
-   if (src_loc[2] > 0 && src_loc[3] > 0 &&
-       dst_loc[2] > 0 && dst_loc[3] > 0) {
-      if (src == dst)
-         renderer_copy_surface(ctx->renderer,
-                               src,
-                               src_loc[0],
-                               src->height - (src_loc[1] + src_loc[3]),
-                               src_loc[0] + src_loc[2],
-                               src->height - src_loc[1],
-                               dst,
-                               dst_loc[0],
-                               dst->height - (dst_loc[1] + dst_loc[3]),
-                               dst_loc[0] + dst_loc[2],
-                               dst->height - dst_loc[1],
-                               0, 0);
-      else
-         renderer_copy_surface(ctx->renderer,
-                               src,
-                               src_loc[0],
-                               src->height - src_loc[1],
-                               src_loc[0] + src_loc[2],
-                               src->height - (src_loc[1] + src_loc[3]),
-                               dst,
-                               dst_loc[0],
-                               dst->height - (dst_loc[1] + dst_loc[3]),
-                               dst_loc[0] + dst_loc[2],
-                               dst->height - dst_loc[1],
-                               0, 0);
-   }
-
-}
-
-static struct pipe_resource *image_texture(struct vg_image *img)
-{
-   struct pipe_resource *tex = img->sampler_view->texture;
-   return tex;
-}
-
-
-static void image_cleari(struct vg_image *img, VGint clear_colori,
-                         VGint x, VGint y, VGint width, VGint height)
-{
-   VGint *clearbuf;
-   VGint i;
-   VGfloat dwidth, dheight;
-
-   clearbuf = malloc(sizeof(VGint)*width*height);
-   for (i = 0; i < width*height; ++i)
-      clearbuf[i] = clear_colori;
-
-   dwidth = MIN2(width, img->width);
-   dheight = MIN2(height, img->height);
-
-   image_sub_data(img, clearbuf, width * sizeof(VGint),
-                  VG_sRGBA_8888,
-                  x, y, dwidth, dheight);
-   free(clearbuf);
-}
-
-struct vg_image * image_create(VGImageFormat format,
-                               VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct pipe_context *pipe = ctx->pipe;
-   struct vg_image *image = CALLOC_STRUCT(vg_image);
-   enum pipe_format pformat = vg_format_to_pipe(format);
-   struct pipe_resource pt, *newtex;
-   struct pipe_sampler_view view_templ;
-   struct pipe_sampler_view *view;
-   struct pipe_screen *screen = ctx->pipe->screen;
-
-   vg_init_object(&image->base, ctx, VG_OBJECT_IMAGE);
-
-   image->format = format;
-   image->width = width;
-   image->height = height;
-
-   image->sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-   image->sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-   image->sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-   image->sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST;
-   image->sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST;
-   image->sampler.normalized_coords = 1;
-
-   assert(screen->is_format_supported(screen, pformat, PIPE_TEXTURE_2D,
-                                      0, PIPE_BIND_SAMPLER_VIEW));
-
-   memset(&pt, 0, sizeof(pt));
-   pt.target = PIPE_TEXTURE_2D;
-   pt.format = pformat;
-   pt.last_level = 0;
-   pt.width0 = width;
-   pt.height0 = height;
-   pt.depth0 = 1;
-   pt.array_size = 1;
-   pt.bind = PIPE_BIND_SAMPLER_VIEW;
-
-   newtex = screen->resource_create(screen, &pt);
-
-   debug_assert(newtex);
-
-   u_sampler_view_default_template(&view_templ, newtex, newtex->format);
-   /* R, G, and B are treated as 1.0 for alpha-only formats in OpenVG */
-   if (newtex->format == PIPE_FORMAT_A8_UNORM) {
-      view_templ.swizzle_r = PIPE_SWIZZLE_ONE;
-      view_templ.swizzle_g = PIPE_SWIZZLE_ONE;
-      view_templ.swizzle_b = PIPE_SWIZZLE_ONE;
-   }
-
-   view = pipe->create_sampler_view(pipe, newtex, &view_templ);
-   /* want the texture to go away if the view is freed */
-   pipe_resource_reference(&newtex, NULL);
-
-   image->sampler_view = view;
-
-   vg_context_add_object(ctx, &image->base);
-
-   image_cleari(image, 0, 0, 0, image->width, image->height);
-   return image;
-}
-
-void image_destroy(struct vg_image *img)
-{
-   struct vg_context *ctx = vg_current_context();
-   vg_context_remove_object(ctx, &img->base);
-
-
-   if (img->parent) {
-      /* remove img from the parent child array */
-      int idx;
-      struct vg_image **array =
-         (struct vg_image **)img->parent->children_array->data;
-
-      for (idx = 0; idx < img->parent->children_array->num_elements; ++idx) {
-         struct vg_image *child = array[idx];
-         if (child == img) {
-            break;
-         }
-      }
-      debug_assert(idx < img->parent->children_array->num_elements);
-      array_remove_element(img->parent->children_array, idx);
-   }
-
-   if (img->children_array && img->children_array->num_elements) {
-      /* reparent the children */
-      VGint i;
-      struct vg_image *parent = img->parent;
-      struct vg_image **children =
-         (struct vg_image **)img->children_array->data;
-      if (!parent) {
-         VGint min_x = children[0]->x;
-         parent = children[0];
-
-         for (i = 1; i < img->children_array->num_elements; ++i) {
-            struct vg_image *child = children[i];
-            if (child->x < min_x) {
-               parent = child;
-            }
-         }
-      }
-
-      for (i = 0; i < img->children_array->num_elements; ++i) {
-         struct vg_image *child = children[i];
-         if (child != parent) {
-            child->parent = parent;
-            if (!parent->children_array) {
-               parent->children_array = array_create(
-                  sizeof(struct vg_image*));
-            }
-            array_append_data(parent->children_array,
-                              &child, 1);
-         } else
-            child->parent = NULL;
-      }
-      array_destroy(img->children_array);
-   }
-
-   vg_free_object(&img->base);
-
-   pipe_sampler_view_reference(&img->sampler_view, NULL);
-   FREE(img);
-}
-
-void image_clear(struct vg_image *img,
-                 VGint x, VGint y, VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   VGfloat *clear_colorf = ctx->state.vg.clear_color;
-   VGubyte r, g, b ,a;
-   VGint clear_colori;
-   /* FIXME: this is very nasty */
-   r = float_to_ubyte(clear_colorf[0]);
-   g = float_to_ubyte(clear_colorf[1]);
-   b = float_to_ubyte(clear_colorf[2]);
-   a = float_to_ubyte(clear_colorf[3]);
-   clear_colori = r << 24 | g << 16 | b << 8 | a;
-   image_cleari(img, clear_colori, x, y, width, height);
-}
-
-void image_sub_data(struct vg_image *image,
-                    const void * data,
-                    VGint dataStride,
-                    VGImageFormat dataFormat,
-                    VGint x, VGint y,
-                    VGint width, VGint height)
-{
-   const VGint yStep = 1;
-   VGubyte *src = (VGubyte *)data;
-   VGfloat temp[VEGA_MAX_IMAGE_WIDTH][4];
-   VGfloat *df = (VGfloat*)temp;
-   VGint i;
-   struct vg_context *ctx = vg_current_context();
-   struct pipe_context *pipe = ctx->pipe;
-   struct pipe_resource *texture = image_texture(image);
-   VGint xoffset = 0, yoffset = 0;
-
-   if (x < 0) {
-      xoffset -= x;
-      width += x;
-      x = 0;
-   }
-   if (y < 0) {
-      yoffset -= y;
-      height += y;
-      y = 0;
-   }
-
-   if (width <= 0 || height <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   if (x > image->width || y > image->width) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   if (x + width > image->width) {
-      width = image->width - x;
-   }
-
-   if (y + height > image->height) {
-      height = image->height - y;
-   }
-
-   { /* upload color_data */
-      struct pipe_transfer *transfer;
-      void *map = pipe_transfer_map(pipe, texture, 0, 0,
-                                    PIPE_TRANSFER_WRITE, 0, 0,
-                                    texture->width0, texture->height0,
-                                    &transfer);
-      src += (dataStride * yoffset);
-      for (i = 0; i < height; i++) {
-         _vega_unpack_float_span_rgba(ctx, width, xoffset, src, dataFormat, temp);
-         pipe_put_tile_rgba(transfer, map, x+image->x, y+image->y, width, 1, df);
-         y += yStep;
-         src += dataStride;
-      }
-      pipe->transfer_unmap(pipe, transfer);
-   }
-}
-
-void image_get_sub_data(struct vg_image * image,
-                        void * data,
-                        VGint dataStride,
-                        VGImageFormat dataFormat,
-                        VGint sx, VGint sy,
-                        VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct pipe_context *pipe = ctx->pipe;
-   VGfloat temp[VEGA_MAX_IMAGE_WIDTH][4];
-   VGfloat *df = (VGfloat*)temp;
-   VGint y = 0, yStep = 1;
-   VGint i;
-   VGubyte *dst = (VGubyte *)data;
-
-   {
-      struct pipe_transfer *transfer;
-      void *map =
-         pipe_transfer_map(pipe,
-                           image->sampler_view->texture,  0, 0,
-                           PIPE_TRANSFER_READ,
-                           0, 0,
-                           image->x + image->width,
-                           image->y + image->height, &transfer);
-      /* Do a row at a time to flip image data vertically */
-      for (i = 0; i < height; i++) {
-#if 0
-         debug_printf("%d-%d  == %d\n", sy, height, y);
-#endif
-         pipe_get_tile_rgba(transfer, map, sx+image->x, y, width, 1, df);
-         y += yStep;
-         _vega_pack_rgba_span_float(ctx, width, temp, dataFormat, dst);
-         dst += dataStride;
-      }
-
-      pipe->transfer_unmap(pipe, transfer);
-   }
-}
-
-struct vg_image * image_child_image(struct vg_image *parent,
-                                    VGint x, VGint y,
-                                    VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_image *image = CALLOC_STRUCT(vg_image);
-
-   vg_init_object(&image->base, ctx, VG_OBJECT_IMAGE);
-
-   image->x = parent->x + x;
-   image->y = parent->y + y;
-   image->width = width;
-   image->height = height;
-   image->parent = parent;
-   image->sampler_view = NULL;
-   pipe_sampler_view_reference(&image->sampler_view,
-                               parent->sampler_view);
-
-   image->sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-   image->sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-   image->sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-   image->sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST;
-   image->sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST;
-   image->sampler.normalized_coords = 1;
-
-   if (!parent->children_array)
-      parent->children_array = array_create(
-         sizeof(struct vg_image*));
-
-   array_append_data(parent->children_array,
-                     &image, 1);
-
-   vg_context_add_object(ctx, &image->base);
-
-   return image;
-}
-
-void image_copy(struct vg_image *dst, VGint dx, VGint dy,
-                struct vg_image *src, VGint sx, VGint sy,
-                VGint width, VGint height,
-                VGboolean dither)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   if (width <= 0 || height <= 0) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-   vg_copy_texture(ctx, dst->sampler_view->texture, dst->x + dx, dst->y + dy,
-                   src->sampler_view, src->x + sx, src->y + sy, width, height);
-}
-
-void image_draw(struct vg_image *img, struct matrix *matrix)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct matrix paint_matrix;
-   VGfloat x1, y1;
-   VGfloat x2, y2;
-   VGfloat x3, y3;
-   VGfloat x4, y4;
-
-   if (!vg_get_paint_matrix(ctx,
-                            &ctx->state.vg.fill_paint_to_user_matrix,
-                            matrix,
-                            &paint_matrix))
-      return;
-
-   x1 = 0;
-   y1 = 0;
-   x2 = img->width;
-   y2 = 0;
-   x3 = img->width;
-   y3 = img->height;
-   x4 = 0;
-   y4 = img->height;
-
-   shader_set_surface_matrix(ctx->shader, matrix);
-   shader_set_drawing_image(ctx->shader, VG_TRUE);
-   shader_set_paint(ctx->shader, ctx->state.vg.fill_paint);
-   shader_set_paint_matrix(ctx->shader, &paint_matrix);
-   shader_set_image(ctx->shader, img);
-   shader_bind(ctx->shader);
-
-   renderer_texture_quad(ctx->renderer, image_texture(img),
-                         img->x, img->y, img->x + img->width, img->y + img->height,
-                         x1, y1, x2, y2, x3, y3, x4, y4);
-}
-
-void image_set_pixels(VGint dx, VGint dy,
-                      struct vg_image *src, VGint sx, VGint sy,
-                      VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct pipe_context *pipe = ctx->pipe;
-   struct pipe_surface *surf, surf_tmpl;
-   struct st_renderbuffer *strb = ctx->draw_buffer->strb;
-
-   u_surface_default_template(&surf_tmpl, image_texture(src));
-   surf = pipe->create_surface(pipe, image_texture(src), &surf_tmpl);
-
-   vg_copy_surface(ctx, strb->surface, dx, dy,
-                   surf, sx+src->x, sy+src->y, width, height);
-
-   pipe->surface_destroy(pipe, surf);
-}
-
-void image_get_pixels(struct vg_image *dst, VGint dx, VGint dy,
-                      VGint sx, VGint sy,
-                      VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct pipe_context *pipe = ctx->pipe;
-   struct pipe_surface *surf, surf_tmpl;
-   struct st_renderbuffer *strb = ctx->draw_buffer->strb;
-
-   /* flip the y coordinates */
-   /*dy = dst->height - dy - height;*/
-
-   u_surface_default_template(&surf_tmpl, image_texture(dst));
-   surf = pipe->create_surface(pipe, image_texture(dst), &surf_tmpl);
-
-   vg_copy_surface(ctx, surf, dst->x + dx, dst->y + dy,
-                   strb->surface, sx, sy, width, height);
-
-   pipe_surface_reference(&surf, NULL);
-}
-
-
-VGboolean vg_image_overlaps(struct vg_image *dst,
-                            struct vg_image *src)
-{
-   if (dst == src || dst->parent == src ||
-       dst == src->parent)
-      return VG_TRUE;
-   if (dst->parent && dst->parent == src->parent) {
-      VGfloat left1 = dst->x;
-      VGfloat left2 = src->x;
-      VGfloat right1 = dst->x + dst->width;
-      VGfloat right2 = src->x + src->width;
-      VGfloat bottom1 = dst->y;
-      VGfloat bottom2 = src->y;
-      VGfloat top1 = dst->y + dst->height;
-      VGfloat top2 = src->y + src->height;
-
-      return !(left2 > right1 || right2 < left1 ||
-               top2 > bottom1 || bottom2 < top1);
-   }
-   return VG_FALSE;
-}
-
-VGint image_bind_samplers(struct vg_image *img, struct pipe_sampler_state **samplers,
-                          struct pipe_sampler_view **sampler_views)
-{
-   img->sampler.min_img_filter = image_sampler_filter(img->base.ctx);
-   img->sampler.mag_img_filter = image_sampler_filter(img->base.ctx);
-   samplers[3] = &img->sampler;
-   sampler_views[3] = img->sampler_view;
-   return 1;
-}
-
-VGint image_sampler_filter(struct vg_context *ctx)
-{
-    switch(ctx->state.vg.image_quality) {
-    case VG_IMAGE_QUALITY_NONANTIALIASED:
-       return PIPE_TEX_FILTER_NEAREST;
-       break;
-    case VG_IMAGE_QUALITY_FASTER:
-       return PIPE_TEX_FILTER_NEAREST;
-       break;
-    case VG_IMAGE_QUALITY_BETTER:
-       /* possibly use anisotropic filtering */
-       return PIPE_TEX_FILTER_LINEAR;
-       break;
-    default:
-       debug_printf("Unknown image quality");
-    }
-    return PIPE_TEX_FILTER_NEAREST;
-}
diff --git a/src/gallium/state_trackers/vega/image.h b/src/gallium/state_trackers/vega/image.h
deleted file mode 100644
index 391c0485948..00000000000
--- a/src/gallium/state_trackers/vega/image.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef IMAGES_H
-#define IMAGES_H
-
-#include "vg_context.h"
-#include "pipe/p_state.h"
-
-struct pipe_resource;
-struct array;
-struct vg_context;
-struct pipe_surface;
-
-struct vg_image {
-   struct vg_object base;
-   VGImageFormat format;
-   VGint x, y;
-   VGint width, height;
-
-   struct vg_image *parent;
-
-   struct pipe_sampler_view *sampler_view;
-   struct pipe_sampler_state sampler;
-
-   struct array *children_array;
-};
-
-struct vg_image *image_create(VGImageFormat format,
-                              VGint width, VGint height);
-void image_destroy(struct vg_image *img);
-
-void image_clear(struct vg_image *img,
-                 VGint x, VGint y, VGint width, VGint height);
-
-void image_sub_data(struct vg_image *image,
-                    const void * data,
-                    VGint dataStride,
-                    VGImageFormat dataFormat,
-                    VGint x, VGint y,
-                    VGint width, VGint height);
-
-void image_get_sub_data(struct vg_image * image,
-                        void * data,
-                        VGint dataStride,
-                        VGImageFormat dataFormat,
-                        VGint x, VGint y,
-                        VGint width, VGint height);
-
-struct vg_image *image_child_image(struct vg_image *parent,
-                                   VGint x, VGint y,
-                                   VGint width, VGint height);
-
-void image_copy(struct vg_image *dst, VGint dx, VGint dy,
-                struct vg_image *src, VGint sx, VGint sy,
-                VGint width, VGint height,
-                VGboolean dither);
-
-void image_draw(struct vg_image *img, struct matrix *matrix);
-
-void image_set_pixels(VGint dx, VGint dy,
-                      struct vg_image *src, VGint sx, VGint sy,
-                      VGint width, VGint height);
-void image_get_pixels(struct vg_image *dst, VGint dx, VGint dy,
-                      VGint sx, VGint sy,
-                      VGint width, VGint height);
-
-VGint image_bind_samplers(struct vg_image *dst, struct pipe_sampler_state **samplers,
-                          struct pipe_sampler_view **sampler_views);
-
-VGboolean vg_image_overlaps(struct vg_image *dst,
-                            struct vg_image *src);
-
-VGint image_sampler_filter(struct vg_context *ctx);
-
-void vg_copy_surface(struct vg_context *ctx,
-                     struct pipe_surface *dst, VGint dx, VGint dy,
-                     struct pipe_surface *src, VGint sx, VGint sy,
-                     VGint width, VGint height);
-
-#endif
diff --git a/src/gallium/state_trackers/vega/mask.c b/src/gallium/state_trackers/vega/mask.c
deleted file mode 100644
index ca8edd01686..00000000000
--- a/src/gallium/state_trackers/vega/mask.c
+++ /dev/null
@@ -1,523 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "mask.h"
-
-#include "path.h"
-#include "image.h"
-#include "shaders_cache.h"
-#include "renderer.h"
-#include "asm_util.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_screen.h"
-#include "util/u_inlines.h"
-#include "util/u_format.h"
-#include "util/u_memory.h"
-#include "util/u_surface.h"
-#include "util/u_sampler.h"
-
-struct vg_mask_layer {
-   struct vg_object base;
-
-   VGint width;
-   VGint height;
-
-   struct pipe_sampler_view *sampler_view;
-};
-
-static INLINE VGboolean
-intersect_rectangles(VGint dwidth, VGint dheight,
-                     VGint swidth, VGint sheight,
-                     VGint tx, VGint ty,
-                     VGint twidth, VGint theight,
-                     VGint *offsets,
-                     VGint *location)
-{
-   if (tx + twidth <= 0 || tx >= dwidth)
-      return VG_FALSE;
-   if (ty + theight <= 0 || ty >= dheight)
-      return VG_FALSE;
-
-   offsets[0] = 0;
-   offsets[1] = 0;
-   location[0] = tx;
-   location[1] = ty;
-
-   if (tx < 0) {
-      offsets[0] -= tx;
-      location[0] = 0;
-
-      location[2] = MIN2(tx + swidth, MIN2(dwidth, tx + twidth));
-      offsets[2] = location[2];
-   } else {
-      offsets[2] = MIN2(twidth, MIN2(dwidth - tx, swidth ));
-      location[2] = offsets[2];
-   }
-
-   if (ty < 0) {
-      offsets[1] -= ty;
-      location[1] = 0;
-
-      location[3] = MIN2(ty + sheight, MIN2(dheight, ty + theight));
-      offsets[3] = location[3];
-   } else {
-      offsets[3] = MIN2(theight, MIN2(dheight - ty, sheight));
-      location[3] = offsets[3];
-   }
-
-   return VG_TRUE;
-}
-
-#if DEBUG_MASKS
-static void read_alpha_mask(void * data, VGint dataStride,
-                            VGImageFormat dataFormat,
-                            VGint sx, VGint sy,
-                            VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct pipe_context *pipe = ctx->pipe;
-
-   struct st_framebuffer *stfb = ctx->draw_buffer;
-   struct st_renderbuffer *strb = stfb->alpha_mask;
-
-   VGfloat temp[VEGA_MAX_IMAGE_WIDTH][4];
-   VGfloat *df = (VGfloat*)temp;
-   VGint y = (stfb->height - sy) - 1, yStep = -1;
-   VGint i;
-   VGubyte *dst = (VGubyte *)data;
-   VGint xoffset = 0, yoffset = 0;
-
-   if (sx < 0) {
-      xoffset = -sx;
-      xoffset *= _vega_size_for_format(dataFormat);
-      width += sx;
-      sx = 0;
-   }
-   if (sy < 0) {
-      yoffset = -sy;
-      height += sy;
-      sy = 0;
-      y = (stfb->height - sy) - 1;
-      yoffset *= dataStride;
-   }
-
-   {
-      struct pipe_surface *surf;
-
-      surf = pipe->create_surface(pipe, strb->texture,  0, 0, 0,
-                                  PIPE_BIND_TRANSFER_READ);
-
-      /* Do a row at a time to flip image data vertically */
-      for (i = 0; i < height; i++) {
-#if 0
-         debug_printf("%d-%d  == %d\n", sy, height, y);
-#endif
-         pipe_get_tile_rgba(surf, sx, y, width, 1, df);
-         y += yStep;
-         _vega_pack_rgba_span_float(ctx, width, temp, dataFormat,
-                                    dst + yoffset + xoffset);
-         dst += dataStride;
-      }
-
-      pipe_surface_reference(&surf, NULL);
-   }
-}
-
-void save_alpha_to_file(const char *filename)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct st_framebuffer *stfb = ctx->draw_buffer;
-   VGint *data;
-   int i, j;
-
-   data = malloc(sizeof(int) * stfb->width * stfb->height);
-   read_alpha_mask(data, stfb->width * sizeof(int),
-                   VG_sRGBA_8888,
-                   0, 0, stfb->width, stfb->height);
-   fprintf(stderr, "/*---------- start */\n");
-   fprintf(stderr, "const int image_width = %d;\n",
-           stfb->width);
-   fprintf(stderr, "const int image_height = %d;\n",
-           stfb->height);
-   fprintf(stderr, "const int image_data = {\n");
-   for (i = 0; i < stfb->height; ++i) {
-      for (j = 0; j < stfb->width; ++j) {
-         int rgba = data[i * stfb->height + j];
-         int argb = 0;
-         argb = (rgba >> 8);
-         argb |= ((rgba & 0xff) << 24);
-         fprintf(stderr, "0x%x, ", argb);
-      }
-      fprintf(stderr, "\n");
-   }
-   fprintf(stderr, "};\n");
-   fprintf(stderr, "/*---------- end */\n");
-}
-#endif
-
-/* setup mask shader */
-static void *setup_mask_operation(VGMaskOperation operation)
-{
-   struct vg_context *ctx = vg_current_context();
-   void *shader = 0;
-
-   switch (operation) {
-   case VG_UNION_MASK: {
-      if (!ctx->mask.union_fs) {
-         ctx->mask.union_fs = shader_create_from_text(ctx->pipe,
-                                                      union_mask_asm,
-                                                      200,
-                                                      PIPE_SHADER_FRAGMENT);
-      }
-      shader = ctx->mask.union_fs->driver;
-   }
-      break;
-   case VG_INTERSECT_MASK: {
-      if (!ctx->mask.intersect_fs) {
-         ctx->mask.intersect_fs = shader_create_from_text(ctx->pipe,
-                                                          intersect_mask_asm,
-                                                          200,
-                                                          PIPE_SHADER_FRAGMENT);
-      }
-      shader = ctx->mask.intersect_fs->driver;
-   }
-      break;
-   case VG_SUBTRACT_MASK: {
-      if (!ctx->mask.subtract_fs) {
-         ctx->mask.subtract_fs = shader_create_from_text(ctx->pipe,
-                                                         subtract_mask_asm,
-                                                         200,
-                                                         PIPE_SHADER_FRAGMENT);
-      }
-      shader = ctx->mask.subtract_fs->driver;
-   }
-      break;
-   case VG_SET_MASK: {
-      if (!ctx->mask.set_fs) {
-         ctx->mask.set_fs = shader_create_from_text(ctx->pipe,
-                                                    set_mask_asm,
-                                                    200,
-                                                    PIPE_SHADER_FRAGMENT);
-      }
-      shader = ctx->mask.set_fs->driver;
-   }
-      break;
-   default:
-         assert(0);
-      break;
-   }
-
-   return shader;
-}
-
-static void mask_resource_fill(struct pipe_resource *dst,
-                               int x, int y, int width, int height,
-                               VGfloat coverage)
-{
-   struct vg_context *ctx = vg_current_context();
-   VGfloat fs_consts[12] = {
-      0.0f, 0.0f, 0.0f, 0.0f, /* not used */
-      0.0f, 0.0f, 0.0f, 0.0f, /* not used */
-      0.0f, 0.0f, 0.0f, coverage /* color */
-   };
-   void *fs;
-
-   if (x < 0) {
-      width += x;
-      x = 0;
-   }
-   if (y < 0) {
-      height += y;
-      y = 0;
-   }
-
-   fs = shaders_cache_fill(ctx->sc, VEGA_SOLID_FILL_SHADER);
-
-   if (renderer_filter_begin(ctx->renderer, dst, VG_FALSE, ~0,
-            NULL, NULL, 0, fs, (const void *) fs_consts, sizeof(fs_consts))) {
-      renderer_filter(ctx->renderer, x, y, width, height, 0, 0, 0, 0);
-      renderer_filter_end(ctx->renderer);
-   }
-
-#if DEBUG_MASKS
-   save_alpha_to_file(0);
-#endif
-}
-
-
-static void mask_using_texture(struct pipe_sampler_view *sampler_view,
-                               VGboolean is_layer,
-                               VGMaskOperation operation,
-                               VGint x, VGint y,
-                               VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct pipe_sampler_view *dst_view = vg_get_surface_mask(ctx);
-   struct pipe_resource *dst = dst_view->texture;
-   struct pipe_resource *texture = sampler_view->texture;
-   const struct pipe_sampler_state *samplers[2];
-   struct pipe_sampler_view *views[2];
-   struct pipe_sampler_state sampler;
-   VGint offsets[4], loc[4];
-   const VGfloat ones[4] = {1.f, 1.f, 1.f, 1.f};
-   void *fs;
-
-   if (!intersect_rectangles(dst->width0, dst->height0,
-                             texture->width0, texture->height0,
-                             x, y, width, height,
-                             offsets, loc))
-      return;
-#if 0
-   debug_printf("Offset = [%d, %d, %d, %d]\n", offsets[0],
-                offsets[1], offsets[2], offsets[3]);
-   debug_printf("Locati = [%d, %d, %d, %d]\n", loc[0],
-                loc[1], loc[2], loc[3]);
-#endif
-
-
-   sampler = ctx->mask.sampler;
-   sampler.normalized_coords = 1;
-   samplers[0] = &sampler;
-   views[0] = sampler_view;
-
-   /* prepare our blend surface */
-   samplers[1] = &ctx->mask.sampler;
-   views[1] = vg_prepare_blend_surface_from_mask(ctx);
-
-   fs = setup_mask_operation(operation);
-
-   if (renderer_filter_begin(ctx->renderer, dst, VG_FALSE,
-            ~0, samplers, views, 2, fs, (const void *) ones, sizeof(ones))) {
-      /* layer should be flipped when used as a texture */
-      if (is_layer) {
-         offsets[1] += offsets[3];
-         offsets[3] = -offsets[3];
-      }
-      renderer_filter(ctx->renderer,
-            loc[0], loc[1], loc[2], loc[3],
-            offsets[0], offsets[1], offsets[2], offsets[3]);
-      renderer_filter_end(ctx->renderer);
-   }
-}
-
-
-#ifdef OPENVG_VERSION_1_1
-
-struct vg_mask_layer * mask_layer_create(VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_mask_layer *mask = 0;
-
-   mask = CALLOC_STRUCT(vg_mask_layer);
-   vg_init_object(&mask->base, ctx, VG_OBJECT_MASK);
-   mask->width = width;
-   mask->height = height;
-
-   {
-      struct pipe_resource pt;
-      struct pipe_context *pipe = ctx->pipe;
-      struct pipe_screen *screen = ctx->pipe->screen;
-      struct pipe_sampler_view view_templ;
-      struct pipe_sampler_view *view = NULL;
-      struct pipe_resource *texture;
-
-      memset(&pt, 0, sizeof(pt));
-      pt.target = PIPE_TEXTURE_2D;
-      pt.format = PIPE_FORMAT_B8G8R8A8_UNORM;
-      pt.last_level = 0;
-      pt.width0 = width;
-      pt.height0 = height;
-      pt.depth0 = 1;
-      pt.array_size = 1;
-      pt.bind = PIPE_BIND_SAMPLER_VIEW;
-
-      texture = screen->resource_create(screen, &pt);
-
-      if (texture) {
-         u_sampler_view_default_template(&view_templ, texture, texture->format);
-         view = pipe->create_sampler_view(pipe, texture, &view_templ);
-      }
-      pipe_resource_reference(&texture, NULL);
-      mask->sampler_view = view;
-   }
-
-   vg_context_add_object(ctx, &mask->base);
-
-   return mask;
-}
-
-void mask_layer_destroy(struct vg_mask_layer *layer)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   vg_context_remove_object(ctx, &layer->base);
-   pipe_sampler_view_reference(&layer->sampler_view, NULL);
-   vg_free_object(&layer->base);
-   FREE(layer);
-}
-
-void mask_layer_fill(struct vg_mask_layer *layer,
-                     VGint x, VGint y,
-                     VGint width, VGint height,
-                     VGfloat value)
-{
-   mask_resource_fill(layer->sampler_view->texture,
-                      x, y, width, height, value);
-}
-
-void mask_copy(struct vg_mask_layer *layer,
-               VGint sx, VGint sy,
-               VGint dx, VGint dy,
-               VGint width, VGint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct pipe_sampler_view *src = vg_get_surface_mask(ctx);
-   struct pipe_surface *surf, surf_tmpl;
-
-   /* get the destination surface */
-   u_surface_default_template(&surf_tmpl, layer->sampler_view->texture);
-   surf = ctx->pipe->create_surface(ctx->pipe, layer->sampler_view->texture,
-                                    &surf_tmpl);
-   if (surf && renderer_copy_begin(ctx->renderer, surf, VG_FALSE, src)) {
-      /* layer should be flipped when used as a texture */
-      sy += height;
-      height = -height;
-
-      renderer_copy(ctx->renderer,
-            dx, dy, width, height,
-            sx, sy, width, height);
-      renderer_copy_end(ctx->renderer);
-   }
-
-   pipe_surface_reference(&surf, NULL);
-}
-
-static void mask_layer_render_to(struct vg_mask_layer *layer,
-                                 struct path *path,
-                                 VGbitfield paint_modes)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct pipe_context *pipe = ctx->pipe;
-   struct pipe_sampler_view *view = vg_get_surface_mask(ctx);
-   struct matrix *mat = &ctx->state.vg.path_user_to_surface_matrix;
-   struct pipe_surface *surf, surf_tmpl;
-   u_surface_default_template(&surf_tmpl, view->texture);
-   surf = pipe->create_surface(pipe, view->texture, &surf_tmpl);
-
-   renderer_validate_for_mask_rendering(ctx->renderer, surf, mat);
-
-   if (paint_modes & VG_FILL_PATH) {
-      path_fill(path);
-   }
-
-   if (paint_modes & VG_STROKE_PATH){
-      path_stroke(path);
-   }
-
-   pipe_surface_reference(&surf, NULL);
-}
-
-void mask_render_to(struct path *path,
-                    VGbitfield paint_modes,
-                    VGMaskOperation operation)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct st_framebuffer *stfb = ctx->draw_buffer;
-   struct vg_mask_layer *temp_layer;
-   VGint width, height;
-
-   width = stfb->width;
-   height = stfb->height;
-
-   temp_layer = mask_layer_create(width, height);
-   mask_layer_fill(temp_layer, 0, 0, width, height, 0.0f);
-
-   mask_layer_render_to(temp_layer, path, paint_modes);
-
-   mask_using_layer(temp_layer, operation, 0, 0, width, height);
-
-   mask_layer_destroy(temp_layer);
-}
-
-void mask_using_layer(struct vg_mask_layer *layer,
-                      VGMaskOperation operation,
-                      VGint x, VGint y,
-                      VGint width, VGint height)
-{
-   mask_using_texture(layer->sampler_view, VG_TRUE, operation,
-                      x, y, width, height);
-}
-
-VGint mask_layer_width(struct vg_mask_layer *layer)
-{
-   return layer->width;
-}
-
-VGint mask_layer_height(struct vg_mask_layer *layer)
-{
-   return layer->height;
-}
-
-
-#endif
-
-void mask_using_image(struct vg_image *image,
-                      VGMaskOperation operation,
-                      VGint x, VGint y,
-                      VGint width, VGint height)
-{
-   mask_using_texture(image->sampler_view, VG_FALSE, operation,
-                      x, y, width, height);
-}
-
-void mask_fill(VGint x, VGint y, VGint width, VGint height,
-               VGfloat value)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct pipe_sampler_view *view = vg_get_surface_mask(ctx);
-
-#if DEBUG_MASKS
-   debug_printf("mask_fill(%d, %d, %d, %d) with  rgba(%f, %f, %f, %f)\n",
-                x, y, width, height,
-                0.0f, 0.0f, 0.0f, value);
-#endif
-
-   mask_resource_fill(view->texture, x, y, width, height, value);
-}
-
-VGint mask_bind_samplers(struct pipe_sampler_state **samplers,
-                         struct pipe_sampler_view **sampler_views)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   if (ctx->state.vg.masking) {
-      samplers[1] = &ctx->mask.sampler;
-      sampler_views[1] = vg_get_surface_mask(ctx);
-      return 1;
-   } else
-      return 0;
-}
diff --git a/src/gallium/state_trackers/vega/mask.h b/src/gallium/state_trackers/vega/mask.h
deleted file mode 100644
index c626402c864..00000000000
--- a/src/gallium/state_trackers/vega/mask.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef MASK_H
-#define MASK_H
-
-#include "vg_context.h"
-
-struct path;
-struct vg_image;
-struct pipe_resource;
-
-struct vg_mask_layer *mask_layer_create(VGint width, VGint height);
-void mask_layer_destroy(struct vg_mask_layer *layer);
-void mask_layer_fill(struct vg_mask_layer *layer,
-                     VGint x, VGint y,
-                     VGint width, VGint height,
-                     VGfloat value);
-VGint mask_layer_width(struct vg_mask_layer *layer);
-VGint mask_layer_height(struct vg_mask_layer *layer);
-void mask_copy(struct vg_mask_layer *layer,
-               VGint sx, VGint sy,
-               VGint dx, VGint dy,
-               VGint width, VGint height);
-
-void mask_render_to(struct path *path,
-                    VGbitfield paint_modes,
-                    VGMaskOperation operation);
-
-void mask_using_layer(struct vg_mask_layer *layer,
-                      VGMaskOperation operation,
-                      VGint x, VGint y,
-                      VGint width, VGint height);
-void mask_using_image(struct vg_image *image,
-                      VGMaskOperation operation,
-                      VGint x, VGint y,
-                      VGint width, VGint height);
-void mask_fill(VGint x, VGint y,
-               VGint width, VGint height,
-               VGfloat value);
-
-VGint mask_bind_samplers(struct pipe_sampler_state **samplers,
-                         struct pipe_sampler_view **sampler_views);
-
-#endif
diff --git a/src/gallium/state_trackers/vega/matrix.h b/src/gallium/state_trackers/vega/matrix.h
deleted file mode 100644
index 794c7e7a4ce..00000000000
--- a/src/gallium/state_trackers/vega/matrix.h
+++ /dev/null
@@ -1,462 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef MATRIX_H
-#define MATRIX_H
-
-#include "VG/openvg.h"
-
-#include "pipe/p_compiler.h"
-#include "util/u_math.h"
-
-#include <stdio.h>
-#include <math.h>
-
-#define floatsEqual(x, y) (fabs(x - y) <= 0.00001f * MIN2(fabs(x), fabs(y)))
-#define floatIsZero(x) (floatsEqual((x) + 1, 1))
-#define ABS(x) (fabsf(x))
-
-#define DEGREES_TO_RADIANS(d) (0.0174532925199 * (d))
-#define FLT_TO_INT(flt) float_to_int_floor(((VGuint*)&(flt))[0])
-
-static INLINE VGint float_to_int_floor(VGuint bits)
-{
-   int sign = (bits >> 31) ? -1 : 1;
-   int exp  = ((bits >> 23) & 255) - 127;
-   int mant = bits & 0x007fffff;
-   int sh   = 23 - exp;
-
-   /* abs(value) >= 2^31 -> clamp. */
-
-   if (exp >= 31)
-      return (VGint)((sign < 0) ? 0x80000000u : 0x7fffffffu);
-
-   /* abs(value) < 1 -> return -1 or 0. */
-
-   if (exp < 0)
-      return (sign < 0 && (exp > -127 || mant != 0)) ? -1 : 0;
-
-   /* abs(value) >= 2^23 -> shift left. */
-
-   mant |= 0x00800000;
-   if (sh <= 0)
-      return sign * (mant << -sh);
-
-   /* Negative -> add a rounding term. */
-
-   if (sign < 0)
-      mant += (1 << sh) - 1;
-
-   /* Shift right to obtain the result. */
-
-   return sign * (mant >> sh);
-}
-
-
-struct matrix {
-   VGfloat m[9];
-};
-
-static INLINE void matrix_init(struct matrix *mat,
-                               const VGfloat *val)
-{
-   memcpy(mat->m, val, sizeof(VGfloat) * 9);
-}
-
-static INLINE void matrix_inits(struct matrix *mat,
-                                VGfloat m11, VGfloat m12, VGfloat m13,
-                                VGfloat m21, VGfloat m22, VGfloat m23,
-                                VGfloat m31, VGfloat m32, VGfloat m33)
-{
-   mat->m[0] = m11; mat->m[1] = m12; mat->m[2] = m13;
-   mat->m[3] = m21; mat->m[4] = m22; mat->m[5] = m23;
-   mat->m[6] = m31; mat->m[7] = m32; mat->m[8] = m33;
-}
-
-static INLINE void matrix_load_identity(struct matrix *matrix)
-{
-   static const VGfloat identity[9] = {1.f, 0.f, 0.f,
-                                       0.f, 1.f, 0.f,
-                                       0.f, 0.f, 1.f};
-   memcpy(matrix->m, identity, sizeof(identity));
-}
-
-static INLINE VGboolean matrix_is_identity(struct matrix *matrix)
-{
-   return floatsEqual(matrix->m[0], 1) && floatIsZero(matrix->m[1]) &&
-      floatIsZero(matrix->m[2]) &&
-      floatIsZero(matrix->m[3]) && floatsEqual(matrix->m[4], 1) &&
-      floatIsZero(matrix->m[5]) &&
-      floatIsZero(matrix->m[6]) && floatIsZero(matrix->m[7]) &&
-      floatIsZero(matrix->m[8]);
-}
-
-static INLINE VGboolean matrix_is_affine(struct matrix *matrix)
-{
-   return floatIsZero(matrix->m[2]) && floatIsZero(matrix->m[5])
-      && floatsEqual(matrix->m[8], 1);
-}
-
-
-static INLINE void matrix_make_affine(struct matrix *matrix)
-{
-   matrix->m[2] = 0.f;
-   matrix->m[5] = 0.f;
-   matrix->m[8] = 1.f;
-}
-
-static INLINE void matrix_mult(struct matrix *dst,
-                               const struct matrix *src)
-{
-   VGfloat m11 = dst->m[0]*src->m[0] + dst->m[3]*src->m[1] + dst->m[6]*src->m[2];
-   VGfloat m12 = dst->m[0]*src->m[3] + dst->m[3]*src->m[4] + dst->m[6]*src->m[5];
-   VGfloat m13 = dst->m[0]*src->m[6] + dst->m[3]*src->m[7] + dst->m[6]*src->m[8];
-
-   VGfloat m21 = dst->m[1]*src->m[0] + dst->m[4]*src->m[1] + dst->m[7]*src->m[2];
-   VGfloat m22 = dst->m[1]*src->m[3] + dst->m[4]*src->m[4] + dst->m[7]*src->m[5];
-   VGfloat m23 = dst->m[1]*src->m[6] + dst->m[4]*src->m[7] + dst->m[7]*src->m[8];
-
-   VGfloat m31 = dst->m[2]*src->m[0] + dst->m[5]*src->m[1] + dst->m[8]*src->m[2];
-   VGfloat m32 = dst->m[2]*src->m[3] + dst->m[5]*src->m[4] + dst->m[8]*src->m[5];
-   VGfloat m33 = dst->m[2]*src->m[6] + dst->m[5]*src->m[7] + dst->m[8]*src->m[8];
-
-   dst->m[0] = m11; dst->m[1] = m21; dst->m[2] = m31;
-   dst->m[3] = m12; dst->m[4] = m22; dst->m[5] = m32;
-   dst->m[6] = m13; dst->m[7] = m23; dst->m[8] = m33;
-}
-
-
-static INLINE void matrix_map_point(struct matrix *mat,
-                                    VGfloat x, VGfloat y,
-                                    VGfloat *out_x, VGfloat *out_y)
-{
-   /* to be able to do matrix_map_point(m, x, y, &x, &y) use
-    * temporaries */
-   VGfloat tmp_x = x, tmp_y = y;
-
-   *out_x = mat->m[0]*tmp_x + mat->m[3]*tmp_y + mat->m[6];
-   *out_y = mat->m[1]*tmp_x + mat->m[4]*tmp_y + mat->m[7];
-   if (!matrix_is_affine(mat)) {
-      VGfloat w = 1/(mat->m[2]*tmp_x + mat->m[5]*tmp_y + mat->m[8]);
-      *out_x *= w;
-      *out_y *= w;
-   }
-}
-
-static INLINE void matrix_translate(struct matrix *dst,
-                                    VGfloat tx, VGfloat ty)
-{
-   if (!matrix_is_affine(dst)) {
-      struct matrix trans_matrix;
-      matrix_load_identity(&trans_matrix);
-      trans_matrix.m[6] = tx;
-      trans_matrix.m[7] = ty;
-      matrix_mult(dst, &trans_matrix);
-   } else {
-      dst->m[6] += tx*dst->m[0] + ty*dst->m[3];
-      dst->m[7] += ty*dst->m[4] + tx*dst->m[1];
-   }
-}
-
-static INLINE void matrix_scale(struct matrix *dst,
-                                VGfloat sx, VGfloat sy)
-{
-   if (!matrix_is_affine(dst)) {
-      struct matrix scale_matrix;
-      matrix_load_identity(&scale_matrix);
-      scale_matrix.m[0] = sx;
-      scale_matrix.m[4] = sy;
-      matrix_mult(dst, &scale_matrix);
-   } else {
-      dst->m[0] *= sx; dst->m[1] *= sx;
-      dst->m[3] *= sy; dst->m[4] *= sy;
-   }
-}
-
-static INLINE void matrix_shear(struct matrix *dst,
-                                VGfloat shx, VGfloat shy)
-{
-   struct matrix shear_matrix;
-   matrix_load_identity(&shear_matrix);
-   shear_matrix.m[1] = shy;
-   shear_matrix.m[3] = shx;
-   matrix_mult(dst, &shear_matrix);
-}
-
-static INLINE void matrix_rotate(struct matrix *dst,
-                                 VGfloat angle)
-{
-   struct matrix mat;
-   float sin_val = 0;
-   float cos_val = 0;
-
-
-   if (floatsEqual(angle, 90) || floatsEqual(angle, -270))
-      sin_val = 1.f;
-   else if (floatsEqual(angle, 270) || floatsEqual(angle, -90))
-      sin_val = -1.f;
-   else if (floatsEqual(angle, 180))
-      cos_val = -1.f;
-   else {
-      double radians = DEGREES_TO_RADIANS(angle);
-      sin_val = (float) sin(radians);
-      cos_val = (float) cos(radians);
-   }
-
-   if (!matrix_is_affine(dst)) {
-      matrix_load_identity(&mat);
-      mat.m[0] =  cos_val;   mat.m[1] =  sin_val;
-      mat.m[3] = -sin_val;   mat.m[4] =  cos_val;
-
-      matrix_mult(dst, &mat);
-   } else  {
-      VGfloat m11 =  cos_val*dst->m[0] + sin_val*dst->m[3];
-      VGfloat m12 =  cos_val*dst->m[1] + sin_val*dst->m[4];
-      VGfloat m21 = -sin_val*dst->m[0] + cos_val*dst->m[3];
-      VGfloat m22 = -sin_val*dst->m[1] + cos_val*dst->m[4];
-      dst->m[0] = m11; dst->m[1] = m12;
-      dst->m[3] = m21; dst->m[4] = m22;
-   }
-}
-
-
-static INLINE VGfloat matrix_determinant(struct matrix *mat)
-{
-   return mat->m[0]*(mat->m[8]*mat->m[4]-mat->m[7]*mat->m[5]) -
-      mat->m[3]*(mat->m[8]*mat->m[1]-mat->m[7]*mat->m[2])+
-      mat->m[6]*(mat->m[5]*mat->m[1]-mat->m[4]*mat->m[2]);
-}
-
-
-static INLINE void matrix_adjoint(struct matrix *mat)
-{
-    VGfloat h[9];
-    h[0] = mat->m[4]*mat->m[8] - mat->m[5]*mat->m[7];
-    h[3] = mat->m[5]*mat->m[6] - mat->m[3]*mat->m[8];
-    h[6] = mat->m[3]*mat->m[7] - mat->m[4]*mat->m[6];
-    h[1] = mat->m[2]*mat->m[7] - mat->m[1]*mat->m[8];
-    h[4] = mat->m[0]*mat->m[8] - mat->m[2]*mat->m[6];
-    h[7] = mat->m[1]*mat->m[6] - mat->m[0]*mat->m[7];
-    h[2] = mat->m[1]*mat->m[5] - mat->m[2]*mat->m[4];
-    h[5] = mat->m[2]*mat->m[3] - mat->m[0]*mat->m[5];
-    h[8] = mat->m[0]*mat->m[4] - mat->m[1]*mat->m[3];
-
-
-    memcpy(mat->m, h, sizeof(VGfloat) * 9);
-}
-
-static INLINE void matrix_divs(struct matrix *mat,
-                               VGfloat s)
-{
-   mat->m[0] /= s;
-   mat->m[1] /= s;
-   mat->m[2] /= s;
-   mat->m[3] /= s;
-   mat->m[4] /= s;
-   mat->m[5] /= s;
-   mat->m[6] /= s;
-   mat->m[7] /= s;
-   mat->m[8] /= s;
-}
-
-static INLINE VGboolean matrix_invert(struct matrix *mat)
-{
-   VGfloat det = matrix_determinant(mat);
-
-   if (floatIsZero(det))
-      return VG_FALSE;
-
-   matrix_adjoint(mat);
-   matrix_divs(mat, det);
-   return VG_TRUE;
-}
-
-static INLINE VGboolean matrix_is_invertible(struct matrix *mat)
-{
-   return !floatIsZero(matrix_determinant(mat));
-}
-
-
-static INLINE VGboolean matrix_square_to_quad(VGfloat dx0, VGfloat dy0,
-                                              VGfloat dx1, VGfloat dy1,
-                                              VGfloat dx3, VGfloat dy3,
-                                              VGfloat dx2, VGfloat dy2,
-                                              struct matrix *mat)
-{
-   VGfloat ax  = dx0 - dx1 + dx2 - dx3;
-   VGfloat ay  = dy0 - dy1 + dy2 - dy3;
-
-   if (floatIsZero(ax) && floatIsZero(ay)) {
-      /* affine case */
-      matrix_inits(mat,
-                   dx1 - dx0, dy1 - dy0,  0,
-                   dx2 - dx1, dy2 - dy1,  0,
-                         dx0,       dy0,  1);
-   } else {
-      VGfloat a, b, c, d, e, f, g, h;
-      VGfloat ax1 = dx1 - dx2;
-      VGfloat ax2 = dx3 - dx2;
-      VGfloat ay1 = dy1 - dy2;
-      VGfloat ay2 = dy3 - dy2;
-
-      /* determinants */
-      VGfloat gtop    =  ax  * ay2 - ax2 * ay;
-      VGfloat htop    =  ax1 * ay  - ax  * ay1;
-      VGfloat bottom  =  ax1 * ay2 - ax2 * ay1;
-
-      if (!bottom)
-         return VG_FALSE;
-
-      g = gtop / bottom;
-      h = htop / bottom;
-
-      a = dx1 - dx0 + g * dx1;
-      b = dx3 - dx0 + h * dx3;
-      c = dx0;
-      d = dy1 - dy0 + g * dy1;
-      e = dy3 - dy0 + h * dy3;
-      f = dy0;
-
-      matrix_inits(mat,
-                   a,  d,   g,
-                   b,  e,   h,
-                   c,  f, 1.f);
-   }
-
-   return VG_TRUE;
-}
-
-static INLINE VGboolean matrix_quad_to_square(VGfloat sx0, VGfloat sy0,
-                                              VGfloat sx1, VGfloat sy1,
-                                              VGfloat sx2, VGfloat sy2,
-                                              VGfloat sx3, VGfloat sy3,
-                                              struct matrix *mat)
-{
-   if (!matrix_square_to_quad(sx0, sy0, sx1, sy1,
-                              sx2, sy2, sx3, sy3,
-                              mat))
-      return VG_FALSE;
-
-    return matrix_invert(mat);
-}
-
-
-static INLINE VGboolean matrix_quad_to_quad(VGfloat dx0, VGfloat dy0,
-                                            VGfloat dx1, VGfloat dy1,
-                                            VGfloat dx2, VGfloat dy2,
-                                            VGfloat dx3, VGfloat dy3,
-                                            VGfloat sx0, VGfloat sy0,
-                                            VGfloat sx1, VGfloat sy1,
-                                            VGfloat sx2, VGfloat sy2,
-                                            VGfloat sx3, VGfloat sy3,
-                                            struct matrix *mat)
-{
-   struct matrix sqr_to_qd;
-
-   if (!matrix_square_to_quad(dx0, dy0, dx1, dy1,
-                              dx2, dy2, dx3, dy3,
-                              mat))
-      return VG_FALSE;
-
-   if (!matrix_quad_to_square(sx0, sy0, sx1, sy1,
-                              sx2, sy2, sx3, sy3,
-                              &sqr_to_qd))
-      return VG_FALSE;
-
-   matrix_mult(mat, &sqr_to_qd);
-
-   return VG_TRUE;
-}
-
-
-static INLINE VGboolean null_line(const VGfloat *l)
-{
-   return floatsEqual(l[0], l[2]) && floatsEqual(l[1], l[3]);
-}
-
-static INLINE void line_normal(float *l, float *norm)
-{
-   norm[0] = l[0];
-   norm[1] = l[1];
-
-   norm[2] = l[0] + (l[3] - l[1]);
-   norm[3] = l[1] - (l[2] - l[0]);
-}
-
-static INLINE void line_normalize(float *l)
-{
-   float x = l[2] - l[0];
-   float y = l[3] - l[1];
-   float len = (float) sqrt(x*x + y*y);
-   l[2] = l[0] + x/len;
-   l[3] = l[1] + y/len;
-}
-
-static INLINE VGfloat line_length(VGfloat x1, VGfloat y1,
-                                  VGfloat x2, VGfloat y2)
-{
-   VGfloat x = x2 - x1;
-   VGfloat y = y2 - y1;
-   return (VGfloat) sqrt(x*x + y*y);
-}
-
-static INLINE VGfloat line_lengthv(const VGfloat *l)
-{
-   VGfloat x = l[2] - l[0];
-   VGfloat y = l[3] - l[1];
-   return (VGfloat) sqrt(x*x + y*y);
-}
-
-
-static INLINE void line_point_at(float *l, float t, float *pt)
-{
-   float dx = l[2] - l[0];
-   float dy = l[3] - l[1];
-
-   pt[0] = l[0] + dx * t;
-   pt[1] = l[1] + dy * t;
-}
-
-static INLINE void vector_unit(float *vec)
-{
-   float len = (float) sqrt(vec[0] * vec[0] + vec[1] * vec[1]);
-   vec[0] /= len;
-   vec[1] /= len;
-}
-
-static INLINE void line_normal_vector(float *line, float *vec)
-{
-   VGfloat normal[4];
-
-   line_normal(line, normal);
-
-   vec[0] = normal[2] - normal[0];
-   vec[1] = normal[3] - normal[1];
-
-   vector_unit(vec);
-}
-
-#endif
diff --git a/src/gallium/state_trackers/vega/paint.c b/src/gallium/state_trackers/vega/paint.c
deleted file mode 100644
index fea9fc18e66..00000000000
--- a/src/gallium/state_trackers/vega/paint.c
+++ /dev/null
@@ -1,759 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "paint.h"
-
-#include "matrix.h"
-#include "image.h"
-
-#include "pipe/p_compiler.h"
-#include "util/u_inlines.h"
-
-#include "util/u_memory.h"
-#include "util/u_math.h"
-#include "util/u_sampler.h"
-
-#include "cso_cache/cso_context.h"
-
-struct vg_paint {
-   struct vg_object base;
-
-   VGPaintType type;
-
-   struct {
-      VGfloat color[4];
-      VGint colori[4];
-   } solid;
-
-   struct {
-      VGColorRampSpreadMode spread;
-      VGuint color_data[1024];
-      struct {
-         VGfloat  coords[4];
-         VGint  coordsi[4];
-      } linear;
-      struct {
-         VGfloat vals[5];
-         VGint valsi[5];
-      } radial;
-      struct pipe_sampler_view *sampler_view;
-      struct pipe_sampler_state sampler;
-
-      VGfloat *ramp_stops;
-      VGint *ramp_stopsi;
-      VGint    num_stops;
-
-      VGboolean color_ramps_premultiplied;
-   } gradient;
-
-   struct {
-      struct pipe_sampler_view *sampler_view;
-      VGTilingMode tiling_mode;
-      struct pipe_sampler_state sampler;
-   } pattern;
-
-   /* XXX next 3 all unneded? */
-   struct pipe_resource *cbuf;
-   struct pipe_shader_state fs_state;
-   void *fs;
-};
-
-static INLINE VGuint mix_pixels(VGuint p1, VGuint a, VGuint p2, VGuint b)
-{
-   VGuint t = (p1 & 0xff00ff) * a + (p2 & 0xff00ff) * b;
-   t >>= 8; t &= 0xff00ff;
-
-   p1 = ((p1 >> 8) & 0xff00ff) * a + ((p2 >> 8) & 0xff00ff) * b;
-   p1 &= 0xff00ff00; p1 |= t;
-
-   return p1;
-}
-
-static INLINE VGuint float4_to_argb(const VGfloat *clr)
-{
-   return float_to_ubyte(clr[3]) << 24 |
-      float_to_ubyte(clr[0]) << 16 |
-      float_to_ubyte(clr[1]) << 8 |
-      float_to_ubyte(clr[2]) << 0;
-}
-
-static INLINE void create_gradient_data(const VGfloat *ramp_stops,
-                                        VGint num,
-                                        VGuint *data,
-                                        VGint size)
-{
-   VGint i;
-   VGint pos = 0;
-   VGfloat fpos = 0, incr = 1.f / size;
-   VGuint last_color;
-
-   while (fpos < ramp_stops[0]) {
-      data[pos] = float4_to_argb(ramp_stops + 1);
-      fpos += incr;
-      ++pos;
-   }
-
-   for (i = 0; i < num - 1; ++i) {
-      VGint rcur  = 5 * i;
-      VGint rnext = 5 * (i + 1);
-      VGfloat delta = 1.f/(ramp_stops[rnext] - ramp_stops[rcur]);
-      while (fpos < ramp_stops[rnext] && pos < size) {
-         VGint dist = 256 * ((fpos - ramp_stops[rcur]) * delta);
-         VGint idist = 256 - dist;
-         VGuint current_color = float4_to_argb(ramp_stops + rcur + 1);
-         VGuint next_color = float4_to_argb(ramp_stops + rnext + 1);
-         data[pos] = mix_pixels(current_color, idist,
-                                next_color, dist);
-         fpos += incr;
-         ++pos;
-      }
-   }
-
-   last_color = float4_to_argb(ramp_stops + ((num - 1) * 5 + 1));
-   while (pos < size) {
-      data[pos] = last_color;
-      ++pos;
-   }
-   data[size-1] = last_color;
-}
-
-static INLINE struct pipe_resource *create_gradient_texture(struct vg_paint *p)
-{
-   struct pipe_context *pipe = p->base.ctx->pipe;
-   struct pipe_screen *screen = pipe->screen;
-   struct pipe_resource *tex = 0;
-   struct pipe_resource templ;
-
-   memset(&templ, 0, sizeof(templ));
-   templ.target = PIPE_TEXTURE_1D;
-   templ.format = PIPE_FORMAT_B8G8R8A8_UNORM;
-   templ.last_level = 0;
-   templ.width0 = 1024;
-   templ.height0 = 1;
-   templ.depth0 = 1;
-   templ.array_size = 1;
-   templ.bind = PIPE_BIND_SAMPLER_VIEW;
-
-   tex = screen->resource_create(screen, &templ);
-
-   { /* upload color_data */
-      struct pipe_transfer *transfer;
-      void *map =
-         pipe_transfer_map(p->base.ctx->pipe, tex, 0, 0,
-                           PIPE_TRANSFER_WRITE, 0, 0, 1024, 1,
-                           &transfer);
-      memcpy(map, p->gradient.color_data, sizeof(VGint)*1024);
-      pipe->transfer_unmap(pipe, transfer);
-   }
-
-   return tex;
-}
-
-static INLINE struct pipe_sampler_view *create_gradient_sampler_view(struct vg_paint *p)
-{
-   struct pipe_context *pipe = p->base.ctx->pipe;
-   struct pipe_resource *texture;
-   struct pipe_sampler_view view_templ;
-   struct pipe_sampler_view *view;
-
-   texture = create_gradient_texture(p);
-
-   if (!texture)
-      return NULL;
-
-   u_sampler_view_default_template(&view_templ, texture, texture->format);
-   view = pipe->create_sampler_view(pipe, texture, &view_templ);
-   /* want the texture to go away if the view is freed */
-   pipe_resource_reference(&texture, NULL);
-
-   return view;
-}
-
-struct vg_paint * paint_create(struct vg_context *ctx)
-{
-   struct vg_paint *paint = CALLOC_STRUCT(vg_paint);
-   const VGfloat default_color[] = {0.0f, 0.0f, 0.0f, 1.0f};
-   const VGfloat def_ling[] = {0.0f, 0.0f, 1.0f, 0.0f};
-   const VGfloat def_radg[] = {0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
-   vg_init_object(&paint->base, ctx, VG_OBJECT_PAINT);
-   vg_context_add_object(ctx, &paint->base);
-
-   paint->type = VG_PAINT_TYPE_COLOR;
-   memcpy(paint->solid.color, default_color,
-          4 * sizeof(VGfloat));
-   paint->gradient.spread = VG_COLOR_RAMP_SPREAD_PAD;
-   memcpy(paint->gradient.linear.coords, def_ling,
-          4 * sizeof(VGfloat));
-   memcpy(paint->gradient.radial.vals, def_radg,
-          5 * sizeof(VGfloat));
-
-   paint->gradient.sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-   paint->gradient.sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-   paint->gradient.sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST;
-   paint->gradient.sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST;
-   paint->gradient.sampler.normalized_coords = 1;
-
-   memcpy(&paint->pattern.sampler,
-          &paint->gradient.sampler,
-          sizeof(struct pipe_sampler_state));
-
-   return paint;
-}
-
-void paint_destroy(struct vg_paint *paint)
-{
-   struct vg_context *ctx = paint->base.ctx;
-   pipe_sampler_view_reference(&paint->gradient.sampler_view, NULL);
-   if (paint->pattern.sampler_view)
-      pipe_sampler_view_reference(&paint->pattern.sampler_view, NULL);
-   if (ctx) {
-      vg_context_remove_object(ctx, &paint->base);
-      vg_free_object(&paint->base);
-   }
-
-   free(paint->gradient.ramp_stopsi);
-   free(paint->gradient.ramp_stops);
-   FREE(paint);
-}
-
-void paint_set_color(struct vg_paint *paint,
-                     const VGfloat *color)
-{
-   paint->solid.color[0] = color[0];
-   paint->solid.color[1] = color[1];
-   paint->solid.color[2] = color[2];
-   paint->solid.color[3] = color[3];
-
-   paint->solid.colori[0] = FLT_TO_INT(color[0]);
-   paint->solid.colori[1] = FLT_TO_INT(color[1]);
-   paint->solid.colori[2] = FLT_TO_INT(color[2]);
-   paint->solid.colori[3] = FLT_TO_INT(color[3]);
-}
-
-static INLINE void paint_color_buffer(struct vg_paint *paint, void *buffer)
-{
-   VGfloat *map = (VGfloat*)buffer;
-   memcpy(buffer, paint->solid.color, 4 * sizeof(VGfloat));
-   map[4] = 0.f;
-   map[5] = 1.f;
-   map[6] = 2.f;
-   map[7] = 4.f;
-}
-
-static INLINE void paint_linear_gradient_buffer(struct vg_paint *paint,
-                                                const struct matrix *inv,
-                                                void *buffer)
-{
-   VGfloat *map = (VGfloat*)buffer;
-   VGfloat dd;
-
-   map[0] = paint->gradient.linear.coords[2] - paint->gradient.linear.coords[0];
-   map[1] = paint->gradient.linear.coords[3] - paint->gradient.linear.coords[1];
-   dd = (map[0] * map[0] + map[1] * map[1]);
-
-   map[2] = (dd > 0.0f) ? 1.f / dd : 0.f;
-   map[3] = 1.f;
-
-   map[4] = 0.f;
-   map[5] = 1.f;
-   map[6] = 2.f;
-   map[7] = 4.f;
-   {
-      struct matrix mat;
-      matrix_load_identity(&mat);
-      /* VEGA_LINEAR_GRADIENT_SHADER expects the first point to be at (0, 0) */
-      matrix_translate(&mat, -paint->gradient.linear.coords[0], -paint->gradient.linear.coords[1]);
-      matrix_mult(&mat, inv);
-
-      map[8]  = mat.m[0]; map[9]  = mat.m[3]; map[10] = mat.m[6]; map[11] = 0.f;
-      map[12] = mat.m[1]; map[13] = mat.m[4]; map[14] = mat.m[7]; map[15] = 0.f;
-      map[16] = mat.m[2]; map[17] = mat.m[5]; map[18] = mat.m[8]; map[19] = 0.f;
-   }
-#if 0
-   debug_printf("Coords  (%f, %f, %f, %f)\n",
-                map[0], map[1], map[2], map[3]);
-#endif
-}
-
-
-static INLINE void paint_radial_gradient_buffer(struct vg_paint *paint,
-                                                const struct matrix *inv,
-                                                void *buffer)
-{
-   const VGfloat *center = &paint->gradient.radial.vals[0];
-   const VGfloat *focal = &paint->gradient.radial.vals[2];
-   VGfloat rr = paint->gradient.radial.vals[4];
-   VGfloat *map = (VGfloat*)buffer;
-   VGfloat dd, new_focal[2];
-
-   rr *= rr;
-
-   map[0] = center[0] - focal[0];
-   map[1] = center[1] - focal[1];
-   dd = map[0] * map[0] + map[1] * map[1];
-
-   /* focal point must lie inside the circle */
-   if (0.998f * rr < dd) {
-      VGfloat scale;
-
-      scale = (dd > 0.0f) ? sqrt(0.998f * rr / dd) : 0.0f;
-      map[0] *= scale;
-      map[1] *= scale;
-
-      new_focal[0] = center[0] - map[0];
-      new_focal[1] = center[1] - map[1];
-      dd = map[0] * map[0] + map[1] * map[1];
-      focal = new_focal;
-   }
-
-   map[2] = (rr > dd) ? rr - dd : 1.0f;
-   map[3] = 1.f;
-
-   map[4] = 0.f;
-   map[5] = 1.f;
-   map[6] = 2.f;
-   map[7] = 4.f;
-
-   {
-      struct matrix mat;
-      matrix_load_identity(&mat);
-      matrix_translate(&mat, -focal[0], -focal[1]);
-      matrix_mult(&mat, inv);
-
-      map[8]  = mat.m[0]; map[9]  = mat.m[3]; map[10] = mat.m[6]; map[11] = 0.f;
-      map[12] = mat.m[1]; map[13] = mat.m[4]; map[14] = mat.m[7]; map[15] = 0.f;
-      map[16] = mat.m[2]; map[17] = mat.m[5]; map[18] = mat.m[8]; map[19] = 0.f;
-   }
-
-#if 0
-   debug_printf("Coords  (%f, %f, %f, %f)\n",
-                map[0], map[1], map[2], map[3]);
-#endif
-}
-
-
-static INLINE void  paint_pattern_buffer(struct vg_paint *paint,
-                                         const struct matrix *inv,
-                                         void *buffer)
-{
-   VGfloat *map = (VGfloat *)buffer;
-   memcpy(map, paint->solid.color, 4 * sizeof(VGfloat));
-
-   map[4] = 0.f;
-   map[5] = 1.f;
-   map[6] = paint->pattern.sampler_view->texture->width0;
-   map[7] = paint->pattern.sampler_view->texture->height0;
-   {
-      struct matrix mat;
-
-      memcpy(&mat, inv, sizeof(*inv));
-
-      map[8]  = mat.m[0]; map[9]  = mat.m[3]; map[10] = mat.m[6]; map[11] = 0.f;
-      map[12] = mat.m[1]; map[13] = mat.m[4]; map[14] = mat.m[7]; map[15] = 0.f;
-      map[16] = mat.m[2]; map[17] = mat.m[5]; map[18] = mat.m[8]; map[19] = 0.f;
-   }
-}
-
-void paint_set_type(struct vg_paint *paint, VGPaintType type)
-{
-   paint->type = type;
-}
-
-void paint_set_ramp_stops(struct vg_paint *paint, const VGfloat *stops,
-                          int num)
-{
-   const VGfloat default_stops[] = {0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
-                                    1.0f, 1.0f, 1.0f, 1.0f, 1.0f};
-   VGint i;
-   const VGint num_stops = num / 5;
-   VGfloat last_coord;
-
-   paint->gradient.num_stops = num;
-   if (num) {
-      free(paint->gradient.ramp_stops);
-      paint->gradient.ramp_stops = malloc(sizeof(VGfloat)*num);
-      memcpy(paint->gradient.ramp_stops, stops, sizeof(VGfloat)*num);
-   } else
-      return;
-
-   /* stops must be in increasing order. the last stop is 1.0. if the
-    * first one is bigger than 1 then the whole sequence is invalid*/
-   if (stops[0] > 1) {
-      stops = default_stops;
-      num = 10;
-   }
-   last_coord = stops[0];
-   for (i = 1; i < num_stops; ++i) {
-      VGint idx = 5 * i;
-      VGfloat coord = stops[idx];
-      if (!floatsEqual(last_coord, coord) && coord < last_coord) {
-         stops = default_stops;
-         num = 10;
-         break;
-      }
-      last_coord = coord;
-   }
-
-   create_gradient_data(stops, num / 5, paint->gradient.color_data,
-                        1024);
-
-   if (paint->gradient.sampler_view) {
-      pipe_sampler_view_reference(&paint->gradient.sampler_view, NULL);
-      paint->gradient.sampler_view = NULL;
-   }
-
-   paint->gradient.sampler_view = create_gradient_sampler_view(paint);
-}
-
-void paint_set_colori(struct vg_paint *p,
-                      VGuint rgba)
-{
-   p->solid.color[0] = ((rgba >> 24) & 0xff) / 255.f;
-   p->solid.color[1] = ((rgba >> 16) & 0xff) / 255.f;
-   p->solid.color[2] = ((rgba >>  8) & 0xff) / 255.f;
-   p->solid.color[3] = ((rgba >>  0) & 0xff) / 255.f;
-}
-
-VGuint paint_colori(struct vg_paint *p)
-{
-#define F2B(f) (float_to_ubyte(f))
-
-   return ((F2B(p->solid.color[0]) << 24) |
-           (F2B(p->solid.color[1]) << 16) |
-           (F2B(p->solid.color[2]) << 8)  |
-           (F2B(p->solid.color[3]) << 0));
-#undef F2B
-}
-
-void paint_set_linear_gradient(struct vg_paint *paint,
-                               const VGfloat *coords)
-{
-   memcpy(paint->gradient.linear.coords, coords, sizeof(VGfloat) * 4);
-}
-
-void paint_set_spread_mode(struct vg_paint *paint,
-                           VGint mode)
-{
-   paint->gradient.spread = mode;
-   switch(mode) {
-   case VG_COLOR_RAMP_SPREAD_PAD:
-      paint->gradient.sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-      break;
-   case VG_COLOR_RAMP_SPREAD_REPEAT:
-      paint->gradient.sampler.wrap_s = PIPE_TEX_WRAP_REPEAT;
-      break;
-   case VG_COLOR_RAMP_SPREAD_REFLECT:
-      paint->gradient.sampler.wrap_s = PIPE_TEX_WRAP_MIRROR_REPEAT;
-      break;
-   }
-}
-
-VGColorRampSpreadMode paint_spread_mode(struct vg_paint *paint)
-{
-   return paint->gradient.spread;
-}
-
-void paint_set_radial_gradient(struct vg_paint *paint,
-                               const VGfloat *values)
-{
-   memcpy(paint->gradient.radial.vals, values, sizeof(VGfloat) * 5);
-}
-
-void paint_set_pattern(struct vg_paint *paint,
-                       struct vg_image *img)
-{
-   if (paint->pattern.sampler_view)
-      pipe_sampler_view_reference(&paint->pattern.sampler_view, NULL);
-
-   paint->pattern.sampler_view = NULL;
-   pipe_sampler_view_reference(&paint->pattern.sampler_view,
-                               img->sampler_view);
-}
-
-void paint_set_pattern_tiling(struct vg_paint *paint,
-                              VGTilingMode mode)
-{
-   paint->pattern.tiling_mode = mode;
-
-   switch(mode) {
-   case VG_TILE_FILL:
-      paint->pattern.sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_BORDER;
-      paint->pattern.sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_BORDER;
-      break;
-   case VG_TILE_PAD:
-      paint->pattern.sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-      paint->pattern.sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-      break;
-   case VG_TILE_REPEAT:
-      paint->pattern.sampler.wrap_s = PIPE_TEX_WRAP_REPEAT;
-      paint->pattern.sampler.wrap_t = PIPE_TEX_WRAP_REPEAT;
-      break;
-   case VG_TILE_REFLECT:
-      paint->pattern.sampler.wrap_s = PIPE_TEX_WRAP_MIRROR_REPEAT;
-      paint->pattern.sampler.wrap_t = PIPE_TEX_WRAP_MIRROR_REPEAT;
-      break;
-   default:
-      debug_assert(!"Unknown tiling mode");
-   }
-}
-
-void paint_get_color(struct vg_paint *paint,
-                     VGfloat *color)
-{
-   color[0] = paint->solid.color[0];
-   color[1] = paint->solid.color[1];
-   color[2] = paint->solid.color[2];
-   color[3] = paint->solid.color[3];
-}
-
-void paint_ramp_stops(struct vg_paint *paint, VGfloat *stops,
-                      int num)
-{
-   memcpy(stops, paint->gradient.ramp_stops, sizeof(VGfloat)*num);
-}
-
-void paint_linear_gradient(struct vg_paint *paint,
-                           VGfloat *coords)
-{
-   memcpy(coords, paint->gradient.linear.coords, sizeof(VGfloat)*4);
-}
-
-void paint_radial_gradient(struct vg_paint *paint,
-                           VGfloat *coords)
-{
-   memcpy(coords, paint->gradient.radial.vals, sizeof(VGfloat)*5);
-}
-
-int paint_num_ramp_stops(struct vg_paint *paint)
-{
-   return paint->gradient.num_stops;
-}
-
-VGPaintType paint_type(struct vg_paint *paint)
-{
-   return paint->type;
-}
-
-void paint_set_coloriv(struct vg_paint *paint,
-                      const VGint *color)
-{
-   paint->solid.color[0] = color[0];
-   paint->solid.color[1] = color[1];
-   paint->solid.color[2] = color[2];
-   paint->solid.color[3] = color[3];
-
-   paint->solid.colori[0] = color[0];
-   paint->solid.colori[1] = color[1];
-   paint->solid.colori[2] = color[2];
-   paint->solid.colori[3] = color[3];
-}
-
-void paint_get_coloriv(struct vg_paint *paint,
-                      VGint *color)
-{
-   color[0] = paint->solid.colori[0];
-   color[1] = paint->solid.colori[1];
-   color[2] = paint->solid.colori[2];
-   color[3] = paint->solid.colori[3];
-}
-
-void paint_set_color_ramp_premultiplied(struct vg_paint *paint,
-                                        VGboolean set)
-{
-   paint->gradient.color_ramps_premultiplied = set;
-}
-
-VGboolean paint_color_ramp_premultiplied(struct vg_paint *paint)
-{
-   return paint->gradient.color_ramps_premultiplied;
-}
-
-void paint_set_ramp_stopsi(struct vg_paint *paint, const VGint *stops,
-                           int num)
-{
-   if (num) {
-      free(paint->gradient.ramp_stopsi);
-      paint->gradient.ramp_stopsi = malloc(sizeof(VGint)*num);
-      memcpy(paint->gradient.ramp_stopsi, stops, sizeof(VGint)*num);
-   }
-}
-
-void paint_ramp_stopsi(struct vg_paint *paint, VGint *stops,
-                       int num)
-{
-   memcpy(stops, paint->gradient.ramp_stopsi, sizeof(VGint)*num);
-}
-
-void paint_set_linear_gradienti(struct vg_paint *paint,
-                                const VGint *coords)
-{
-   memcpy(paint->gradient.linear.coordsi, coords, sizeof(VGint) * 4);
-}
-
-void paint_linear_gradienti(struct vg_paint *paint,
-                            VGint *coords)
-{
-   memcpy(coords, paint->gradient.linear.coordsi, sizeof(VGint)*4);
-}
-
-void paint_set_radial_gradienti(struct vg_paint *paint,
-                                const VGint *values)
-{
-   memcpy(paint->gradient.radial.valsi, values, sizeof(VGint) * 5);
-}
-
-void paint_radial_gradienti(struct vg_paint *paint,
-                            VGint *coords)
-{
-   memcpy(coords, paint->gradient.radial.valsi, sizeof(VGint)*5);
-}
-
-VGTilingMode paint_pattern_tiling(struct vg_paint *paint)
-{
-   return paint->pattern.tiling_mode;
-}
-
-VGint paint_bind_samplers(struct vg_paint *paint, struct pipe_sampler_state **samplers,
-                          struct pipe_sampler_view **sampler_views)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   switch(paint->type) {
-   case VG_PAINT_TYPE_LINEAR_GRADIENT:
-   case VG_PAINT_TYPE_RADIAL_GRADIENT: {
-      if (paint->gradient.sampler_view) {
-         paint->gradient.sampler.min_img_filter = image_sampler_filter(ctx);
-         paint->gradient.sampler.mag_img_filter = image_sampler_filter(ctx);
-         samplers[0] = &paint->gradient.sampler;
-         sampler_views[0] = paint->gradient.sampler_view;
-         return 1;
-      }
-   }
-      break;
-   case VG_PAINT_TYPE_PATTERN: {
-      memcpy(paint->pattern.sampler.border_color.f,
-             ctx->state.vg.tile_fill_color,
-             sizeof(VGfloat) * 4);
-      paint->pattern.sampler.min_img_filter = image_sampler_filter(ctx);
-      paint->pattern.sampler.mag_img_filter = image_sampler_filter(ctx);
-      samplers[0] = &paint->pattern.sampler;
-      sampler_views[0] = paint->pattern.sampler_view;
-      return 1;
-   }
-      break;
-   default:
-      break;
-   }
-   return 0;
-}
-
-void paint_resolve_type(struct vg_paint *paint)
-{
-   if (paint->type == VG_PAINT_TYPE_PATTERN &&
-       !paint->pattern.sampler_view) {
-      paint->type = VG_PAINT_TYPE_COLOR;
-   }
-}
-
-VGboolean paint_is_degenerate(struct vg_paint *paint)
-{
-   VGboolean degen;
-   VGfloat *vals;
-
-
-   switch (paint->type) {
-   case VG_PAINT_TYPE_LINEAR_GRADIENT:
-      vals = paint->gradient.linear.coords;
-      /* two points are coincident */
-      degen = (floatsEqual(vals[0], vals[2]) &&
-               floatsEqual(vals[1], vals[3]));
-      break;
-   case VG_PAINT_TYPE_RADIAL_GRADIENT:
-      vals = paint->gradient.radial.vals;
-      /* radius <= 0 */
-      degen = (vals[4] <= 0.0f);
-      break;
-   case VG_PAINT_TYPE_COLOR:
-   case VG_PAINT_TYPE_PATTERN:
-   default:
-      degen = VG_FALSE;
-      break;
-   }
-
-   return degen;
-}
-
-VGint paint_constant_buffer_size(struct vg_paint *paint)
-{
-   switch(paint->type) {
-   case VG_PAINT_TYPE_COLOR:
-      return 8 * sizeof(VGfloat);/*4 color + 4 constants (0.f,1.f,2.f,4.f)*/
-      break;
-   case VG_PAINT_TYPE_LINEAR_GRADIENT:
-      return 20 * sizeof(VGfloat);
-      break;
-   case VG_PAINT_TYPE_RADIAL_GRADIENT:
-      return 20 * sizeof(VGfloat);
-      break;
-   case VG_PAINT_TYPE_PATTERN:
-      return 20 * sizeof(VGfloat);
-      break;
-   default:
-      debug_printf("Uknown paint type: %d\n", paint->type);
-   }
-
-   return 0;
-}
-
-void paint_fill_constant_buffer(struct vg_paint *paint,
-                                const struct matrix *mat,
-                                void *buffer)
-{
-   switch(paint->type) {
-   case VG_PAINT_TYPE_COLOR:
-      paint_color_buffer(paint, buffer);
-      break;
-   case VG_PAINT_TYPE_LINEAR_GRADIENT:
-      paint_linear_gradient_buffer(paint, mat, buffer);
-      break;
-   case VG_PAINT_TYPE_RADIAL_GRADIENT:
-      paint_radial_gradient_buffer(paint, mat, buffer);
-      break;
-   case VG_PAINT_TYPE_PATTERN:
-      paint_pattern_buffer(paint, mat, buffer);
-      break;
-
-   default:
-      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
deleted file mode 100644
index e5357763b89..00000000000
--- a/src/gallium/state_trackers/vega/paint.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef PAINT_H
-#define PAINT_H
-
-#include "vg_context.h"
-
-#include "VG/openvg.h"
-#include "pipe/p_state.h"
-
-struct vg_paint;
-struct vg_image;
-struct pipe_sampler_state;
-struct pipe_resource;
-
-struct vg_paint *paint_create(struct vg_context *ctx);
-void paint_destroy(struct vg_paint *paint);
-
-void paint_set_color(struct vg_paint *paint,
-                     const VGfloat *color);
-void paint_get_color(struct vg_paint *paint,
-                     VGfloat *color);
-
-void paint_set_coloriv(struct vg_paint *paint,
-                      const VGint *color);
-void paint_get_coloriv(struct vg_paint *paint,
-                      VGint *color);
-
-void paint_set_colori(struct vg_paint *paint,
-                      VGuint rgba);
-
-VGuint paint_colori(struct vg_paint *paint);
-
-void paint_set_type(struct vg_paint *paint, VGPaintType type);
-VGPaintType paint_type(struct vg_paint *paint);
-void paint_resolve_type(struct vg_paint *paint);
-
-void paint_set_linear_gradient(struct vg_paint *paint,
-                               const VGfloat *coords);
-void paint_linear_gradient(struct vg_paint *paint,
-                           VGfloat *coords);
-void paint_set_linear_gradienti(struct vg_paint *paint,
-                               const VGint *coords);
-void paint_linear_gradienti(struct vg_paint *paint,
-                           VGint *coords);
-
-
-void paint_set_radial_gradient(struct vg_paint *paint,
-                               const VGfloat *values);
-void paint_radial_gradient(struct vg_paint *paint,
-                           VGfloat *coords);
-void paint_set_radial_gradienti(struct vg_paint *paint,
-                                const VGint *values);
-void paint_radial_gradienti(struct vg_paint *paint,
-                            VGint *coords);
-
-
-void paint_set_ramp_stops(struct vg_paint *paint, const VGfloat *stops,
-                          int num);
-void paint_ramp_stops(struct vg_paint *paint, VGfloat *stops,
-                      int num);
-
-void paint_set_ramp_stopsi(struct vg_paint *paint, const VGint *stops,
-                           int num);
-void paint_ramp_stopsi(struct vg_paint *paint, VGint *stops,
-                       int num);
-
-int paint_num_ramp_stops(struct vg_paint *paint);
-
-void paint_set_spread_mode(struct vg_paint *paint,
-                           VGint mode);
-VGColorRampSpreadMode paint_spread_mode(struct vg_paint *paint);
-
-
-void paint_set_pattern(struct vg_paint *paint,
-                       struct vg_image *img);
-void paint_set_pattern_tiling(struct vg_paint *paint,
-                              VGTilingMode mode);
-VGTilingMode paint_pattern_tiling(struct vg_paint *paint);
-
-void paint_set_color_ramp_premultiplied(struct vg_paint *paint,
-                                        VGboolean set);
-VGboolean paint_color_ramp_premultiplied(struct vg_paint *paint);
-
-
-VGint paint_bind_samplers(struct vg_paint *paint, struct pipe_sampler_state **samplers,
-                          struct pipe_sampler_view **sampler_views);
-
-VGboolean paint_is_degenerate(struct vg_paint *paint);
-
-VGint paint_constant_buffer_size(struct vg_paint *paint);
-
-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/path.c b/src/gallium/state_trackers/vega/path.c
deleted file mode 100644
index 6448e642cd6..00000000000
--- a/src/gallium/state_trackers/vega/path.c
+++ /dev/null
@@ -1,2077 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "path.h"
-
-#include "stroker.h"
-#include "polygon.h"
-#include "bezier.h"
-#include "matrix.h"
-#include "vg_context.h"
-#include "util_array.h"
-#include "arc.h"
-#include "path_utils.h"
-#include "paint.h"
-#include "shader.h"
-
-#include "util/u_memory.h"
-
-#include <assert.h>
-
-#define DEBUG_PATH 0
-
-struct path {
-   struct vg_object base;
-   VGbitfield caps;
-   VGboolean dirty;
-   VGboolean dirty_stroke;
-
-   VGPathDatatype datatype;
-
-   VGfloat scale;
-   VGfloat bias;
-
-   VGint num_segments;
-
-   struct array * segments;
-   struct array * control_points;
-
-   struct {
-      struct polygon_array polygon_array;
-      struct matrix matrix;
-   } fill_polys;
-
-   struct {
-      struct path *path;
-      struct matrix matrix;
-      VGfloat stroke_width;
-      VGfloat miter_limit;
-      VGCapStyle cap_style;
-      VGJoinStyle join_style;
-   } stroked;
-};
-
-
-static INLINE void data_at(void **data,
-                           struct path *p,
-                           VGint start, VGint count,
-                           VGfloat *out)
-{
-   VGPathDatatype dt = p->datatype;
-   VGint i;
-   VGint end = start + count;
-   VGfloat *itr = out;
-
-   switch(dt) {
-   case VG_PATH_DATATYPE_S_8: {
-      VGbyte **bdata = (VGbyte **)data;
-      for (i = start; i < end; ++i) {
-         *itr = (*bdata)[i];
-         ++itr;
-      }
-      *bdata += count;
-   }
-      break;
-   case VG_PATH_DATATYPE_S_16: {
-      VGshort **bdata = (VGshort **)data;
-      for (i = start; i < end; ++i) {
-         *itr = (*bdata)[i];
-         ++itr;
-      }
-      *bdata += count;
-   }
-      break;
-   case VG_PATH_DATATYPE_S_32: {
-      VGint **bdata = (VGint **)data;
-      for (i = start; i < end; ++i) {
-         *itr = (*bdata)[i];
-         ++itr;
-      }
-      *bdata += count;
-   }
-      break;
-   case VG_PATH_DATATYPE_F: {
-      VGfloat **fdata = (VGfloat **)data;
-      for (i = start; i < end; ++i) {
-         *itr = (*fdata)[i];
-         ++itr;
-      }
-      *fdata += count;
-   }
-      break;
-   default:
-      debug_assert(!"Unknown path datatype!");
-   }
-}
-
-
-void vg_float_to_datatype(VGPathDatatype datatype,
-                          VGubyte *common_data,
-                          const VGfloat *data,
-                          VGint num_coords)
-{
-   VGint i;
-   switch(datatype) {
-   case VG_PATH_DATATYPE_S_8: {
-      for (i = 0; i < num_coords; ++i) {
-         common_data[i] = (VGubyte)data[i];
-      }
-   }
-      break;
-   case VG_PATH_DATATYPE_S_16: {
-      VGshort *buf = (VGshort*)common_data;
-      for (i = 0; i < num_coords; ++i) {
-         buf[i] = (VGshort)data[i];
-      }
-   }
-      break;
-   case VG_PATH_DATATYPE_S_32: {
-      VGint *buf = (VGint*)common_data;
-      for (i = 0; i < num_coords; ++i) {
-         buf[i] = (VGint)data[i];
-      }
-   }
-      break;
-   case VG_PATH_DATATYPE_F: {
-      memcpy(common_data, data, sizeof(VGfloat) * num_coords);
-   }
-      break;
-   default:
-      debug_assert(!"Unknown path datatype!");
-   }
-}
-
-static void coords_adjust_by_scale_bias(struct path *p,
-                                        void *pdata, VGint num_coords,
-                                        VGfloat scale, VGfloat bias,
-                                        VGPathDatatype datatype)
-{
-   VGfloat data[8];
-   void *coords = (VGfloat *)pdata;
-   VGubyte *common_data = (VGubyte *)pdata;
-   VGint size_dst = size_for_datatype(datatype);
-   VGint i;
-
-   for (i = 0; i < num_coords; ++i) {
-      data_at(&coords, p, 0, 1, data);
-      data[0] = data[0] * scale + bias;
-      vg_float_to_datatype(datatype, common_data, data, 1);
-      common_data += size_dst;
-   }
-}
-
-struct path * path_create(VGPathDatatype dt, VGfloat scale, VGfloat bias,
-                          VGint segmentCapacityHint,
-                          VGint coordCapacityHint,
-                          VGbitfield capabilities)
-{
-   struct path *path = CALLOC_STRUCT(path);
-
-   vg_init_object(&path->base, vg_current_context(), VG_OBJECT_PATH);
-   path->caps = capabilities & VG_PATH_CAPABILITY_ALL;
-   vg_context_add_object(vg_current_context(), &path->base);
-
-   path->datatype = dt;
-   path->scale = scale;
-   path->bias = bias;
-
-   path->segments = array_create(size_for_datatype(VG_PATH_DATATYPE_S_8));
-   path->control_points = array_create(size_for_datatype(dt));
-
-   path->dirty = VG_TRUE;
-   path->dirty_stroke = VG_TRUE;
-
-   return path;
-}
-
-static void polygon_array_cleanup(struct polygon_array *polyarray)
-{
-   if (polyarray->array) {
-      VGint i;
-
-      for (i = 0; i < polyarray->array->num_elements; i++) {
-         struct polygon *p = ((struct polygon **) polyarray->array->data)[i];
-         polygon_destroy(p);
-      }
-
-      array_destroy(polyarray->array);
-      polyarray->array = NULL;
-   }
-}
-
-void path_destroy(struct path *p)
-{
-   vg_context_remove_object(vg_current_context(), &p->base);
-
-   array_destroy(p->segments);
-   array_destroy(p->control_points);
-
-   polygon_array_cleanup(&p->fill_polys.polygon_array);
-
-   if (p->stroked.path)
-      path_destroy(p->stroked.path);
-
-   vg_free_object(&p->base);
-
-   FREE(p);
-}
-
-VGbitfield path_capabilities(struct path *p)
-{
-   return p->caps;
-}
-
-void path_set_capabilities(struct path *p, VGbitfield bf)
-{
-   p->caps = (bf & VG_PATH_CAPABILITY_ALL);
-}
-
-void path_append_data(struct path *p,
-                      VGint numSegments,
-                      const VGubyte * pathSegments,
-                      const void * pathData)
-{
-   VGint old_segments = p->num_segments;
-   VGint num_new_coords = num_elements_for_segments(pathSegments, numSegments);
-   array_append_data(p->segments, pathSegments, numSegments);
-   array_append_data(p->control_points, pathData, num_new_coords);
-
-   p->num_segments += numSegments;
-   if (!floatsEqual(p->scale, 1.f) || !floatsEqual(p->bias, 0.f)) {
-      VGubyte *coords = (VGubyte*)p->control_points->data;
-      coords_adjust_by_scale_bias(p,
-                                  coords + old_segments * p->control_points->datatype_size,
-                                  num_new_coords,
-                                  p->scale, p->bias, p->datatype);
-   }
-   p->dirty = VG_TRUE;
-   p->dirty_stroke = VG_TRUE;
-}
-
-VGint path_num_segments(struct path *p)
-{
-   return p->num_segments;
-}
-
-static INLINE void map_if_relative(VGfloat ox, VGfloat oy,
-                                   VGboolean relative,
-                                   VGfloat *x, VGfloat *y)
-{
-   if (relative) {
-      if (x)
-         *x += ox;
-      if (y)
-         *y += oy;
-   }
-}
-
-static INLINE void close_polygon(struct polygon *current,
-                                 VGfloat sx, VGfloat sy,
-                                 VGfloat ox, VGfloat oy,
-                                 struct  matrix *matrix)
-{
-   if (!floatsEqual(sx, ox) ||
-       !floatsEqual(sy, oy)) {
-      VGfloat x0 = sx;
-      VGfloat y0 = sy;
-      matrix_map_point(matrix, x0, y0, &x0, &y0);
-      polygon_vertex_append(current, x0, y0);
-   }
-}
-
-static void convert_path(struct path *p,
-                          VGPathDatatype to,
-                          void *dst,
-                          VGint num_coords)
-{
-   VGfloat data[8];
-   void *coords = (VGfloat *)p->control_points->data;
-   VGubyte *common_data = (VGubyte *)dst;
-   VGint size_dst = size_for_datatype(to);
-   VGint i;
-
-   for (i = 0; i < num_coords; ++i) {
-      data_at(&coords, p, 0, 1, data);
-      vg_float_to_datatype(to, common_data, data, 1);
-      common_data += size_dst;
-   }
-}
-
-static void polygon_array_calculate_bounds( struct polygon_array *polyarray )
-{
-   struct array *polys = polyarray->array;
-   VGfloat min_x, max_x;
-   VGfloat min_y, max_y;
-   VGfloat bounds[4];
-   unsigned i;
-
-   assert(polys);
-
-   if (!polys->num_elements) {
-      polyarray->min_x = 0.0f;
-      polyarray->min_y = 0.0f;
-      polyarray->max_x = 0.0f;
-      polyarray->max_y = 0.0f;
-      return;
-   }
-
-   polygon_bounding_rect((((struct polygon**)polys->data)[0]), bounds);
-   min_x = bounds[0];
-   min_y = bounds[1];
-   max_x = bounds[0] + bounds[2];
-   max_y = bounds[1] + bounds[3];
-   for (i = 1; i < polys->num_elements; ++i) {
-      struct polygon *p = (((struct polygon**)polys->data)[i]);
-      polygon_bounding_rect(p, bounds);
-      min_x = MIN2(min_x, bounds[0]);
-      min_y = MIN2(min_y, bounds[1]);
-      max_x = MAX2(max_x, bounds[0] + bounds[2]);
-      max_y = MAX2(max_y, bounds[1] + bounds[3]);
-   }
-
-   polyarray->min_x = min_x;
-   polyarray->min_y = min_y;
-   polyarray->max_x = max_x;
-   polyarray->max_y = max_y;
-}
-
-
-static struct polygon_array * path_get_fill_polygons(struct path *p, struct matrix *matrix)
-{
-   VGint i;
-   struct polygon *current = 0;
-   VGfloat sx, sy, px, py, ox, oy;
-   VGfloat x0, y0, x1, y1, x2, y2, x3, y3;
-   VGfloat data[8];
-   void *coords = (VGfloat *)p->control_points->data;
-   struct array *array;
-
-   memset(data, 0, sizeof(data));
-
-   if (p->fill_polys.polygon_array.array)
-   {
-      if (memcmp( &p->fill_polys.matrix,
-                  matrix,
-                  sizeof *matrix ) == 0 && p->dirty == VG_FALSE)
-      {
-         return &p->fill_polys.polygon_array;
-      }
-      else {
-         polygon_array_cleanup(&p->fill_polys.polygon_array);
-      }
-   }
-
-   /* an array of pointers to polygons */
-   array = array_create(sizeof(struct polygon *));
-
-   sx = sy = px = py = ox = oy = 0.f;
-
-   if (p->num_segments)
-      current = polygon_create(32);
-
-   for (i = 0; i < p->num_segments; ++i) {
-      VGubyte segment = ((VGubyte*)(p->segments->data))[i];
-      VGint command = SEGMENT_COMMAND(segment);
-      VGboolean relative = SEGMENT_ABS_REL(segment);
-
-      switch(command) {
-      case VG_CLOSE_PATH:
-         close_polygon(current, sx, sy, ox, oy, matrix);
-         ox = sx;
-         oy = sy;
-         break;
-      case VG_MOVE_TO:
-         if (current && polygon_vertex_count(current) > 0) {
-            /* add polygon */
-            close_polygon(current, sx, sy, ox, oy, matrix);
-            array_append_data(array, &current, 1);
-            current = polygon_create(32);
-         }
-         data_at(&coords, p, 0, 2, data);
-         x0 = data[0];
-         y0 = data[1];
-         map_if_relative(ox, oy, relative, &x0, &y0);
-         sx = x0;
-         sy = y0;
-         ox = x0;
-         oy = y0;
-         px = x0;
-         py = y0;
-         matrix_map_point(matrix, x0, y0, &x0, &y0);
-         polygon_vertex_append(current, x0, y0);
-         break;
-      case VG_LINE_TO:
-         data_at(&coords, p, 0, 2, data);
-         x0 = data[0];
-         y0 = data[1];
-         map_if_relative(ox, oy, relative, &x0, &y0);
-         ox = x0;
-         oy = y0;
-         px = x0;
-         py = y0;
-         matrix_map_point(matrix, x0, y0, &x0, &y0);
-         polygon_vertex_append(current, x0, y0);
-         break;
-      case VG_HLINE_TO:
-         data_at(&coords, p, 0, 1, data);
-         x0 = data[0];
-         y0 = oy;
-         map_if_relative(ox, oy, relative, &x0, 0);
-         ox = x0;
-         px = x0;
-         py = y0;
-         matrix_map_point(matrix, x0, y0, &x0, &y0);
-         polygon_vertex_append(current, x0, y0);
-         break;
-      case VG_VLINE_TO:
-         data_at(&coords, p, 0, 1, data);
-         x0 = ox;
-         y0 = data[0];
-         map_if_relative(ox, oy, relative, 0, &y0);
-         oy = y0;
-         px = x0;
-         py = y0;
-         matrix_map_point(matrix, x0, y0, &x0, &y0);
-         polygon_vertex_append(current, x0, y0);
-         break;
-      case VG_CUBIC_TO: {
-         struct bezier bezier;
-         data_at(&coords, p, 0, 6, data);
-         x0 = ox;
-         y0 = oy;
-         x1 = data[0];
-         y1 = data[1];
-         x2 = data[2];
-         y2 = data[3];
-         x3 = data[4];
-         y3 = data[5];
-         map_if_relative(ox, oy, relative, &x1, &y1);
-         map_if_relative(ox, oy, relative, &x2, &y2);
-         map_if_relative(ox, oy, relative, &x3, &y3);
-         ox = x3;
-         oy = y3;
-         px = x2;
-         py = y2;
-         assert(matrix_is_affine(matrix));
-         matrix_map_point(matrix, x0, y0, &x0, &y0);
-         matrix_map_point(matrix, x1, y1, &x1, &y1);
-         matrix_map_point(matrix, x2, y2, &x2, &y2);
-         matrix_map_point(matrix, x3, y3, &x3, &y3);
-         bezier_init(&bezier, x0, y0, x1, y1,
-                       x2, y2, x3, y3);
-         bezier_add_to_polygon(&bezier, current);
-      }
-         break;
-      case VG_QUAD_TO: {
-         struct bezier bezier;
-         data_at(&coords, p, 0, 4, data);
-         x0 = ox;
-         y0 = oy;
-         x1 = data[0];
-         y1 = data[1];
-         x3 = data[2];
-         y3 = data[3];
-         map_if_relative(ox, oy, relative, &x1, &y1);
-         map_if_relative(ox, oy, relative, &x3, &y3);
-         px = x1;
-         py = y1;
-         { /* form a cubic out of it */
-            x2 = (x3 + 2*x1) / 3.f;
-            y2 = (y3 + 2*y1) / 3.f;
-            x1 = (x0 + 2*x1) / 3.f;
-            y1 = (y0 + 2*y1) / 3.f;
-         }
-         ox = x3;
-         oy = y3;
-         assert(matrix_is_affine(matrix));
-         matrix_map_point(matrix, x0, y0, &x0, &y0);
-         matrix_map_point(matrix, x1, y1, &x1, &y1);
-         matrix_map_point(matrix, x2, y2, &x2, &y2);
-         matrix_map_point(matrix, x3, y3, &x3, &y3);
-         bezier_init(&bezier, x0, y0, x1, y1,
-                       x2, y2, x3, y3);
-         bezier_add_to_polygon(&bezier, current);
-      }
-         break;
-      case VG_SQUAD_TO: {
-         struct bezier bezier;
-         data_at(&coords, p, 0, 2, data);
-         x0 = ox;
-         y0 = oy;
-         x1 = 2*ox-px;
-         y1 = 2*oy-py;
-         x3 = data[0];
-         y3 = data[1];
-         map_if_relative(ox, oy, relative, &x3, &y3);
-         px = x1;
-         py = y1;
-         { /* form a cubic out of it */
-            x2 = (x3 + 2*x1) / 3.f;
-            y2 = (y3 + 2*y1) / 3.f;
-            x1 = (x0 + 2*x1) / 3.f;
-            y1 = (y0 + 2*y1) / 3.f;
-         }
-         ox = x3;
-         oy = y3;
-         assert(matrix_is_affine(matrix));
-         matrix_map_point(matrix, x0, y0, &x0, &y0);
-         matrix_map_point(matrix, x1, y1, &x1, &y1);
-         matrix_map_point(matrix, x2, y2, &x2, &y2);
-         matrix_map_point(matrix, x3, y3, &x3, &y3);
-         bezier_init(&bezier, x0, y0, x1, y1,
-                     x2, y2, x3, y3);
-         bezier_add_to_polygon(&bezier, current);
-      }
-         break;
-      case VG_SCUBIC_TO: {
-         struct bezier bezier;
-         data_at(&coords, p, 0, 4, data);
-         x0 = ox;
-         y0 = oy;
-         x1 = 2*ox-px;
-         y1 = 2*oy-py;
-         x2 = data[0];
-         y2 = data[1];
-         x3 = data[2];
-         y3 = data[3];
-         map_if_relative(ox, oy, relative, &x2, &y2);
-         map_if_relative(ox, oy, relative, &x3, &y3);
-         ox = x3;
-         oy = y3;
-         px = x2;
-         py = y2;
-         assert(matrix_is_affine(matrix));
-         matrix_map_point(matrix, x0, y0, &x0, &y0);
-         matrix_map_point(matrix, x1, y1, &x1, &y1);
-         matrix_map_point(matrix, x2, y2, &x2, &y2);
-         matrix_map_point(matrix, x3, y3, &x3, &y3);
-         bezier_init(&bezier, x0, y0, x1, y1,
-                              x2, y2, x3, y3);
-         bezier_add_to_polygon(&bezier, current);
-      }
-         break;
-      case VG_SCCWARC_TO:
-      case VG_SCWARC_TO:
-      case VG_LCCWARC_TO:
-      case VG_LCWARC_TO: {
-         VGfloat rh, rv, rot;
-         struct arc arc;
-
-         data_at(&coords, p, 0, 5, data);
-         x0  = ox;
-         y0  = oy;
-         rh  = data[0];
-         rv  = data[1];
-         rot = data[2];
-         x1  = data[3];
-         y1  = data[4];
-         map_if_relative(ox, oy, relative, &x1, &y1);
-#if 0
-         debug_printf("------- ARC (%f, %f), (%f, %f) %f, %f, %f\n",
-                      x0, y0, x1, y1, rh, rv, rot);
-#endif
-         arc_init(&arc, command, x0, y0, x1, y1,
-                  rh, rv, rot);
-         arc_add_to_polygon(&arc, current,
-                            matrix);
-         ox = x1;
-         oy = y1;
-         px = x1;
-         py = y1;
-      }
-         break;
-      default:
-         abort();
-         assert(!"Unknown segment!");
-      }
-   }
-   if (current) {
-      if (polygon_vertex_count(current) > 0) {
-         close_polygon(current, sx, sy, ox, oy, matrix);
-         array_append_data(array, &current, 1);
-      } else
-         polygon_destroy(current);
-   }
-
-   p->fill_polys.polygon_array.array = array;
-   p->fill_polys.matrix = *matrix;
-
-   polygon_array_calculate_bounds( &p->fill_polys.polygon_array );
-
-   p->dirty = VG_FALSE;
-
-   return &p->fill_polys.polygon_array;
-}
-
-VGbyte path_datatype_size(struct path *p)
-{
-   return size_for_datatype(p->datatype);
-}
-
-VGPathDatatype path_datatype(struct path *p)
-{
-   return p->datatype;
-}
-
-VGfloat path_scale(struct path *p)
-{
-   return p->scale;
-}
-
-VGfloat path_bias(struct path *p)
-{
-   return p->bias;
-}
-
-VGint path_num_coords(struct path *p)
-{
-   return num_elements_for_segments((VGubyte*)p->segments->data,
-                                    p->num_segments);
-}
-
-void path_modify_coords(struct path *p,
-                        VGint startIndex,
-                        VGint numSegments,
-                        const void * pathData)
-{
-   VGubyte *segments = (VGubyte*)(p->segments->data);
-   VGint count = num_elements_for_segments(&segments[startIndex], numSegments);
-   VGint start_cp = num_elements_for_segments(segments, startIndex);
-
-   array_change_data(p->control_points, pathData, start_cp, count);
-   coords_adjust_by_scale_bias(p,
-                               ((VGubyte*)p->control_points->data) +
-                               (startIndex * p->control_points->datatype_size),
-                               path_num_coords(p),
-                               p->scale, p->bias, p->datatype);
-   p->dirty = VG_TRUE;
-   p->dirty_stroke = VG_TRUE;
-}
-
-void path_for_each_segment(struct path *path,
-                           path_for_each_cb cb,
-                           void *user_data)
-{
-   VGint i;
-   struct path_for_each_data p;
-   VGfloat data[8];
-   void *coords = (VGfloat *)path->control_points->data;
-
-   p.coords = data;
-   p.sx = p.sy = p.px = p.py = p.ox = p.oy = 0.f;
-   p.user_data = user_data;
-
-   for (i = 0; i < path->num_segments; ++i) {
-      VGint command;
-      VGboolean relative;
-
-      p.segment = ((VGubyte*)(path->segments->data))[i];
-      command = SEGMENT_COMMAND(p.segment);
-      relative = SEGMENT_ABS_REL(p.segment);
-
-      switch(command) {
-      case VG_CLOSE_PATH:
-         cb(path, &p);
-         break;
-      case VG_MOVE_TO:
-         data_at(&coords, path, 0, 2, data);
-         map_if_relative(p.ox, p.oy, relative, &data[0], &data[1]);
-         cb(path, &p);
-         p.sx = data[0];
-         p.sy = data[1];
-         p.ox = data[0];
-         p.oy = data[1];
-         p.px = data[0];
-         p.py = data[1];
-         break;
-      case VG_LINE_TO:
-         data_at(&coords, path, 0, 2, data);
-         map_if_relative(p.ox, p.oy, relative, &data[0], &data[1]);
-         cb(path, &p);
-         p.ox = data[0];
-         p.oy = data[1];
-         p.px = data[0];
-         p.py = data[1];
-         break;
-      case VG_HLINE_TO:
-         data_at(&coords, path, 0, 1, data);
-         map_if_relative(p.ox, p.oy, relative, &data[0], 0);
-         p.segment = VG_LINE_TO;
-         data[1] = p.oy;
-         cb(path, &p);
-         p.ox = data[0];
-         p.oy = data[1];
-         p.px = data[0];
-         p.py = data[1];
-         break;
-      case VG_VLINE_TO:
-         data_at(&coords, path, 0, 1, data);
-         map_if_relative(p.ox, p.oy, relative, 0, &data[0]);
-         p.segment = VG_LINE_TO;
-         data[1] = data[0];
-         data[0] = p.ox;
-         cb(path, &p);
-         p.ox = data[0];
-         p.oy = data[1];
-         p.px = data[0];
-         p.py = data[1];
-         break;
-      case VG_CUBIC_TO: {
-         data_at(&coords, path, 0, 6, data);
-         map_if_relative(p.ox, p.oy, relative, &data[0], &data[1]);
-         map_if_relative(p.ox, p.oy, relative, &data[2], &data[3]);
-         map_if_relative(p.ox, p.oy, relative, &data[4], &data[5]);
-         cb(path, &p);
-         p.px = data[2];
-         p.py = data[3];
-         p.ox = data[4];
-         p.oy = data[5];
-      }
-         break;
-      case VG_QUAD_TO: {
-         data_at(&coords, path, 0, 4, data);
-         map_if_relative(p.ox, p.oy, relative, &data[0], &data[1]);
-         map_if_relative(p.ox, p.oy, relative, &data[2], &data[3]);
-         cb(path, &p);
-         p.px = data[0];
-         p.py = data[1];
-         p.ox = data[2];
-         p.oy = data[3];
-      }
-         break;
-      case VG_SQUAD_TO: {
-         data_at(&coords, path, 0, 2, data);
-         map_if_relative(p.ox, p.oy, relative, &data[0], &data[1]);
-         cb(path, &p);
-         p.px = 2*p.ox-p.px;
-         p.py = 2*p.oy-p.py;
-         p.ox = data[2];
-         p.oy = data[3];
-      }
-         break;
-      case VG_SCUBIC_TO: {
-         data_at(&coords, path, 0, 4, data);
-         map_if_relative(p.ox, p.oy, relative, &data[0], &data[1]);
-         map_if_relative(p.ox, p.oy, relative, &data[2], &data[3]);
-         cb(path, &p);
-         p.px = data[0];
-         p.py = data[1];
-         p.ox = data[2];
-         p.oy = data[3];
-      }
-         break;
-      case VG_SCCWARC_TO:
-      case VG_SCWARC_TO:
-      case VG_LCCWARC_TO:
-      case VG_LCWARC_TO: {
-         data_at(&coords, path, 0, 5, data);
-         map_if_relative(p.ox, p.oy, relative, &data[3], &data[4]);
-#if 0
-         debug_printf("------- ARC (%f, %f), (%f, %f) %f, %f, %f\n",
-                      p.ox, p.oy, data[3], data[4], data[0], data[1], data[2]);
-#endif
-         cb(path, &p);
-         p.ox = data[3];
-         p.oy = data[4];
-         p.px = data[3];
-         p.py = data[4];
-      }
-         break;
-      default:
-         abort();
-         assert(!"Unknown segment!");
-      }
-   }
-}
-
-struct transform_data {
-   struct array *segments;
-   struct array *coords;
-
-   struct matrix *matrix;
-
-   VGPathDatatype datatype;
-};
-
-static VGboolean transform_cb(struct path *p,
-                              struct path_for_each_data *pd)
-{
-   struct transform_data *td = (struct transform_data *)pd->user_data;
-   VGint num_coords = num_elements_for_segments(&pd->segment, 1);
-   VGubyte segment = SEGMENT_COMMAND(pd->segment);/* abs bit is 0 */
-   VGfloat data[8];
-   VGubyte common_data[sizeof(VGfloat)*8];
-
-   memcpy(data, pd->coords, sizeof(VGfloat) * num_coords);
-
-   switch(segment) {
-   case VG_CLOSE_PATH:
-      break;
-   case VG_MOVE_TO:
-      matrix_map_point(td->matrix,
-                       data[0], data[1], &data[0], &data[1]);
-      break;
-   case VG_LINE_TO:
-      matrix_map_point(td->matrix,
-                       data[0], data[1], &data[0], &data[1]);
-      break;
-   case VG_HLINE_TO:
-   case VG_VLINE_TO:
-      assert(0);
-      break;
-   case VG_QUAD_TO:
-      matrix_map_point(td->matrix,
-                       data[0], data[1], &data[0], &data[1]);
-      matrix_map_point(td->matrix,
-                       data[2], data[3], &data[2], &data[3]);
-      break;
-   case VG_CUBIC_TO:
-      matrix_map_point(td->matrix,
-                       data[0], data[1], &data[0], &data[1]);
-      matrix_map_point(td->matrix,
-                       data[2], data[3], &data[2], &data[3]);
-      matrix_map_point(td->matrix,
-                       data[4], data[5], &data[4], &data[5]);
-      break;
-   case VG_SQUAD_TO:
-      matrix_map_point(td->matrix,
-                       data[0], data[1], &data[0], &data[1]);
-      break;
-   case VG_SCUBIC_TO:
-      matrix_map_point(td->matrix,
-                       data[0], data[1], &data[0], &data[1]);
-      matrix_map_point(td->matrix,
-                       data[2], data[3], &data[2], &data[3]);
-      break;
-   case VG_SCCWARC_TO:
-   case VG_SCWARC_TO:
-   case VG_LCCWARC_TO:
-   case VG_LCWARC_TO: {
-      struct arc arc;
-      struct path *path = path_create(td->datatype,
-                                      1, 0, 0, 0, VG_PATH_CAPABILITY_ALL);
-      arc_init(&arc, segment,
-               pd->ox, pd->oy, data[3], data[4],
-               data[0], data[1], data[2]);
-
-      arc_to_path(&arc, path, td->matrix);
-
-      num_coords = path_num_coords(path);
-
-      array_append_data(td->segments, path->segments->data,
-                        path->num_segments);
-      array_append_data(td->coords, path->control_points->data,
-                        num_coords);
-      path_destroy(path);
-
-      return VG_TRUE;
-   }
-      break;
-   default:
-      break;
-   }
-
-   vg_float_to_datatype(td->datatype, common_data, data, num_coords);
-
-   array_append_data(td->segments, &pd->segment, 1);
-   array_append_data(td->coords, common_data, num_coords);
-   return VG_TRUE;
-}
-
-void path_transform(struct path *dst, struct path *src)
-{
-   struct transform_data data;
-   struct vg_context *ctx = dst->base.ctx;
-
-   data.segments =  dst->segments;
-   data.coords   =  dst->control_points;
-   data.matrix   = &ctx->state.vg.path_user_to_surface_matrix;
-   data.datatype = dst->datatype;
-
-   path_for_each_segment(src, transform_cb, (void*)&data);
-
-   dst->num_segments = dst->segments->num_elements;
-   dst->dirty = VG_TRUE;
-   dst->dirty_stroke = VG_TRUE;
-}
-
-void path_append_path(struct path *dst,
-                      struct path *src)
-{
-   VGint num_coords = path_num_coords(src);
-   void *dst_data = malloc(size_for_datatype(dst->datatype) * num_coords);
-   array_append_data(dst->segments,
-                     src->segments->data,
-                     src->num_segments);
-   convert_path(src, dst->datatype,
-                dst_data, num_coords);
-   array_append_data(dst->control_points,
-                     dst_data,
-                     num_coords);
-   free(dst_data);
-
-   dst->num_segments += src->num_segments;
-   dst->dirty = VG_TRUE;
-   dst->dirty_stroke = VG_TRUE;
-}
-
-static INLINE VGboolean is_segment_arc(VGubyte segment)
-{
-   VGubyte scommand = SEGMENT_COMMAND(segment);
-   return (scommand == VG_SCCWARC_TO ||
-           scommand == VG_SCWARC_TO ||
-           scommand == VG_LCCWARC_TO ||
-           scommand == VG_LCWARC_TO);
-}
-
-struct path_iter_data {
-   struct path *path;
-   VGubyte segment;
-   void *coords;
-   VGfloat px, py, ox, oy, sx, sy;
-};
-static INLINE VGubyte normalize_coords(struct path_iter_data *pd,
-                                       VGint *num_coords,
-                                       VGfloat *data)
-{
-   VGint command = SEGMENT_COMMAND(pd->segment);
-   VGboolean relative = SEGMENT_ABS_REL(pd->segment);
-
-   switch(command) {
-   case VG_CLOSE_PATH:
-      *num_coords = 0;
-      pd->ox = pd->sx;
-      pd->oy = pd->sy;
-      return VG_CLOSE_PATH;
-      break;
-   case VG_MOVE_TO:
-      data_at(&pd->coords, pd->path, 0, 2, data);
-      map_if_relative(pd->ox, pd->oy, relative, &data[0], &data[1]);
-      pd->sx = data[0];
-      pd->sy = data[1];
-      pd->ox = data[0];
-      pd->oy = data[1];
-      pd->px = data[0];
-      pd->py = data[1];
-      *num_coords = 2;
-      return VG_MOVE_TO_ABS;
-      break;
-   case VG_LINE_TO:
-      data_at(&pd->coords, pd->path, 0, 2, data);
-      map_if_relative(pd->ox, pd->oy, relative, &data[0], &data[1]);
-      pd->ox = data[0];
-      pd->oy = data[1];
-      pd->px = data[0];
-      pd->py = data[1];
-      *num_coords = 2;
-      return VG_LINE_TO_ABS;
-      break;
-   case VG_HLINE_TO:
-      data_at(&pd->coords, pd->path, 0, 1, data);
-      map_if_relative(pd->ox, pd->oy, relative, &data[0], 0);
-      data[1] = pd->oy;
-      pd->ox = data[0];
-      pd->oy = data[1];
-      pd->px = data[0];
-      pd->py = data[1];
-      *num_coords = 2;
-      return VG_LINE_TO_ABS;
-      break;
-   case VG_VLINE_TO:
-      data_at(&pd->coords, pd->path, 0, 1, data);
-      map_if_relative(pd->ox, pd->oy, relative, 0, &data[0]);
-      data[1] = data[0];
-      data[0] = pd->ox;
-      pd->ox = data[0];
-      pd->oy = data[1];
-      pd->px = data[0];
-      pd->py = data[1];
-      *num_coords = 2;
-      return VG_LINE_TO_ABS;
-      break;
-   case VG_CUBIC_TO: {
-      data_at(&pd->coords, pd->path, 0, 6, data);
-      map_if_relative(pd->ox, pd->oy, relative, &data[0], &data[1]);
-      map_if_relative(pd->ox, pd->oy, relative, &data[2], &data[3]);
-      map_if_relative(pd->ox, pd->oy, relative, &data[4], &data[5]);
-      pd->px = data[2];
-      pd->py = data[3];
-      pd->ox = data[4];
-      pd->oy = data[5];
-      *num_coords = 6;
-      return VG_CUBIC_TO_ABS;
-   }
-      break;
-   case VG_QUAD_TO: {
-      VGfloat x0, y0, x1, y1, x2, y2, x3, y3;
-      data_at(&pd->coords, pd->path, 0, 4, data);
-      x0 = pd->ox;
-      y0 = pd->oy;
-      x1 = data[0];
-      y1 = data[1];
-      x3 = data[2];
-      y3 = data[3];
-      map_if_relative(pd->ox, pd->oy, relative, &x1, &y1);
-      map_if_relative(pd->ox, pd->oy, relative, &x3, &y3);
-      pd->px = x1;
-      pd->py = y1;
-      { /* form a cubic out of it */
-         x2 = (x3 + 2*x1) / 3.f;
-         y2 = (y3 + 2*y1) / 3.f;
-         x1 = (x0 + 2*x1) / 3.f;
-         y1 = (y0 + 2*y1) / 3.f;
-      }
-      pd->ox = x3;
-      pd->oy = y3;
-      data[0] = x1;
-      data[1] = y1;
-      data[2] = x2;
-      data[3] = y2;
-      data[4] = x3;
-      data[5] = y3;
-      *num_coords = 6;
-      return VG_CUBIC_TO_ABS;
-   }
-      break;
-   case VG_SQUAD_TO: {
-      VGfloat x0, y0, x1, y1, x2, y2, x3, y3;
-      data_at(&pd->coords, pd->path, 0, 2, data);
-      x0 = pd->ox;
-      y0 = pd->oy;
-      x1 = 2 * pd->ox - pd->px;
-      y1 = 2 * pd->oy - pd->py;
-      x3 = data[0];
-      y3 = data[1];
-      map_if_relative(pd->ox, pd->oy, relative, &x3, &y3);
-      pd->px = x1;
-      pd->py = y1;
-      { /* form a cubic out of it */
-         x2 = (x3 + 2*x1) / 3.f;
-         y2 = (y3 + 2*y1) / 3.f;
-         x1 = (x0 + 2*x1) / 3.f;
-         y1 = (y0 + 2*y1) / 3.f;
-      }
-      pd->ox = x3;
-      pd->oy = y3;
-      data[0] = x1;
-      data[1] = y1;
-      data[2] = x2;
-      data[3] = y2;
-      data[4] = x3;
-      data[5] = y3;
-      *num_coords = 6;
-      return VG_CUBIC_TO_ABS;
-   }
-      break;
-   case VG_SCUBIC_TO: {
-      VGfloat x1, y1, x2, y2, x3, y3;
-      data_at(&pd->coords, pd->path, 0, 4, data);
-      x1 = 2*pd->ox-pd->px;
-      y1 = 2*pd->oy-pd->py;
-      x2 = data[0];
-      y2 = data[1];
-      x3 = data[2];
-      y3 = data[3];
-      map_if_relative(pd->ox, pd->oy, relative, &x2, &y2);
-      map_if_relative(pd->ox, pd->oy, relative, &x3, &y3);
-      pd->ox = x3;
-      pd->oy = y3;
-      pd->px = x2;
-      pd->py = y2;
-      data[0] = x1;
-      data[1] = y1;
-      data[2] = x2;
-      data[3] = y2;
-      data[4] = x3;
-      data[5] = y3;
-      *num_coords = 6;
-      return VG_CUBIC_TO_ABS;
-   }
-      break;
-   case VG_SCCWARC_TO:
-   case VG_SCWARC_TO:
-   case VG_LCCWARC_TO:
-   case VG_LCWARC_TO: {
-      data_at(&pd->coords, pd->path, 0, 5, data);
-      map_if_relative(pd->ox, pd->oy, relative, &data[3], &data[4]);
-      pd->ox = data[3];
-      pd->oy = data[4];
-      pd->px = data[3];
-      pd->py = data[4];
-      *num_coords = 5;
-      return command | VG_ABSOLUTE;
-   }
-      break;
-   default:
-      abort();
-      assert(!"Unknown segment!");
-      return 0;
-   }
-}
-
-static void linearly_interpolate(VGfloat *result,
-                                 const VGfloat *start,
-                                 const VGfloat *end,
-                                 VGfloat amount,
-                                 VGint number)
-{
-   VGint i;
-   for (i = 0; i < number; ++i) {
-      result[i] = start[i] + (end[i] - start[i]) * amount;
-   }
-}
-
-VGboolean path_interpolate(struct path *dst,
-                           struct path *start, struct path *end,
-                           VGfloat amount)
-{
-   /* temporary path that we can discard if it will turn
-    * out that start is not compatible with end */
-   struct path *res_path = path_create(dst->datatype,
-                                       1.0, 0.0,
-                                       0, 0, dst->caps);
-   VGint i;
-   VGfloat start_coords[8];
-   VGfloat end_coords[8];
-   VGfloat results[8];
-   VGubyte common_data[sizeof(VGfloat)*8];
-   struct path_iter_data start_iter, end_iter;
-
-   memset(&start_iter, 0, sizeof(struct path_iter_data));
-   memset(&end_iter, 0, sizeof(struct path_iter_data));
-
-   start_iter.path = start;
-   start_iter.coords = start->control_points->data;
-   end_iter.path = end;
-   end_iter.coords = end->control_points->data;
-
-   for (i = 0; i < start->num_segments; ++i) {
-      VGubyte segment;
-      VGubyte ssegment, esegment;
-      VGint snum_coords, enum_coords;
-      start_iter.segment = ((VGubyte*)(start->segments->data))[i];
-      end_iter.segment = ((VGubyte*)(end->segments->data))[i];
-
-      ssegment = normalize_coords(&start_iter, &snum_coords,
-                                  start_coords);
-      esegment = normalize_coords(&end_iter, &enum_coords,
-                                  end_coords);
-
-      if (is_segment_arc(ssegment)) {
-         if (!is_segment_arc(esegment)) {
-            path_destroy(res_path);
-            return VG_FALSE;
-         }
-         if (amount > 0.5)
-            segment = esegment;
-         else
-            segment = ssegment;
-      } else if (is_segment_arc(esegment)) {
-         path_destroy(res_path);
-         return VG_FALSE;
-      }
-      else if (ssegment != esegment) {
-         path_destroy(res_path);
-         return VG_FALSE;
-      }
-      else
-         segment = ssegment;
-
-      linearly_interpolate(results, start_coords, end_coords,
-                           amount, snum_coords);
-      vg_float_to_datatype(dst->datatype, common_data, results, snum_coords);
-      path_append_data(res_path, 1, &segment, common_data);
-   }
-
-   path_append_path(dst, res_path);
-   path_destroy(res_path);
-
-   dst->dirty = VG_TRUE;
-   dst->dirty_stroke = VG_TRUE;
-
-   return VG_TRUE;
-}
-
-void path_clear(struct path *p, VGbitfield capabilities)
-{
-   path_set_capabilities(p, capabilities);
-   array_destroy(p->segments);
-   array_destroy(p->control_points);
-   p->segments = array_create(size_for_datatype(VG_PATH_DATATYPE_S_8));
-   p->control_points = array_create(size_for_datatype(p->datatype));
-   p->num_segments = 0;
-   p->dirty = VG_TRUE;
-   p->dirty_stroke = VG_TRUE;
-}
-
-struct path * path_create_stroke(struct path *p,
-                                 struct matrix *matrix)
-{
-   VGint i;
-   VGfloat sx, sy, px, py, ox, oy;
-   VGfloat x0, y0, x1, y1, x2, y2, x3, y3;
-   VGfloat data[8];
-   void *coords = (VGfloat *)p->control_points->data;
-   int dashed = (p->base.ctx->state.vg.stroke.dash_pattern_num ? 1 : 0);
-   struct dash_stroker stroker;
-   struct vg_state *vg_state = &p->base.ctx->state.vg;
-
-   if (p->stroked.path)
-   {
-      /* ### compare the dash patterns to see if we can cache them.
-       *     for now we simply always bail out if the path is dashed.
-       */
-      if (memcmp( &p->stroked.matrix,
-                  matrix,
-                  sizeof *matrix ) == 0 &&
-          !dashed && !p->dirty_stroke &&
-          floatsEqual(p->stroked.stroke_width, vg_state->stroke.line_width.f) &&
-          floatsEqual(p->stroked.miter_limit, vg_state->stroke.miter_limit.f) &&
-          p->stroked.cap_style == vg_state->stroke.cap_style &&
-          p->stroked.join_style == vg_state->stroke.join_style)
-      {
-         return p->stroked.path;
-      }
-      else {
-         path_destroy( p->stroked.path );
-         p->stroked.path = NULL;
-      }
-   }
-
-
-   sx = sy = px = py = ox = oy = 0.f;
-
-   if (dashed)
-      dash_stroker_init((struct stroker *)&stroker, vg_state);
-   else
-      stroker_init((struct stroker *)&stroker, vg_state);
-
-   stroker_begin((struct stroker *)&stroker);
-
-   for (i = 0; i < p->num_segments; ++i) {
-      VGubyte segment = ((VGubyte*)(p->segments->data))[i];
-      VGint command = SEGMENT_COMMAND(segment);
-      VGboolean relative = SEGMENT_ABS_REL(segment);
-
-      switch(command) {
-      case VG_CLOSE_PATH: {
-            VGfloat x0 = sx;
-            VGfloat y0 = sy;
-            matrix_map_point(matrix, x0, y0, &x0, &y0);
-            stroker_line_to((struct stroker *)&stroker, x0, y0);
-      }
-         break;
-      case VG_MOVE_TO:
-         data_at(&coords, p, 0, 2, data);
-         x0 = data[0];
-         y0 = data[1];
-         map_if_relative(ox, oy, relative, &x0, &y0);
-         sx = x0;
-         sy = y0;
-         ox = x0;
-         oy = y0;
-         px = x0;
-         py = y0;
-         matrix_map_point(matrix, x0, y0, &x0, &y0);
-         stroker_move_to((struct stroker *)&stroker, x0, y0);
-         break;
-      case VG_LINE_TO:
-         data_at(&coords, p, 0, 2, data);
-         x0 = data[0];
-         y0 = data[1];
-         map_if_relative(ox, oy, relative, &x0, &y0);
-         ox = x0;
-         oy = y0;
-         px = x0;
-         py = y0;
-         matrix_map_point(matrix, x0, y0, &x0, &y0);
-         stroker_line_to((struct stroker *)&stroker, x0, y0);
-         break;
-      case VG_HLINE_TO:
-         data_at(&coords, p, 0, 1, data);
-         x0 = data[0];
-         y0 = oy;
-         map_if_relative(ox, oy, relative, &x0, 0);
-         ox = x0;
-         px = x0;
-         py = y0;
-         matrix_map_point(matrix, x0, y0, &x0, &y0);
-         stroker_line_to((struct stroker *)&stroker, x0, y0);
-         break;
-      case VG_VLINE_TO:
-         data_at(&coords, p, 0, 1, data);
-         x0 = ox;
-         y0 = data[0];
-         map_if_relative(ox, oy, relative, 0, &y0);
-         oy = y0;
-         px = x0;
-         py = y0;
-         matrix_map_point(matrix, x0, y0, &x0, &y0);
-         stroker_line_to((struct stroker *)&stroker, x0, y0);
-         break;
-      case VG_CUBIC_TO: {
-         data_at(&coords, p, 0, 6, data);
-         x0 = ox;
-         y0 = oy;
-         x1 = data[0];
-         y1 = data[1];
-         x2 = data[2];
-         y2 = data[3];
-         x3 = data[4];
-         y3 = data[5];
-         map_if_relative(ox, oy, relative, &x1, &y1);
-         map_if_relative(ox, oy, relative, &x2, &y2);
-         map_if_relative(ox, oy, relative, &x3, &y3);
-         if (floatsEqual(x1, ox) && floatsEqual(y1, oy) &&
-             floatsEqual(x1, x2) && floatsEqual(y1, y2) &&
-             floatsEqual(x2, x3) && floatsEqual(y2, y3)) {
-            /*ignore the empty segment */
-            continue;
-         } else if (floatsEqual(x3, ox) && floatsEqual(y3, oy)) {
-            /* if dup vertex, emit a line */
-            ox = x3;
-            oy = y3;
-            matrix_map_point(matrix, x3, y3, &x3, &y3);
-            stroker_line_to((struct stroker *)&stroker, x3, y3);
-            continue;
-         }
-         ox = x3;
-         oy = y3;
-         px = x2;
-         py = y2;
-         assert(matrix_is_affine(matrix));
-         matrix_map_point(matrix, x0, y0, &x0, &y0);
-         matrix_map_point(matrix, x1, y1, &x1, &y1);
-         matrix_map_point(matrix, x2, y2, &x2, &y2);
-         matrix_map_point(matrix, x3, y3, &x3, &y3);
-         stroker_curve_to((struct stroker *)&stroker, x1, y1, x2, y2, x3, y3);
-      }
-         break;
-      case VG_QUAD_TO: {
-         data_at(&coords, p, 0, 4, data);
-         x0 = ox;
-         y0 = oy;
-         x1 = data[0];
-         y1 = data[1];
-         x3 = data[2];
-         y3 = data[3];
-         map_if_relative(ox, oy, relative, &x1, &y1);
-         map_if_relative(ox, oy, relative, &x3, &y3);
-         px = x1;
-         py = y1;
-         { /* form a cubic out of it */
-            x2 = (x3 + 2*x1) / 3.f;
-            y2 = (y3 + 2*y1) / 3.f;
-            x1 = (x0 + 2*x1) / 3.f;
-            y1 = (y0 + 2*y1) / 3.f;
-         }
-         if (floatsEqual(x1, ox) && floatsEqual(y1, oy) &&
-             floatsEqual(x1, x2) && floatsEqual(y1, y2) &&
-             floatsEqual(x2, x3) && floatsEqual(y2, y3)) {
-            /*ignore the empty segment */
-            continue;
-         } else if (floatsEqual(x3, ox) && floatsEqual(y3, oy)) {
-            /* if dup vertex, emit a line */
-            ox = x3;
-            oy = y3;
-            matrix_map_point(matrix, x3, y3, &x3, &y3);
-            stroker_line_to((struct stroker *)&stroker, x3, y3);
-            continue;
-         }
-         ox = x3;
-         oy = y3;
-         assert(matrix_is_affine(matrix));
-         matrix_map_point(matrix, x0, y0, &x0, &y0);
-         matrix_map_point(matrix, x1, y1, &x1, &y1);
-         matrix_map_point(matrix, x2, y2, &x2, &y2);
-         matrix_map_point(matrix, x3, y3, &x3, &y3);
-         stroker_curve_to((struct stroker *)&stroker, x1, y1, x2, y2, x3, y3);
-      }
-         break;
-      case VG_SQUAD_TO: {
-         data_at(&coords, p, 0, 2, data);
-         x0 = ox;
-         y0 = oy;
-         x1 = 2*ox-px;
-         y1 = 2*oy-py;
-         x3 = data[0];
-         y3 = data[1];
-         map_if_relative(ox, oy, relative, &x3, &y3);
-         px = x1;
-         py = y1;
-         { /* form a cubic out of it */
-            x2 = (x3 + 2*x1) / 3.f;
-            y2 = (y3 + 2*y1) / 3.f;
-            x1 = (x0 + 2*x1) / 3.f;
-            y1 = (y0 + 2*y1) / 3.f;
-         }
-         if (floatsEqual(x1, ox) && floatsEqual(y1, oy) &&
-             floatsEqual(x1, x2) && floatsEqual(y1, y2) &&
-             floatsEqual(x2, x3) && floatsEqual(y2, y3)) {
-            /*ignore the empty segment */
-            continue;
-         } else if (floatsEqual(x3, ox) && floatsEqual(y3, oy)) {
-            /* if dup vertex, emit a line */
-            ox = x3;
-            oy = y3;
-            matrix_map_point(matrix, x3, y3, &x3, &y3);
-            stroker_line_to((struct stroker *)&stroker, x3, y3);
-            continue;
-         }
-         ox = x3;
-         oy = y3;
-         assert(matrix_is_affine(matrix));
-         matrix_map_point(matrix, x0, y0, &x0, &y0);
-         matrix_map_point(matrix, x1, y1, &x1, &y1);
-         matrix_map_point(matrix, x2, y2, &x2, &y2);
-         matrix_map_point(matrix, x3, y3, &x3, &y3);
-         stroker_curve_to((struct stroker *)&stroker, x1, y1, x2, y2, x3, y3);
-      }
-         break;
-      case VG_SCUBIC_TO: {
-         data_at(&coords, p, 0, 4, data);
-         x0 = ox;
-         y0 = oy;
-         x1 = 2*ox-px;
-         y1 = 2*oy-py;
-         x2 = data[0];
-         y2 = data[1];
-         x3 = data[2];
-         y3 = data[3];
-         map_if_relative(ox, oy, relative, &x2, &y2);
-         map_if_relative(ox, oy, relative, &x3, &y3);
-         if (floatsEqual(x1, ox) && floatsEqual(y1, oy) &&
-             floatsEqual(x1, x2) && floatsEqual(y1, y2) &&
-             floatsEqual(x2, x3) && floatsEqual(y2, y3)) {
-            /*ignore the empty segment */
-            continue;
-         } else if (floatsEqual(x3, ox) && floatsEqual(y3, oy)) {
-            /* if dup vertex, emit a line */
-            ox = x3;
-            oy = y3;
-            matrix_map_point(matrix, x3, y3, &x3, &y3);
-            stroker_line_to((struct stroker *)&stroker, x3, y3);
-            continue;
-         }
-         ox = x3;
-         oy = y3;
-         px = x2;
-         py = y2;
-         assert(matrix_is_affine(matrix));
-         matrix_map_point(matrix, x0, y0, &x0, &y0);
-         matrix_map_point(matrix, x1, y1, &x1, &y1);
-         matrix_map_point(matrix, x2, y2, &x2, &y2);
-         matrix_map_point(matrix, x3, y3, &x3, &y3);
-         stroker_curve_to((struct stroker *)&stroker, x1, y1, x2, y2, x3, y3);
-      }
-         break;
-      case VG_SCCWARC_TO:
-      case VG_SCWARC_TO:
-      case VG_LCCWARC_TO:
-      case VG_LCWARC_TO: {
-         VGfloat rh, rv, rot;
-         struct arc arc;
-
-         data_at(&coords, p, 0, 5, data);
-         x0  = ox;
-         y0  = oy;
-         rh  = data[0];
-         rv  = data[1];
-         rot = data[2];
-         x1  = data[3];
-         y1  = data[4];
-         map_if_relative(ox, oy, relative, &x1, &y1);
-         if (floatsEqual(x1, ox) && floatsEqual(y1, oy)) {
-            /* if dup vertex, emit a line */
-            ox = x1;
-            oy = y1;
-            matrix_map_point(matrix, x1, y1, &x1, &y1);
-            stroker_line_to((struct stroker *)&stroker, x1, y1);
-            continue;
-         }
-         arc_init(&arc, command, x0, y0, x1, y1,
-                  rh, rv, rot);
-         arc_stroke_cb(&arc, (struct stroker *)&stroker,
-                       matrix);
-         ox = x1;
-         oy = y1;
-         px = x1;
-         py = y1;
-      }
-         break;
-      default:
-         abort();
-         assert(!"Unknown segment!");
-      }
-   }
-
-   stroker_end((struct stroker *)&stroker);
-
-   if (dashed)
-      dash_stroker_cleanup((struct dash_stroker *)&stroker);
-   else
-      stroker_cleanup((struct stroker *)&stroker);
-
-   p->stroked.path = stroker.base.path;
-   p->stroked.matrix = *matrix;
-   p->dirty_stroke = VG_FALSE;
-   p->stroked.stroke_width = vg_state->stroke.line_width.f;
-   p->stroked.miter_limit = vg_state->stroke.miter_limit.f;
-   p->stroked.cap_style = vg_state->stroke.cap_style;
-   p->stroked.join_style = vg_state->stroke.join_style;
-
-   return stroker.base.path;
-}
-
-void path_render(struct path *p, VGbitfield paintModes,
-                 struct matrix *mat)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct matrix paint_matrix;
-
-   vg_validate_state(ctx);
-
-   shader_set_drawing_image(ctx->shader, VG_FALSE);
-   shader_set_image(ctx->shader, 0);
-#if 0
-   fprintf(stderr, "Matrix(11=%f 12=%f 13=%f 21=%f 22=%f 23=%f 31=%f 32=%f 33=%f)\n",
-           mat->m[0], mat->m[1], mat->m[2],
-           mat->m[3], mat->m[4], mat->m[5],
-           mat->m[6], mat->m[7], mat->m[8]);
-#endif
-   if ((paintModes & VG_FILL_PATH) &&
-       vg_get_paint_matrix(ctx,
-                           &ctx->state.vg.fill_paint_to_user_matrix,
-                           mat,
-                           &paint_matrix)) {
-      /* First the fill */
-      shader_set_surface_matrix(ctx->shader, mat);
-      shader_set_paint(ctx->shader, ctx->state.vg.fill_paint);
-      shader_set_paint_matrix(ctx->shader, &paint_matrix);
-      shader_bind(ctx->shader);
-      path_fill(p);
-   }
-
-   if ((paintModes & VG_STROKE_PATH) &&
-       vg_get_paint_matrix(ctx,
-                           &ctx->state.vg.stroke_paint_to_user_matrix,
-                           mat,
-                           &paint_matrix)) {
-      /* 8.7.5: "line width less than or equal to 0 prevents stroking from
-       *  taking place."*/
-      if (ctx->state.vg.stroke.line_width.f <= 0)
-         return;
-      shader_set_surface_matrix(ctx->shader, mat);
-      shader_set_paint(ctx->shader, ctx->state.vg.stroke_paint);
-      shader_set_paint_matrix(ctx->shader, &paint_matrix);
-      shader_bind(ctx->shader);
-      path_stroke(p);
-   }
-}
-
-void path_fill(struct path *p)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct matrix identity;
-
-   matrix_load_identity(&identity);
-
-   {
-      struct polygon_array *polygon_array = path_get_fill_polygons(p, &identity);
-      struct array *polys = polygon_array->array;
-
-      if (!polygon_array || !polys || !polys->num_elements) {
-         return;
-      }
-      polygon_array_fill(polygon_array, ctx);
-   }
-}
-
-void path_stroke(struct path *p)
-{
-   struct vg_context *ctx = vg_current_context();
-   VGFillRule old_fill = ctx->state.vg.fill_rule;
-   struct matrix identity;
-   struct path *stroke;
-
-   matrix_load_identity(&identity);
-   stroke = path_create_stroke(p, &identity);
-   if (stroke && !path_is_empty(stroke)) {
-      ctx->state.vg.fill_rule = VG_NON_ZERO;
-
-      path_fill(stroke);
-
-      ctx->state.vg.fill_rule = old_fill;
-   }
-}
-
-void path_move_to(struct path *p, float x, float y)
-{
-   VGubyte segment = VG_MOVE_TO_ABS;
-   VGubyte common_data[sizeof(VGfloat) * 2];
-   VGfloat data[2] = {x, y};
-
-   vg_float_to_datatype(p->datatype, common_data, data, 2);
-   path_append_data(p, 1, &segment, common_data);
-}
-
-void path_line_to(struct path *p, float x, float y)
-{
-   VGubyte segment = VG_LINE_TO_ABS;
-   VGubyte common_data[sizeof(VGfloat) * 2];
-   VGfloat data[2] = {x, y};
-
-   vg_float_to_datatype(p->datatype, common_data, data, 2);
-
-   path_append_data(p, 1, &segment, common_data);
-}
-
-void path_cubic_to(struct path *p, float px1, float py1,
-                   float px2, float py2,
-                   float x, float y)
-{
-   VGubyte segment = VG_CUBIC_TO_ABS;
-   VGubyte common_data[sizeof(VGfloat) * 6];
-   VGfloat data[6];
-
-   data[0] = px1; data[1] = py1;
-   data[2] = px2; data[3] = py2;
-   data[4] = x;   data[5] = y;
-
-   vg_float_to_datatype(p->datatype, common_data, data, 6);
-
-   path_append_data(p, 1, &segment, common_data);
-}
-
-static INLINE void line_bounds(VGfloat *line /*x1,y1,x2,y2*/,
-                               VGfloat *bounds)
-{
-   bounds[0] = MIN2(line[0], line[2]);
-   bounds[1] = MIN2(line[1], line[3]);
-   bounds[2] = MAX2(line[0], line[2]) - bounds[0];
-   bounds[3] = MAX2(line[1], line[3]) - bounds[1];
-}
-
-static INLINE void unite_bounds(VGfloat *bounds,
-                                VGfloat *el)
-{
-   VGfloat cx1, cy1, cx2, cy2;
-   VGfloat nx1, ny1, nx2, ny2;
-
-   cx1 = bounds[0];
-   cy1 = bounds[1];
-   cx2 = bounds[0] + bounds[2];
-   cy2 = bounds[1] + bounds[3];
-
-   nx1 = el[0];
-   ny1 = el[1];
-   nx2 = el[0] + el[2];
-   ny2 = el[1] + el[3];
-
-   bounds[0] = MIN2(cx1, nx1);
-   bounds[1] = MIN2(cy1, ny1);
-   bounds[2] = MAX2(cx2, nx2) - bounds[0];
-   bounds[3] = MAX2(cy2, ny2) - bounds[1];
-}
-
-static INLINE void set_bounds(VGfloat *bounds,
-                              VGfloat *element_bounds,
-                              VGboolean *initialized)
-{
-   if (!(*initialized)) {
-      memcpy(bounds, element_bounds, 4 * sizeof(VGfloat));
-      *initialized = VG_TRUE;
-   } else
-      unite_bounds(bounds, element_bounds);
-}
-
-void path_bounding_rect(struct path *p, float *x, float *y,
-                        float *w, float *h)
-{
-   VGint i;
-   VGfloat coords[8];
-   struct path_iter_data iter;
-   VGint num_coords;
-   VGfloat bounds[4];
-   VGfloat element_bounds[4];
-   VGfloat ox, oy;
-   VGboolean bounds_inited = VG_FALSE;
-
-   memset(&iter, 0, sizeof(struct path_iter_data));
-   memset(&bounds, 0, sizeof(bounds));
-
-   if (!p->num_segments) {
-      bounds[2] = -1;
-      bounds[3] = -1;
-   }
-
-
-   iter.path = p;
-   iter.coords = p->control_points->data;
-
-   for (i = 0; i < p->num_segments; ++i) {
-      VGubyte segment;
-      iter.segment = ((VGubyte*)(p->segments->data))[i];
-
-      ox = iter.ox;
-      oy = iter.oy;
-
-      segment = normalize_coords(&iter, &num_coords, coords);
-
-      switch(segment) {
-      case VG_CLOSE_PATH:
-      case VG_MOVE_TO_ABS:
-         break;
-      case VG_LINE_TO_ABS: {
-         VGfloat line[4] = {ox, oy, coords[0], coords[1]};
-         line_bounds(line, element_bounds);
-         set_bounds(bounds, element_bounds, &bounds_inited);
-      }
-         break;
-      case VG_CUBIC_TO_ABS: {
-         struct bezier bezier;
-         bezier_init(&bezier, ox, oy,
-                     coords[0], coords[1],
-                     coords[2], coords[3],
-                     coords[4], coords[5]);
-         bezier_exact_bounds(&bezier, element_bounds);
-         set_bounds(bounds, element_bounds, &bounds_inited);
-      }
-         break;
-      case VG_SCCWARC_TO:
-      case VG_SCWARC_TO:
-      case VG_LCCWARC_TO:
-      case VG_LCWARC_TO: {
-         struct arc arc;
-         struct matrix identity;
-         struct path *path = path_create(VG_PATH_DATATYPE_F,
-                                         1, 0, 0, 0, VG_PATH_CAPABILITY_ALL);
-
-         matrix_load_identity(&identity);
-         arc_init(&arc, segment,
-                  ox, oy, coords[3], coords[4],
-                  coords[0], coords[1], coords[2]);
-
-         arc_to_path(&arc, path, &identity);
-
-         path_bounding_rect(path, element_bounds + 0, element_bounds + 1,
-                            element_bounds + 2, element_bounds + 3);
-         set_bounds(bounds, element_bounds, &bounds_inited);
-      }
-         break;
-      default:
-         assert(0);
-      }
-   }
-
-   *x = bounds[0];
-   *y = bounds[1];
-   *w = bounds[2];
-   *h = bounds[3];
-}
-
-float path_length(struct path *p, int start_segment, int num_segments)
-{
-   VGint i;
-   VGfloat coords[8];
-   struct path_iter_data iter;
-   VGint num_coords;
-   VGfloat length = 0;
-   VGfloat ox, oy;
-   VGboolean in_range = VG_FALSE;
-
-   memset(&iter, 0, sizeof(struct path_iter_data));
-
-   iter.path = p;
-   iter.coords = p->control_points->data;
-
-   for (i = 0; i < (start_segment + num_segments); ++i) {
-      VGubyte segment;
-
-      iter.segment = ((VGubyte*)(p->segments->data))[i];
-
-      ox = iter.ox;
-      oy = iter.oy;
-
-      segment = normalize_coords(&iter, &num_coords, coords);
-
-      in_range = (i >= start_segment) && i <= (start_segment + num_segments);
-      if (!in_range)
-         continue;
-
-      switch(segment) {
-      case VG_MOVE_TO_ABS:
-         break;
-      case VG_CLOSE_PATH: {
-         VGfloat line[4] = {ox, oy, iter.sx, iter.sy};
-         length += line_lengthv(line);
-      }
-         break;
-      case VG_LINE_TO_ABS: {
-         VGfloat line[4] = {ox, oy, coords[0], coords[1]};
-         length += line_lengthv(line);
-      }
-         break;
-      case VG_CUBIC_TO_ABS: {
-         struct bezier bezier;
-         bezier_init(&bezier, ox, oy,
-                     coords[0], coords[1],
-                     coords[2], coords[3],
-                     coords[4], coords[5]);
-         length += bezier_length(&bezier, BEZIER_DEFAULT_ERROR);
-      }
-         break;
-      case VG_SCCWARC_TO:
-      case VG_SCWARC_TO:
-      case VG_LCCWARC_TO:
-      case VG_LCWARC_TO: {
-         struct arc arc;
-         struct matrix identity;
-         struct path *path = path_create(VG_PATH_DATATYPE_F,
-                                         1, 0, 0, 0, VG_PATH_CAPABILITY_ALL);
-
-         matrix_load_identity(&identity);
-         arc_init(&arc, segment,
-                  ox, oy, coords[3], coords[4],
-                  coords[0], coords[1], coords[2]);
-
-         arc_to_path(&arc, path, &identity);
-
-         length += path_length(path, 0, path_num_segments(path));
-      }
-         break;
-      default:
-         assert(0);
-      }
-   }
-
-   return length;
-}
-
-static INLINE VGboolean point_on_current_segment(VGfloat distance,
-                                                 VGfloat length,
-                                                 VGfloat segment_length)
-{
-   return
-      (((floatIsZero(distance) || distance < 0) && floatIsZero(length)) ||
-       ((distance > length || floatsEqual(distance, length)) &&
-        (floatsEqual(distance, length + segment_length) ||
-         distance < (length + segment_length))));
-}
-
-static VGboolean path_point_segment(struct path_iter_data iter,
-                                    struct path_iter_data prev_iter,
-                                    VGfloat coords[8],
-                                    VGfloat distance,
-                                    VGfloat length, VGfloat *current_length,
-                                    VGfloat *point, VGfloat *normal)
-{
-   switch (iter.segment) {
-   case VG_MOVE_TO_ABS:
-      break;
-   case VG_CLOSE_PATH: {
-      VGfloat line[4] = {prev_iter.ox, prev_iter.oy, iter.sx, iter.sy};
-      VGboolean on_current_segment = VG_FALSE;
-      *current_length = line_lengthv(line);
-      on_current_segment = point_on_current_segment(distance,
-                                                    length,
-                                                    *current_length);
-      if (on_current_segment) {
-         VGfloat at = (distance - length) / line_lengthv(line);
-         line_normal_vector(line, normal);
-         line_point_at(line, at, point);
-         return VG_TRUE;
-      }
-   }
-      break;
-   case VG_LINE_TO_ABS: {
-      VGfloat line[4] = {prev_iter.ox, prev_iter.oy, coords[0], coords[1]};
-      VGboolean on_current_segment = VG_FALSE;
-      *current_length = line_lengthv(line);
-      on_current_segment = point_on_current_segment(distance,
-                                                    length,
-                                                    *current_length);
-      if (on_current_segment) {
-         VGfloat at = (distance - length) / line_lengthv(line);
-         line_normal_vector(line, normal);
-         line_point_at(line, at, point);
-         return VG_TRUE;
-      }
-   }
-      break;
-   case VG_CUBIC_TO_ABS: {
-      struct bezier bezier;
-      bezier_init(&bezier, prev_iter.ox, prev_iter.oy,
-                  coords[0], coords[1],
-                  coords[2], coords[3],
-                  coords[4], coords[5]);
-      *current_length = bezier_length(&bezier, BEZIER_DEFAULT_ERROR);
-      if (point_on_current_segment(distance, length, *current_length)) {
-         bezier_point_at_length(&bezier, distance - length,
-                                point, normal);
-         return VG_TRUE;
-      }
-   }
-      break;
-   case VG_SCCWARC_TO:
-   case VG_SCWARC_TO:
-   case VG_LCCWARC_TO:
-   case VG_LCWARC_TO: {
-      struct arc arc;
-      struct matrix identity;
-      struct path *path = path_create(VG_PATH_DATATYPE_F,
-                                      1, 0, 0, 0, VG_PATH_CAPABILITY_ALL);
-
-      matrix_load_identity(&identity);
-      arc_init(&arc, iter.segment,
-               prev_iter.ox, prev_iter.oy, coords[3], coords[4],
-               coords[0], coords[1], coords[2]);
-
-      arc_to_path(&arc, path, &identity);
-
-      *current_length = path_length(path, 0, path_num_segments(path));
-      if (point_on_current_segment(distance, length, *current_length)) {
-         path_point(path, 0, path_num_segments(path),
-                    distance - length, point, normal);
-         return VG_TRUE;
-      }
-   }
-      break;
-   default:
-      assert(0);
-   }
-   return VG_FALSE;
-}
-
-void path_point(struct path *p, VGint start_segment, VGint num_segments,
-                VGfloat distance, VGfloat *point, VGfloat *normal)
-{
-   VGint i;
-   VGfloat coords[8];
-   struct path_iter_data iter, prev_iter;
-   VGint num_coords;
-   VGfloat length = 0;
-   VGfloat current_length = 0;
-
-   memset(&iter, 0, sizeof(struct path_iter_data));
-   memset(&prev_iter, 0, sizeof(struct path_iter_data));
-
-   point[0] = 0;
-   point[1] = 0;
-
-   normal[0] = 0;
-   normal[1] = -1;
-
-   iter.path = p;
-   iter.coords = p->control_points->data;
-   if (distance < 0)
-      distance = 0;
-
-   for (i = 0; i < (start_segment + num_segments); ++i) {
-      VGboolean outside_range = (i < start_segment ||
-                                 i >= (start_segment + num_segments));
-
-      prev_iter = iter;
-
-      iter.segment = ((VGubyte*)(p->segments->data))[i];
-      iter.segment = normalize_coords(&iter, &num_coords, coords);
-
-      if (outside_range)
-         continue;
-
-      if (path_point_segment(iter, prev_iter, coords,
-                             distance, length, &current_length,
-                             point, normal))
-         return;
-
-      length += current_length;
-   }
-
-   /*
-    *OpenVG 1.0 - 8.6.11 vgPointAlongPath
-    *
-    * If distance is greater than or equal to the path length
-    *(i.e., the value returned by vgPathLength when called with the same
-    *startSegment and numSegments parameters), the visual ending point of
-    *the path is used.
-    */
-   {
-      switch (iter.segment) {
-      case VG_MOVE_TO_ABS:
-         break;
-      case VG_CLOSE_PATH: {
-         VGfloat line[4] = {prev_iter.ox, prev_iter.oy, iter.sx, iter.sy};
-         line_normal_vector(line, normal);
-         line_point_at(line, 1.f, point);
-      }
-         break;
-      case VG_LINE_TO_ABS: {
-         VGfloat line[4] = {prev_iter.ox, prev_iter.oy, coords[0], coords[1]};
-         line_normal_vector(line, normal);
-         line_point_at(line, 1.f, point);
-      }
-         break;
-      case VG_CUBIC_TO_ABS: {
-         struct bezier bezier;
-         bezier_init(&bezier, prev_iter.ox, prev_iter.oy,
-                     coords[0], coords[1],
-                     coords[2], coords[3],
-                     coords[4], coords[5]);
-         bezier_point_at_t(&bezier, 1.f, point, normal);
-      }
-         break;
-      case VG_SCCWARC_TO:
-      case VG_SCWARC_TO:
-      case VG_LCCWARC_TO:
-      case VG_LCWARC_TO: {
-         struct arc arc;
-         struct matrix identity;
-         struct path *path = path_create(VG_PATH_DATATYPE_F,
-                                         1, 0, 0, 0, VG_PATH_CAPABILITY_ALL);
-
-         matrix_load_identity(&identity);
-         arc_init(&arc, iter.segment,
-                  prev_iter.ox, prev_iter.oy, coords[3], coords[4],
-                  coords[0], coords[1], coords[2]);
-
-         arc_to_path(&arc, path, &identity);
-
-         path_point(path, 0, path_num_segments(path),
-                    /* to make sure we're bigger than len * 2 it */
-                    2 * path_length(path, 0, path_num_segments(path)),
-                    point, normal);
-      }
-         break;
-      default:
-         assert(0);
-      }
-   }
-}
-
-VGboolean path_is_empty(struct path *p)
-{
-   return p->segments->num_elements == 0;
-}
diff --git a/src/gallium/state_trackers/vega/path.h b/src/gallium/state_trackers/vega/path.h
deleted file mode 100644
index d84b1f083ce..00000000000
--- a/src/gallium/state_trackers/vega/path.h
+++ /dev/null
@@ -1,126 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef _PATH_H
-#define _PATH_H
-
-#include "VG/openvg.h"
-
-struct path;
-struct polygon;
-struct matrix;
-
-enum fill_rule {
-   ODD_EVEN_FILL,
-   WINDING_FILL
-};
-
-
-struct path_for_each_data {
-   VGubyte segment;
-   /* all coords are absolute, even if segment is relative */
-   const VGfloat *coords;
-   VGfloat sx, sy, ox, oy, px, py;
-   void *user_data;
-};
-
-typedef VGboolean (*path_for_each_cb)(struct path *p,
-                                      struct path_for_each_data *data);
-
-
-struct path *path_create(VGPathDatatype dt, VGfloat scale, VGfloat bias,
-                         VGint segmentCapacityHint,
-                         VGint coordCapacityHint,
-                         VGbitfield capabilities);
-void path_destroy(struct path *p);
-
-VGbitfield path_capabilities(struct path *p);
-void path_set_capabilities(struct path *p, VGbitfield bf);
-
-void path_append_data(struct path *p,
-                      VGint numSegments,
-                      const VGubyte * pathSegments,
-                      const void * pathData);
-
-void path_append_path(struct path *dst,
-                      struct path *src);
-
-VGint path_num_segments(struct path *p);
-
-void path_bounding_rect(struct path *p, float *x, float *y,
-                        float *w, float *h);
-float path_length(struct path *p, int start_segment, int num_segments);
-
-void path_set_fill_rule(enum fill_rule fill);
-enum fill_rule path_fill_rule(enum fill_rule fill);
-
-VGboolean path_is_empty(struct path *p);
-
-VGbyte path_datatype_size(struct path *p);
-
-VGPathDatatype path_datatype(struct path *p);
-VGfloat path_scale(struct path *p);
-VGfloat path_bias(struct path *p);
-VGint path_num_coords(struct path *p);
-
-void path_modify_coords(struct path *p,
-                        VGint startIndex,
-                        VGint numSegments,
-                        const void * pathData);
-
-struct path *path_create_stroke(struct path *p,
-                                struct matrix *m);
-
-void path_for_each_segment(struct path *path,
-                           path_for_each_cb cb,
-                           void *user_data);
-
-void path_transform(struct path *dst, struct path *src);
-VGboolean path_interpolate(struct path *dst,
-                           struct path *start, struct path *end,
-                           VGfloat amount);
-
-void path_clear(struct path *p, VGbitfield capabilities);
-void path_render(struct path *p, VGbitfield paintModes, struct matrix *mat);
-void path_fill(struct path *p);
-void path_stroke(struct path *p);
-
-void path_move_to(struct path *p, float x, float y);
-void path_line_to(struct path *p, float x, float y);
-void path_cubic_to(struct path *p, float px1, float py1,
-                   float px2, float py2,
-                   float x, float y);
-
-void path_point(struct path *p, VGint startSegment, VGint numSegments,
-                VGfloat distance, VGfloat *point, VGfloat *normal);
-
-
-
-void vg_float_to_datatype(VGPathDatatype datatype,
-                          VGubyte *common_data,
-                          const VGfloat *data,
-                          VGint num_coords);
-#endif
diff --git a/src/gallium/state_trackers/vega/path_utils.h b/src/gallium/state_trackers/vega/path_utils.h
deleted file mode 100644
index c2b3221dc53..00000000000
--- a/src/gallium/state_trackers/vega/path_utils.h
+++ /dev/null
@@ -1,109 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef PATH_UTILS_H
-#define PATH_UTILS_H
-
-#include "VG/openvg.h"
-
-#define SEGMENT_COMMAND(command) /* Extract segment type */     \
-    ((command) & 0x1e)
-#define SEGMENT_ABS_REL(command) /* Extract absolute/relative bit */ \
-    ((command) & 0x1)
-
-static INLINE VGint size_for_datatype(VGPathDatatype datatype)
-{
-   switch(datatype) {
-   case VG_PATH_DATATYPE_S_8:
-      return 1;
-   case VG_PATH_DATATYPE_S_16:
-      return 2;
-   case VG_PATH_DATATYPE_S_32:
-      return 4;
-   case VG_PATH_DATATYPE_F:
-      return 4;
-   default:
-      assert(!"unknown datatype");
-   }
-   return 0;
-}
-
-static INLINE VGint num_elements_for_segments(const VGubyte *segments,
-                                              VGint num_segments)
-{
-   VGint i;
-   VGint count = 0;
-
-   for (i = 0; i < num_segments; ++i) {
-      VGubyte segment = segments[i];
-      VGint command = SEGMENT_COMMAND(segment);
-      switch(command) {
-      case VG_CLOSE_PATH:
-         break;
-      case VG_MOVE_TO:
-         count += 2;
-         break;
-      case VG_LINE_TO:
-         count += 2;
-         break;
-      case VG_HLINE_TO:
-         count += 1;
-         break;
-      case VG_VLINE_TO:
-         count += 1;
-         break;
-      case VG_QUAD_TO:
-         count += 4;
-         break;
-      case VG_CUBIC_TO:
-         count += 6;
-         break;
-      case VG_SQUAD_TO:
-         count += 2;
-         break;
-      case VG_SCUBIC_TO:
-         count += 4;
-         break;
-      case VG_SCCWARC_TO:
-         count += 5;
-         break;
-      case VG_SCWARC_TO:
-         count += 5;
-         break;
-      case VG_LCCWARC_TO:
-         count += 5;
-         break;
-      case VG_LCWARC_TO:
-         count += 5;
-         break;
-      default:
-         assert(!"Unknown segment!");
-      }
-   }
-   return count;
-}
-
-#endif
diff --git a/src/gallium/state_trackers/vega/polygon.c b/src/gallium/state_trackers/vega/polygon.c
deleted file mode 100644
index 37f96d48347..00000000000
--- a/src/gallium/state_trackers/vega/polygon.c
+++ /dev/null
@@ -1,351 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "polygon.h"
-
-#include "matrix.h" /*for floatsEqual*/
-#include "vg_context.h"
-#include "vg_state.h"
-#include "renderer.h"
-#include "util_array.h"
-#include "VG/openvg.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_state.h"
-#include "util/u_inlines.h"
-#include "pipe/p_screen.h"
-
-#include "util/u_draw_quad.h"
-#include "util/u_math.h"
-
-#include <string.h>
-#include <stdlib.h>
-
-#define DEBUG_POLYGON 0
-
-#define COMPONENTS 2
-
-struct polygon
-{
-   VGfloat *data;
-   VGint    size;
-
-   VGint    num_verts;
-
-   VGboolean dirty;
-   void *user_vbuf;
-   struct pipe_screen *screen;
-};
-
-static float *ptr_to_vertex(float *data, int idx)
-{
-   return data + (idx * COMPONENTS);
-}
-
-#if 0
-static void polygon_print(struct polygon *poly)
-{
-   int i;
-   float *vert;
-   debug_printf("Polygon %p, size = %d\n", poly, poly->num_verts);
-   for (i = 0; i < poly->num_verts; ++i) {
-      vert = ptr_to_vertex(poly->data, i);
-      debug_printf("%f, %f,  ", vert[0], vert[1]);
-   }
-   debug_printf("\nend\n");
-}
-#endif
-
-
-struct polygon * polygon_create(int size)
-{
-   struct polygon *poly = malloc(sizeof(struct polygon));
-
-   poly->data = malloc(sizeof(float) * COMPONENTS * size);
-   poly->size = size;
-   poly->num_verts = 0;
-   poly->dirty = VG_TRUE;
-   poly->user_vbuf = NULL;
-
-   return poly;
-}
-
-struct polygon * polygon_create_from_data(float *data, int size)
-{
-   struct polygon *poly = polygon_create(size);
-
-   memcpy(poly->data, data, sizeof(float) * COMPONENTS * size);
-   poly->num_verts = size;
-   poly->dirty = VG_TRUE;
-   poly->user_vbuf = NULL;
-
-   return poly;
-}
-
-void polygon_destroy(struct polygon *poly)
-{
-   free(poly->data);
-   free(poly);
-}
-
-void polygon_resize(struct polygon *poly, int new_size)
-{
-   float *data = malloc(sizeof(float) * COMPONENTS * new_size);
-   int size = MIN2(sizeof(float) * COMPONENTS * new_size,
-                   sizeof(float) * COMPONENTS * poly->size);
-   memcpy(data, poly->data, size);
-   free(poly->data);
-   poly->data = data;
-   poly->size = new_size;
-   poly->dirty = VG_TRUE;
-}
-
-int polygon_size(struct polygon *poly)
-{
-   return poly->size;
-}
-
-int polygon_vertex_count(struct polygon *poly)
-{
-   return poly->num_verts;
-}
-
-float * polygon_data(struct polygon *poly)
-{
-   return poly->data;
-}
-
-void polygon_vertex_append(struct polygon *p,
-                           float x, float y)
-{
-   float *vert;
-#if DEBUG_POLYGON
-   debug_printf("Append vertex [%f, %f]\n", x, y);
-#endif
-   if (p->num_verts >= p->size) {
-      polygon_resize(p, p->size * 2);
-   }
-
-   vert = ptr_to_vertex(p->data, p->num_verts);
-   vert[0] = x;
-   vert[1] = y;
-   ++p->num_verts;
-   p->dirty = VG_TRUE;
-}
-
-void polygon_set_vertex(struct polygon *p, int idx,
-                        float x, float y)
-{
-   float *vert;
-   if (idx >= p->num_verts) {
-      /*fixme: error reporting*/
-      abort();
-      return;
-   }
-
-   vert = ptr_to_vertex(p->data, idx);
-   vert[0] = x;
-   vert[1] = y;
-   p->dirty = VG_TRUE;
-}
-
-void polygon_vertex(struct polygon *p, int idx,
-                    float *vertex)
-{
-   float *vert;
-   if (idx >= p->num_verts) {
-      /*fixme: error reporting*/
-      abort();
-      return;
-   }
-
-   vert = ptr_to_vertex(p->data, idx);
-   vertex[0] = vert[0];
-   vertex[1] = vert[1];
-}
-
-void polygon_bounding_rect(struct polygon *p,
-                           float *rect)
-{
-   int i;
-   float minx, miny, maxx, maxy;
-   float *vert = ptr_to_vertex(p->data, 0);
-   minx = vert[0];
-   maxx = vert[0];
-   miny = vert[1];
-   maxy = vert[1];
-
-   for (i = 1; i < p->num_verts; ++i) {
-      vert = ptr_to_vertex(p->data, i);
-      minx = MIN2(vert[0], minx);
-      miny = MIN2(vert[1], miny);
-
-      maxx = MAX2(vert[0], maxx);
-      maxy = MAX2(vert[1], maxy);
-   }
-
-   rect[0] = minx;
-   rect[1] = miny;
-   rect[2] = maxx - minx;
-   rect[3] = maxy - miny;
-}
-
-int polygon_contains_point(struct polygon *p,
-                           float x, float y)
-{
-   return 0;
-}
-
-void polygon_append_polygon(struct polygon *dst,
-                            struct polygon *src)
-{
-   if (dst->num_verts + src->num_verts >= dst->size) {
-      polygon_resize(dst, dst->num_verts + src->num_verts * 1.5);
-   }
-   memcpy(ptr_to_vertex(dst->data, dst->num_verts),
-          src->data, src->num_verts * COMPONENTS * sizeof(VGfloat));
-   dst->num_verts += src->num_verts;
-}
-
-VGboolean polygon_is_closed(struct polygon *p)
-{
-   VGfloat start[2], end[2];
-
-   polygon_vertex(p, 0, start);
-   polygon_vertex(p, p->num_verts - 1, end);
-
-   return floatsEqual(start[0], end[0]) && floatsEqual(start[1], end[1]);
-}
-
-static void polygon_prepare_buffer(struct vg_context *ctx,
-                                   struct polygon *poly)
-{
-   struct pipe_context *pipe;
-
-   /*polygon_print(poly);*/
-
-   pipe = ctx->pipe;
-
-   if (poly->user_vbuf == NULL || poly->dirty) {
-      poly->screen = pipe->screen;
-      poly->user_vbuf = poly->data;
-      poly->dirty = VG_FALSE;
-   }
-}
-
-void polygon_fill(struct polygon *poly, struct vg_context *ctx)
-{
-   struct pipe_vertex_element velement;
-   struct pipe_vertex_buffer vbuffer;
-   VGfloat bounds[4];
-   VGfloat min_x, min_y, max_x, max_y;
-
-   assert(poly);
-   polygon_bounding_rect(poly, bounds);
-   min_x = bounds[0];
-   min_y = bounds[1];
-   max_x = bounds[0] + bounds[2];
-   max_y = bounds[1] + bounds[3];
-
-#if DEBUG_POLYGON
-   debug_printf("Poly bounds are [%f, %f], [%f, %f]\n",
-                min_x, min_y, max_x, max_y);
-#endif
-
-   polygon_prepare_buffer(ctx, poly);
-
-   /* tell renderer about the vertex attributes */
-   memset(&velement, 0, sizeof(velement));
-   velement.src_offset = 0;
-   velement.instance_divisor = 0;
-   velement.vertex_buffer_index = 0;
-   velement.src_format = PIPE_FORMAT_R32G32_FLOAT;
-
-   /* tell renderer about the vertex buffer */
-   memset(&vbuffer, 0, sizeof(vbuffer));
-   vbuffer.user_buffer = poly->user_vbuf;
-   vbuffer.stride = COMPONENTS * sizeof(float);  /* vertex size */
-
-   renderer_polygon_stencil_begin(ctx->renderer,
-         &velement, ctx->state.vg.fill_rule, VG_FALSE);
-   renderer_polygon_stencil(ctx->renderer, &vbuffer,
-         PIPE_PRIM_TRIANGLE_FAN, 0, (VGuint) poly->num_verts);
-   renderer_polygon_stencil_end(ctx->renderer);
-
-   renderer_polygon_fill_begin(ctx->renderer, VG_FALSE);
-   renderer_polygon_fill(ctx->renderer, min_x, min_y, max_x, max_y);
-   renderer_polygon_fill_end(ctx->renderer);
-}
-
-void polygon_array_fill(struct polygon_array *polyarray, struct vg_context *ctx)
-{
-   struct array *polys = polyarray->array;
-   VGfloat min_x = polyarray->min_x;
-   VGfloat min_y = polyarray->min_y;
-   VGfloat max_x = polyarray->max_x;
-   VGfloat max_y = polyarray->max_y;
-   struct pipe_vertex_element velement;
-   struct pipe_vertex_buffer vbuffer;
-   VGint i;
-
-
-#if DEBUG_POLYGON
-   debug_printf("%s: Poly bounds are [%f, %f], [%f, %f]\n",
-                __FUNCTION__,
-                min_x, min_y, max_x, max_y);
-#endif
-
-   /* tell renderer about the vertex attributes */
-   memset(&velement, 0, sizeof(velement));
-   velement.src_offset = 0;
-   velement.instance_divisor = 0;
-   velement.vertex_buffer_index = 0;
-   velement.src_format = PIPE_FORMAT_R32G32_FLOAT;
-
-   /* tell renderer about the vertex buffer */
-   memset(&vbuffer, 0, sizeof(vbuffer));
-   vbuffer.stride = COMPONENTS * sizeof(float);  /* vertex size */
-
-   /* prepare the stencil buffer */
-   renderer_polygon_stencil_begin(ctx->renderer,
-         &velement, ctx->state.vg.fill_rule, VG_FALSE);
-   for (i = 0; i < polys->num_elements; ++i) {
-      struct polygon *poly = (((struct polygon**)polys->data)[i]);
-
-      polygon_prepare_buffer(ctx, poly);
-      vbuffer.user_buffer = poly->user_vbuf;
-
-      renderer_polygon_stencil(ctx->renderer, &vbuffer,
-            PIPE_PRIM_TRIANGLE_FAN, 0, (VGuint) poly->num_verts);
-   }
-   renderer_polygon_stencil_end(ctx->renderer);
-
-   /* fill it */
-   renderer_polygon_fill_begin(ctx->renderer, VG_FALSE);
-   renderer_polygon_fill(ctx->renderer, min_x, min_y, max_x, max_y);
-   renderer_polygon_fill_end(ctx->renderer);
-}
diff --git a/src/gallium/state_trackers/vega/polygon.h b/src/gallium/state_trackers/vega/polygon.h
deleted file mode 100644
index 22672b728ed..00000000000
--- a/src/gallium/state_trackers/vega/polygon.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef POLYGON_H
-#define POLYGON_H
-
-#include "VG/openvg.h"
-
-struct polygon;
-struct vg_context;
-struct vg_paint;
-struct array;
-
-struct polygon *polygon_create(int size);
-struct polygon *polygon_create_from_data(float *data, int size);
-void            polygon_destroy(struct polygon *poly);
-
-void            polygon_resize(struct polygon *poly, int new_size);
-int             polygon_size(struct polygon *poly);
-
-int             polygon_vertex_count(struct polygon *poly);
-float *         polygon_data(struct polygon *poly);
-
-void            polygon_vertex_append(struct polygon *p,
-                                      float x, float y);
-void            polygon_append_polygon(struct polygon *dst,
-                                       struct polygon *src);
-void            polygon_set_vertex(struct polygon *p, int idx,
-                                   float x, float y);
-void            polygon_vertex(struct polygon *p, int idx,
-                               float *vertex);
-
-void            polygon_bounding_rect(struct polygon *p,
-                                      float *rect);
-int             polygon_contains_point(struct polygon *p,
-                                       float x, float y);
-
-VGboolean       polygon_is_closed(struct polygon *p);
-
-void polygon_fill(struct polygon *p, struct vg_context *pipe);
-
-/* TODO: make a file/module around this struct
- */
-struct polygon_array {
-   struct array *array;
-   VGfloat min_x, max_x;
-   VGfloat min_y, max_y;
-};
-
-void polygon_array_fill(struct polygon_array *polyarray, struct vg_context *ctx);
-
-#endif
diff --git a/src/gallium/state_trackers/vega/renderer.c b/src/gallium/state_trackers/vega/renderer.c
deleted file mode 100644
index d369c323bcc..00000000000
--- a/src/gallium/state_trackers/vega/renderer.c
+++ /dev/null
@@ -1,1558 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc.  All Rights Reserved.
- * Copyright 2010 LunarG, 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 "renderer.h"
-
-#include "vg_context.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_state.h"
-#include "util/u_inlines.h"
-#include "pipe/p_screen.h"
-#include "pipe/p_shader_tokens.h"
-
-#include "util/u_draw_quad.h"
-#include "util/u_simple_shaders.h"
-#include "util/u_memory.h"
-#include "util/u_sampler.h"
-#include "util/u_surface.h"
-#include "util/u_math.h"
-#include "util/u_format.h"
-
-#include "cso_cache/cso_context.h"
-#include "tgsi/tgsi_ureg.h"
-
-typedef enum {
-   RENDERER_STATE_INIT,
-   RENDERER_STATE_COPY,
-   RENDERER_STATE_DRAWTEX,
-   RENDERER_STATE_SCISSOR,
-   RENDERER_STATE_CLEAR,
-   RENDERER_STATE_FILTER,
-   RENDERER_STATE_POLYGON_STENCIL,
-   RENDERER_STATE_POLYGON_FILL,
-   NUM_RENDERER_STATES
-} RendererState;
-
-typedef enum {
-   RENDERER_VS_PLAIN,
-   RENDERER_VS_COLOR,
-   RENDERER_VS_TEXTURE,
-   NUM_RENDERER_VS
-} RendererVs;
-
-typedef enum {
-   RENDERER_FS_COLOR,
-   RENDERER_FS_TEXTURE,
-   RENDERER_FS_SCISSOR,
-   RENDERER_FS_WHITE,
-   NUM_RENDERER_FS
-} RendererFs;
-
-struct renderer {
-   struct pipe_context *pipe;
-   struct cso_context *cso;
-
-   VGbitfield dirty;
-   struct {
-      struct pipe_rasterizer_state rasterizer;
-      struct pipe_depth_stencil_alpha_state dsa;
-      struct pipe_framebuffer_state fb;
-   } g3d;
-   struct matrix projection;
-
-   struct matrix mvp;
-   struct pipe_resource *vs_cbuf;
-
-   struct pipe_resource *fs_cbuf;
-   VGfloat fs_cbuf_data[32];
-   VGint fs_cbuf_len;
-
-   struct pipe_vertex_element velems[2];
-   VGfloat vertices[4][2][4];
-
-   void *cached_vs[NUM_RENDERER_VS];
-   void *cached_fs[NUM_RENDERER_FS];
-
-   RendererState state;
-
-   /* state data */
-   union {
-      struct {
-         VGint tex_width;
-         VGint tex_height;
-      } copy;
-
-      struct {
-         VGint tex_width;
-         VGint tex_height;
-      } drawtex;
-
-      struct {
-         VGboolean restore_dsa;
-      } scissor;
-
-      struct {
-         VGboolean use_sampler;
-         VGint tex_width, tex_height;
-      } filter;
-
-      struct {
-         struct pipe_depth_stencil_alpha_state dsa;
-         VGboolean manual_two_sides;
-         VGboolean restore_dsa;
-      } polygon_stencil;
-   } u;
-};
-
-/**
- * Return VG_TRUE if the renderer can use the resource as the asked bindings.
- */
-static VGboolean renderer_can_support(struct renderer *renderer,
-                                      struct pipe_resource *res,
-                                      unsigned bindings)
-{
-   struct pipe_screen *screen = renderer->pipe->screen;
-
-   return screen->is_format_supported(screen,
-         res->format, res->target, 0, bindings);
-}
-
-/**
- * Set the model-view-projection matrix used by vertex shaders.
- */
-static void renderer_set_mvp(struct renderer *renderer,
-                             const struct matrix *mvp)
-{
-   struct matrix *cur = &renderer->mvp;
-   struct pipe_resource *cbuf;
-   VGfloat consts[3][4];
-   VGint i;
-
-   /* projection only */
-   if (!mvp)
-      mvp = &renderer->projection;
-
-   /* re-upload only if necessary */
-   if (memcmp(cur, mvp, sizeof(*mvp)) == 0)
-      return;
-
-   /* 3x3 matrix to 3 constant vectors (no Z) */
-   for (i = 0; i < 3; i++) {
-      consts[i][0] = mvp->m[i + 0];
-      consts[i][1] = mvp->m[i + 3];
-      consts[i][2] = 0.0f;
-      consts[i][3] = mvp->m[i + 6];
-   }
-
-   cbuf = renderer->vs_cbuf;
-   pipe_resource_reference(&cbuf, NULL);
-   cbuf = pipe_buffer_create(renderer->pipe->screen,
-                             PIPE_BIND_CONSTANT_BUFFER,
-                             PIPE_USAGE_DEFAULT,
-                             sizeof(consts));
-   if (cbuf) {
-      pipe_buffer_write(renderer->pipe, cbuf,
-            0, sizeof(consts), consts);
-   }
-   pipe_set_constant_buffer(renderer->pipe,
-         PIPE_SHADER_VERTEX, 0, cbuf);
-
-   memcpy(cur, mvp, sizeof(*mvp));
-   renderer->vs_cbuf = cbuf;
-}
-
-/**
- * Create a simple vertex shader that passes through position and the given
- * attribute.
- */
-static void *create_passthrough_vs(struct pipe_context *pipe, int semantic_name)
-{
-   struct ureg_program *ureg;
-   struct ureg_src src[2], constants[3];
-   struct ureg_dst dst[2], tmp;
-   int i;
-
-   ureg = ureg_create(TGSI_PROCESSOR_VERTEX);
-   if (!ureg)
-      return NULL;
-
-   /* position is in user coordinates */
-   src[0] = ureg_DECL_vs_input(ureg, 0);
-   dst[0] = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);
-   tmp = ureg_DECL_temporary(ureg);
-   for (i = 0; i < Elements(constants); i++)
-      constants[i] = ureg_DECL_constant(ureg, i);
-
-   /* transform to clipped coordinates */
-   ureg_DP4(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_X), src[0], constants[0]);
-   ureg_DP4(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_Y), src[0], constants[1]);
-   ureg_MOV(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_Z), src[0]);
-   ureg_DP4(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_W), src[0], constants[2]);
-   ureg_MOV(ureg, dst[0], ureg_src(tmp));
-
-   if (semantic_name >= 0) {
-      src[1] = ureg_DECL_vs_input(ureg, 1);
-      dst[1] = ureg_DECL_output(ureg, semantic_name, 0);
-      ureg_MOV(ureg, dst[1], src[1]);
-   }
-
-   ureg_END(ureg);
-
-   return ureg_create_shader_and_destroy(ureg, pipe);
-}
-
-/**
- * Set renderer vertex shader.
- *
- * This function modifies vertex_shader state.
- */
-static void renderer_set_vs(struct renderer *r, RendererVs id)
-{
-   /* create as needed */
-   if (!r->cached_vs[id]) {
-      int semantic_name = -1;
-
-      switch (id) {
-      case RENDERER_VS_PLAIN:
-         break;
-      case RENDERER_VS_COLOR:
-         semantic_name = TGSI_SEMANTIC_COLOR;
-         break;
-      case RENDERER_VS_TEXTURE:
-         semantic_name = TGSI_SEMANTIC_GENERIC;
-         break;
-      default:
-         assert(!"Unknown renderer vs id");
-         break;
-      }
-
-      r->cached_vs[id] = create_passthrough_vs(r->pipe, semantic_name);
-   }
-
-   cso_set_vertex_shader_handle(r->cso, r->cached_vs[id]);
-}
-
-/**
- * Create a simple fragment shader that sets the depth to 0.0f.
- */
-static void *create_scissor_fs(struct pipe_context *pipe)
-{
-   struct ureg_program *ureg;
-   struct ureg_dst out;
-   struct ureg_src imm;
-
-   ureg = ureg_create(TGSI_PROCESSOR_FRAGMENT);
-   out = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);
-   imm = ureg_imm4f(ureg, 0.0f, 0.0f, 0.0f, 0.0f);
-
-   ureg_MOV(ureg, ureg_writemask(out, TGSI_WRITEMASK_Z), imm);
-   ureg_END(ureg);
-
-   return ureg_create_shader_and_destroy(ureg, pipe);
-}
-
-/**
- * Create a simple fragment shader that sets the color to white.
- */
-static void *create_white_fs(struct pipe_context *pipe)
-{
-   struct ureg_program *ureg;
-   struct ureg_dst out;
-   struct ureg_src imm;
-
-   ureg = ureg_create(TGSI_PROCESSOR_FRAGMENT);
-   out = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);
-   imm = ureg_imm4f(ureg, 1.0f, 1.0f, 1.0f, 1.0f);
-
-   ureg_MOV(ureg, out, imm);
-   ureg_END(ureg);
-
-   return ureg_create_shader_and_destroy(ureg, pipe);
-}
-
-/**
- * Set renderer fragment shader.
- *
- * This function modifies fragment_shader state.
- */
-static void renderer_set_fs(struct renderer *r, RendererFs id)
-{
-   /* create as needed */
-   if (!r->cached_fs[id]) {
-      void *fs = NULL;
-
-      switch (id) {
-      case RENDERER_FS_COLOR:
-         fs = util_make_fragment_passthrough_shader(r->pipe,
-                          TGSI_SEMANTIC_COLOR, TGSI_INTERPOLATE_PERSPECTIVE,
-                          TRUE);
-         break;
-      case RENDERER_FS_TEXTURE:
-         fs = util_make_fragment_tex_shader(r->pipe,
-               TGSI_TEXTURE_2D, TGSI_INTERPOLATE_LINEAR);
-         break;
-      case RENDERER_FS_SCISSOR:
-         fs = create_scissor_fs(r->pipe);
-         break;
-      case RENDERER_FS_WHITE:
-         fs = create_white_fs(r->pipe);
-         break;
-      default:
-         assert(!"Unknown renderer fs id");
-         break;
-      }
-
-      r->cached_fs[id] = fs;
-   }
-
-   cso_set_fragment_shader_handle(r->cso, r->cached_fs[id]);
-}
-
-typedef enum {
-   VEGA_Y0_TOP,
-   VEGA_Y0_BOTTOM
-} VegaOrientation;
-
-static void vg_set_viewport(struct renderer *r,
-                            VegaOrientation orientation)
-{
-   const struct pipe_framebuffer_state *fb = &r->g3d.fb;
-   struct pipe_viewport_state viewport;
-   VGfloat y_scale = (orientation == VEGA_Y0_BOTTOM) ? -2.f : 2.f;
-
-   viewport.scale[0] =  fb->width / 2.f;
-   viewport.scale[1] =  fb->height / y_scale;
-   viewport.scale[2] =  1.0;
-   viewport.translate[0] = fb->width / 2.f;
-   viewport.translate[1] = fb->height / 2.f;
-   viewport.translate[2] = 0.0;
-
-   cso_set_viewport(r->cso, &viewport);
-}
-
-/**
- * Set renderer target.
- *
- * This function modifies framebuffer and viewport states.
- */
-static void renderer_set_target(struct renderer *r,
-                                struct pipe_surface *cbuf,
-                                struct pipe_surface *zsbuf,
-                                VGboolean y0_top)
-{
-   struct pipe_framebuffer_state fb;
-
-   memset(&fb, 0, sizeof(fb));
-   fb.width = cbuf->width;
-   fb.height = cbuf->height;
-   fb.cbufs[0] = cbuf;
-   fb.nr_cbufs = 1;
-   fb.zsbuf = zsbuf;
-   cso_set_framebuffer(r->cso, &fb);
-
-   vg_set_viewport(r, (y0_top) ? VEGA_Y0_TOP : VEGA_Y0_BOTTOM);
-}
-
-/**
- * Set renderer blend state.  Blending is disabled.
- *
- * This function modifies blend state.
- */
-static void renderer_set_blend(struct renderer *r,
-                               VGbitfield channel_mask)
-{
-   struct pipe_blend_state blend;
-
-   memset(&blend, 0, sizeof(blend));
-
-   blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE;
-   blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
-   blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO;
-   blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
-
-   if (channel_mask & VG_RED)
-      blend.rt[0].colormask |= PIPE_MASK_R;
-   if (channel_mask & VG_GREEN)
-      blend.rt[0].colormask |= PIPE_MASK_G;
-   if (channel_mask & VG_BLUE)
-      blend.rt[0].colormask |= PIPE_MASK_B;
-   if (channel_mask & VG_ALPHA)
-      blend.rt[0].colormask |= PIPE_MASK_A;
-
-   cso_set_blend(r->cso, &blend);
-}
-
-/**
- * Set renderer sampler and view states.
- *
- * This function modifies samplers and fragment_sampler_views states.
- */
-static void renderer_set_samplers(struct renderer *r,
-                                  uint num_views,
-                                  struct pipe_sampler_view **views)
-{
-   struct pipe_sampler_state sampler;
-   unsigned tex_filter = PIPE_TEX_FILTER_NEAREST;
-   unsigned tex_wrap = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-   uint i;
-
-   memset(&sampler, 0, sizeof(sampler));
-
-   sampler.min_img_filter = tex_filter;
-   sampler.mag_img_filter = tex_filter;
-   sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
-
-   sampler.wrap_s = tex_wrap;
-   sampler.wrap_t = tex_wrap;
-   sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-
-   sampler.normalized_coords = 1;
-
-   /* set samplers */
-   for (i = 0; i < num_views; i++)
-      cso_single_sampler(r->cso, PIPE_SHADER_FRAGMENT, i, &sampler);
-   cso_single_sampler_done(r->cso, PIPE_SHADER_FRAGMENT);
-
-   /* set views */
-   cso_set_sampler_views(r->cso, PIPE_SHADER_FRAGMENT, num_views, views);
-}
-
-/**
- * Set custom renderer fragment shader, and optionally set samplers and views
- * and upload the fragment constant buffer.
- *
- * This function modifies fragment_shader, samplers and fragment_sampler_views
- * states.
- */
-static void renderer_set_custom_fs(struct renderer *renderer,
-                                   void *fs,
-                                   const struct pipe_sampler_state **samplers,
-                                   struct pipe_sampler_view **views,
-                                   VGint num_samplers,
-                                   const void *const_buffer,
-                                   VGint const_buffer_len)
-{
-   cso_set_fragment_shader_handle(renderer->cso, fs);
-
-   /* set samplers and views */
-   if (num_samplers) {
-      cso_set_samplers(renderer->cso, PIPE_SHADER_FRAGMENT, num_samplers, samplers);
-      cso_set_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT, num_samplers, views);
-   }
-
-   /* upload fs constant buffer */
-   if (const_buffer_len) {
-      struct pipe_resource *cbuf = renderer->fs_cbuf;
-
-      if (!cbuf || renderer->fs_cbuf_len != const_buffer_len ||
-          memcmp(renderer->fs_cbuf_data, const_buffer, const_buffer_len)) {
-         pipe_resource_reference(&cbuf, NULL);
-
-         cbuf = pipe_buffer_create(renderer->pipe->screen,
-               PIPE_BIND_CONSTANT_BUFFER, PIPE_USAGE_DEFAULT,
-               const_buffer_len);
-         pipe_buffer_write(renderer->pipe, cbuf, 0,
-               const_buffer_len, const_buffer);
-         pipe_set_constant_buffer(renderer->pipe,
-               PIPE_SHADER_FRAGMENT, 0, cbuf);
-
-         renderer->fs_cbuf = cbuf;
-         if (const_buffer_len <= sizeof(renderer->fs_cbuf_data)) {
-            memcpy(renderer->fs_cbuf_data, const_buffer, const_buffer_len);
-            renderer->fs_cbuf_len = const_buffer_len;
-         }
-         else {
-            renderer->fs_cbuf_len = 0;
-         }
-      }
-   }
-}
-
-/**
- * Setup renderer quad position.
- */
-static void renderer_quad_pos(struct renderer *r,
-                              VGfloat x0, VGfloat y0,
-                              VGfloat x1, VGfloat y1,
-                              VGboolean scissor)
-{
-   VGfloat z;
-
-   /* the depth test is used for scissoring */
-   z = (scissor) ? 0.0f : 1.0f;
-
-   /* positions */
-   r->vertices[0][0][0] = x0;
-   r->vertices[0][0][1] = y0;
-   r->vertices[0][0][2] = z;
-
-   r->vertices[1][0][0] = x1;
-   r->vertices[1][0][1] = y0;
-   r->vertices[1][0][2] = z;
-
-   r->vertices[2][0][0] = x1;
-   r->vertices[2][0][1] = y1;
-   r->vertices[2][0][2] = z;
-
-   r->vertices[3][0][0] = x0;
-   r->vertices[3][0][1] = y1;
-   r->vertices[3][0][2] = z;
-}
-
-/**
- * Setup renderer quad texture coordinates.
- */
-static void renderer_quad_texcoord(struct renderer *r,
-                                   VGfloat x0, VGfloat y0,
-                                   VGfloat x1, VGfloat y1,
-                                   VGint tex_width, VGint tex_height)
-{
-   VGfloat s0, t0, s1, t1, r0, q0;
-   VGint i;
-
-   s0 = x0 / tex_width;
-   s1 = x1 / tex_width;
-   t0 = y0 / tex_height;
-   t1 = y1 / tex_height;
-   r0 = 0.0f;
-   q0 = 1.0f;
-
-   /* texcoords */
-   r->vertices[0][1][0] = s0;
-   r->vertices[0][1][1] = t0;
-
-   r->vertices[1][1][0] = s1;
-   r->vertices[1][1][1] = t0;
-
-   r->vertices[2][1][0] = s1;
-   r->vertices[2][1][1] = t1;
-
-   r->vertices[3][1][0] = s0;
-   r->vertices[3][1][1] = t1;
-
-   for (i = 0; i < 4; i++) {
-      r->vertices[i][1][2] = r0;
-      r->vertices[i][1][3] = q0;
-   }
-}
-
-/**
- * Draw renderer quad.
- */
-static void renderer_quad_draw(struct renderer *r)
-{
-   util_draw_user_vertex_buffer(r->cso, r->vertices, PIPE_PRIM_TRIANGLE_FAN,
-                                Elements(r->vertices),     /* verts */
-                                Elements(r->vertices[0])); /* attribs/vert */
-}
-
-/**
- * Prepare the renderer for copying.
- */
-VGboolean renderer_copy_begin(struct renderer *renderer,
-                              struct pipe_surface *dst,
-                              VGboolean y0_top,
-                              struct pipe_sampler_view *src)
-{
-   assert(renderer->state == RENDERER_STATE_INIT);
-
-   /* sanity check */
-   if (!renderer_can_support(renderer,
-            dst->texture, PIPE_BIND_RENDER_TARGET) ||
-       !renderer_can_support(renderer,
-          src->texture, PIPE_BIND_SAMPLER_VIEW))
-      return VG_FALSE;
-
-   cso_save_framebuffer(renderer->cso);
-   cso_save_viewport(renderer->cso);
-   cso_save_blend(renderer->cso);
-   cso_save_samplers(renderer->cso, PIPE_SHADER_FRAGMENT);
-   cso_save_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT);
-   cso_save_fragment_shader(renderer->cso);
-   cso_save_vertex_shader(renderer->cso);
-
-   renderer_set_target(renderer, dst, NULL, y0_top);
-
-   renderer_set_blend(renderer, ~0);
-   renderer_set_samplers(renderer, 1, &src);
-
-   renderer_set_fs(renderer, RENDERER_FS_TEXTURE);
-   renderer_set_vs(renderer, RENDERER_VS_TEXTURE);
-
-   renderer_set_mvp(renderer, NULL);
-
-   /* remember the texture size */
-   renderer->u.copy.tex_width = src->texture->width0;
-   renderer->u.copy.tex_height = src->texture->height0;
-   renderer->state = RENDERER_STATE_COPY;
-
-   return VG_TRUE;
-}
-
-/**
- * Draw into the destination rectangle given by (x, y, w, h).  The texture is
- * sampled from within the rectangle given by (sx, sy, sw, sh).
- *
- * The coordinates are in surface coordinates.
- */
-void renderer_copy(struct renderer *renderer,
-                   VGint x, VGint y, VGint w, VGint h,
-                   VGint sx, VGint sy, VGint sw, VGint sh)
-{
-   assert(renderer->state == RENDERER_STATE_COPY);
-
-   /* there is no depth buffer for scissoring anyway */
-   renderer_quad_pos(renderer, x, y, x + w, y + h, VG_FALSE);
-   renderer_quad_texcoord(renderer, sx, sy, sx + sw, sy + sh,
-         renderer->u.copy.tex_width,
-         renderer->u.copy.tex_height);
-
-   renderer_quad_draw(renderer);
-}
-
-/**
- * End copying and restore the states.
- */
-void renderer_copy_end(struct renderer *renderer)
-{
-   assert(renderer->state == RENDERER_STATE_COPY);
-
-   cso_restore_framebuffer(renderer->cso);
-   cso_restore_viewport(renderer->cso);
-   cso_restore_blend(renderer->cso);
-   cso_restore_samplers(renderer->cso, PIPE_SHADER_FRAGMENT);
-   cso_restore_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT);
-   cso_restore_fragment_shader(renderer->cso);
-   cso_restore_vertex_shader(renderer->cso);
-
-   renderer->state = RENDERER_STATE_INIT;
-}
-
-/**
- * Prepare the renderer for textured drawing.
- */
-VGboolean renderer_drawtex_begin(struct renderer *renderer,
-                                 struct pipe_sampler_view *src)
-{
-   assert(renderer->state == RENDERER_STATE_INIT);
-
-   if (!renderer_can_support(renderer, src->texture, PIPE_BIND_SAMPLER_VIEW))
-      return VG_FALSE;
-
-   cso_save_blend(renderer->cso);
-   cso_save_samplers(renderer->cso, PIPE_SHADER_FRAGMENT);
-   cso_save_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT);
-   cso_save_fragment_shader(renderer->cso);
-   cso_save_vertex_shader(renderer->cso);
-
-   renderer_set_blend(renderer, ~0);
-
-   renderer_set_samplers(renderer, 1, &src);
-
-   renderer_set_fs(renderer, RENDERER_FS_TEXTURE);
-   renderer_set_vs(renderer, RENDERER_VS_TEXTURE);
-
-   renderer_set_mvp(renderer, NULL);
-
-   /* remember the texture size */
-   renderer->u.drawtex.tex_width = src->texture->width0;
-   renderer->u.drawtex.tex_height = src->texture->height0;
-   renderer->state = RENDERER_STATE_DRAWTEX;
-
-   return VG_TRUE;
-}
-
-/**
- * Draw into the destination rectangle given by (x, y, w, h).  The texture is
- * sampled from within the rectangle given by (sx, sy, sw, sh).
- *
- * The coordinates are in surface coordinates.
- */
-void renderer_drawtex(struct renderer *renderer,
-                      VGint x, VGint y, VGint w, VGint h,
-                      VGint sx, VGint sy, VGint sw, VGint sh)
-{
-   assert(renderer->state == RENDERER_STATE_DRAWTEX);
-
-   /* with scissoring */
-   renderer_quad_pos(renderer, x, y, x + w, y + h, VG_TRUE);
-   renderer_quad_texcoord(renderer, sx, sy, sx + sw, sy + sh,
-         renderer->u.drawtex.tex_width,
-         renderer->u.drawtex.tex_height);
-
-   renderer_quad_draw(renderer);
-}
-
-/**
- * End textured drawing and restore the states.
- */
-void renderer_drawtex_end(struct renderer *renderer)
-{
-   assert(renderer->state == RENDERER_STATE_DRAWTEX);
-
-   cso_restore_blend(renderer->cso);
-   cso_restore_samplers(renderer->cso, PIPE_SHADER_FRAGMENT);
-   cso_restore_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT);
-   cso_restore_fragment_shader(renderer->cso);
-   cso_restore_vertex_shader(renderer->cso);
-
-   renderer->state = RENDERER_STATE_INIT;
-}
-
-/**
- * Prepare the renderer for scissor update.  This will reset the depth buffer
- * to 1.0f.
- */
-VGboolean renderer_scissor_begin(struct renderer *renderer,
-                                 VGboolean restore_dsa)
-{
-   struct pipe_depth_stencil_alpha_state dsa;
-
-   assert(renderer->state == RENDERER_STATE_INIT);
-
-   if (restore_dsa)
-      cso_save_depth_stencil_alpha(renderer->cso);
-   cso_save_blend(renderer->cso);
-   cso_save_fragment_shader(renderer->cso);
-
-   /* enable depth writes */
-   memset(&dsa, 0, sizeof(dsa));
-   dsa.depth.enabled = 1;
-   dsa.depth.writemask = 1;
-   dsa.depth.func = PIPE_FUNC_ALWAYS;
-   cso_set_depth_stencil_alpha(renderer->cso, &dsa);
-
-   /* disable color writes */
-   renderer_set_blend(renderer, 0);
-   renderer_set_fs(renderer, RENDERER_FS_SCISSOR);
-
-   renderer_set_mvp(renderer, NULL);
-
-   renderer->u.scissor.restore_dsa = restore_dsa;
-   renderer->state = RENDERER_STATE_SCISSOR;
-
-   /* clear the depth buffer to 1.0f */
-   renderer->pipe->clear(renderer->pipe,
-         PIPE_CLEAR_DEPTHSTENCIL, NULL, 1.0f, 0);
-
-   return VG_TRUE;
-}
-
-/**
- * Add a scissor rectangle.  Depth values inside the rectangle will be set to
- * 0.0f.
- */
-void renderer_scissor(struct renderer *renderer,
-                      VGint x, VGint y, VGint width, VGint height)
-{
-   assert(renderer->state == RENDERER_STATE_SCISSOR);
-
-   renderer_quad_pos(renderer, x, y, x + width, y + height, VG_FALSE);
-   renderer_quad_draw(renderer);
-}
-
-/**
- * End scissor update and restore the states.
- */
-void renderer_scissor_end(struct renderer *renderer)
-{
-   assert(renderer->state == RENDERER_STATE_SCISSOR);
-
-   if (renderer->u.scissor.restore_dsa)
-      cso_restore_depth_stencil_alpha(renderer->cso);
-   cso_restore_blend(renderer->cso);
-   cso_restore_fragment_shader(renderer->cso);
-
-   renderer->state = RENDERER_STATE_INIT;
-}
-
-/**
- * Prepare the renderer for clearing.
- */
-VGboolean renderer_clear_begin(struct renderer *renderer)
-{
-   assert(renderer->state == RENDERER_STATE_INIT);
-
-   cso_save_blend(renderer->cso);
-   cso_save_fragment_shader(renderer->cso);
-   cso_save_vertex_shader(renderer->cso);
-
-   renderer_set_blend(renderer, ~0);
-   renderer_set_fs(renderer, RENDERER_FS_COLOR);
-   renderer_set_vs(renderer, RENDERER_VS_COLOR);
-
-   renderer_set_mvp(renderer, NULL);
-
-   renderer->state = RENDERER_STATE_CLEAR;
-
-   return VG_TRUE;
-}
-
-/**
- * Clear the framebuffer with the specified region and color.
- *
- * The coordinates are in surface coordinates.
- */
-void renderer_clear(struct renderer *renderer,
-                    VGint x, VGint y, VGint width, VGint height,
-                    const VGfloat color[4])
-{
-   VGuint i;
-
-   assert(renderer->state == RENDERER_STATE_CLEAR);
-
-   renderer_quad_pos(renderer, x, y, x + width, y + height, VG_TRUE);
-   for (i = 0; i < 4; i++)
-      memcpy(renderer->vertices[i][1], color, sizeof(VGfloat) * 4);
-
-   renderer_quad_draw(renderer);
-}
-
-/**
- * End clearing and retore the states.
- */
-void renderer_clear_end(struct renderer *renderer)
-{
-   assert(renderer->state == RENDERER_STATE_CLEAR);
-
-   cso_restore_blend(renderer->cso);
-   cso_restore_fragment_shader(renderer->cso);
-   cso_restore_vertex_shader(renderer->cso);
-
-   renderer->state = RENDERER_STATE_INIT;
-}
-
-/**
- * Prepare the renderer for image filtering.
- */
-VGboolean renderer_filter_begin(struct renderer *renderer,
-                                struct pipe_resource *dst,
-                                VGboolean y0_top,
-                                VGbitfield channel_mask,
-                                const struct pipe_sampler_state **samplers,
-                                struct pipe_sampler_view **views,
-                                VGint num_samplers,
-                                void *fs,
-                                const void *const_buffer,
-                                VGint const_buffer_len)
-{
-   struct pipe_surface *surf, surf_tmpl;
-
-   assert(renderer->state == RENDERER_STATE_INIT);
-
-   if (!fs)
-      return VG_FALSE;
-   if (!renderer_can_support(renderer, dst, PIPE_BIND_RENDER_TARGET))
-      return VG_FALSE;
-
-   u_surface_default_template(&surf_tmpl, dst);
-   surf = renderer->pipe->create_surface(renderer->pipe, dst, &surf_tmpl);
-   if (!surf)
-      return VG_FALSE;
-
-   cso_save_framebuffer(renderer->cso);
-   cso_save_viewport(renderer->cso);
-   cso_save_blend(renderer->cso);
-
-   /* set the image as the target */
-   renderer_set_target(renderer, surf, NULL, y0_top);
-   pipe_surface_reference(&surf, NULL);
-
-   renderer_set_blend(renderer, channel_mask);
-
-   if (num_samplers) {
-      struct pipe_resource *tex;
-
-      cso_save_samplers(renderer->cso, PIPE_SHADER_FRAGMENT);
-      cso_save_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT);
-      cso_save_fragment_shader(renderer->cso);
-      cso_save_vertex_shader(renderer->cso);
-
-      renderer_set_custom_fs(renderer, fs,
-                             samplers, views, num_samplers,
-                             const_buffer, const_buffer_len);
-      renderer_set_vs(renderer, RENDERER_VS_TEXTURE);
-
-      tex = views[0]->texture;
-      renderer->u.filter.tex_width = tex->width0;
-      renderer->u.filter.tex_height = tex->height0;
-      renderer->u.filter.use_sampler = VG_TRUE;
-   }
-   else {
-      cso_save_fragment_shader(renderer->cso);
-
-      renderer_set_custom_fs(renderer, fs, NULL, NULL, 0,
-                             const_buffer, const_buffer_len);
-
-      renderer->u.filter.use_sampler = VG_FALSE;
-   }
-
-   renderer_set_mvp(renderer, NULL);
-
-   renderer->state = RENDERER_STATE_FILTER;
-
-   return VG_TRUE;
-}
-
-/**
- * Draw into a rectangle of the destination with the specified region of the
- * texture(s).
- *
- * The coordinates are in surface coordinates.
- */
-void renderer_filter(struct renderer *renderer,
-                    VGint x, VGint y, VGint w, VGint h,
-                    VGint sx, VGint sy, VGint sw, VGint sh)
-{
-   assert(renderer->state == RENDERER_STATE_FILTER);
-
-   renderer_quad_pos(renderer, x, y, x + w, y + h, VG_FALSE);
-   if (renderer->u.filter.use_sampler) {
-      renderer_quad_texcoord(renderer, sx, sy, sx + sw, sy + sh,
-            renderer->u.filter.tex_width,
-            renderer->u.filter.tex_height);
-   }
-
-   renderer_quad_draw(renderer);
-}
-
-/**
- * End image filtering and restore the states.
- */
-void renderer_filter_end(struct renderer *renderer)
-{
-   assert(renderer->state == RENDERER_STATE_FILTER);
-
-   if (renderer->u.filter.use_sampler) {
-      cso_restore_samplers(renderer->cso, PIPE_SHADER_FRAGMENT);
-      cso_restore_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT);
-      cso_restore_vertex_shader(renderer->cso);
-   }
-
-   cso_restore_framebuffer(renderer->cso);
-   cso_restore_viewport(renderer->cso);
-   cso_restore_blend(renderer->cso);
-   cso_restore_fragment_shader(renderer->cso);
-
-   renderer->state = RENDERER_STATE_INIT;
-}
-
-/**
- * Prepare the renderer for polygon silhouette rendering.
- */
-VGboolean renderer_polygon_stencil_begin(struct renderer *renderer,
-                                         struct pipe_vertex_element *velem,
-                                         VGFillRule rule,
-                                         VGboolean restore_dsa)
-{
-   struct pipe_depth_stencil_alpha_state *dsa;
-   VGboolean manual_two_sides;
-
-   assert(renderer->state == RENDERER_STATE_INIT);
-
-   cso_save_vertex_elements(renderer->cso);
-   cso_save_blend(renderer->cso);
-   cso_save_depth_stencil_alpha(renderer->cso);
-
-   cso_set_vertex_elements(renderer->cso, 1, velem);
-
-   /* disable color writes */
-   renderer_set_blend(renderer, 0);
-
-   manual_two_sides = VG_FALSE;
-   dsa = &renderer->u.polygon_stencil.dsa;
-   memset(dsa, 0, sizeof(*dsa));
-   if (rule == VG_EVEN_ODD) {
-      dsa->stencil[0].enabled = 1;
-      dsa->stencil[0].writemask = 1;
-      dsa->stencil[0].fail_op = PIPE_STENCIL_OP_KEEP;
-      dsa->stencil[0].zfail_op = PIPE_STENCIL_OP_KEEP;
-      dsa->stencil[0].zpass_op = PIPE_STENCIL_OP_INVERT;
-      dsa->stencil[0].func = PIPE_FUNC_ALWAYS;
-      dsa->stencil[0].valuemask = ~0;
-   }
-   else {
-      assert(rule == VG_NON_ZERO);
-
-      /* front face */
-      dsa->stencil[0].enabled = 1;
-      dsa->stencil[0].writemask = ~0;
-      dsa->stencil[0].fail_op = PIPE_STENCIL_OP_KEEP;
-      dsa->stencil[0].zfail_op = PIPE_STENCIL_OP_KEEP;
-      dsa->stencil[0].zpass_op = PIPE_STENCIL_OP_INCR_WRAP;
-      dsa->stencil[0].func = PIPE_FUNC_ALWAYS;
-      dsa->stencil[0].valuemask = ~0;
-
-      if (renderer->pipe->screen->get_param(renderer->pipe->screen,
-                                            PIPE_CAP_TWO_SIDED_STENCIL)) {
-         /* back face */
-         dsa->stencil[1] = dsa->stencil[0];
-         dsa->stencil[1].zpass_op = PIPE_STENCIL_OP_DECR_WRAP;
-      }
-      else {
-         manual_two_sides = VG_TRUE;
-      }
-   }
-   cso_set_depth_stencil_alpha(renderer->cso, dsa);
-
-   if (manual_two_sides)
-      cso_save_rasterizer(renderer->cso);
-
-   renderer->u.polygon_stencil.manual_two_sides = manual_two_sides;
-   renderer->u.polygon_stencil.restore_dsa = restore_dsa;
-   renderer->state = RENDERER_STATE_POLYGON_STENCIL;
-
-   return VG_TRUE;
-}
-
-/**
- * Render a polygon silhouette to stencil buffer.
- */
-void renderer_polygon_stencil(struct renderer *renderer,
-                              struct pipe_vertex_buffer *vbuf,
-                              VGuint mode, VGuint start, VGuint count)
-{
-   assert(renderer->state == RENDERER_STATE_POLYGON_STENCIL);
-
-   cso_set_vertex_buffers(renderer->cso, 0, 1, vbuf);
-
-   if (!renderer->u.polygon_stencil.manual_two_sides) {
-      cso_draw_arrays(renderer->cso, mode, start, count);
-   }
-   else {
-      struct pipe_rasterizer_state raster;
-      struct pipe_depth_stencil_alpha_state dsa;
-
-      raster = renderer->g3d.rasterizer;
-      dsa = renderer->u.polygon_stencil.dsa;
-
-      /* front */
-      raster.cull_face = PIPE_FACE_BACK;
-      dsa.stencil[0].zpass_op = PIPE_STENCIL_OP_INCR_WRAP;
-
-      cso_set_rasterizer(renderer->cso, &raster);
-      cso_set_depth_stencil_alpha(renderer->cso, &dsa);
-      cso_draw_arrays(renderer->cso, mode, start, count);
-
-      /* back */
-      raster.cull_face = PIPE_FACE_FRONT;
-      dsa.stencil[0].zpass_op = PIPE_STENCIL_OP_DECR_WRAP;
-
-      cso_set_rasterizer(renderer->cso, &raster);
-      cso_set_depth_stencil_alpha(renderer->cso, &dsa);
-      cso_draw_arrays(renderer->cso, mode, start, count);
-   }
-}
-
-/**
- * End polygon silhouette rendering.
- */
-void renderer_polygon_stencil_end(struct renderer *renderer)
-{
-   assert(renderer->state == RENDERER_STATE_POLYGON_STENCIL);
-
-   if (renderer->u.polygon_stencil.manual_two_sides)
-      cso_restore_rasterizer(renderer->cso);
-
-   cso_restore_vertex_elements(renderer->cso);
-
-   /* restore color writes */
-   cso_restore_blend(renderer->cso);
-
-   if (renderer->u.polygon_stencil.restore_dsa)
-      cso_restore_depth_stencil_alpha(renderer->cso);
-
-   renderer->state = RENDERER_STATE_INIT;
-}
-
-/**
- * Prepare the renderer for polygon filling.
- */
-VGboolean renderer_polygon_fill_begin(struct renderer *renderer,
-                                      VGboolean save_dsa)
-{
-   struct pipe_depth_stencil_alpha_state dsa;
-
-   assert(renderer->state == RENDERER_STATE_INIT);
-
-   if (save_dsa)
-      cso_save_depth_stencil_alpha(renderer->cso);
-
-   /* setup stencil ops */
-   memset(&dsa, 0, sizeof(dsa));
-   dsa.stencil[0].enabled = 1;
-   dsa.stencil[0].func = PIPE_FUNC_NOTEQUAL;
-   dsa.stencil[0].fail_op = PIPE_STENCIL_OP_REPLACE;
-   dsa.stencil[0].zfail_op = PIPE_STENCIL_OP_REPLACE;
-   dsa.stencil[0].zpass_op = PIPE_STENCIL_OP_REPLACE;
-   dsa.stencil[0].valuemask = ~0;
-   dsa.stencil[0].writemask = ~0;
-   dsa.depth = renderer->g3d.dsa.depth;
-   cso_set_depth_stencil_alpha(renderer->cso, &dsa);
-
-   renderer->state = RENDERER_STATE_POLYGON_FILL;
-
-   return VG_TRUE;
-}
-
-/**
- * Fill a polygon.
- */
-void renderer_polygon_fill(struct renderer *renderer,
-                           VGfloat min_x, VGfloat min_y,
-                           VGfloat max_x, VGfloat max_y)
-{
-   assert(renderer->state == RENDERER_STATE_POLYGON_FILL);
-
-   renderer_quad_pos(renderer, min_x, min_y, max_x, max_y, VG_TRUE);
-   renderer_quad_draw(renderer);
-}
-
-/**
- * End polygon filling.
- */
-void renderer_polygon_fill_end(struct renderer *renderer)
-{
-   assert(renderer->state == RENDERER_STATE_POLYGON_FILL);
-
-   cso_restore_depth_stencil_alpha(renderer->cso);
-
-   renderer->state = RENDERER_STATE_INIT;
-}
-
-struct renderer * renderer_create(struct vg_context *owner)
-{
-   struct renderer *renderer;
-   struct pipe_rasterizer_state *raster;
-   struct pipe_stencil_ref sr;
-   VGint i;
-
-   renderer = CALLOC_STRUCT(renderer);
-   if (!renderer)
-      return NULL;
-
-   renderer->pipe = owner->pipe;
-   renderer->cso = owner->cso_context;
-
-   /* init vertex data that doesn't change */
-   for (i = 0; i < 4; i++)
-      renderer->vertices[i][0][3] = 1.0f; /* w */
-
-   for (i = 0; i < 2; i++) {
-      renderer->velems[i].src_offset = i * 4 * sizeof(float);
-      renderer->velems[i].instance_divisor = 0;
-      renderer->velems[i].vertex_buffer_index = 0;
-      renderer->velems[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
-   }
-   cso_set_vertex_elements(renderer->cso, 2, renderer->velems);
-
-   /* GL rasterization rules */
-   raster = &renderer->g3d.rasterizer;
-   memset(raster, 0, sizeof(*raster));
-   raster->half_pixel_center = 1;
-   raster->bottom_edge_rule = 1;
-   raster->depth_clip = 1;
-   cso_set_rasterizer(renderer->cso, raster);
-
-   /* fixed at 0 */
-   memset(&sr, 0, sizeof(sr));
-   cso_set_stencil_ref(renderer->cso, &sr);
-
-   renderer_set_vs(renderer, RENDERER_VS_PLAIN);
-
-   renderer->state = RENDERER_STATE_INIT;
-
-   return renderer;
-}
-
-void renderer_destroy(struct renderer *ctx)
-{
-   int i;
-
-   for (i = 0; i < NUM_RENDERER_VS; i++) {
-      if (ctx->cached_vs[i])
-         cso_delete_vertex_shader(ctx->cso, ctx->cached_vs[i]);
-   }
-   for (i = 0; i < NUM_RENDERER_FS; i++) {
-      if (ctx->cached_fs[i])
-         cso_delete_fragment_shader(ctx->cso, ctx->cached_fs[i]);
-   }
-
-   pipe_resource_reference(&ctx->vs_cbuf, NULL);
-   pipe_resource_reference(&ctx->fs_cbuf, NULL);
-
-   FREE(ctx);
-}
-
-static void update_clip_state(struct renderer *renderer,
-                              const struct vg_state *state)
-{
-   struct pipe_depth_stencil_alpha_state *dsa = &renderer->g3d.dsa;
-
-   memset(dsa, 0, sizeof(struct pipe_depth_stencil_alpha_state));
-
-   if (state->scissoring) {
-      struct pipe_framebuffer_state *fb = &renderer->g3d.fb;
-      int i;
-
-      renderer_scissor_begin(renderer, VG_FALSE);
-
-      for (i = 0; i < state->scissor_rects_num; ++i) {
-         const float x      = state->scissor_rects[i * 4 + 0].f;
-         const float y      = state->scissor_rects[i * 4 + 1].f;
-         const float width  = state->scissor_rects[i * 4 + 2].f;
-         const float height = state->scissor_rects[i * 4 + 3].f;
-         VGint x0, y0, x1, y1, iw, ih;
-
-         x0 = (VGint) x;
-         y0 = (VGint) y;
-         if (x0 < 0)
-            x0 = 0;
-         if (y0 < 0)
-            y0 = 0;
-
-         /* note that x1 and y1 are exclusive */
-         x1 = (VGint) ceilf(x + width);
-         y1 = (VGint) ceilf(y + height);
-         if (x1 > fb->width)
-            x1 = fb->width;
-         if (y1 > fb->height)
-            y1 = fb->height;
-
-         iw = x1 - x0;
-         ih = y1 - y0;
-         if (iw > 0 && ih> 0 )
-            renderer_scissor(renderer, x0, y0, iw, ih);
-      }
-
-      renderer_scissor_end(renderer);
-
-      dsa->depth.enabled = 1; /* glEnable(GL_DEPTH_TEST); */
-      dsa->depth.writemask = 0;/*glDepthMask(FALSE);*/
-      dsa->depth.func = PIPE_FUNC_GEQUAL;
-   }
-}
-
-static void renderer_validate_blend(struct renderer *renderer,
-                                     const struct vg_state *state,
-                                     enum pipe_format fb_format)
-{
-   struct pipe_blend_state blend;
-
-   memset(&blend, 0, sizeof(blend));
-   blend.rt[0].colormask = PIPE_MASK_RGBA;
-   blend.rt[0].rgb_src_factor   = PIPE_BLENDFACTOR_ONE;
-   blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
-   blend.rt[0].rgb_dst_factor   = PIPE_BLENDFACTOR_ZERO;
-   blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
-
-   /* TODO alpha masking happens after blending? */
-
-   switch (state->blend_mode) {
-   case VG_BLEND_SRC:
-      blend.rt[0].rgb_src_factor   = PIPE_BLENDFACTOR_ONE;
-      blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
-      blend.rt[0].rgb_dst_factor   = PIPE_BLENDFACTOR_ZERO;
-      blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
-      break;
-   case VG_BLEND_SRC_OVER:
-      /* use the blend state only when there is no alpha channel */
-      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;
-         blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_INV_SRC_ALPHA;
-         blend.rt[0].blend_enable = 1;
-      }
-      break;
-   case VG_BLEND_SRC_IN:
-      blend.rt[0].rgb_src_factor   = PIPE_BLENDFACTOR_ONE;
-      blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_DST_ALPHA;
-      blend.rt[0].rgb_dst_factor   = PIPE_BLENDFACTOR_ZERO;
-      blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
-      blend.rt[0].blend_enable = 1;
-      break;
-   case VG_BLEND_DST_IN:
-      blend.rt[0].rgb_src_factor   = PIPE_BLENDFACTOR_ZERO;
-      blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ZERO;
-      blend.rt[0].rgb_dst_factor   = PIPE_BLENDFACTOR_ONE;
-      blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_SRC_ALPHA;
-      blend.rt[0].blend_enable = 1;
-      break;
-   case VG_BLEND_DST_OVER:
-   case VG_BLEND_MULTIPLY:
-   case VG_BLEND_SCREEN:
-   case VG_BLEND_DARKEN:
-   case VG_BLEND_LIGHTEN:
-   case VG_BLEND_ADDITIVE:
-      /* need a shader */
-      break;
-   default:
-      assert(!"not implemented blend mode");
-      break;
-   }
-
-   cso_set_blend(renderer->cso, &blend);
-}
-
-/**
- * Propogate OpenVG state changes to the renderer.  Only framebuffer, blending
- * and scissoring states are relevant here.
- */
-void renderer_validate(struct renderer *renderer,
-                       VGbitfield dirty,
-                       const struct st_framebuffer *stfb,
-                       const struct vg_state *state)
-{
-   assert(renderer->state == RENDERER_STATE_INIT);
-
-   dirty |= renderer->dirty;
-   renderer->dirty = 0;
-
-   if (dirty & FRAMEBUFFER_DIRTY) {
-      struct pipe_framebuffer_state *fb = &renderer->g3d.fb;
-      struct matrix *proj = &renderer->projection;
-
-      memset(fb, 0, sizeof(struct pipe_framebuffer_state));
-      fb->width  = stfb->width;
-      fb->height = stfb->height;
-      fb->nr_cbufs = 1;
-      fb->cbufs[0] = stfb->strb->surface;
-      fb->zsbuf = stfb->dsrb->surface;
-
-      cso_set_framebuffer(renderer->cso, fb);
-      vg_set_viewport(renderer, VEGA_Y0_BOTTOM);
-
-      matrix_load_identity(proj);
-      matrix_translate(proj, -1.0f, -1.0f);
-      matrix_scale(proj, 2.0f / fb->width, 2.0f / fb->height);
-
-      /* we also got a new depth buffer */
-      if (dirty & DEPTH_STENCIL_DIRTY) {
-         renderer->pipe->clear(renderer->pipe,
-               PIPE_CLEAR_DEPTHSTENCIL, NULL, 0.0, 0);
-      }
-   }
-
-   /* must be last because it renders to the depth buffer*/
-   if (dirty & DEPTH_STENCIL_DIRTY) {
-      update_clip_state(renderer, state);
-      cso_set_depth_stencil_alpha(renderer->cso, &renderer->g3d.dsa);
-   }
-
-   if (dirty & BLEND_DIRTY)
-      renderer_validate_blend(renderer, state, stfb->strb->format);
-}
-
-/**
- * Prepare the renderer for OpenVG pipeline.
- */
-void renderer_validate_for_shader(struct renderer *renderer,
-                                  const struct pipe_sampler_state **samplers,
-                                  struct pipe_sampler_view **views,
-                                  VGint num_samplers,
-                                  const struct matrix *modelview,
-                                  void *fs,
-                                  const void *const_buffer,
-                                  VGint const_buffer_len)
-{
-   struct matrix mvp = renderer->projection;
-
-   /* will be used in POLYGON_STENCIL and POLYGON_FILL */
-   matrix_mult(&mvp, modelview);
-   renderer_set_mvp(renderer, &mvp);
-
-   renderer_set_custom_fs(renderer, fs,
-                          samplers, views, num_samplers,
-                          const_buffer, const_buffer_len);
-}
-
-void renderer_validate_for_mask_rendering(struct renderer *renderer,
-                                          struct pipe_surface *dst,
-                                          const struct matrix *modelview)
-{
-   struct matrix mvp = renderer->projection;
-
-   /* will be used in POLYGON_STENCIL and POLYGON_FILL */
-   matrix_mult(&mvp, modelview);
-   renderer_set_mvp(renderer, &mvp);
-
-   renderer_set_target(renderer, dst, renderer->g3d.fb.zsbuf, VG_FALSE);
-   renderer_set_blend(renderer, ~0);
-   renderer_set_fs(renderer, RENDERER_FS_WHITE);
-
-   /* set internal dirty flags (hacky!) */
-   renderer->dirty = FRAMEBUFFER_DIRTY | BLEND_DIRTY;
-}
-
-void renderer_copy_surface(struct renderer *ctx,
-                           struct pipe_surface *src,
-                           int srcX0, int srcY0,
-                           int srcX1, int srcY1,
-                           struct pipe_surface *dst,
-                           int dstX0, int dstY0,
-                           int dstX1, int dstY1,
-                           float z, unsigned filter)
-{
-   struct pipe_context *pipe = ctx->pipe;
-   struct pipe_screen *screen = pipe->screen;
-   struct pipe_sampler_view view_templ;
-   struct pipe_sampler_view *view;
-   struct pipe_box src_box;
-   struct pipe_resource texTemp, *tex;
-   const struct pipe_framebuffer_state *fb = &ctx->g3d.fb;
-   const int srcW = abs(srcX1 - srcX0);
-   const int srcH = abs(srcY1 - srcY0);
-   const int srcLeft = MIN2(srcX0, srcX1);
-   const int srcTop = MIN2(srcY0, srcY1);
-
-   assert(filter == PIPE_TEX_MIPFILTER_NEAREST ||
-          filter == PIPE_TEX_MIPFILTER_LINEAR);
-
-   if (srcLeft != srcX0) {
-      /* left-right flip */
-      int tmp = dstX0;
-      dstX0 = dstX1;
-      dstX1 = tmp;
-   }
-
-   if (srcTop != srcY0) {
-      /* up-down flip */
-      int tmp = dstY0;
-      dstY0 = dstY1;
-      dstY1 = tmp;
-   }
-
-   assert(screen->is_format_supported(screen, src->format, PIPE_TEXTURE_2D,
-                                      0, PIPE_BIND_SAMPLER_VIEW));
-   assert(screen->is_format_supported(screen, dst->format, PIPE_TEXTURE_2D,
-                                      0, PIPE_BIND_SAMPLER_VIEW));
-   assert(screen->is_format_supported(screen, dst->format, PIPE_TEXTURE_2D,
-                                      0, PIPE_BIND_RENDER_TARGET));
-
-   /*
-    * XXX for now we're always creating a temporary texture.
-    * Strictly speaking that's not always needed.
-    */
-
-   /* create temp texture */
-   memset(&texTemp, 0, sizeof(texTemp));
-   texTemp.target = PIPE_TEXTURE_2D;
-   texTemp.format = src->format;
-   texTemp.last_level = 0;
-   texTemp.width0 = srcW;
-   texTemp.height0 = srcH;
-   texTemp.depth0 = 1;
-   texTemp.array_size = 1;
-   texTemp.bind = PIPE_BIND_SAMPLER_VIEW;
-
-   tex = screen->resource_create(screen, &texTemp);
-   if (!tex)
-      return;
-
-   u_sampler_view_default_template(&view_templ, tex, tex->format);
-   view = pipe->create_sampler_view(pipe, tex, &view_templ);
-
-   if (!view)
-      return;
-
-   u_box_2d_zslice(srcLeft, srcTop, src->u.tex.first_layer, srcW, srcH, &src_box);
-
-   pipe->resource_copy_region(pipe,
-                              tex, 0, 0, 0, 0,  /* dest */
-                              src->texture, 0, &src_box);
-
-   assert(floatsEqual(z, 0.0f));
-
-   /* draw */
-   if (fb->cbufs[0] == dst) {
-      /* transform back to surface coordinates */
-      dstY0 = dst->height - dstY0;
-      dstY1 = dst->height - dstY1;
-
-      if (renderer_drawtex_begin(ctx, view)) {
-         renderer_drawtex(ctx,
-               dstX0, dstY0, dstX1 - dstX0, dstY1 - dstY0,
-               0, 0, view->texture->width0, view->texture->height0);
-         renderer_drawtex_end(ctx);
-      }
-   }
-   else {
-      if (renderer_copy_begin(ctx, dst, VG_TRUE, view)) {
-         renderer_copy(ctx,
-               dstX0, dstY0, dstX1 - dstX0, dstY1 - dstY0,
-               0, 0, view->texture->width0, view->texture->height0);
-         renderer_copy_end(ctx);
-      }
-   }
-}
-
-void renderer_texture_quad(struct renderer *r,
-                           struct pipe_resource *tex,
-                           VGfloat x1offset, VGfloat y1offset,
-                           VGfloat x2offset, VGfloat y2offset,
-                           VGfloat x1, VGfloat y1,
-                           VGfloat x2, VGfloat y2,
-                           VGfloat x3, VGfloat y3,
-                           VGfloat x4, VGfloat y4)
-{
-   const VGfloat z = 0.0f;
-
-   assert(r->state == RENDERER_STATE_INIT);
-   assert(tex->width0 != 0);
-   assert(tex->height0 != 0);
-
-   cso_save_vertex_shader(r->cso);
-
-   renderer_set_vs(r, RENDERER_VS_TEXTURE);
-
-   /* manually set up positions */
-   r->vertices[0][0][0] = x1;
-   r->vertices[0][0][1] = y1;
-   r->vertices[0][0][2] = z;
-
-   r->vertices[1][0][0] = x2;
-   r->vertices[1][0][1] = y2;
-   r->vertices[1][0][2] = z;
-
-   r->vertices[2][0][0] = x3;
-   r->vertices[2][0][1] = y3;
-   r->vertices[2][0][2] = z;
-
-   r->vertices[3][0][0] = x4;
-   r->vertices[3][0][1] = y4;
-   r->vertices[3][0][2] = z;
-
-   /* texcoords */
-   renderer_quad_texcoord(r, x1offset, y1offset,
-         x2offset, y2offset, tex->width0, tex->height0);
-
-   renderer_quad_draw(r);
-
-   cso_restore_vertex_shader(r->cso);
-}
diff --git a/src/gallium/state_trackers/vega/renderer.h b/src/gallium/state_trackers/vega/renderer.h
deleted file mode 100644
index fe719936580..00000000000
--- a/src/gallium/state_trackers/vega/renderer.h
+++ /dev/null
@@ -1,159 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc.  All Rights Reserved.
- * Copyright 2010 LunarG, 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.
- *
- **************************************************************************/
-
-#ifndef RENDERER_H
-#define RENDERER_H
-
-#include "VG/openvg.h"
-
-struct renderer;
-
-struct vg_context;
-struct vg_state;
-struct st_framebuffer;
-struct pipe_resource;
-struct pipe_sampler_state;
-struct pipe_sampler_view;
-struct pipe_surface;
-struct pipe_vertex_element;
-struct pipe_vertex_buffer;
-struct matrix;
-
-struct renderer *renderer_create(struct vg_context *owner);
-void renderer_destroy(struct renderer *);
-
-void renderer_validate(struct renderer *renderer,
-                       VGbitfield dirty,
-                       const struct st_framebuffer *stfb,
-                       const struct vg_state *state);
-
-void renderer_validate_for_shader(struct renderer *renderer,
-                                  const struct pipe_sampler_state **samplers,
-                                  struct pipe_sampler_view **views,
-                                  VGint num_samplers,
-                                  const struct matrix *modelview,
-                                  void *fs,
-                                  const void *const_buffer,
-                                  VGint const_buffer_len);
-
-void renderer_validate_for_mask_rendering(struct renderer *renderer,
-                                          struct pipe_surface *dst,
-                                          const struct matrix *modelview);
-
-VGboolean renderer_copy_begin(struct renderer *renderer,
-                              struct pipe_surface *dst,
-                              VGboolean y0_top,
-                              struct pipe_sampler_view *src);
-
-void renderer_copy(struct renderer *renderer,
-                   VGint x, VGint y, VGint w, VGint h,
-                   VGint sx, VGint sy, VGint sw, VGint sh);
-
-void renderer_copy_end(struct renderer *renderer);
-
-VGboolean renderer_drawtex_begin(struct renderer *renderer,
-                                 struct pipe_sampler_view *src);
-
-void renderer_drawtex(struct renderer *renderer,
-                      VGint x, VGint y, VGint w, VGint h,
-                      VGint sx, VGint sy, VGint sw, VGint sh);
-
-void renderer_drawtex_end(struct renderer *renderer);
-
-VGboolean renderer_scissor_begin(struct renderer *renderer,
-                                 VGboolean restore_dsa);
-
-void renderer_scissor(struct renderer *renderer,
-                      VGint x, VGint y, VGint width, VGint height);
-
-void renderer_scissor_end(struct renderer *renderer);
-
-VGboolean renderer_clear_begin(struct renderer *renderer);
-
-void renderer_clear(struct renderer *renderer,
-                    VGint x, VGint y, VGint width, VGint height,
-                    const VGfloat color[4]);
-
-void renderer_clear_end(struct renderer *renderer);
-
-VGboolean renderer_filter_begin(struct renderer *renderer,
-                                struct pipe_resource *dst,
-                                VGboolean y0_top,
-                                VGbitfield channel_mask,
-                                const struct pipe_sampler_state **samplers,
-                                struct pipe_sampler_view **views,
-                                VGint num_samplers,
-                                void *fs,
-                                const void *const_buffer,
-                                VGint const_buffer_len);
-
-void renderer_filter(struct renderer *renderer,
-                     VGint x, VGint y, VGint w, VGint h,
-                     VGint sx, VGint sy, VGint sw, VGint sh);
-
-void renderer_filter_end(struct renderer *renderer);
-
-VGboolean renderer_polygon_stencil_begin(struct renderer *renderer,
-                                         struct pipe_vertex_element *velem,
-                                         VGFillRule rule,
-                                         VGboolean restore_dsa);
-
-void renderer_polygon_stencil(struct renderer *renderer,
-                              struct pipe_vertex_buffer *vbuf,
-                              VGuint mode, VGuint start, VGuint count);
-
-void renderer_polygon_stencil_end(struct renderer *renderer);
-
-VGboolean renderer_polygon_fill_begin(struct renderer *renderer,
-                                      VGboolean save_dsa);
-
-void renderer_polygon_fill(struct renderer *renderer,
-                           VGfloat min_x, VGfloat min_y,
-                           VGfloat max_x, VGfloat max_y);
-
-void renderer_polygon_fill_end(struct renderer *renderer);
-
-void renderer_texture_quad(struct renderer *,
-                           struct pipe_resource *texture,
-                           VGfloat x1offset, VGfloat y1offset,
-                           VGfloat x2offset, VGfloat y2offset,
-                           VGfloat x1, VGfloat y1,
-                           VGfloat x2, VGfloat y2,
-                           VGfloat x3, VGfloat y3,
-                           VGfloat x4, VGfloat y4);
-
-void renderer_copy_surface(struct renderer *r,
-                           struct pipe_surface *src,
-                           int sx1, int sy1,
-                           int sx2, int sy2,
-                           struct pipe_surface *dst,
-                           int dx1, int dy1,
-                           int dx2, int dy2,
-                           float z, unsigned filter);
-
-
-#endif
diff --git a/src/gallium/state_trackers/vega/shader.c b/src/gallium/state_trackers/vega/shader.c
deleted file mode 100644
index 09ba4049cb6..00000000000
--- a/src/gallium/state_trackers/vega/shader.c
+++ /dev/null
@@ -1,414 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "shader.h"
-
-#include "vg_context.h"
-#include "shaders_cache.h"
-#include "paint.h"
-#include "mask.h"
-#include "image.h"
-#include "renderer.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_state.h"
-#include "util/u_memory.h"
-#include "util/u_math.h"
-#include "util/u_format.h"
-
-#define MAX_CONSTANTS 28
-
-struct shader {
-   struct vg_context *context;
-
-   VGboolean color_transform;
-   VGboolean masking;
-   struct vg_paint *paint;
-   struct vg_image *image;
-
-   struct matrix modelview;
-   struct matrix paint_matrix;
-
-   VGboolean drawing_image;
-   VGImageMode image_mode;
-
-   float constants[MAX_CONSTANTS];
-   struct pipe_resource *cbuf;
-   struct pipe_shader_state fs_state;
-   void *fs;
-};
-
-struct shader * shader_create(struct vg_context *ctx)
-{
-   struct shader *shader = 0;
-
-   shader = CALLOC_STRUCT(shader);
-   shader->context = ctx;
-
-   return shader;
-}
-
-void shader_destroy(struct shader *shader)
-{
-   FREE(shader);
-}
-
-void shader_set_color_transform(struct shader *shader, VGboolean set)
-{
-   shader->color_transform = set;
-}
-
-void shader_set_masking(struct shader *shader, VGboolean set)
-{
-   shader->masking = set;
-}
-
-VGboolean shader_is_masking(struct shader *shader)
-{
-   return shader->masking;
-}
-
-void shader_set_paint(struct shader *shader, struct vg_paint *paint)
-{
-   shader->paint = paint;
-}
-
-struct vg_paint * shader_paint(struct shader *shader)
-{
-   return shader->paint;
-}
-
-static VGint setup_constant_buffer(struct shader *shader)
-{
-   const struct vg_state *state = &shader->context->state.vg;
-   VGint param_bytes = paint_constant_buffer_size(shader->paint);
-   VGint i;
-
-   param_bytes += sizeof(VGfloat) * 8;
-   assert(param_bytes <= sizeof(shader->constants));
-
-   if (state->color_transform) {
-      for (i = 0; i < 8; i++) {
-         VGfloat val = (i < 4) ? 127.0f : 1.0f;
-         shader->constants[i] =
-            CLAMP(state->color_transform_values[i], -val, val);
-      }
-   }
-   else {
-      memset(shader->constants, 0, sizeof(VGfloat) * 8);
-   }
-
-   paint_fill_constant_buffer(shader->paint,
-         &shader->paint_matrix, shader->constants + 8);
-
-   return param_bytes;
-}
-
-static VGboolean blend_use_shader(struct shader *shader)
-{
-   struct vg_context *ctx = shader->context;
-   VGboolean advanced_blending;
-
-   switch (ctx->state.vg.blend_mode) {
-   case VG_BLEND_DST_OVER:
-   case VG_BLEND_MULTIPLY:
-   case VG_BLEND_SCREEN:
-   case VG_BLEND_DARKEN:
-   case VG_BLEND_LIGHTEN:
-   case VG_BLEND_ADDITIVE:
-      advanced_blending = VG_TRUE;
-      break;
-   case VG_BLEND_SRC_OVER:
-      if (util_format_has_alpha(ctx->draw_buffer->strb->format)) {
-         /* no blending is required if the paints and the image are opaque */
-         advanced_blending = !paint_is_opaque(ctx->state.vg.fill_paint) ||
-                             !paint_is_opaque(ctx->state.vg.stroke_paint);
-         if (!advanced_blending && shader->drawing_image) {
-            advanced_blending =
-               util_format_has_alpha(shader->image->sampler_view->format);
-         }
-         break;
-      }
-      /* fall through */
-   default:
-      advanced_blending = VG_FALSE;
-      break;
-   }
-
-   return advanced_blending;
-}
-
-static VGint blend_bind_samplers(struct shader *shader,
-                                 struct pipe_sampler_state **samplers,
-                                 struct pipe_sampler_view **sampler_views)
-{
-   if (blend_use_shader(shader)) {
-      struct vg_context *ctx = shader->context;
-
-      samplers[2] = &ctx->blend_sampler;
-      sampler_views[2] = vg_prepare_blend_surface(ctx);
-
-      if (!samplers[0] || !sampler_views[0]) {
-         samplers[0] = samplers[2];
-         sampler_views[0] = sampler_views[2];
-      }
-      if (!samplers[1] || !sampler_views[1]) {
-         samplers[1] = samplers[0];
-         sampler_views[1] = sampler_views[0];
-      }
-
-      return 1;
-   }
-   return 0;
-}
-
-static VGint setup_samplers(struct shader *shader,
-                            struct pipe_sampler_state **samplers,
-                            struct pipe_sampler_view **sampler_views)
-{
-   /* a little wonky: we use the num as a boolean that just says
-    * whether any sampler/textures have been set. the actual numbering
-    * for samplers is always the same:
-    * 0 - paint sampler/texture for gradient/pattern
-    * 1 - mask sampler/texture
-    * 2 - blend sampler/texture
-    * 3 - image sampler/texture
-    * */
-   VGint num = 0;
-
-   samplers[0] = NULL;
-   samplers[1] = NULL;
-   samplers[2] = NULL;
-   samplers[3] = NULL;
-   sampler_views[0] = NULL;
-   sampler_views[1] = NULL;
-   sampler_views[2] = NULL;
-   sampler_views[3] = NULL;
-
-   num += paint_bind_samplers(shader->paint, samplers, sampler_views);
-   num += mask_bind_samplers(samplers, sampler_views);
-   num += blend_bind_samplers(shader, samplers, sampler_views);
-   if (shader->drawing_image && shader->image)
-      num += image_bind_samplers(shader->image, samplers, sampler_views);
-
-   return (num) ? 4 : 0;
-}
-
-static INLINE VGboolean is_format_bw(struct shader *shader)
-{
-#if 0
-   struct vg_context *ctx = shader->context;
-   struct st_framebuffer *stfb = ctx->draw_buffer;
-#endif
-
-   if (shader->drawing_image && shader->image) {
-      if (shader->image->format == VG_BW_1)
-         return VG_TRUE;
-   }
-
-   return VG_FALSE;
-}
-
-static void setup_shader_program(struct shader *shader)
-{
-   struct vg_context *ctx = shader->context;
-   VGint shader_id = 0;
-   VGBlendMode blend_mode = ctx->state.vg.blend_mode;
-   VGboolean black_white = is_format_bw(shader);
-
-   /* 1st stage: fill */
-   if (!shader->drawing_image ||
-       (shader->image_mode == VG_DRAW_IMAGE_MULTIPLY || shader->image_mode == VG_DRAW_IMAGE_STENCIL)) {
-      switch(paint_type(shader->paint)) {
-      case VG_PAINT_TYPE_COLOR:
-         shader_id |= VEGA_SOLID_FILL_SHADER;
-         break;
-      case VG_PAINT_TYPE_LINEAR_GRADIENT:
-         shader_id |= VEGA_LINEAR_GRADIENT_SHADER;
-         break;
-      case VG_PAINT_TYPE_RADIAL_GRADIENT:
-         shader_id |= VEGA_RADIAL_GRADIENT_SHADER;
-         break;
-      case VG_PAINT_TYPE_PATTERN:
-         shader_id |= VEGA_PATTERN_SHADER;
-         break;
-
-      default:
-         abort();
-      }
-
-      if (paint_is_degenerate(shader->paint))
-         shader_id = VEGA_PAINT_DEGENERATE_SHADER;
-   }
-
-   /* second stage image */
-   if (shader->drawing_image) {
-      switch(shader->image_mode) {
-      case VG_DRAW_IMAGE_NORMAL:
-         shader_id |= VEGA_IMAGE_NORMAL_SHADER;
-         break;
-      case VG_DRAW_IMAGE_MULTIPLY:
-         shader_id |= VEGA_IMAGE_MULTIPLY_SHADER;
-         break;
-      case VG_DRAW_IMAGE_STENCIL:
-         shader_id |= VEGA_IMAGE_STENCIL_SHADER;
-         break;
-      default:
-         debug_printf("Unknown image mode!");
-      }
-   }
-
-   if (shader->color_transform)
-      shader_id |= VEGA_COLOR_TRANSFORM_SHADER;
-
-   if (blend_use_shader(shader)) {
-      if (shader->drawing_image && shader->image_mode == VG_DRAW_IMAGE_STENCIL)
-         shader_id |= VEGA_ALPHA_PER_CHANNEL_SHADER;
-      else
-         shader_id |= VEGA_ALPHA_NORMAL_SHADER;
-
-      switch(blend_mode) {
-      case VG_BLEND_SRC:
-         shader_id |= VEGA_BLEND_SRC_SHADER;
-         break;
-      case VG_BLEND_SRC_OVER:
-         shader_id |= VEGA_BLEND_SRC_OVER_SHADER;
-         break;
-      case VG_BLEND_DST_OVER:
-         shader_id |= VEGA_BLEND_DST_OVER_SHADER;
-         break;
-      case VG_BLEND_SRC_IN:
-         shader_id |= VEGA_BLEND_SRC_IN_SHADER;
-         break;
-      case VG_BLEND_DST_IN:
-         shader_id |= VEGA_BLEND_DST_IN_SHADER;
-         break;
-      case VG_BLEND_MULTIPLY:
-         shader_id |= VEGA_BLEND_MULTIPLY_SHADER;
-         break;
-      case VG_BLEND_SCREEN:
-         shader_id |= VEGA_BLEND_SCREEN_SHADER;
-         break;
-      case VG_BLEND_DARKEN:
-         shader_id |= VEGA_BLEND_DARKEN_SHADER;
-         break;
-      case VG_BLEND_LIGHTEN:
-         shader_id |= VEGA_BLEND_LIGHTEN_SHADER;
-         break;
-      case VG_BLEND_ADDITIVE:
-         shader_id |= VEGA_BLEND_ADDITIVE_SHADER;
-         break;
-      default:
-         assert(0);
-         break;
-      }
-   }
-   else {
-      /* update alpha of the source */
-      if (shader->drawing_image && shader->image_mode == VG_DRAW_IMAGE_STENCIL)
-         shader_id |= VEGA_ALPHA_PER_CHANNEL_SHADER;
-   }
-
-   if (shader->masking)
-      shader_id |= VEGA_MASK_SHADER;
-
-   if (black_white)
-      shader_id |= VEGA_BW_SHADER;
-
-   shader->fs = shaders_cache_fill(ctx->sc, shader_id);
-}
-
-
-void shader_bind(struct shader *shader)
-{
-   struct vg_context *ctx = shader->context;
-   struct pipe_sampler_state *samplers[PIPE_MAX_SAMPLERS];
-   struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS];
-   VGint num_samplers, param_bytes;
-
-   /* first resolve the real paint type */
-   paint_resolve_type(shader->paint);
-
-   num_samplers = setup_samplers(shader, samplers, sampler_views);
-   param_bytes = setup_constant_buffer(shader);
-   setup_shader_program(shader);
-
-   renderer_validate_for_shader(ctx->renderer,
-         (const struct pipe_sampler_state **) samplers,
-         sampler_views, num_samplers,
-         &shader->modelview,
-         shader->fs, (const void *) shader->constants, param_bytes);
-}
-
-void shader_set_image_mode(struct shader *shader, VGImageMode image_mode)
-{
-   shader->image_mode = image_mode;
-}
-
-VGImageMode shader_image_mode(struct shader *shader)
-{
-   return shader->image_mode;
-}
-
-void shader_set_drawing_image(struct shader *shader, VGboolean drawing_image)
-{
-   shader->drawing_image = drawing_image;
-}
-
-VGboolean shader_drawing_image(struct shader *shader)
-{
-   return shader->drawing_image;
-}
-
-void shader_set_image(struct shader *shader, struct vg_image *img)
-{
-   shader->image = img;
-}
-
-/**
- * Set the transformation to map a vertex to the surface coordinates.
- */
-void shader_set_surface_matrix(struct shader *shader,
-                               const struct matrix *mat)
-{
-   shader->modelview = *mat;
-}
-
-/**
- * Set the transformation to map a pixel to the paint coordinates.
- */
-void shader_set_paint_matrix(struct shader *shader, const struct matrix *mat)
-{
-   const struct st_framebuffer *stfb = shader->context->draw_buffer;
-   const VGfloat px_center_offset = 0.5f;
-
-   memcpy(&shader->paint_matrix, mat, sizeof(*mat));
-
-   /* make it window-to-paint for the shaders */
-   matrix_translate(&shader->paint_matrix, px_center_offset,
-         stfb->height - 1.0f + px_center_offset);
-   matrix_scale(&shader->paint_matrix, 1.0f, -1.0f);
-}
diff --git a/src/gallium/state_trackers/vega/shader.h b/src/gallium/state_trackers/vega/shader.h
deleted file mode 100644
index 8b97e537efe..00000000000
--- a/src/gallium/state_trackers/vega/shader.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef SHADER_H
-#define SHADER_H
-
-#include "VG/openvg.h"
-
-struct shader;
-struct vg_paint;
-struct vg_context;
-struct vg_image;
-struct matrix;
-
-struct shader *shader_create(struct vg_context *context);
-void shader_destroy(struct shader *shader);
-
-void shader_set_color_transform(struct shader *shader, VGboolean set);
-
-void shader_set_masking(struct shader *shader, VGboolean set);
-VGboolean shader_is_masking(struct shader *shader);
-
-void shader_set_paint(struct shader *shader, struct vg_paint *paint);
-struct vg_paint *shader_paint(struct shader *shader);
-
-void shader_set_image_mode(struct shader *shader, VGImageMode image_mode);
-VGImageMode shader_image_mode(struct shader *shader);
-
-void shader_set_drawing_image(struct shader *shader, VGboolean drawing_image);
-VGboolean shader_drawing_image(struct shader *shader);
-
-void shader_set_image(struct shader *shader, struct vg_image *img);
-
-void shader_set_surface_matrix(struct shader *shader,
-                               const struct matrix *mat);
-void shader_set_paint_matrix(struct shader *shader, const struct matrix *mat);
-
-void shader_bind(struct shader *shader);
-
-#endif
diff --git a/src/gallium/state_trackers/vega/shaders_cache.c b/src/gallium/state_trackers/vega/shaders_cache.c
deleted file mode 100644
index c1082ca3673..00000000000
--- a/src/gallium/state_trackers/vega/shaders_cache.c
+++ /dev/null
@@ -1,462 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "shaders_cache.h"
-
-#include "vg_context.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_shader_tokens.h"
-
-#include "tgsi/tgsi_build.h"
-#include "tgsi/tgsi_dump.h"
-#include "tgsi/tgsi_parse.h"
-#include "tgsi/tgsi_util.h"
-#include "tgsi/tgsi_text.h"
-
-#include "util/u_memory.h"
-#include "util/u_math.h"
-#include "util/u_debug.h"
-#include "cso_cache/cso_hash.h"
-#include "cso_cache/cso_context.h"
-
-#include "VG/openvg.h"
-
-#include "asm_fill.h"
-
-/* Essentially we construct an ubber-shader based on the state
- * of the pipeline. The stages are:
- * 1) Paint generation (color/gradient/pattern)
- * 2) Image composition (normal/multiply/stencil)
- * 3) Color transform
- * 4) Per-channel alpha generation
- * 5) Extended blend (multiply/screen/darken/lighten)
- * 6) Mask
- * 7) Premultiply/Unpremultiply
- * 8) Color transform (to black and white)
- */
-#define SHADER_STAGES 8
-
-struct cached_shader {
-   void *driver_shader;
-   struct pipe_shader_state state;
-};
-
-struct shaders_cache {
-   struct vg_context *pipe;
-
-   struct cso_hash *hash;
-};
-
-
-static INLINE struct tgsi_token *tokens_from_assembly(const char *txt, int num_tokens)
-{
-   struct tgsi_token *tokens;
-
-   tokens = (struct tgsi_token *) MALLOC(num_tokens * sizeof(tokens[0]));
-
-   tgsi_text_translate(txt, tokens, num_tokens);
-
-#if DEBUG_SHADERS
-   tgsi_dump(tokens, 0);
-#endif
-
-   return tokens;
-}
-
-/*
-static const char max_shader_preamble[] =
-   "FRAG\n"
-   "DCL IN[0], POSITION, LINEAR\n"
-   "DCL IN[1], GENERIC[0], PERSPECTIVE\n"
-   "DCL OUT[0], COLOR, CONSTANT\n"
-   "DCL CONST[0..9], CONSTANT\n"
-   "DCL TEMP[0..9], CONSTANT\n"
-   "DCL SAMP[0..9], CONSTANT\n";
-
-   max_shader_preamble strlen == 175
-*/
-#define MAX_PREAMBLE 175
-
-static INLINE VGint range_min(VGint min, VGint current)
-{
-   if (min < 0)
-      min = current;
-   else
-      min = MIN2(min, current);
-   return min;
-}
-
-static INLINE VGint range_max(VGint max, VGint current)
-{
-   return MAX2(max, current);
-}
-
-static void *
-combine_shaders(const struct shader_asm_info *shaders[SHADER_STAGES], int num_shaders,
-                struct pipe_context *pipe,
-                struct pipe_shader_state *shader)
-{
-   VGboolean declare_input = VG_FALSE;
-   VGint start_const   = -1, end_const   = 0;
-   VGint start_temp    = -1, end_temp    = 0;
-   VGint start_sampler = -1, end_sampler = 0;
-   VGint i, current_shader = 0;
-   VGint num_consts, num_temps, num_samplers;
-   struct ureg_program *ureg;
-   struct ureg_src in[2];
-   struct ureg_src *sampler = NULL;
-   struct ureg_src *constant = NULL;
-   struct ureg_dst out, *temp = NULL;
-   void *p = NULL;
-
-   for (i = 0; i < num_shaders; ++i) {
-      if (shaders[i]->num_consts)
-         start_const = range_min(start_const, shaders[i]->start_const);
-      if (shaders[i]->num_temps)
-         start_temp = range_min(start_temp, shaders[i]->start_temp);
-      if (shaders[i]->num_samplers)
-         start_sampler = range_min(start_sampler, shaders[i]->start_sampler);
-
-      end_const = range_max(end_const, shaders[i]->start_const +
-                            shaders[i]->num_consts);
-      end_temp = range_max(end_temp, shaders[i]->start_temp +
-                            shaders[i]->num_temps);
-      end_sampler = range_max(end_sampler, shaders[i]->start_sampler +
-                            shaders[i]->num_samplers);
-      if (shaders[i]->needs_position)
-         declare_input = VG_TRUE;
-   }
-   /* if they're still unitialized, initialize them */
-   if (start_const < 0)
-      start_const = 0;
-   if (start_temp < 0)
-      start_temp = 0;
-   if (start_sampler < 0)
-       start_sampler = 0;
-
-   num_consts   = end_const   - start_const;
-   num_temps    = end_temp    - start_temp;
-   num_samplers = end_sampler - start_sampler;
-
-   ureg = ureg_create(TGSI_PROCESSOR_FRAGMENT);
-   if (!ureg)
-       return NULL;
-
-   if (declare_input) {
-      in[0] = ureg_DECL_fs_input(ureg,
-                                 TGSI_SEMANTIC_POSITION,
-                                 0,
-                                 TGSI_INTERPOLATE_LINEAR);
-      in[1] = ureg_DECL_fs_input(ureg,
-                                 TGSI_SEMANTIC_GENERIC,
-                                 0,
-                                 TGSI_INTERPOLATE_PERSPECTIVE);
-   }
-
-   /* we always have a color output */
-   out = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);
-
-   if (num_consts >= 1) {
-      constant = malloc(sizeof(struct ureg_src) * end_const);
-      for (i = start_const; i < end_const; i++) {
-         constant[i] = ureg_DECL_constant(ureg, i);
-      }
-
-   }
-
-   if (num_temps >= 1) {
-      temp = malloc(sizeof(struct ureg_dst) * end_temp);
-      for (i = start_temp; i < end_temp; i++) {
-         temp[i] = ureg_DECL_temporary(ureg);
-      }
-   }
-
-   if (num_samplers >= 1) {
-      sampler = malloc(sizeof(struct ureg_src) * end_sampler);
-      for (i = start_sampler; i < end_sampler; i++) {
-         sampler[i] = ureg_DECL_sampler(ureg, i);
-      }
-   }
-
-   while (current_shader < num_shaders) {
-      if ((current_shader + 1) == num_shaders) {
-         shaders[current_shader]->func(ureg,
-                                       &out,
-                                       in,
-                                       sampler,
-                                       temp,
-                                       constant);
-      } else {
-         shaders[current_shader]->func(ureg,
-                                      &temp[0],
-                                      in,
-                                      sampler,
-                                      temp,
-                                      constant);
-      }
-      current_shader++;
-   }
-
-   ureg_END(ureg);
-
-   shader->tokens = ureg_finalize(ureg);
-   if (!shader->tokens) {
-      ureg_destroy(ureg);
-      return NULL;
-   }
-
-   p = pipe->create_fs_state(pipe, shader);
-
-   if (num_temps >= 1) {
-      for (i = start_temp; i < end_temp; i++) {
-         ureg_release_temporary(ureg, temp[i]);
-      }
-   }
-
-   ureg_destroy(ureg);
-
-   free(temp);
-   free(constant);
-   free(sampler);
-
-   return p;
-}
-
-static void *
-create_shader(struct pipe_context *pipe,
-              int id,
-              struct pipe_shader_state *shader)
-{
-   int idx = 0, sh;
-   const struct shader_asm_info * shaders[SHADER_STAGES];
-
-   /* first stage */
-   sh = SHADERS_GET_PAINT_SHADER(id);
-   switch (sh << SHADERS_PAINT_SHIFT) {
-   case VEGA_SOLID_FILL_SHADER:
-   case VEGA_LINEAR_GRADIENT_SHADER:
-   case VEGA_RADIAL_GRADIENT_SHADER:
-   case VEGA_PATTERN_SHADER:
-   case VEGA_PAINT_DEGENERATE_SHADER:
-      shaders[idx] = &shaders_paint_asm[(sh >> SHADERS_PAINT_SHIFT) - 1];
-      assert(shaders[idx]->id == sh);
-      idx++;
-      break;
-   default:
-      break;
-   }
-
-   /* second stage */
-   sh = SHADERS_GET_IMAGE_SHADER(id);
-   switch (sh) {
-   case VEGA_IMAGE_NORMAL_SHADER:
-   case VEGA_IMAGE_MULTIPLY_SHADER:
-   case VEGA_IMAGE_STENCIL_SHADER:
-      shaders[idx] = &shaders_image_asm[(sh >> SHADERS_IMAGE_SHIFT) - 1];
-      assert(shaders[idx]->id == sh);
-      idx++;
-      break;
-   default:
-      break;
-   }
-
-   /* sanity check */
-   assert(idx == ((!sh || sh == VEGA_IMAGE_NORMAL_SHADER) ? 1 : 2));
-
-   /* third stage */
-   sh = SHADERS_GET_COLOR_TRANSFORM_SHADER(id);
-   switch (sh) {
-   case VEGA_COLOR_TRANSFORM_SHADER:
-      shaders[idx] = &shaders_color_transform_asm[
-         (sh >> SHADERS_COLOR_TRANSFORM_SHIFT) - 1];
-      assert(shaders[idx]->id == sh);
-      idx++;
-      break;
-   default:
-      break;
-   }
-
-   /* fourth stage */
-   sh = SHADERS_GET_ALPHA_SHADER(id);
-   switch (sh) {
-   case VEGA_ALPHA_NORMAL_SHADER:
-   case VEGA_ALPHA_PER_CHANNEL_SHADER:
-      shaders[idx] = &shaders_alpha_asm[
-         (sh >> SHADERS_ALPHA_SHIFT) - 1];
-      assert(shaders[idx]->id == sh);
-      idx++;
-      break;
-   default:
-      break;
-   }
-
-   /* fifth stage */
-   sh = SHADERS_GET_BLEND_SHADER(id);
-   switch (sh) {
-   case VEGA_BLEND_SRC_SHADER:
-   case VEGA_BLEND_SRC_OVER_SHADER:
-   case VEGA_BLEND_DST_OVER_SHADER:
-   case VEGA_BLEND_SRC_IN_SHADER:
-   case VEGA_BLEND_DST_IN_SHADER:
-   case VEGA_BLEND_MULTIPLY_SHADER:
-   case VEGA_BLEND_SCREEN_SHADER:
-   case VEGA_BLEND_DARKEN_SHADER:
-   case VEGA_BLEND_LIGHTEN_SHADER:
-   case VEGA_BLEND_ADDITIVE_SHADER:
-      shaders[idx] = &shaders_blend_asm[(sh >> SHADERS_BLEND_SHIFT) - 1];
-      assert(shaders[idx]->id == sh);
-      idx++;
-      break;
-   default:
-      break;
-   }
-
-   /* sixth stage */
-   sh = SHADERS_GET_MASK_SHADER(id);
-   switch (sh) {
-   case VEGA_MASK_SHADER:
-      shaders[idx] = &shaders_mask_asm[(sh >> SHADERS_MASK_SHIFT) - 1];
-      assert(shaders[idx]->id == sh);
-      idx++;
-      break;
-   default:
-      break;
-   }
-
-   /* seventh stage */
-   sh = SHADERS_GET_PREMULTIPLY_SHADER(id);
-   switch (sh) {
-   case VEGA_PREMULTIPLY_SHADER:
-   case VEGA_UNPREMULTIPLY_SHADER:
-      shaders[idx] = &shaders_premultiply_asm[
-         (sh >> SHADERS_PREMULTIPLY_SHIFT) - 1];
-      assert(shaders[idx]->id == sh);
-      idx++;
-      break;
-   default:
-      break;
-   }
-
-   /* eighth stage */
-   sh = SHADERS_GET_BW_SHADER(id);
-   switch (sh) {
-   case VEGA_BW_SHADER:
-      shaders[idx] = &shaders_bw_asm[(sh >> SHADERS_BW_SHIFT) - 1];
-      assert(shaders[idx]->id == sh);
-      idx++;
-      break;
-   default:
-      break;
-   }
-
-   return combine_shaders(shaders, idx, pipe, shader);
-}
-
-/*************************************************/
-
-struct shaders_cache * shaders_cache_create(struct vg_context *vg)
-{
-   struct shaders_cache *sc = CALLOC_STRUCT(shaders_cache);
-
-   sc->pipe = vg;
-   sc->hash = cso_hash_create();
-
-   return sc;
-}
-
-void shaders_cache_destroy(struct shaders_cache *sc)
-{
-   struct cso_hash_iter iter = cso_hash_first_node(sc->hash);
-
-   while (!cso_hash_iter_is_null(iter)) {
-      struct cached_shader *cached =
-         (struct cached_shader *)cso_hash_iter_data(iter);
-      cso_delete_fragment_shader(sc->pipe->cso_context,
-                                 cached->driver_shader);
-      iter = cso_hash_erase(sc->hash, iter);
-   }
-
-   cso_hash_delete(sc->hash);
-   FREE(sc);
-}
-
-void * shaders_cache_fill(struct shaders_cache *sc,
-                          int shader_key)
-{
-   VGint key = shader_key;
-   struct cached_shader *cached;
-   struct cso_hash_iter iter = cso_hash_find(sc->hash, key);
-
-   if (cso_hash_iter_is_null(iter)) {
-      cached = CALLOC_STRUCT(cached_shader);
-      cached->driver_shader = create_shader(sc->pipe->pipe, key, &cached->state);
-
-      cso_hash_insert(sc->hash, key, cached);
-
-      return cached->driver_shader;
-   }
-
-   cached = (struct cached_shader *)cso_hash_iter_data(iter);
-
-   assert(cached->driver_shader);
-   return cached->driver_shader;
-}
-
-struct vg_shader * shader_create_from_text(struct pipe_context *pipe,
-                                           const char *txt, int num_tokens,
-                                           int type)
-{
-   struct vg_shader *shader = (struct vg_shader *)MALLOC(
-      sizeof(struct vg_shader));
-   struct tgsi_token *tokens = tokens_from_assembly(txt, num_tokens);
-   struct pipe_shader_state state;
-
-   debug_assert(type == PIPE_SHADER_VERTEX ||
-                type == PIPE_SHADER_FRAGMENT);
-
-   state.tokens = tokens;
-   memset(&state.stream_output, 0, sizeof(state.stream_output));
-   shader->type = type;
-   shader->tokens = tokens;
-
-   if (type == PIPE_SHADER_FRAGMENT)
-      shader->driver = pipe->create_fs_state(pipe, &state);
-   else
-      shader->driver = pipe->create_vs_state(pipe, &state);
-   return shader;
-}
-
-void vg_shader_destroy(struct vg_context *ctx, struct vg_shader *shader)
-{
-   if (shader->type == PIPE_SHADER_FRAGMENT)
-      cso_delete_fragment_shader(ctx->cso_context, shader->driver);
-   else
-      cso_delete_vertex_shader(ctx->cso_context, shader->driver);
-   FREE(shader->tokens);
-   FREE(shader);
-}
diff --git a/src/gallium/state_trackers/vega/shaders_cache.h b/src/gallium/state_trackers/vega/shaders_cache.h
deleted file mode 100644
index 05014f25dcc..00000000000
--- a/src/gallium/state_trackers/vega/shaders_cache.h
+++ /dev/null
@@ -1,120 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef SHADERS_CACHE_H
-#define SHADERS_CACHE_H
-
-
-struct vg_context;
-struct pipe_context;
-struct tgsi_token;
-struct shaders_cache;
-
-#define _SHADERS_PAINT_BITS            3
-#define _SHADERS_IMAGE_BITS            2
-#define _SHADERS_COLOR_TRANSFORM_BITS  1
-#define _SHADERS_ALPHA_BITS            2
-#define _SHADERS_BLEND_BITS            4
-#define _SHADERS_MASK_BITS             1
-#define _SHADERS_PREMULTIPLY_BITS      2
-#define _SHADERS_BW_BITS               1
-
-#define SHADERS_PAINT_SHIFT           (0)
-#define SHADERS_IMAGE_SHIFT           (SHADERS_PAINT_SHIFT + _SHADERS_PAINT_BITS)
-#define SHADERS_COLOR_TRANSFORM_SHIFT (SHADERS_IMAGE_SHIFT + _SHADERS_IMAGE_BITS)
-#define SHADERS_ALPHA_SHIFT           (SHADERS_COLOR_TRANSFORM_SHIFT + _SHADERS_COLOR_TRANSFORM_BITS)
-#define SHADERS_BLEND_SHIFT           (SHADERS_ALPHA_SHIFT + _SHADERS_ALPHA_BITS)
-#define SHADERS_MASK_SHIFT            (SHADERS_BLEND_SHIFT + _SHADERS_BLEND_BITS)
-#define SHADERS_PREMULTIPLY_SHIFT     (SHADERS_MASK_SHIFT + _SHADERS_MASK_BITS)
-#define SHADERS_BW_SHIFT              (SHADERS_PREMULTIPLY_SHIFT + _SHADERS_PREMULTIPLY_BITS)
-
-#define _SHADERS_GET_STAGE(stage, id) \
-   ((id) & (((1 << _SHADERS_ ## stage ## _BITS) - 1) << SHADERS_ ## stage ## _SHIFT))
-
-#define SHADERS_GET_PAINT_SHADER(id)           _SHADERS_GET_STAGE(PAINT, id)
-#define SHADERS_GET_IMAGE_SHADER(id)           _SHADERS_GET_STAGE(IMAGE, id)
-#define SHADERS_GET_COLOR_TRANSFORM_SHADER(id) _SHADERS_GET_STAGE(COLOR_TRANSFORM, id)
-#define SHADERS_GET_ALPHA_SHADER(id)           _SHADERS_GET_STAGE(ALPHA, id)
-#define SHADERS_GET_BLEND_SHADER(id)           _SHADERS_GET_STAGE(BLEND, id)
-#define SHADERS_GET_MASK_SHADER(id)            _SHADERS_GET_STAGE(MASK, id)
-#define SHADERS_GET_PREMULTIPLY_SHADER(id)     _SHADERS_GET_STAGE(PREMULTIPLY, id)
-#define SHADERS_GET_BW_SHADER(id)              _SHADERS_GET_STAGE(BW, id)
-
-enum VegaShaderType {
-   VEGA_SOLID_FILL_SHADER         = 1 << SHADERS_PAINT_SHIFT,
-   VEGA_LINEAR_GRADIENT_SHADER    = 2 << SHADERS_PAINT_SHIFT,
-   VEGA_RADIAL_GRADIENT_SHADER    = 3 << SHADERS_PAINT_SHIFT,
-   VEGA_PATTERN_SHADER            = 4 << SHADERS_PAINT_SHIFT,
-   VEGA_PAINT_DEGENERATE_SHADER   = 5 << SHADERS_PAINT_SHIFT,
-
-   VEGA_IMAGE_NORMAL_SHADER       = 1 << SHADERS_IMAGE_SHIFT,
-   VEGA_IMAGE_MULTIPLY_SHADER     = 2 << SHADERS_IMAGE_SHIFT,
-   VEGA_IMAGE_STENCIL_SHADER      = 3 << SHADERS_IMAGE_SHIFT,
-
-   VEGA_COLOR_TRANSFORM_SHADER    = 1 <<  SHADERS_COLOR_TRANSFORM_SHIFT,
-
-   VEGA_ALPHA_NORMAL_SHADER       = 1 <<  SHADERS_ALPHA_SHIFT,
-   VEGA_ALPHA_PER_CHANNEL_SHADER  = 2 <<  SHADERS_ALPHA_SHIFT,
-
-   VEGA_BLEND_SRC_SHADER          = 1 << SHADERS_BLEND_SHIFT,
-   VEGA_BLEND_SRC_OVER_SHADER     = 2 << SHADERS_BLEND_SHIFT,
-   VEGA_BLEND_DST_OVER_SHADER     = 3 << SHADERS_BLEND_SHIFT,
-   VEGA_BLEND_SRC_IN_SHADER       = 4 << SHADERS_BLEND_SHIFT,
-   VEGA_BLEND_DST_IN_SHADER       = 5 << SHADERS_BLEND_SHIFT,
-   VEGA_BLEND_MULTIPLY_SHADER     = 6 << SHADERS_BLEND_SHIFT,
-   VEGA_BLEND_SCREEN_SHADER       = 7 << SHADERS_BLEND_SHIFT,
-   VEGA_BLEND_DARKEN_SHADER       = 8 << SHADERS_BLEND_SHIFT,
-   VEGA_BLEND_LIGHTEN_SHADER      = 9 << SHADERS_BLEND_SHIFT,
-   VEGA_BLEND_ADDITIVE_SHADER     = 10<< SHADERS_BLEND_SHIFT,
-
-   VEGA_MASK_SHADER               = 1 << SHADERS_MASK_SHIFT,
-
-   VEGA_PREMULTIPLY_SHADER        = 1 << SHADERS_PREMULTIPLY_SHIFT,
-   VEGA_UNPREMULTIPLY_SHADER      = 2 << SHADERS_PREMULTIPLY_SHIFT,
-
-   VEGA_BW_SHADER                 = 1 << SHADERS_BW_SHIFT
-};
-
-struct vg_shader {
-   void *driver;
-   struct tgsi_token *tokens;
-   int type;/* PIPE_SHADER_VERTEX, PIPE_SHADER_FRAGMENT */
-};
-
-struct shaders_cache *shaders_cache_create(struct vg_context *pipe);
-void shaders_cache_destroy(struct shaders_cache *sc);
-void *shaders_cache_fill(struct shaders_cache *sc,
-                         int shader_key);
-
-struct vg_shader *shader_create_from_text(struct pipe_context *pipe,
-                                          const char *txt, int num_tokens,
-                                          int type);
-
-void vg_shader_destroy(struct vg_context *ctx, struct vg_shader *shader);
-
-
-
-#endif
diff --git a/src/gallium/state_trackers/vega/stroker.c b/src/gallium/state_trackers/vega/stroker.c
deleted file mode 100644
index b9f0f2c284f..00000000000
--- a/src/gallium/state_trackers/vega/stroker.c
+++ /dev/null
@@ -1,1351 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "stroker.h"
-
-#include "path.h"
-#include "vg_state.h"
-#include "util_array.h"
-#include "arc.h"
-#include "bezier.h"
-#include "matrix.h"
-#include "path_utils.h"
-#include "polygon.h"
-
-#include "util/u_math.h"
-
-#ifndef M_2PI
-#define M_2PI 6.28318530717958647692528676655900576
-#endif
-
-#define STROKE_SEGMENTS 0
-#define STROKE_DEBUG 0
-#define DEBUG_EMITS 0
-
-static const VGfloat curve_threshold = 0.25f;
-
-static const VGfloat zero_coords[] = {0.f, 0.f};
-
-enum intersection_type {
-   NoIntersections,
-   BoundedIntersection,
-   UnboundedIntersection,
-};
-
-enum line_join_mode {
-   FlatJoin,
-   SquareJoin,
-   MiterJoin,
-   RoundJoin,
-   RoundCap
-};
-
-struct stroke_iterator {
-   void (*next)(struct stroke_iterator *);
-   VGboolean (*has_next)(struct stroke_iterator *);
-
-   VGPathCommand (*current_command)(struct stroke_iterator *it);
-   void (*current_coords)(struct stroke_iterator *it, VGfloat *coords);
-
-   VGint position;
-   VGint coord_position;
-
-   const VGubyte *cmds;
-   const VGfloat *coords;
-   VGint num_commands;
-   VGint num_coords;
-
-   struct polygon *curve_poly;
-   VGint curve_index;
-};
-
-static VGPathCommand stroke_itr_command(struct stroke_iterator *itr)
-{
-   return itr->current_command(itr);
-}
-
-static void stroke_itr_coords(struct stroke_iterator *itr, VGfloat *coords)
-{
-   itr->current_coords(itr, coords);
-}
-
-static void stroke_fw_itr_coords(struct stroke_iterator *itr, VGfloat *coords)
-{
-   if (itr->position >= itr->num_commands)
-      return;
-   switch (stroke_itr_command(itr)) {
-   case VG_MOVE_TO_ABS:
-      coords[0] = itr->coords[itr->coord_position];
-      coords[1] = itr->coords[itr->coord_position + 1];
-      break;
-   case VG_LINE_TO_ABS:
-      coords[0] = itr->coords[itr->coord_position];
-      coords[1] = itr->coords[itr->coord_position + 1];
-      break;
-   case VG_CUBIC_TO_ABS:
-      coords[0] = itr->coords[itr->coord_position];
-      coords[1] = itr->coords[itr->coord_position + 1];
-      coords[2] = itr->coords[itr->coord_position + 2];
-      coords[3] = itr->coords[itr->coord_position + 3];
-      coords[4] = itr->coords[itr->coord_position + 4];
-      coords[5] = itr->coords[itr->coord_position + 5];
-      break;
-   default:
-      debug_assert(!"invalid command!\n");
-   }
-}
-
-
-static void stroke_bw_itr_coords(struct stroke_iterator *itr, VGfloat *coords)
-{
-   if (itr->position >= itr->num_commands)
-      return;
-   switch (stroke_itr_command(itr)) {
-   case VG_MOVE_TO_ABS:
-      coords[0] = itr->coords[itr->coord_position];
-      coords[1] = itr->coords[itr->coord_position + 1];
-      break;
-   case VG_LINE_TO_ABS:
-      coords[0] = itr->coords[itr->coord_position];
-      coords[1] = itr->coords[itr->coord_position + 1];
-      break;
-   case VG_CUBIC_TO_ABS:
-      coords[0] = itr->coords[itr->coord_position + 4];
-      coords[1] = itr->coords[itr->coord_position + 5];
-      coords[2] = itr->coords[itr->coord_position + 2];
-      coords[3] = itr->coords[itr->coord_position + 3];
-      coords[4] = itr->coords[itr->coord_position + 0];
-      coords[5] = itr->coords[itr->coord_position + 1];
-      break;
-   default:
-      debug_assert(!"invalid command!\n");
-   }
-}
-
-
-static VGPathCommand stroke_fw_current_command(struct stroke_iterator *it)
-{
-   return it->cmds[it->position];
-}
-
-static VGPathCommand stroke_bw_current_command(struct stroke_iterator *it)
-{
-   VGPathCommand prev_cmd;
-   if (it->position == it->num_commands  -1)
-      return VG_MOVE_TO_ABS;
-
-   prev_cmd = it->cmds[it->position + 1];
-   return prev_cmd;
-}
-
-static VGboolean stroke_fw_has_next(struct stroke_iterator *itr)
-{
-   return itr->position < (itr->num_commands - 1);
-}
-
-static VGboolean stroke_bw_has_next(struct stroke_iterator *itr)
-{
-   return itr->position > 0;
-}
-
-static void stroke_fw_next(struct stroke_iterator *itr)
-{
-   VGubyte cmd;
-   debug_assert(stroke_fw_has_next(itr));
-
-   cmd = stroke_itr_command(itr);
-
-   itr->coord_position += num_elements_for_segments(&cmd, 1);
-   ++itr->position;
-}
-
-static void stroke_bw_next(struct stroke_iterator *itr)
-{
-   VGubyte cmd;
-   debug_assert(stroke_bw_has_next(itr));
-
-   --itr->position;
-   cmd = stroke_itr_command(itr);
-
-   itr->coord_position -= num_elements_for_segments(&cmd, 1);
-}
-
-static void stroke_itr_common_init(struct stroke_iterator *itr,
-                                   struct array *cmds,
-                                   struct array *coords)
-{
-   itr->cmds = (VGubyte*)cmds->data;
-   itr->num_commands = cmds->num_elements;
-
-   itr->coords = (VGfloat*)coords->data;
-   itr->num_coords = coords->num_elements;
-}
-
-static void stroke_forward_iterator(struct stroke_iterator *itr,
-                                    struct array *cmds,
-                                    struct array *coords)
-{
-   stroke_itr_common_init(itr, cmds, coords);
-   itr->position = 0;
-   itr->coord_position = 0;
-
-   itr->next = stroke_fw_next;
-   itr->has_next = stroke_fw_has_next;
-   itr->current_command = stroke_fw_current_command;
-   itr->current_coords = stroke_fw_itr_coords;
-}
-
-static void stroke_backward_iterator(struct stroke_iterator *itr,
-                                     struct array *cmds,
-                                     struct array *coords)
-{
-   VGubyte cmd;
-   stroke_itr_common_init(itr, cmds, coords);
-   itr->position = itr->num_commands - 1;
-
-   cmd = stroke_bw_current_command(itr);
-   itr->coord_position = itr->num_coords -
-                         num_elements_for_segments(&cmd, 1);
-
-   itr->next = stroke_bw_next;
-   itr->has_next = stroke_bw_has_next;
-   itr->current_command = stroke_bw_current_command;
-   itr->current_coords = stroke_bw_itr_coords;
-}
-
-
-
-static void stroke_flat_next(struct stroke_iterator *itr)
-{
-   VGubyte cmd;
-
-   if (itr->curve_index >= 0) {
-      ++itr->curve_index;
-      if (itr->curve_index >= polygon_vertex_count(itr->curve_poly)) {
-         itr->curve_index = -1;
-         polygon_destroy(itr->curve_poly);
-         itr->curve_poly = 0;
-      } else
-         return;
-   }
-   debug_assert(stroke_fw_has_next(itr));
-
-   cmd = itr->cmds[itr->position];
-   itr->coord_position += num_elements_for_segments(&cmd, 1);
-   ++itr->position;
-
-   cmd = itr->cmds[itr->position];
-
-   if (cmd == VG_CUBIC_TO_ABS) {
-      struct bezier bezier;
-      VGfloat bez[8];
-
-      bez[0] = itr->coords[itr->coord_position - 2];
-      bez[1] = itr->coords[itr->coord_position - 1];
-      bez[2] = itr->coords[itr->coord_position];
-      bez[3] = itr->coords[itr->coord_position + 1];
-      bez[4] = itr->coords[itr->coord_position + 2];
-      bez[5] = itr->coords[itr->coord_position + 3];
-      bez[6] = itr->coords[itr->coord_position + 4];
-      bez[7] = itr->coords[itr->coord_position + 5];
-
-      bezier_init(&bezier,
-                  bez[0], bez[1],
-                  bez[2], bez[3],
-                  bez[4], bez[5],
-                  bez[6], bez[7]);
-      /* skip the first one, it's the same as the prev point */
-      itr->curve_index = 1;
-      if (itr->curve_poly) {
-         polygon_destroy(itr->curve_poly);
-         itr->curve_poly = 0;
-      }
-      itr->curve_poly = bezier_to_polygon(&bezier);
-   }
-}
-
-static VGboolean stroke_flat_has_next(struct stroke_iterator *itr)
-{
-   return  (itr->curve_index >= 0 &&
-            itr->curve_index < (polygon_vertex_count(itr->curve_poly)-1))
-            || itr->position < (itr->num_commands - 1);
-}
-
-static VGPathCommand stroke_flat_current_command(struct stroke_iterator *it)
-{
-   if (it->cmds[it->position] == VG_CUBIC_TO_ABS) {
-      return VG_LINE_TO_ABS;
-   }
-   return it->cmds[it->position];
-}
-
-static void stroke_flat_itr_coords(struct stroke_iterator *itr, VGfloat *coords)
-{
-   if (itr->curve_index <= -1 && itr->position >= itr->num_commands)
-      return;
-
-   if (itr->curve_index >= 0) {
-      polygon_vertex(itr->curve_poly, itr->curve_index,
-                     coords);
-      return;
-   }
-
-   switch (stroke_itr_command(itr)) {
-   case VG_MOVE_TO_ABS:
-      coords[0] = itr->coords[itr->coord_position];
-      coords[1] = itr->coords[itr->coord_position + 1];
-      break;
-   case VG_LINE_TO_ABS:
-      coords[0] = itr->coords[itr->coord_position];
-      coords[1] = itr->coords[itr->coord_position + 1];
-      break;
-   case VG_CUBIC_TO_ABS:
-   default:
-      debug_assert(!"invalid command!\n");
-   }
-}
-
-static void stroke_flat_iterator(struct stroke_iterator *itr,
-                                 struct array *cmds,
-                                 struct array *coords)
-{
-   stroke_itr_common_init(itr, cmds, coords);
-   itr->position = 0;
-   itr->coord_position = 0;
-
-   itr->next = stroke_flat_next;
-   itr->has_next = stroke_flat_has_next;
-   itr->current_command = stroke_flat_current_command;
-   itr->current_coords = stroke_flat_itr_coords;
-   itr->curve_index = -1;
-   itr->curve_poly = 0;
-}
-
-
-static INLINE VGboolean finite_coords4(const VGfloat *c)
-{
-   return
-      isfinite(c[0]) && isfinite(c[1]) &&
-      isfinite(c[2]) && isfinite(c[3]);
-}
-
-/* from Graphics Gems II */
-#define SAME_SIGNS(a, b) ((a) * (b) >= 0)
-static VGboolean do_lines_intersect(VGfloat x1, VGfloat y1, VGfloat x2, VGfloat y2,
-                                    VGfloat x3, VGfloat y3, VGfloat x4, VGfloat y4)
-{
-   VGfloat a1, a2, b1, b2, c1, c2; /* Coefficients of line eqns */
-   VGfloat r1, r2, r3, r4;         /* 'sign' values */
-
-   a1 = y2 - y1;
-   b1 = x1 - x2;
-   c1 = x2 * y1 - x1 * y2;
-
-   r3 = a1 * x3 + b1 * y3 + c1;
-   r4 = a1 * x4 + b1 * y4 + c1;
-
-   if (r3 != 0 && r4 != 0 && SAME_SIGNS(r3, r4))
-      return VG_FALSE;
-
-   a2 = y4 - y3;
-   b2 = x3 - x4;
-   c2 = x4 * y3 - x3 * y4;
-
-   r1 = a2 * x1 + b2 * y1 + c2;
-   r2 = a2 * x2 + b2 * y2 + c2;
-
-   if (r1 != 0 && r2 != 0 && SAME_SIGNS(r1, r2))
-      return VG_FALSE;
-
-   return VG_TRUE;
-}
-
-static INLINE VGfloat line_dx(const VGfloat *l)
-{
-   return l[2] - l[0];
-}
-
-static INLINE VGfloat line_dy(const VGfloat *l)
-{
-   return l[3] - l[1];
-}
-
-static INLINE VGfloat line_angle(const VGfloat *l)
-{
-   const VGfloat dx = line_dx(l);
-   const VGfloat dy = line_dy(l);
-
-   const VGfloat theta = atan2(-dy, dx) * 360.0 / M_2PI;
-
-   const VGfloat theta_normalized = theta < 0 ? theta + 360 : theta;
-
-   if (floatsEqual(theta_normalized, 360.f))
-      return 0;
-   else
-      return theta_normalized;
-}
-
-static INLINE void line_set_length(VGfloat *l, VGfloat len)
-{
-   VGfloat uv[] = {l[0], l[1], l[2], l[3]};
-   if (null_line(l))
-      return;
-   line_normalize(uv);
-   l[2] = l[0] + line_dx(uv) * len;
-   l[3] = l[1] + line_dy(uv) * len;
-}
-
-static INLINE void line_translate(VGfloat *l, VGfloat x, VGfloat y)
-{
-   l[0] += x;
-   l[1] += y;
-   l[2] += x;
-   l[3] += y;
-}
-
-static INLINE VGfloat line_angle_to(const VGfloat *l1,
-                                    const VGfloat *l2)
-{
-   VGfloat a1, a2, delta, delta_normalized;
-   if (null_line(l1) || null_line(l1))
-      return 0;
-
-   a1 = line_angle(l1);
-   a2 = line_angle(l2);
-
-   delta = a2 - a1;
-   delta_normalized = delta < 0 ? delta + 360 : delta;
-
-   if (floatsEqual(delta, 360.f))
-      return 0;
-   else
-      return delta_normalized;
-}
-
-static INLINE VGfloat line_angles(const VGfloat *l1,
-                                  const VGfloat *l2)
-{
-   VGfloat cos_line, rad = 0;
-
-   if (null_line(l1) || null_line(l2))
-      return 0;
-
-   cos_line = (line_dx(l1)*line_dx(l2) + line_dy(l1)*line_dy(l2)) /
-              (line_lengthv(l1)*line_lengthv(l2));
-   rad = 0;
-
-   if (cos_line >= -1.0 && cos_line <= 1.0)
-      rad = acos(cos_line);
-   return rad * 360 / M_2PI;
-}
-
-
-static INLINE VGfloat adapted_angle_on_x(const VGfloat *line)
-{
-   const VGfloat identity[] = {0, 0, 1, 0};
-   VGfloat angle = line_angles(line, identity);
-   if (line_dy(line) > 0)
-      angle = 360 - angle;
-   return angle;
-}
-
-static enum intersection_type line_intersect(const VGfloat *l1,
-                                             const VGfloat *l2,
-                                             float *intersection_point)
-{
-   VGfloat isect[2] = { 0 };
-   enum intersection_type type;
-   VGboolean dx_zero, ldx_zero;
-
-   if (null_line(l1) || null_line(l2) ||
-       !finite_coords4(l1) || !finite_coords4(l2))
-      return NoIntersections;
-
-   type = do_lines_intersect(l1[0], l1[1], l1[2], l1[3], l2[0], l2[1], l2[2], l2[3])
-          ? BoundedIntersection : UnboundedIntersection;
-
-   dx_zero  = floatsEqual(line_dx(l1) + 1, 1);
-   ldx_zero = floatsEqual(line_dx(l2) + 1, 1);
-
-   /* one of the lines is vertical */
-   if (dx_zero && ldx_zero) {
-      type = NoIntersections;
-   } else if (dx_zero) {
-      VGfloat la = line_dy(l2) / line_dx(l2);
-      isect[0] = l1[0];
-      isect[1] = la * l1[0] + l2[1] - la * l2[0];
-   } else if (ldx_zero) {
-      VGfloat ta = line_dy(l1) / line_dx(l1);
-      isect[0] = l2[0];
-      isect[1] = ta * l2[0] + l1[1] - ta*l1[0];
-   } else {
-      VGfloat x;
-      VGfloat ta = line_dy(l1) / line_dx(l1);
-      VGfloat la = line_dy(l2) / line_dx(l2);
-      if (ta == la)
-         return NoIntersections;
-
-      x = ( - l2[1] + la * l2[0] + l1[1] - ta * l1[0] ) / (la - ta);
-      isect[0] = x;
-      isect[1] = ta*(x - l1[0]) + l1[1];
-   }
-   if (intersection_point) {
-      intersection_point[0] = isect[0];
-      intersection_point[1] = isect[1];
-   }
-   return type;
-}
-
-static INLINE enum line_join_mode stroker_join_mode(struct stroker *s)
-{
-   switch(s->join_style) {
-   case VG_JOIN_MITER:
-      return MiterJoin;
-   case VG_JOIN_ROUND:
-      return RoundJoin;
-   case VG_JOIN_BEVEL:
-      return FlatJoin;
-   default:
-      return FlatJoin;
-   }
-}
-
-static INLINE enum line_join_mode stroker_cap_mode(struct stroker *s)
-{
-   switch(s->cap_style) {
-   case VG_CAP_BUTT:
-      return FlatJoin;
-   case VG_CAP_ROUND:
-      return RoundCap;
-   case VG_CAP_SQUARE:
-      return SquareJoin;
-   default:
-      return FlatJoin;
-   }
-}
-
-void stroker_emit_move_to(struct stroker *stroker, VGfloat x, VGfloat y)
-{
-   VGubyte cmds = VG_MOVE_TO_ABS;
-   VGfloat coords[2] = {x, y};
-#if DEBUG_EMITS
-   debug_printf("emit move %f, %f\n", x, y);
-#endif
-   stroker->back2_x = stroker->back1_x;
-   stroker->back2_y = stroker->back1_y;
-   stroker->back1_x = x;
-   stroker->back1_y = y;
-
-   path_append_data(stroker->path,
-                    1,
-                    &cmds, &coords);
-}
-
-void stroker_emit_line_to(struct stroker *stroker, VGfloat x, VGfloat y)
-{
-   VGubyte cmds = VG_LINE_TO_ABS;
-   VGfloat coords[2] = {x, y};
-#if DEBUG_EMITS
-   debug_printf("emit line %f, %f\n", x, y);
-#endif
-   stroker->back2_x = stroker->back1_x;
-   stroker->back2_y = stroker->back1_y;
-   stroker->back1_x = x;
-   stroker->back1_y = y;
-   path_append_data(stroker->path,
-                    1,
-                    &cmds, &coords);
-}
-
-void stroker_emit_curve_to(struct stroker *stroker, VGfloat px1, VGfloat py1,
-                                  VGfloat px2, VGfloat py2,
-                                  VGfloat x, VGfloat y)
-{
-   VGubyte cmds = VG_CUBIC_TO_ABS;
-   VGfloat coords[6] = {px1, py1, px2, py2, x, y};
-#if DEBUG_EMITS
-   debug_printf("emit curve %f, %f, %f, %f, %f, %f\n", px1, py1,
-                px2, py2, x, y);
-#endif
-
-   if (px2 == x && py2 == y) {
-      if (px1 == x && py1 == y) {
-         stroker->back2_x = stroker->back1_x;
-         stroker->back2_y = stroker->back1_y;
-      } else {
-         stroker->back2_x = px1;
-         stroker->back2_y = py1;
-      }
-   } else {
-      stroker->back2_x = px2;
-      stroker->back2_y = py2;
-   }
-   stroker->back1_x = x;
-   stroker->back1_y = y;
-
-   path_append_data(stroker->path,
-                    1,
-                    &cmds, &coords);
-}
-
-static INLINE void create_round_join(struct stroker *stroker,
-                                     VGfloat x1, VGfloat y1,
-                                     VGfloat x2, VGfloat y2,
-                                     VGfloat width, VGfloat height)
-{
-   struct arc arc;
-   struct matrix matrix;
-
-   matrix_load_identity(&matrix);
-
-   /*stroker_emit_line_to(stroker, nx, ny);*/
-
-   arc_init(&arc, VG_SCCWARC_TO,
-            x1, y1, x2, y2, width/2, height/2, 0);
-   arc_stroker_emit(&arc, stroker, &matrix);
-}
-
-
-static void create_joins(struct stroker *stroker,
-                         VGfloat focal_x, VGfloat focal_y,
-                         const VGfloat *next_line, enum line_join_mode join)
-{
-#if DEBUG_EMITS
-   debug_printf("create_joins: focal=[%f, %f], next_line=[%f, %f,%f, %f]\n",
-                focal_x, focal_y,
-                next_line[0], next_line[1], next_line[2], next_line[3]);
-#endif
-   /* if we're alredy connected do nothing */
-   if (floatsEqual(stroker->back1_x, next_line[0]) &&
-       floatsEqual(stroker->back1_y, next_line[1]))
-      return;
-
-   if (join == FlatJoin) {
-      stroker_emit_line_to(stroker, next_line[0], next_line[1]);
-   } else {
-      VGfloat prev_line[] = {stroker->back2_x, stroker->back2_y,
-                             stroker->back1_x, stroker->back1_y};
-
-      VGfloat isect[2] = { 0 };
-      enum intersection_type type = line_intersect(prev_line, next_line, isect);
-
-      if (join == SquareJoin) {
-         VGfloat offset = stroker->stroke_width / 2;
-         VGfloat l1[4] = {prev_line[0],
-                          prev_line[1],
-                          prev_line[2],
-                          prev_line[3]};
-         VGfloat l2[4] = {next_line[2],
-                          next_line[3],
-                          next_line[0],
-                          next_line[1]};
-
-         line_translate(l1, line_dx(l1), line_dy(l1));
-         line_set_length(l1, offset);
-
-         line_translate(l2, line_dx(l2), line_dy(l2));
-         line_set_length(l2, offset);
-
-         stroker_emit_line_to(stroker, l1[2], l1[3]);
-         stroker_emit_line_to(stroker, l2[2], l2[3]);
-         stroker_emit_line_to(stroker, l2[0], l2[1]);
-      } else if (join == RoundJoin) {
-         VGfloat offset = stroker->stroke_width / 2;
-         VGfloat short_cut[4] = {prev_line[2], prev_line[3],
-                                 next_line[0], next_line[1]};
-         VGfloat angle = line_angles(prev_line, short_cut);
-
-         if (type == BoundedIntersection ||
-             (angle > 90 && !floatsEqual(angle, 90.f))) {
-            stroker_emit_line_to(stroker, next_line[0], next_line[1]);
-            return;
-         }
-         create_round_join(stroker, prev_line[2], prev_line[3],
-                           next_line[0], next_line[1],
-                           offset * 2, offset * 2);
-
-         stroker_emit_line_to(stroker, next_line[0], next_line[1]);
-      } else if (join == RoundCap) {
-         VGfloat offset = stroker->stroke_width / 2;
-         VGfloat l1[4] = { prev_line[0], prev_line[1],
-                           prev_line[2], prev_line[3] };
-         VGfloat l2[4] = {focal_x, focal_y,
-                          prev_line[2], prev_line[3]};
-
-         line_translate(l1, line_dx(l1), line_dy(l1));
-         line_set_length(l1, KAPPA * offset);
-
-         /* normal between prev_line and focal */
-         line_translate(l2, -line_dy(l2), line_dx(l2));
-         line_set_length(l2, KAPPA * offset);
-
-         stroker_emit_curve_to(stroker, l1[2], l1[3],
-                               l2[2], l2[3],
-                               l2[0], l2[1]);
-
-         l2[0] = l2[0];
-         l2[1] = l2[1];
-         l2[2] = l2[0] - line_dx(l2);
-         l2[3] = l2[1] - line_dy(l2);
-
-         line_translate(l1, next_line[0] - l1[0], next_line[1] - l1[1]);
-
-         stroker_emit_curve_to(stroker,
-                               l2[2], l2[3],
-                               l1[2], l1[3],
-                               l1[0], l1[1]);
-      } else if (join == MiterJoin) {
-         VGfloat miter_line[4] = {stroker->back1_x, stroker->back1_y,
-                                  isect[0], isect[1]};
-         VGfloat sl = (stroker->stroke_width * stroker->miter_limit);
-         VGfloat inside_line[4] = {prev_line[2], prev_line[3],
-                                   next_line[0], next_line[1]};
-         VGfloat angle = line_angle_to(inside_line, prev_line);
-
-         if (type == BoundedIntersection ||
-             (angle > 90 && !floatsEqual(angle, 90.f))) {
-            /*
-            debug_printf("f = %f, nl = %f, pl = %f, is = %f\n",
-                         focal_x, next_line[0],
-                         prev_line[2], isect[0]);*/
-            stroker_emit_line_to(stroker, next_line[0], next_line[1]);
-            return;
-         }
-
-         if (type == NoIntersections || line_lengthv(miter_line) > sl) {
-            stroker_emit_line_to(stroker, next_line[0], next_line[1]);
-         } else {
-            stroker_emit_line_to(stroker, isect[0], isect[1]);
-            stroker_emit_line_to(stroker, next_line[0], next_line[1]);
-         }
-      } else {
-         debug_assert(!"create_joins bad join style");
-      }
-   }
-}
-
-static void stroker_add_segment(struct stroker *stroker,
-                                VGPathCommand cmd,
-                                const VGfloat *coords,
-                                VGint num_coords)
-{
-   /* skip duplicated points */
-   if (stroker->segments->num_elements &&
-       stroker->last_cmd == cmd) {
-      VGfloat *data = stroker->control_points->data;
-      data += stroker->control_points->num_elements;
-      data -= num_coords;
-      switch (cmd) {
-      case VG_MOVE_TO_ABS:
-         if (floatsEqual(coords[0], data[0]) &&
-             floatsEqual(coords[1], data[1]))
-            return;
-         break;
-      case VG_LINE_TO_ABS:
-         if (floatsEqual(coords[0], data[0]) &&
-             floatsEqual(coords[1], data[1]))
-            return;
-         break;
-      case VG_CUBIC_TO_ABS:
-         if (floatsEqual(coords[0], data[0]) &&
-             floatsEqual(coords[1], data[1]) &&
-             floatsEqual(coords[2], data[2]) &&
-             floatsEqual(coords[3], data[3]) &&
-             floatsEqual(coords[4], data[4]) &&
-             floatsEqual(coords[5], data[5]))
-            return;
-         break;
-      default:
-         debug_assert(!"Invalid stroke segment");
-      }
-   } else if (stroker->last_cmd == VG_CUBIC_TO_ABS &&
-              cmd == VG_LINE_TO_ABS) {
-      VGfloat *data = stroker->control_points->data;
-      data += stroker->control_points->num_elements;
-      data -= 2;
-      if (floatsEqual(coords[0], data[0]) &&
-          floatsEqual(coords[1], data[1]))
-         return;
-   }
-   stroker->last_cmd = cmd;
-   array_append_data(stroker->segments, &cmd, 1);
-   array_append_data(stroker->control_points, coords, num_coords);
-}
-
-void stroker_move_to(struct stroker *stroker, VGfloat x, VGfloat y)
-{
-   VGfloat coords[2] = {x, y};
-#if STROKE_SEGMENTS
-   debug_printf("stroker_move_to(%f, %f)\n", x, y);
-#endif
-
-   if (stroker->segments->num_elements > 0)
-      stroker->process_subpath(stroker);
-
-   array_reset(stroker->segments);
-   array_reset(stroker->control_points);
-
-   stroker_add_segment(stroker, VG_MOVE_TO_ABS, coords, 2);
-}
-
-void stroker_line_to(struct stroker *stroker, VGfloat x, VGfloat y)
-{
-   VGfloat coords[] = {x, y};
-
-#if STROKE_SEGMENTS
-   debug_printf("stroker_line_to(%f, %f)\n", x, y);
-#endif
-   if (!stroker->segments->num_elements)
-      stroker_add_segment(stroker, VG_MOVE_TO_ABS, zero_coords, 2);
-
-   stroker_add_segment(stroker, VG_LINE_TO_ABS, coords, 2);
-}
-
-void stroker_curve_to(struct stroker *stroker, VGfloat px1, VGfloat py1,
-                      VGfloat px2, VGfloat py2,
-                      VGfloat x, VGfloat y)
-{
-   VGfloat coords[] = {px1, py1,
-                       px2, py2,
-                       x, y};
-#if STROKE_SEGMENTS
-   debug_printf("stroker_curve_to(%f, %f, %f, %f, %f, %f)\n",
-                px1, py1, px2, py2, x, y);
-#endif
-   if (!stroker->segments->num_elements)
-      stroker_add_segment(stroker, VG_MOVE_TO_ABS, zero_coords, 2);
-
-   stroker_add_segment(stroker, VG_CUBIC_TO_ABS, coords, 6);
-}
-
-static INLINE VGboolean is_segment_null(VGPathCommand cmd,
-                                        VGfloat *coords,
-                                        VGfloat *res)
-{
-   switch(cmd) {
-   case VG_MOVE_TO_ABS:
-   case VG_LINE_TO_ABS:
-      return floatsEqual(coords[0], res[0]) &&
-         floatsEqual(coords[1], res[1]);
-      break;
-   case VG_CUBIC_TO_ABS:
-      return floatsEqual(coords[0], res[0]) &&
-         floatsEqual(coords[1], res[1]) &&
-         floatsEqual(coords[2], res[0]) &&
-         floatsEqual(coords[3], res[1]) &&
-         floatsEqual(coords[4], res[0]) &&
-         floatsEqual(coords[5], res[1]);
-      break;
-   default:
-      assert(0);
-   }
-   return VG_FALSE;
-}
-
-static VGboolean vg_stroke_outline(struct stroke_iterator *it,
-                                struct stroker *stroker,
-                                VGboolean cap_first,
-                                VGfloat *start_tangent)
-{
-#define MAX_OFFSET 16
-   struct bezier offset_curves[MAX_OFFSET];
-   VGPathCommand first_element;
-   VGfloat start[2], prev[2];
-   VGboolean first = VG_TRUE;
-   VGfloat offset;
-
-   first_element = stroke_itr_command(it);
-   if (first_element != VG_MOVE_TO_ABS) {
-      stroker_emit_move_to(stroker, 0.f, 0.f);
-      prev[0] = 0.f;
-      prev[1] = 0.f;
-   }
-   stroke_itr_coords(it, start);
-#if STROKE_DEBUG
-   debug_printf(" -> (side) [%.2f, %.2f]\n",
-                start[0],
-                start[1]);
-#endif
-
-   prev[0] = start[0];
-   prev[1] = start[1];
-
-   offset = stroker->stroke_width / 2;
-
-   if (!it->has_next(it)) {
-      /* single point */
-
-      return VG_TRUE;
-   }
-
-   while (it->has_next(it)) {
-      VGPathCommand cmd;
-      VGfloat coords[8];
-
-      it->next(it);
-      cmd = stroke_itr_command(it);
-      stroke_itr_coords(it, coords);
-
-      if (cmd == VG_LINE_TO_ABS) {
-         VGfloat line[4] = {prev[0], prev[1], coords[0], coords[1]};
-         VGfloat normal[4];
-         line_normal(line, normal);
-
-#if STROKE_DEBUG
-         debug_printf("\n ---> (side) lineto [%.2f, %.2f]\n", coords[0], coords[1]);
-#endif
-         line_set_length(normal, offset);
-         line_translate(line, line_dx(normal), line_dy(normal));
-
-         /* if we are starting a new subpath, move to correct starting point */
-         if (first) {
-            if (cap_first)
-               create_joins(stroker, prev[0], prev[1], line,
-                            stroker_cap_mode(stroker));
-            else
-               stroker_emit_move_to(stroker, line[0], line[1]);
-            memcpy(start_tangent, line,
-                   sizeof(VGfloat) * 4);
-            first = VG_FALSE;
-         } else {
-            create_joins(stroker, prev[0], prev[1], line,
-                         stroker_join_mode(stroker));
-         }
-
-         /* add the stroke for this line */
-         stroker_emit_line_to(stroker, line[2], line[3]);
-         prev[0] = coords[0];
-         prev[1] = coords[1];
-      } else if (cmd == VG_CUBIC_TO_ABS) {
-#if STROKE_DEBUG
-         debug_printf("\n ---> (side) cubicTo [%.2f, %.2f]\n",
-                coords[4],
-                coords[5]);
-#endif
-         struct bezier bezier;
-         int count;
-
-         bezier_init(&bezier,
-                     prev[0], prev[1], coords[0], coords[1],
-                     coords[2], coords[3], coords[4], coords[5]);
-
-         count = bezier_translate_by_normal(&bezier,
-                                            offset_curves,
-                                            MAX_OFFSET,
-                                            offset,
-                                            curve_threshold);
-
-         if (count) {
-            /* if we are starting a new subpath, move to correct starting point */
-            VGfloat tangent[4];
-            VGint i;
-
-            bezier_start_tangent(&bezier, tangent);
-            line_translate(tangent,
-                           offset_curves[0].x1 - bezier.x1,
-                           offset_curves[0].y1 - bezier.y1);
-            if (first) {
-               VGfloat pt[2] = {offset_curves[0].x1,
-                                offset_curves[0].y1};
-
-               if (cap_first) {
-                  create_joins(stroker, prev[0], prev[1], tangent,
-                               stroker_cap_mode(stroker));
-               } else {
-                  stroker_emit_move_to(stroker, pt[0], pt[1]);
-               }
-               start_tangent[0] = tangent[0];
-               start_tangent[1] = tangent[1];
-               start_tangent[2] = tangent[2];
-               start_tangent[3] = tangent[3];
-               first = VG_FALSE;
-            } else {
-               create_joins(stroker, prev[0], prev[1], tangent,
-                            stroker_join_mode(stroker));
-            }
-
-            /* add these beziers */
-            for (i = 0; i < count; ++i) {
-               struct bezier *bez = &offset_curves[i];
-               stroker_emit_curve_to(stroker,
-                                     bez->x2, bez->y2,
-                                     bez->x3, bez->y3,
-                                     bez->x4, bez->y4);
-            }
-         }
-
-         prev[0] = coords[4];
-         prev[1] = coords[5];
-      }
-   }
-
-   if (floatsEqual(start[0], prev[0]) &&
-       floatsEqual(start[1], prev[1])) {
-      /* closed subpath, join first and last point */
-#if STROKE_DEBUG
-      debug_printf("\n stroker: closed subpath\n");
-#endif
-      create_joins(stroker, prev[0], prev[1], start_tangent,
-                   stroker_join_mode(stroker));
-      return VG_TRUE;
-   } else {
-#if STROKE_DEBUG
-      debug_printf("\n stroker: open subpath\n");
-#endif
-      return VG_FALSE;
-   }
-#undef MAX_OFFSET
-}
-
-static void stroker_process_subpath(struct stroker *stroker)
-{
-   VGboolean fwclosed, bwclosed;
-   VGfloat fw_start_tangent[4], bw_start_tangent[4];
-   struct stroke_iterator fwit;
-   struct stroke_iterator bwit;
-   debug_assert(stroker->segments->num_elements > 0);
-
-   memset(fw_start_tangent, 0,
-          sizeof(VGfloat)*4);
-   memset(bw_start_tangent, 0,
-          sizeof(VGfloat)*4);
-
-   stroke_forward_iterator(&fwit, stroker->segments,
-                           stroker->control_points);
-   stroke_backward_iterator(&bwit, stroker->segments,
-                            stroker->control_points);
-
-   debug_assert(fwit.cmds[0] == VG_MOVE_TO_ABS);
-
-   fwclosed = vg_stroke_outline(&fwit, stroker, VG_FALSE, fw_start_tangent);
-   bwclosed = vg_stroke_outline(&bwit, stroker, !fwclosed, bw_start_tangent);
-
-   if (!bwclosed)
-      create_joins(stroker,
-                   fwit.coords[0], fwit.coords[1], fw_start_tangent,
-                   stroker_cap_mode(stroker));
-   else {
-      /* hack to handle the requirement of the VG spec that says that strokes
-       * of len==0 that have butt cap or round cap still need
-       * to be rendered. (8.7.4 Stroke Generation) */
-      if (stroker->segments->num_elements <= 3) {
-         VGPathCommand cmd;
-         VGfloat data[8], coords[8];
-         struct stroke_iterator *it = &fwit;
-
-         stroke_forward_iterator(it, stroker->segments,
-                                 stroker->control_points);
-         cmd = stroke_itr_command(it);
-         stroke_itr_coords(it, coords);
-         if (cmd != VG_MOVE_TO_ABS) {
-            memset(data, 0, sizeof(VGfloat) * 8);
-            if (!is_segment_null(cmd, coords, data))
-               return;
-         } else {
-            data[0] = coords[0];
-            data[1] = coords[1];
-         }
-         while (it->has_next(it)) {
-            it->next(it);
-            cmd = stroke_itr_command(it);
-            stroke_itr_coords(it, coords);
-            if (!is_segment_null(cmd, coords, data))
-               return;
-         }
-         /* generate the square/round cap */
-         if (stroker->cap_style == VG_CAP_SQUARE) {
-            VGfloat offset = stroker->stroke_width / 2;
-            stroker_emit_move_to(stroker, data[0] - offset,
-                                 data[1] - offset);
-            stroker_emit_line_to(stroker, data[0] + offset,
-                                 data[1] - offset);
-            stroker_emit_line_to(stroker, data[0] + offset,
-                                 data[1] + offset);
-            stroker_emit_line_to(stroker, data[0] - offset,
-                                 data[1] + offset);
-            stroker_emit_line_to(stroker, data[0] - offset,
-                                 data[1] - offset);
-         } else if (stroker->cap_style == VG_CAP_ROUND) {
-            VGfloat offset = stroker->stroke_width / 2;
-            VGfloat cx = data[0], cy = data[1];
-            { /*circle */
-               struct arc arc;
-               struct matrix matrix;
-               matrix_load_identity(&matrix);
-
-               stroker_emit_move_to(stroker, cx + offset, cy);
-               arc_init(&arc, VG_SCCWARC_TO,
-                        cx + offset, cy,
-                        cx - offset, cy,
-                        offset, offset, 0);
-               arc_stroker_emit(&arc, stroker, &matrix);
-               arc_init(&arc, VG_SCCWARC_TO,
-                         cx - offset, cy,
-                         cx + offset, cy,
-                         offset, offset, 0);
-               arc_stroker_emit(&arc, stroker, &matrix);
-            }
-         }
-      }
-   }
-}
-
-static INLINE VGfloat dash_pattern(struct dash_stroker *stroker,
-                                   VGint idx)
-{
-   if (stroker->dash_pattern[idx] < 0)
-      return 0.f;
-   return stroker->dash_pattern[idx];
-}
-
-static void dash_stroker_process_subpath(struct stroker *str)
-{
-   struct dash_stroker *stroker = (struct dash_stroker *)str;
-   VGfloat sum_length = 0;
-   VGint i;
-   VGint idash = 0;
-   VGfloat pos = 0;
-   VGfloat elen = 0;
-   VGfloat doffset = stroker->dash_phase;
-   VGfloat estart = 0;
-   VGfloat estop = 0;
-   VGfloat cline[4];
-   struct stroke_iterator it;
-   VGfloat prev[2];
-   VGfloat move_to_pos[2];
-   VGfloat line_to_pos[2];
-
-   VGboolean has_move_to = VG_FALSE;
-
-   stroke_flat_iterator(&it, stroker->base.segments,
-                        stroker->base.control_points);
-
-   stroke_itr_coords(&it, prev);
-   move_to_pos[0] = prev[0];
-   move_to_pos[1] = prev[1];
-
-   debug_assert(stroker->dash_pattern_num > 0);
-
-   for (i = 0; i < stroker->dash_pattern_num; ++i) {
-      sum_length += dash_pattern(stroker, i);
-   }
-
-   if (floatIsZero(sum_length)) {
-      return;
-   }
-
-   doffset -= floorf(doffset / sum_length) * sum_length;
-
-   while (!floatIsZero(doffset) && doffset >= dash_pattern(stroker, idash)) {
-      doffset -= dash_pattern(stroker, idash);
-      idash = (idash + 1) % stroker->dash_pattern_num;
-   }
-
-   while (it.has_next(&it)) {
-      VGPathCommand cmd;
-      VGfloat coords[8];
-      VGboolean done;
-
-      it.next(&it);
-      cmd = stroke_itr_command(&it);
-      stroke_itr_coords(&it, coords);
-
-      debug_assert(cmd == VG_LINE_TO_ABS);
-      cline[0] = prev[0];
-      cline[1] = prev[1];
-      cline[2] = coords[0];
-      cline[3] = coords[1];
-
-      elen = line_lengthv(cline);
-
-      estop = estart + elen;
-
-      done = pos >= estop;
-      while (!done) {
-         VGfloat p2[2];
-
-         VGint idash_incr = 0;
-         VGboolean has_offset = doffset > 0;
-         VGfloat dpos = pos + dash_pattern(stroker, idash) - doffset - estart;
-
-         debug_assert(dpos >= 0);
-
-         if (dpos > elen) { /* dash extends this line */
-            doffset = dash_pattern(stroker, idash) - (dpos - elen);
-            pos = estop;
-            done = VG_TRUE;
-            p2[0] = cline[2];
-            p2[1] = cline[3];
-         } else { /* Dash is on this line */
-            line_point_at(cline, dpos/elen, p2);
-            pos = dpos + estart;
-            done = pos >= estop;
-            idash_incr = 1;
-            doffset = 0;
-         }
-
-         if (idash % 2 == 0) {
-            line_to_pos[0] = p2[0];
-            line_to_pos[1] = p2[1];
-
-            if (!has_offset || !has_move_to) {
-               stroker_move_to(&stroker->stroker, move_to_pos[0], move_to_pos[1]);
-               has_move_to = VG_TRUE;
-            }
-            stroker_line_to(&stroker->stroker, line_to_pos[0], line_to_pos[1]);
-         } else {
-            move_to_pos[0] = p2[0];
-            move_to_pos[1] = p2[1];
-         }
-
-         idash = (idash + idash_incr) % stroker->dash_pattern_num;
-      }
-
-      estart = estop;
-      prev[0] = coords[0];
-      prev[1] = coords[1];
-   }
-
-   if (it.curve_poly) {
-      polygon_destroy(it.curve_poly);
-      it.curve_poly = 0;
-   }
-
-   stroker->base.path = stroker->stroker.path;
-}
-
-static void default_begin(struct stroker *stroker)
-{
-   array_reset(stroker->segments);
-   array_reset(stroker->control_points);
-}
-
-static void default_end(struct stroker *stroker)
-{
-   if (stroker->segments->num_elements > 0)
-      stroker->process_subpath(stroker);
-}
-
-
-static void dash_stroker_begin(struct stroker *stroker)
-{
-   struct dash_stroker *dasher =
-      (struct dash_stroker *)stroker;
-
-   default_begin(&dasher->stroker);
-   default_begin(stroker);
-}
-
-static void dash_stroker_end(struct stroker *stroker)
-{
-   struct dash_stroker *dasher =
-      (struct dash_stroker *)stroker;
-
-   default_end(stroker);
-   default_end(&dasher->stroker);
-}
-
-void stroker_init(struct stroker *stroker,
-                  struct vg_state *state)
-{
-   stroker->stroke_width = state->stroke.line_width.f;
-   stroker->miter_limit = state->stroke.miter_limit.f;
-   stroker->cap_style = state->stroke.cap_style;
-   stroker->join_style = state->stroke.join_style;
-
-   stroker->begin = default_begin;
-   stroker->process_subpath = stroker_process_subpath;
-   stroker->end = default_end;
-
-   stroker->segments = array_create(sizeof(VGubyte));
-   stroker->control_points = array_create(sizeof(VGfloat));
-
-   stroker->back1_x = 0;
-   stroker->back1_y = 0;
-   stroker->back2_x = 0;
-   stroker->back2_y = 0;
-
-   stroker->path = path_create(VG_PATH_DATATYPE_F, 1.0f, 0.0f,
-                               0, 0, VG_PATH_CAPABILITY_ALL);
-
-   /* Initialize with an invalid value */
-   stroker->last_cmd = (VGPathCommand)0;
-}
-
-void dash_stroker_init(struct stroker *str,
-                       struct vg_state *state)
-{
-   struct dash_stroker *stroker = (struct dash_stroker *)str;
-   int i;
-
-   stroker_init(str, state);
-   stroker_init(&stroker->stroker, state);
-
-   {
-      int real_num = state->stroke.dash_pattern_num;
-      if (real_num % 2)/* if odd, ignore the last one */
-         --real_num;
-      for (i = 0; i < real_num; ++i)
-         stroker->dash_pattern[i] = state->stroke.dash_pattern[i].f;
-      stroker->dash_pattern_num = real_num;
-   }
-
-   stroker->dash_phase = state->stroke.dash_phase.f;
-   stroker->dash_phase_reset = state->stroke.dash_phase_reset;
-
-   stroker->base.begin = dash_stroker_begin;
-   stroker->base.process_subpath = dash_stroker_process_subpath;
-   stroker->base.end = dash_stroker_end;
-   path_destroy(stroker->base.path);
-   stroker->base.path = NULL;
-}
-
-void stroker_begin(struct stroker *stroker)
-{
-   stroker->begin(stroker);
-}
-
-void stroker_end(struct stroker *stroker)
-{
-   stroker->end(stroker);
-}
-
-void stroker_cleanup(struct stroker *stroker)
-{
-   array_destroy(stroker->segments);
-   array_destroy(stroker->control_points);
-}
-
-void dash_stroker_cleanup(struct dash_stroker *stroker)
-{
-   /* if stroker->base.path is null means we never
-    * processed a valid path so delete the temp one
-    * we already created */
-   if (!stroker->base.path)
-      path_destroy(stroker->stroker.path);
-   stroker_cleanup(&stroker->stroker);
-   stroker_cleanup((struct stroker*)stroker);
-}
diff --git a/src/gallium/state_trackers/vega/stroker.h b/src/gallium/state_trackers/vega/stroker.h
deleted file mode 100644
index 36543cd9237..00000000000
--- a/src/gallium/state_trackers/vega/stroker.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef STROKER_H
-#define STROKER_H
-
-#include "VG/openvg.h"
-#include "api_consts.h"
-
-struct path;
-struct vg_state;
-struct array;
-
-struct stroker {
-   void (*begin)(struct stroker *stroker);
-   void (*process_subpath)(struct stroker *stroker);
-   void (*end)(struct stroker *stroker);
-
-   struct array *segments;
-   struct array *control_points;
-   struct path *path;
-
-   VGfloat back1_x, back1_y;
-   VGfloat back2_x, back2_y;
-
-   VGfloat     stroke_width;
-   VGfloat     miter_limit;
-   VGCapStyle  cap_style;
-   VGJoinStyle join_style;
-
-   VGPathCommand last_cmd;
-};
-
-struct dash_stroker {
-   struct stroker base;
-
-   struct stroker stroker;
-
-   VGfloat dash_pattern[VEGA_MAX_DASH_COUNT];
-   VGint dash_pattern_num;
-   VGfloat dash_phase;
-   VGboolean dash_phase_reset;
-};
-
-void stroker_init(struct stroker *stroker,
-                  struct vg_state *state);
-void dash_stroker_init(struct stroker *stroker,
-                       struct vg_state *state);
-void dash_stroker_cleanup(struct dash_stroker *stroker);
-void stroker_cleanup(struct stroker *stroker);
-
-void stroker_begin(struct stroker *stroker);
-void stroker_move_to(struct stroker *stroker, VGfloat x, VGfloat y);
-void stroker_line_to(struct stroker *stroker, VGfloat x, VGfloat y);
-void stroker_curve_to(struct stroker *stroker, VGfloat px1, VGfloat py1,
-                      VGfloat px2, VGfloat py2,
-                      VGfloat x, VGfloat y);
-void stroker_end(struct stroker *stroker);
-
-void stroker_emit_move_to(struct stroker *stroker, VGfloat x, VGfloat y);
-void stroker_emit_line_to(struct stroker *stroker, VGfloat x, VGfloat y);
-void stroker_emit_curve_to(struct stroker *stroker, VGfloat px1, VGfloat py1,
-                           VGfloat px2, VGfloat py2,
-                           VGfloat x, VGfloat y);
-
-#endif
diff --git a/src/gallium/state_trackers/vega/text.c b/src/gallium/state_trackers/vega/text.c
deleted file mode 100644
index 3537f3fb8ac..00000000000
--- a/src/gallium/state_trackers/vega/text.c
+++ /dev/null
@@ -1,250 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2010 LunarG, 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 "util/u_memory.h"
-#include "cso_cache/cso_hash.h"
-
-#include "text.h"
-#include "image.h"
-#include "path.h"
-
-#ifdef OPENVG_VERSION_1_1
-
-struct vg_font {
-   struct vg_object base;
-   struct cso_hash *glyphs;
-};
-
-struct vg_glyph {
-   struct vg_object *object; /* it could be NULL */
-   VGboolean is_hinted;
-   VGfloat glyph_origin[2];
-   VGfloat escapement[2];
-};
-
-static VGboolean del_glyph(struct vg_font *font,
-                           VGuint glyphIndex)
-{
-   struct vg_glyph *glyph;
-
-   glyph = (struct vg_glyph *)
-      cso_hash_take(font->glyphs, (unsigned) glyphIndex);
-   FREE(glyph);
-
-   return (glyph != NULL);
-}
-
-static void add_glyph(struct vg_font *font,
-                      VGuint glyphIndex,
-                      struct vg_object *obj,
-                      VGboolean isHinted,
-                      const VGfloat glyphOrigin[2],
-                      const VGfloat escapement[2])
-{
-   struct vg_glyph *glyph;
-
-   /* remove the existing one */
-   del_glyph(font, glyphIndex);
-
-   glyph = CALLOC_STRUCT(vg_glyph);
-   glyph->object = obj;
-   glyph->is_hinted = isHinted;
-   memcpy(glyph->glyph_origin, glyphOrigin, sizeof(glyph->glyph_origin));
-   memcpy(glyph->escapement, escapement, sizeof(glyph->glyph_origin));
-
-   cso_hash_insert(font->glyphs, (unsigned) glyphIndex, glyph);
-}
-
-static struct vg_glyph *get_glyph(struct vg_font *font,
-                                  VGuint glyphIndex)
-{
-   struct cso_hash_iter iter;
-
-   iter = cso_hash_find(font->glyphs, (unsigned) glyphIndex);
-   return (struct vg_glyph *) cso_hash_iter_data(iter);
-}
-
-static void vg_render_glyph(struct vg_context *ctx,
-                            struct vg_glyph *glyph,
-                            VGbitfield paintModes,
-                            VGboolean allowAutoHinting)
-{
-   if (glyph->object && paintModes) {
-      struct vg_state *state = &ctx->state.vg;
-      struct matrix m;
-
-      m = state->glyph_user_to_surface_matrix;
-      matrix_translate(&m,
-            state->glyph_origin[0].f - glyph->glyph_origin[0],
-            state->glyph_origin[1].f - glyph->glyph_origin[1]);
-
-      if (glyph->object->type == VG_OBJECT_PATH) {
-         path_render((struct path *) glyph->object, paintModes, &m);
-      }
-      else {
-         assert(glyph->object->type == VG_OBJECT_IMAGE);
-         image_draw((struct vg_image *) glyph->object, &m);
-      }
-   }
-}
-
-static void vg_advance_glyph(struct vg_context *ctx,
-                             struct vg_glyph *glyph,
-                             VGfloat adjustment_x,
-                             VGfloat adjustment_y,
-                             VGboolean last)
-{
-   struct vg_value *glyph_origin = ctx->state.vg.glyph_origin;
-
-   glyph_origin[0].f += glyph->escapement[0] + adjustment_x;
-   glyph_origin[1].f += glyph->escapement[1] + adjustment_y;
-
-   if (last) {
-      glyph_origin[0].i = float_to_int_floor(glyph_origin[0].f);
-      glyph_origin[1].i = float_to_int_floor(glyph_origin[1].f);
-   }
-}
-
-struct vg_font *font_create(VGint glyphCapacityHint)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_font *font;
-
-   font = CALLOC_STRUCT(vg_font);
-   vg_init_object(&font->base, ctx, VG_OBJECT_FONT);
-   font->glyphs = cso_hash_create();
-
-   vg_context_add_object(ctx, &font->base);
-
-   return font;
-}
-
-void font_destroy(struct vg_font *font)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct cso_hash_iter iter;
-
-   vg_context_remove_object(ctx, &font->base);
-
-   iter = cso_hash_first_node(font->glyphs);
-   while (!cso_hash_iter_is_null(iter)) {
-      struct vg_glyph *glyph = (struct vg_glyph *) cso_hash_iter_data(iter);
-      FREE(glyph);
-      iter = cso_hash_iter_next(iter);
-   }
-   cso_hash_delete(font->glyphs);
-
-   vg_free_object(&font->base);
-
-   FREE(font);
-}
-
-void font_set_glyph_to_path(struct vg_font *font,
-                            VGuint glyphIndex,
-                            struct path *path,
-                            VGboolean isHinted,
-                            const VGfloat glyphOrigin[2],
-                            const VGfloat escapement[2])
-{
-   add_glyph(font, glyphIndex, (struct vg_object *) path,
-         isHinted, glyphOrigin, escapement);
-}
-
-void font_set_glyph_to_image(struct vg_font *font,
-                             VGuint glyphIndex,
-                             struct vg_image *image,
-                             const VGfloat glyphOrigin[2],
-                             const VGfloat escapement[2])
-{
-   add_glyph(font, glyphIndex, (struct vg_object *) image,
-         VG_TRUE, glyphOrigin, escapement);
-}
-
-void font_clear_glyph(struct vg_font *font,
-                      VGuint glyphIndex)
-{
-   if (!del_glyph(font, glyphIndex)) {
-      struct vg_context *ctx = vg_current_context();
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-   }
-}
-
-void font_draw_glyph(struct vg_font *font,
-                     VGuint glyphIndex,
-                     VGbitfield paintModes,
-                     VGboolean allowAutoHinting)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct vg_glyph *glyph;
-
-   glyph = get_glyph(font, glyphIndex);
-   if (!glyph) {
-      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-      return;
-   }
-
-   vg_render_glyph(ctx, glyph, paintModes, allowAutoHinting);
-   vg_advance_glyph(ctx, glyph, 0.0f, 0.0f, VG_TRUE);
-}
-
-void font_draw_glyphs(struct vg_font *font,
-                      VGint glyphCount,
-                      const VGuint *glyphIndices,
-                      const VGfloat *adjustments_x,
-                      const VGfloat *adjustments_y,
-                      VGbitfield paintModes,
-                      VGboolean allowAutoHinting)
-{
-   struct vg_context *ctx = vg_current_context();
-   VGint i;
-
-   for (i = 0; i < glyphCount; ++i) {
-      if (!get_glyph(font, glyphIndices[i])) {
-         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
-         return;
-      }
-   }
-
-   for (i = 0; i < glyphCount; ++i) {
-      struct vg_glyph *glyph;
-      VGfloat adj_x, adj_y;
-
-      glyph = get_glyph(font, glyphIndices[i]);
-
-      vg_render_glyph(ctx, glyph, paintModes, allowAutoHinting);
-
-      adj_x = (adjustments_x) ? adjustments_x[i] : 0.0f;
-      adj_y = (adjustments_y) ? adjustments_y[i] : 0.0f;
-      vg_advance_glyph(ctx, glyph, adj_x, adj_y, (i == glyphCount - 1));
-   }
-}
-
-VGint font_num_glyphs(struct vg_font *font)
-{
-   return cso_hash_size(font->glyphs);
-}
-
-#endif /* OPENVG_VERSION_1_1 */
diff --git a/src/gallium/state_trackers/vega/text.h b/src/gallium/state_trackers/vega/text.h
deleted file mode 100644
index 6b3fa7323e9..00000000000
--- a/src/gallium/state_trackers/vega/text.h
+++ /dev/null
@@ -1,71 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2010 LunarG, 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.
- *
- **************************************************************************/
-
-#ifndef _TEXT_H
-#define _TEXT_H
-
-#include "vg_context.h"
-#include "cso_cache/cso_hash.h"
-
-struct vg_font;
-struct vg_image;
-struct path;
-
-struct vg_font *font_create(VGint glyphCapacityHint);
-void font_destroy(struct vg_font *font);
-
-void font_set_glyph_to_path(struct vg_font *font,
-                            VGuint glyphIndex,
-                            struct path *path,
-                            VGboolean isHinted,
-                            const VGfloat glyphOrigin[2],
-                            const VGfloat escapement[2]);
-
-void font_set_glyph_to_image(struct vg_font *font,
-                             VGuint glyphIndex,
-                             struct vg_image *image,
-                             const VGfloat glyphOrigin[2],
-                             const VGfloat escapement[2]);
-
-void font_clear_glyph(struct vg_font *font,
-                      VGuint glyphIndex);
-
-void font_draw_glyph(struct vg_font *font,
-                     VGuint glyphIndex,
-                     VGbitfield paintModes,
-                     VGboolean allowAutoHinting);
-
-void font_draw_glyphs(struct vg_font *font,
-                      VGint glyphCount,
-                      const VGuint *glyphIndices,
-                      const VGfloat *adjustments_x,
-                      const VGfloat *adjustments_y,
-                      VGbitfield paintModes,
-                      VGboolean allowAutoHinting);
-
-VGint font_num_glyphs(struct vg_font *font);
-
-#endif /* _TEXT_H */
diff --git a/src/gallium/state_trackers/vega/util_array.h b/src/gallium/state_trackers/vega/util_array.h
deleted file mode 100644
index b2d22f476ee..00000000000
--- a/src/gallium/state_trackers/vega/util_array.h
+++ /dev/null
@@ -1,122 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef UTIL_ARRAY_H
-#define UTIL_ARRAY_H
-
-#include "util/u_memory.h"
-
-#define DEFAULT_ARRAY_SIZE 256
-
-struct array {
-   VGint          datatype_size;
-   void          *data;
-   VGint          size;
-   VGint          num_elements;
-};
-
-static INLINE struct array *array_create(VGint datatype_size)
-{
-   struct array *array = CALLOC_STRUCT(array);
-   array->datatype_size = datatype_size;
-
-   array->size = DEFAULT_ARRAY_SIZE;
-   array->data = malloc(array->size * array->datatype_size);
-
-   return array;
-}
-
-
-static INLINE struct array *array_create_size(VGint datatype_size, VGint size)
-{
-   struct array *array = CALLOC_STRUCT(array);
-   array->datatype_size = datatype_size;
-
-   array->size = size;
-   array->data = malloc(array->size * array->datatype_size);
-
-   return array;
-}
-
-static INLINE void array_destroy(struct array *array)
-{
-   if (array)
-      free(array->data);
-   FREE(array);
-}
-
-static INLINE void array_resize(struct array *array, int num)
-{
-   VGint size = array->datatype_size * num;
-   void *data = malloc(size);
-   memcpy(data, array->data, array->size * array->datatype_size);
-   free(array->data);
-   array->data = data;
-   array->size = num;
-   array->num_elements = (array->num_elements > num) ? num :
-                         array->num_elements;
-}
-
-static INLINE void array_append_data(struct array *array,
-                              const void *data, int num_elements)
-{
-   VGbyte *adata;
-
-   while (array->num_elements + num_elements > array->size) {
-      array_resize(array, (array->num_elements + num_elements) * 1.5);
-   }
-   adata = (VGbyte *)array->data;
-   memcpy(adata + (array->num_elements * array->datatype_size), data,
-          num_elements * array->datatype_size);
-   array->num_elements += num_elements;
-}
-
-static INLINE void array_change_data(struct array *array,
-                              const void *data,
-                              int start_idx,
-                              int num_elements)
-{
-   VGbyte *adata = (VGbyte *)array->data;
-   memcpy(adata + (start_idx * array->datatype_size), data,
-          num_elements * array->datatype_size);
-}
-
-static INLINE void array_remove_element(struct array *array,
-                                        int idx)
-{
-   VGbyte *adata = (VGbyte *)array->data;
-   memmove(adata + (idx * array->datatype_size),
-           adata + ((idx + 1) * array->datatype_size),
-           (array->num_elements - idx - 1) * array->datatype_size);
-   --array->num_elements;
-}
-
-static INLINE void array_reset(struct array *array)
-{
-   array->num_elements = 0;
-}
-
-#endif
diff --git a/src/gallium/state_trackers/vega/vg_api.h b/src/gallium/state_trackers/vega/vg_api.h
deleted file mode 100644
index e97e238b849..00000000000
--- a/src/gallium/state_trackers/vega/vg_api.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Mesa 3-D graphics library
- *
- * Copyright (C) 2010 LunarG Inc.
- *
- * 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.
- *
- * Authors:
- *    Chia-I Wu <[email protected]>
- */
-
-#ifndef VG_API_H
-#define VG_API_H
-
-struct st_api;
-
-const struct st_api *
-vg_api_get(void);
-
-#endif /* VG_API_H */
diff --git a/src/gallium/state_trackers/vega/vg_context.c b/src/gallium/state_trackers/vega/vg_context.c
deleted file mode 100644
index 48a03c5a64a..00000000000
--- a/src/gallium/state_trackers/vega/vg_context.c
+++ /dev/null
@@ -1,537 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "vg_context.h"
-
-#include "paint.h"
-#include "renderer.h"
-#include "shaders_cache.h"
-#include "shader.h"
-#include "vg_manager.h"
-#include "api.h"
-#include "mask.h"
-#include "handle.h"
-
-#include "pipe/p_context.h"
-#include "util/u_inlines.h"
-
-#include "cso_cache/cso_context.h"
-
-#include "util/u_memory.h"
-#include "util/u_sampler.h"
-#include "util/u_surface.h"
-#include "util/u_format.h"
-
-struct vg_context *_vg_context = 0;
-
-struct vg_context * vg_current_context(void)
-{
-   return _vg_context;
-}
-
-/**
- * A depth/stencil rb will be needed regardless of what the visual says.
- */
-static boolean
-choose_depth_stencil_format(struct vg_context *ctx)
-{
-   struct pipe_screen *screen = ctx->pipe->screen;
-   enum pipe_format formats[] = {
-      PIPE_FORMAT_Z24_UNORM_S8_UINT,
-      PIPE_FORMAT_S8_UINT_Z24_UNORM,
-      PIPE_FORMAT_NONE
-   };
-   enum pipe_format *fmt;
-
-   for (fmt = formats; *fmt != PIPE_FORMAT_NONE; fmt++) {
-      if (screen->is_format_supported(screen, *fmt,
-               PIPE_TEXTURE_2D, 0, PIPE_BIND_DEPTH_STENCIL))
-         break;
-   }
-
-   ctx->ds_format = *fmt;
-
-   return (ctx->ds_format != PIPE_FORMAT_NONE);
-}
-
-void vg_set_current_context(struct vg_context *ctx)
-{
-   _vg_context = ctx;
-   api_make_dispatch_current((ctx) ? ctx->dispatch : NULL);
-}
-
-struct vg_context * vg_create_context(struct pipe_context *pipe,
-                                      const void *visual,
-                                      struct vg_context *share)
-{
-   struct vg_context *ctx;
-
-   ctx = CALLOC_STRUCT(vg_context);
-
-   ctx->pipe = pipe;
-   if (!choose_depth_stencil_format(ctx)) {
-      FREE(ctx);
-      return NULL;
-   }
-
-   ctx->dispatch = api_create_dispatch();
-
-   vg_init_state(&ctx->state.vg);
-   ctx->state.dirty = ALL_DIRTY;
-
-   ctx->cso_context = cso_create_context(pipe);
-
-   ctx->default_paint = paint_create(ctx);
-   ctx->state.vg.stroke_paint = ctx->default_paint;
-   ctx->state.vg.fill_paint = ctx->default_paint;
-
-
-   ctx->mask.sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-   ctx->mask.sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-   ctx->mask.sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-   ctx->mask.sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
-   ctx->mask.sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
-   ctx->mask.sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
-   ctx->mask.sampler.normalized_coords = 0;
-
-   ctx->blend_sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-   ctx->blend_sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-   ctx->blend_sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-   ctx->blend_sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
-   ctx->blend_sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
-   ctx->blend_sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
-   ctx->blend_sampler.normalized_coords = 0;
-
-   vg_set_error(ctx, VG_NO_ERROR);
-
-   ctx->owned_objects[VG_OBJECT_PAINT] = cso_hash_create();
-   ctx->owned_objects[VG_OBJECT_IMAGE] = cso_hash_create();
-   ctx->owned_objects[VG_OBJECT_MASK] = cso_hash_create();
-   ctx->owned_objects[VG_OBJECT_FONT] = cso_hash_create();
-   ctx->owned_objects[VG_OBJECT_PATH] = cso_hash_create();
-
-   ctx->renderer = renderer_create(ctx);
-   ctx->sc = shaders_cache_create(ctx);
-   ctx->shader = shader_create(ctx);
-
-   return ctx;
-}
-
-void vg_destroy_context(struct vg_context *ctx)
-{
-   struct pipe_resource **cbuf = &ctx->mask.cbuf;
-
-   renderer_destroy(ctx->renderer);
-   shaders_cache_destroy(ctx->sc);
-   shader_destroy(ctx->shader);
-   paint_destroy(ctx->default_paint);
-
-   if (*cbuf)
-      pipe_resource_reference(cbuf, NULL);
-
-   if (ctx->mask.union_fs)
-      vg_shader_destroy(ctx, ctx->mask.union_fs);
-   if (ctx->mask.intersect_fs)
-      vg_shader_destroy(ctx, ctx->mask.intersect_fs);
-   if (ctx->mask.subtract_fs)
-      vg_shader_destroy(ctx, ctx->mask.subtract_fs);
-   if (ctx->mask.set_fs)
-      vg_shader_destroy(ctx, ctx->mask.set_fs);
-
-   cso_destroy_context(ctx->cso_context);
-
-   cso_hash_delete(ctx->owned_objects[VG_OBJECT_PAINT]);
-   cso_hash_delete(ctx->owned_objects[VG_OBJECT_IMAGE]);
-   cso_hash_delete(ctx->owned_objects[VG_OBJECT_MASK]);
-   cso_hash_delete(ctx->owned_objects[VG_OBJECT_FONT]);
-   cso_hash_delete(ctx->owned_objects[VG_OBJECT_PATH]);
-
-   api_destroy_dispatch(ctx->dispatch);
-
-   FREE(ctx);
-}
-
-void vg_init_object(struct vg_object *obj, struct vg_context *ctx, enum vg_object_type type)
-{
-   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,
-                                VGHandle handle)
-{
-    if (ctx) {
-       struct cso_hash *hash = ctx->owned_objects[type];
-       if (!hash)
-          return VG_FALSE;
-       return cso_hash_contains(hash, (unsigned) handle);
-    }
-    return VG_FALSE;
-}
-
-void vg_context_add_object(struct vg_context *ctx,
-                           struct vg_object *obj)
-{
-    if (ctx) {
-       struct cso_hash *hash = ctx->owned_objects[obj->type];
-       if (!hash)
-          return;
-       cso_hash_insert(hash, (unsigned) obj->handle, obj);
-    }
-}
-
-void vg_context_remove_object(struct vg_context *ctx,
-                              struct vg_object *obj)
-{
-   if (ctx) {
-      struct cso_hash *hash = ctx->owned_objects[obj->type];
-      if (!hash)
-         return;
-      cso_hash_take(hash, (unsigned) obj->handle);
-   }
-}
-
-static struct pipe_resource *
-create_texture(struct pipe_context *pipe, enum pipe_format format,
-                    VGint width, VGint height)
-{
-   struct pipe_resource templ;
-
-   memset(&templ, 0, sizeof(templ));
-
-   if (format != PIPE_FORMAT_NONE) {
-      templ.format = format;
-   }
-   else {
-      templ.format = PIPE_FORMAT_B8G8R8A8_UNORM;
-   }
-
-   templ.target = PIPE_TEXTURE_2D;
-   templ.width0 = width;
-   templ.height0 = height;
-   templ.depth0 = 1;
-   templ.array_size = 1;
-   templ.last_level = 0;
-
-   if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 1)) {
-      templ.bind = PIPE_BIND_DEPTH_STENCIL;
-   } else {
-      templ.bind = (PIPE_BIND_DISPLAY_TARGET |
-                    PIPE_BIND_RENDER_TARGET |
-                    PIPE_BIND_SAMPLER_VIEW);
-   }
-
-   return pipe->screen->resource_create(pipe->screen, &templ);
-}
-
-static struct pipe_sampler_view *
-create_tex_and_view(struct pipe_context *pipe, enum pipe_format format,
-                    VGint width, VGint height)
-{
-   struct pipe_resource *texture;
-   struct pipe_sampler_view view_templ;
-   struct pipe_sampler_view *view;
-
-   texture = create_texture(pipe, format, width, height);
-
-   if (!texture)
-      return NULL;
-
-   u_sampler_view_default_template(&view_templ, texture, texture->format);
-   view = pipe->create_sampler_view(pipe, texture, &view_templ);
-   /* want the texture to go away if the view is freed */
-   pipe_resource_reference(&texture, NULL);
-
-   return view;
-}
-
-static void
-vg_context_update_surface_mask_view(struct vg_context *ctx,
-                                    uint width, uint height)
-{
-   struct st_framebuffer *stfb = ctx->draw_buffer;
-   struct pipe_sampler_view *old_sampler_view = stfb->surface_mask_view;
-   struct pipe_context *pipe = ctx->pipe;
-
-   if (old_sampler_view &&
-       old_sampler_view->texture->width0 == width &&
-       old_sampler_view->texture->height0 == height)
-      return;
-
-   /*
-     we use PIPE_FORMAT_B8G8R8A8_UNORM because we want to render to
-     this texture and use it as a sampler, so while this wastes some
-     space it makes both of those a lot simpler
-   */
-   stfb->surface_mask_view = create_tex_and_view(pipe,
-         PIPE_FORMAT_B8G8R8A8_UNORM, width, height);
-
-   if (!stfb->surface_mask_view) {
-      if (old_sampler_view)
-         pipe_sampler_view_reference(&old_sampler_view, NULL);
-      return;
-   }
-
-   /* XXX could this call be avoided? */
-   vg_validate_state(ctx);
-
-   /* alpha mask starts with 1.f alpha */
-   mask_fill(0, 0, width, height, 1.f);
-
-   /* if we had an old surface copy it over */
-   if (old_sampler_view) {
-      struct pipe_box src_box;
-      u_box_origin_2d(MIN2(old_sampler_view->texture->width0,
-                           stfb->surface_mask_view->texture->width0),
-                      MIN2(old_sampler_view->texture->height0,
-                           stfb->surface_mask_view->texture->height0),
-                      &src_box);
-
-      pipe->resource_copy_region(pipe,
-                                 stfb->surface_mask_view->texture,
-                                 0, 0, 0, 0,
-                                 old_sampler_view->texture,
-                                 0, &src_box);
-   }
-
-   /* Free the old texture
-    */
-   if (old_sampler_view)
-      pipe_sampler_view_reference(&old_sampler_view, NULL);
-}
-
-static void
-vg_context_update_blend_texture_view(struct vg_context *ctx,
-                                     uint width, uint height)
-{
-   struct pipe_context *pipe = ctx->pipe;
-   struct st_framebuffer *stfb = ctx->draw_buffer;
-   struct pipe_sampler_view *old = stfb->blend_texture_view;
-
-   if (old &&
-       old->texture->width0 == width &&
-       old->texture->height0 == height)
-      return;
-
-   stfb->blend_texture_view = create_tex_and_view(pipe,
-         PIPE_FORMAT_B8G8R8A8_UNORM, width, height);
-
-   pipe_sampler_view_reference(&old, NULL);
-}
-
-static boolean
-vg_context_update_depth_stencil_rb(struct vg_context * ctx,
-                                   uint width, uint height)
-{
-   struct st_renderbuffer *dsrb = ctx->draw_buffer->dsrb;
-   struct pipe_context *pipe = ctx->pipe;
-   struct pipe_surface surf_tmpl;
-
-   if ((dsrb->width == width && dsrb->height == height) && dsrb->texture)
-      return FALSE;
-
-   /* unreference existing ones */
-   pipe_surface_reference(&dsrb->surface, NULL);
-   pipe_resource_reference(&dsrb->texture, NULL);
-   dsrb->width = dsrb->height = 0;
-
-   dsrb->texture = create_texture(pipe, dsrb->format, width, height);
-   if (!dsrb->texture)
-      return TRUE;
-
-   u_surface_default_template(&surf_tmpl, dsrb->texture);
-   dsrb->surface = pipe->create_surface(pipe,
-                                        dsrb->texture,
-                                        &surf_tmpl);
-   if (!dsrb->surface) {
-      pipe_resource_reference(&dsrb->texture, NULL);
-      return TRUE;
-   }
-
-   dsrb->width = width;
-   dsrb->height = height;
-
-   assert(dsrb->surface->width == width);
-   assert(dsrb->surface->height == height);
-
-   return TRUE;
-}
-
-void vg_validate_state(struct vg_context *ctx)
-{
-   struct st_framebuffer *stfb = ctx->draw_buffer;
-
-   vg_manager_validate_framebuffer(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 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,
-         ctx->draw_buffer, &ctx->state.vg);
-
-   ctx->state.dirty = 0;
-
-   shader_set_masking(ctx->shader, ctx->state.vg.masking);
-   shader_set_image_mode(ctx->shader, ctx->state.vg.image_mode);
-   shader_set_color_transform(ctx->shader, ctx->state.vg.color_transform);
-}
-
-VGboolean vg_object_is_valid(VGHandle object, enum vg_object_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;
-}
-
-void vg_set_error(struct vg_context *ctx,
-                  VGErrorCode code)
-{
-   /*vgGetError returns the oldest error code provided by
-    * an API call on the current context since the previous
-    * call to vgGetError on that context (or since the creation
-    of the context).*/
-   if (ctx->_error == VG_NO_ERROR)
-      ctx->_error = code;
-}
-
-static void vg_prepare_blend_texture(struct vg_context *ctx,
-                                     struct pipe_sampler_view *src)
-{
-   struct st_framebuffer *stfb = ctx->draw_buffer;
-   struct pipe_context *pipe = ctx->pipe;
-   struct pipe_blit_info info;
-
-   vg_context_update_blend_texture_view(ctx, stfb->width, stfb->height);
-
-   memset(&info, 0, sizeof info);
-   info.dst.resource = stfb->blend_texture_view->texture;
-   info.dst.level = 0;
-   info.dst.box.x = 0;
-   info.dst.box.y = 0;
-   info.dst.box.z = 0;
-   info.dst.box.width = stfb->width;
-   info.dst.box.height = stfb->height;
-   info.dst.box.depth = 1;
-   info.dst.format = stfb->blend_texture_view->format;
-   info.src.resource = src->texture;
-   info.src.level = src->u.tex.first_level;
-   info.src.box.x = 0;
-   info.src.box.y = 0;
-   info.src.box.z = src->u.tex.first_layer;
-   info.src.box.width = stfb->width;
-   info.src.box.height = stfb->height;
-   info.src.box.depth = 1;
-   info.src.format = src->format;
-   info.mask = PIPE_MASK_RGBA;
-   info.filter = PIPE_TEX_MIPFILTER_NEAREST;
-   info.scissor_enable = 0;
-
-   pipe->blit(pipe, &info);
-}
-
-struct pipe_sampler_view *vg_prepare_blend_surface(struct vg_context *ctx)
-{
-   struct pipe_context *pipe = ctx->pipe;
-   struct pipe_sampler_view *view;
-   struct pipe_sampler_view view_templ;
-   struct st_framebuffer *stfb = ctx->draw_buffer;
-   struct st_renderbuffer *strb = stfb->strb;
-
-   vg_validate_state(ctx);
-
-   u_sampler_view_default_template(&view_templ, strb->texture, strb->texture->format);
-   view = pipe->create_sampler_view(pipe, strb->texture, &view_templ);
-
-   vg_prepare_blend_texture(ctx, view);
-
-   pipe_sampler_view_reference(&view, NULL);
-
-   return stfb->blend_texture_view;
-}
-
-
-struct pipe_sampler_view *vg_prepare_blend_surface_from_mask(struct vg_context *ctx)
-{
-   struct st_framebuffer *stfb = ctx->draw_buffer;
-
-   vg_validate_state(ctx);
-
-   vg_context_update_surface_mask_view(ctx, stfb->width, stfb->height);
-   vg_prepare_blend_texture(ctx, stfb->surface_mask_view);
-
-   return stfb->blend_texture_view;
-}
-
-struct pipe_sampler_view *vg_get_surface_mask(struct vg_context *ctx)
-{
-   struct st_framebuffer *stfb = ctx->draw_buffer;
-
-   vg_context_update_surface_mask_view(ctx, stfb->width, stfb->height);
-
-   return stfb->surface_mask_view;
-}
-
-/**
- * A transformation from window coordinates to paint coordinates.
- */
-VGboolean vg_get_paint_matrix(struct vg_context *ctx,
-                              const struct matrix *paint_to_user,
-                              const struct matrix *user_to_surface,
-                              struct matrix *mat)
-{
-   struct matrix tmp;
-
-   /* get user-to-paint matrix */
-   memcpy(mat, paint_to_user, sizeof(*paint_to_user));
-   if (!matrix_invert(mat))
-      return VG_FALSE;
-
-   /* get surface-to-user matrix */
-   memcpy(&tmp, user_to_surface, sizeof(*user_to_surface));
-   if (!matrix_invert(&tmp))
-      return VG_FALSE;
-
-   matrix_mult(mat, &tmp);
-
-   return VG_TRUE;
-}
diff --git a/src/gallium/state_trackers/vega/vg_context.h b/src/gallium/state_trackers/vega/vg_context.h
deleted file mode 100644
index 5a2a322743d..00000000000
--- a/src/gallium/state_trackers/vega/vg_context.h
+++ /dev/null
@@ -1,280 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef VG_CONTEXT_H
-#define VG_CONTEXT_H
-
-#include "vg_state.h"
-
-#include "pipe/p_format.h"
-#include "pipe/p_state.h"
-#include "util/u_pointer.h"
-#include "util/u_math.h"
-#include "state_tracker/st_api.h"
-
-#include "cso_cache/cso_hash.h"
-#include "cso_cache/cso_context.h"
-
-struct renderer;
-struct shaders_cache;
-struct shader;
-struct vg_shader;
-struct mapi_table;
-
-struct st_renderbuffer {
-   enum pipe_format   format;
-   struct pipe_surface *surface;
-   struct pipe_resource *texture;
-   VGint width, height;
-};
-
-struct st_framebuffer {
-   VGint width, height;
-   struct st_renderbuffer *strb;
-   struct st_renderbuffer *dsrb;
-
-   struct pipe_sampler_view *surface_mask_view;
-
-   struct pipe_sampler_view *blend_texture_view;
-
-
-   struct st_framebuffer_iface *iface;
-   enum st_attachment_type strb_att;
-
-   void *privateData;
-   int32_t stamp;
-   int32_t iface_stamp;
-};
-
-enum vg_object_type {
-   VG_OBJECT_UNKNOWN = 0,
-   VG_OBJECT_PAINT,
-   VG_OBJECT_IMAGE,
-   VG_OBJECT_MASK,
-   VG_OBJECT_FONT,
-   VG_OBJECT_PATH,
-
-   VG_OBJECT_LAST
-};
-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 |
-                         PAINT_DIRTY
-};
-
-struct vg_context
-{
-   struct st_context_iface iface;
-   struct mapi_table *dispatch;
-
-   struct pipe_context *pipe;
-   enum pipe_format ds_format;
-
-   struct {
-      struct vg_state vg;
-      VGbitfield dirty;
-   } state;
-
-   VGErrorCode _error;
-
-   struct st_framebuffer *draw_buffer;
-
-   struct cso_hash *owned_objects[VG_OBJECT_LAST];
-
-   struct {
-      struct pipe_resource *cbuf;
-      struct pipe_sampler_state sampler;
-
-      struct vg_shader *union_fs;
-      struct vg_shader *intersect_fs;
-      struct vg_shader *subtract_fs;
-      struct vg_shader *set_fs;
-   } mask;
-
-   struct cso_context *cso_context;
-
-   struct renderer *renderer;
-   struct shaders_cache *sc;
-   struct shader *shader;
-
-   struct pipe_sampler_state blend_sampler;
-   struct vg_paint *default_paint;
-
-   int32_t draw_stamp;
-};
-
-
-/**
- *  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);
-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,
-                                     struct vg_context *share);
-void vg_destroy_context(struct vg_context *ctx);
-struct vg_context *vg_current_context(void);
-void vg_set_current_context(struct vg_context *ctx);
-
-VGboolean vg_context_is_object_valid(struct vg_context *ctx,
-                                     enum vg_object_type type,
-                                     VGHandle object);
-void vg_context_add_object(struct vg_context *ctx,
-                           struct vg_object *obj);
-void vg_context_remove_object(struct vg_context *ctx,
-                              struct vg_object *obj);
-
-void vg_validate_state(struct vg_context *ctx);
-
-void vg_set_error(struct vg_context *ctx,
-                  VGErrorCode code);
-
-struct pipe_sampler_view *vg_prepare_blend_surface(struct vg_context *ctx);
-struct pipe_sampler_view *vg_prepare_blend_surface_from_mask(struct vg_context *ctx);
-
-struct pipe_sampler_view *vg_get_surface_mask(struct vg_context *ctx);
-
-VGboolean vg_get_paint_matrix(struct vg_context *ctx,
-                              const struct matrix *paint_to_user,
-                              const struct matrix *user_to_surface,
-                              struct matrix *mat);
-
-static INLINE VGboolean is_aligned_to(const void *ptr, VGbyte alignment)
-{
-   void *aligned = align_pointer(ptr, alignment);
-   return (ptr == aligned) ? VG_TRUE : VG_FALSE;
-}
-
-static INLINE VGboolean is_aligned(const void *ptr)
-{
-   return is_aligned_to(ptr, 4);
-}
-
-static INLINE void vg_shift_rectx(VGfloat coords[4],
-                                 const VGfloat *bounds,
-                                 const VGfloat shift)
-{
-   coords[0] += shift;
-   coords[2] -= shift;
-   if (bounds) {
-      coords[2] = MIN2(coords[2], bounds[2]);
-      /* bound x/y + width/height */
-      if ((coords[0] + coords[2]) > (bounds[0] + bounds[2])) {
-         coords[2] = (bounds[0] + bounds[2]) - coords[0];
-      }
-   }
-}
-
-static INLINE void vg_shift_recty(VGfloat coords[4],
-                                 const VGfloat *bounds,
-                                 const VGfloat shift)
-{
-   coords[1] += shift;
-   coords[3] -= shift;
-   if (bounds) {
-      coords[3] = MIN2(coords[3], bounds[3]);
-      if ((coords[1] + coords[3]) > (bounds[1] + bounds[3])) {
-         coords[3] = (bounds[1] + bounds[3]) - coords[1];
-      }
-   }
-}
-
-static INLINE void vg_bound_rect(VGfloat coords[4],
-                                 const VGfloat bounds[4],
-                                 VGfloat shift[4])
-{
-   /* if outside the bounds */
-   if (coords[0] > (bounds[0] + bounds[2]) ||
-       coords[1] > (bounds[1] + bounds[3]) ||
-       (coords[0] + coords[2]) < bounds[0] ||
-       (coords[1] + coords[3]) < bounds[1]) {
-      coords[0] = 0.f;
-      coords[1] = 0.f;
-      coords[2] = 0.f;
-      coords[3] = 0.f;
-      shift[0] = 0.f;
-      shift[1] = 0.f;
-      return;
-   }
-
-   /* bound x */
-   if (coords[0] < bounds[0]) {
-      shift[0] = bounds[0] - coords[0];
-      coords[2] -= shift[0];
-      coords[0] = bounds[0];
-   } else
-      shift[0] = 0.f;
-
-   /* bound y */
-   if (coords[1] < bounds[1]) {
-      shift[1] = bounds[1] - coords[1];
-      coords[3] -= shift[1];
-      coords[1] = bounds[1];
-   } else
-      shift[1] = 0.f;
-
-   shift[2] = bounds[2] - coords[2];
-   shift[3] = bounds[3] - coords[3];
-   /* bound width/height */
-   coords[2] = MIN2(coords[2], bounds[2]);
-   coords[3] = MIN2(coords[3], bounds[3]);
-
-   /* bound x/y + width/height */
-   if ((coords[0] + coords[2]) > (bounds[0] + bounds[2])) {
-      coords[2] = (bounds[0] + bounds[2]) - coords[0];
-   }
-   if ((coords[1] + coords[3]) > (bounds[1] + bounds[3])) {
-      coords[3] = (bounds[1] + bounds[3]) - coords[1];
-   }
-
-   /* if outside the bounds */
-   if ((coords[0] + coords[2]) < bounds[0] ||
-       (coords[1] + coords[3]) < bounds[1]) {
-      coords[0] = 0.f;
-      coords[1] = 0.f;
-      coords[2] = 0.f;
-      coords[3] = 0.f;
-      return;
-   }
-}
-
-#endif
diff --git a/src/gallium/state_trackers/vega/vg_manager.c b/src/gallium/state_trackers/vega/vg_manager.c
deleted file mode 100644
index 7960b0692c3..00000000000
--- a/src/gallium/state_trackers/vega/vg_manager.c
+++ /dev/null
@@ -1,399 +0,0 @@
-/*
- * Mesa 3-D graphics library
- *
- * Copyright 2009 VMware, Inc.  All Rights Reserved.
- * Copyright (C) 2010 LunarG Inc.
- *
- * 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.
- *
- * Authors:
- *    Chia-I Wu <[email protected]>
- */
-
-#include "state_tracker/st_api.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_screen.h"
-#include "util/u_memory.h"
-#include "util/u_inlines.h"
-#include "util/u_box.h"
-#include "util/u_surface.h"
-
-#include "vg_api.h"
-#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)
-{
-   struct st_renderbuffer *strb = ctx->draw_buffer->strb;
-   struct pipe_context *pipe = ctx->pipe;
-   struct pipe_surface surf_tmpl;
-
-   if (strb->texture == pt) {
-      pipe_resource_reference(&pt, NULL);
-      return FALSE;
-   }
-
-   /* unreference existing ones */
-   pipe_surface_reference(&strb->surface, NULL);
-   pipe_resource_reference(&strb->texture, NULL);
-   strb->width = strb->height = 0;
-
-   strb->texture = pt;
-
-   u_surface_default_template(&surf_tmpl, strb->texture);
-   strb->surface = pipe->create_surface(pipe, strb->texture, &surf_tmpl);
-
-   if (!strb->surface) {
-      pipe_resource_reference(&strb->texture, NULL);
-      return TRUE;
-   }
-
-   strb->width = pt->width0;
-   strb->height = pt->height0;
-
-   return TRUE;
-}
-
-/**
- * Flush the front buffer if the current context renders to the front buffer.
- */
-void
-vg_manager_flush_frontbuffer(struct vg_context *ctx)
-{
-   struct st_framebuffer *stfb = ctx->draw_buffer;
-
-   if (!stfb)
-      return;
-
-   switch (stfb->strb_att) {
-   case ST_ATTACHMENT_FRONT_LEFT:
-   case ST_ATTACHMENT_FRONT_RIGHT:
-      stfb->iface->flush_front(&ctx->iface, stfb->iface, stfb->strb_att);
-      break;
-   default:
-      break;
-   }
-}
-
-/**
- * Re-validate the framebuffer.
- */
-void
-vg_manager_validate_framebuffer(struct vg_context *ctx)
-{
-   struct st_framebuffer *stfb = ctx->draw_buffer;
-   struct pipe_resource *pt;
-   int32_t new_stamp;
-
-   /* no binding surface */
-   if (!stfb)
-      return;
-
-   new_stamp = p_atomic_read(&stfb->iface->stamp);
-   if (stfb->iface_stamp != new_stamp) {
-      do {
-	 /* validate the fb */
-	 if (!stfb->iface->validate((struct st_context_iface *)ctx,
-				    stfb->iface, &stfb->strb_att,
-				    1, &pt) || !pt)
-	    return;
-
-	 stfb->iface_stamp = new_stamp;
-	 new_stamp = p_atomic_read(&stfb->iface->stamp);
-
-      } while (stfb->iface_stamp != new_stamp);
-
-      if (vg_context_update_color_rb(ctx, pt) ||
-          stfb->width != pt->width0 ||
-          stfb->height != pt->height0)
-         ++stfb->stamp;
-
-      stfb->width = pt->width0;
-      stfb->height = pt->height0;
-   }
-
-   if (ctx->draw_stamp != stfb->stamp) {
-      ctx->state.dirty |= FRAMEBUFFER_DIRTY;
-      ctx->draw_stamp = stfb->stamp;
-   }
-}
-
-static void
-vg_context_flush(struct st_context_iface *stctxi, unsigned flags,
-                 struct pipe_fence_handle **fence)
-{
-   struct vg_context *ctx = (struct vg_context *) stctxi;
-   unsigned pipe_flags = 0;
-
-   if (flags & ST_FLUSH_END_OF_FRAME) {
-      pipe_flags |= PIPE_FLUSH_END_OF_FRAME;
-   }
-
-   ctx->pipe->flush(ctx->pipe, fence, pipe_flags);
-   if (flags & ST_FLUSH_FRONT)
-      vg_manager_flush_frontbuffer(ctx);
-}
-
-static void
-vg_context_destroy(struct st_context_iface *stctxi)
-{
-   struct vg_context *ctx = (struct vg_context *) stctxi;
-   struct pipe_context *pipe = ctx->pipe;
-
-   vg_destroy_context(ctx);
-   pipe->destroy(pipe);
-}
-
-static struct st_context_iface *
-vg_api_create_context(struct st_api *stapi, struct st_manager *smapi,
-                      const struct st_context_attribs *attribs,
-                      enum st_context_error *error,
-                      struct st_context_iface *shared_stctxi)
-{
-   struct vg_context *shared_ctx = (struct vg_context *) shared_stctxi;
-   struct vg_context *ctx;
-   struct pipe_context *pipe;
-
-   if (!(stapi->profile_mask & (1 << attribs->profile))) {
-      *error = ST_CONTEXT_ERROR_BAD_API;
-      return NULL;
-   }
-
-   /* only 1.0 is supported */
-   if (attribs->major > 1 || (attribs->major == 1 && attribs->minor > 0)) {
-      *error = ST_CONTEXT_ERROR_BAD_VERSION;
-      return NULL;
-   }
-
-   /* for VGHandle / pointer lookups */
-   init_handles();
-
-   pipe = smapi->screen->context_create(smapi->screen, NULL);
-   if (!pipe) {
-      *error = ST_CONTEXT_ERROR_NO_MEMORY;
-      return NULL;
-   }
-   ctx = vg_create_context(pipe, NULL, shared_ctx);
-   if (!ctx) {
-      pipe->destroy(pipe);
-      *error = ST_CONTEXT_ERROR_NO_MEMORY;
-      return NULL;
-   }
-
-   ctx->iface.destroy = vg_context_destroy;
-
-   ctx->iface.flush = vg_context_flush;
-
-   ctx->iface.teximage = NULL;
-   ctx->iface.copy = NULL;
-
-   ctx->iface.st_context_private = (void *) smapi;
-
-   return &ctx->iface;
-}
-
-static struct st_renderbuffer *
-create_renderbuffer(enum pipe_format format)
-{
-   struct st_renderbuffer *strb;
-
-   strb = CALLOC_STRUCT(st_renderbuffer);
-   if (strb)
-      strb->format = format;
-
-   return strb;
-}
-
-static void
-destroy_renderbuffer(struct st_renderbuffer *strb)
-{
-   pipe_surface_reference(&strb->surface, NULL);
-   pipe_resource_reference(&strb->texture, NULL);
-   FREE(strb);
-}
-
-/**
- * Decide the buffer to render to.
- */
-static enum st_attachment_type
-choose_attachment(struct st_framebuffer_iface *stfbi)
-{
-   enum st_attachment_type statt;
-
-   statt = stfbi->visual->render_buffer;
-   if (statt != ST_ATTACHMENT_INVALID) {
-      /* use the buffer given by the visual, unless it is unavailable */
-      if (!st_visual_have_buffers(stfbi->visual, 1 << statt)) {
-         switch (statt) {
-         case ST_ATTACHMENT_BACK_LEFT:
-            statt = ST_ATTACHMENT_FRONT_LEFT;
-            break;
-         case ST_ATTACHMENT_BACK_RIGHT:
-            statt = ST_ATTACHMENT_FRONT_RIGHT;
-            break;
-         default:
-            break;
-         }
-
-         if (!st_visual_have_buffers(stfbi->visual, 1 << statt))
-            statt = ST_ATTACHMENT_INVALID;
-      }
-   }
-
-   return statt;
-}
-
-/**
- * Bind the context to the given framebuffers.
- */
-static boolean
-vg_context_bind_framebuffers(struct st_context_iface *stctxi,
-                             struct st_framebuffer_iface *stdrawi,
-                             struct st_framebuffer_iface *streadi)
-{
-   struct vg_context *ctx = (struct vg_context *) stctxi;
-   struct st_framebuffer *stfb;
-   enum st_attachment_type strb_att;
-
-   /* the draw and read framebuffers must be the same */
-   if (stdrawi != streadi)
-      return FALSE;
-
-   strb_att = (stdrawi) ? choose_attachment(stdrawi) : ST_ATTACHMENT_INVALID;
-
-   if (ctx->draw_buffer) {
-      stfb = ctx->draw_buffer;
-
-      /* free the existing fb */
-      if (!stdrawi ||
-          stfb->strb_att != strb_att ||
-          stfb->strb->format != stdrawi->visual->color_format) {
-         destroy_renderbuffer(stfb->strb);
-         destroy_renderbuffer(stfb->dsrb);
-         FREE(stfb);
-
-         ctx->draw_buffer = NULL;
-      }
-   }
-
-   if (!stdrawi)
-      return TRUE;
-
-   if (strb_att == ST_ATTACHMENT_INVALID)
-      return FALSE;
-
-   /* create a new fb */
-   if (!ctx->draw_buffer) {
-      stfb = CALLOC_STRUCT(st_framebuffer);
-      if (!stfb)
-         return FALSE;
-
-      stfb->strb = create_renderbuffer(stdrawi->visual->color_format);
-      if (!stfb->strb) {
-         FREE(stfb);
-         return FALSE;
-      }
-
-      stfb->dsrb = create_renderbuffer(ctx->ds_format);
-      if (!stfb->dsrb) {
-         FREE(stfb->strb);
-         FREE(stfb);
-         return FALSE;
-      }
-
-      stfb->width = 0;
-      stfb->height = 0;
-      stfb->strb_att = strb_att;
-      stfb->stamp = 1;
-      stfb->iface_stamp = p_atomic_read(&stdrawi->stamp) - 1;
-
-      ctx->draw_buffer = stfb;
-   }
-
-   ctx->draw_buffer->iface = stdrawi;
-   ctx->draw_stamp = ctx->draw_buffer->stamp - 1;
-
-   return TRUE;
-}
-
-static boolean
-vg_api_make_current(struct st_api *stapi, struct st_context_iface *stctxi,
-                    struct st_framebuffer_iface *stdrawi,
-                    struct st_framebuffer_iface *streadi)
-{
-   struct vg_context *ctx = (struct vg_context *) stctxi;
-
-   if (stctxi)
-      vg_context_bind_framebuffers(stctxi, stdrawi, streadi);
-   vg_set_current_context(ctx);
-
-   return TRUE;
-}
-
-static struct st_context_iface *
-vg_api_get_current(struct st_api *stapi)
-{
-   struct vg_context *ctx = vg_current_context();
-
-   return (ctx) ? &ctx->iface : NULL;
-}
-
-static st_proc_t
-vg_api_get_proc_address(struct st_api *stapi, const char *procname)
-{
-   return api_get_proc_address(procname);
-}
-
-static void
-vg_api_destroy(struct st_api *stapi)
-{
-}
-
-static void
-vg_api_query_versions(struct st_api *stapi, struct st_manager *sm,
-                      struct st_config_options *options,
-                      int *gl_core_version,
-                      int *gl_compat_version,
-                      int *gl_es1_version,
-                      int *gl_es2_version)
-{
-}
-
-static const struct st_api vg_api = {
-   "Vega " PACKAGE_VERSION,
-   ST_API_OPENVG,
-   ST_PROFILE_DEFAULT_MASK,
-   0,
-   vg_api_destroy,
-   vg_api_query_versions,
-   vg_api_get_proc_address,
-   vg_api_create_context,
-   vg_api_make_current,
-   vg_api_get_current,
-};
-
-const struct st_api *
-vg_api_get(void)
-{
-   return &vg_api;
-}
diff --git a/src/gallium/state_trackers/vega/vg_manager.h b/src/gallium/state_trackers/vega/vg_manager.h
deleted file mode 100644
index 02b4842b288..00000000000
--- a/src/gallium/state_trackers/vega/vg_manager.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Mesa 3-D graphics library
- *
- * Copyright (C) 2010 LunarG Inc.
- *
- * 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.
- *
- * Authors:
- *    Chia-I Wu <[email protected]>
- */
-
-#ifndef VG_MANAGER_H
-#define VG_MANAGER_H
-
-#include "state_tracker/st_api.h"
-#include "vg_context.h"
-
-void
-vg_manager_flush_frontbuffer(struct vg_context *ctx);
-
-void
-vg_manager_validate_framebuffer(struct vg_context *ctx);
-
-#endif /* VG_MANAGER_H */
diff --git a/src/gallium/state_trackers/vega/vg_state.c b/src/gallium/state_trackers/vega/vg_state.c
deleted file mode 100644
index 6f6bfdaf7a2..00000000000
--- a/src/gallium/state_trackers/vega/vg_state.c
+++ /dev/null
@@ -1,124 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "vg_state.h"
-
-#include <string.h>
-
-void vg_init_state(struct vg_state *state)
-{
-   state->matrix_mode = VG_MATRIX_PATH_USER_TO_SURFACE;
-   state->fill_rule = VG_EVEN_ODD;
-   state->image_quality = VG_IMAGE_QUALITY_FASTER;
-   state->rendering_quality = VG_RENDERING_QUALITY_BETTER;
-   state->blend_mode = VG_BLEND_SRC_OVER;
-   state->image_mode = VG_DRAW_IMAGE_NORMAL;
-
-   memset(state->scissor_rects, 0, sizeof(state->scissor_rects));
-   state->scissor_rects_num = 0;
-
-   state->color_transform = VG_FALSE;
-   state->color_transform_values[0] = 1.0f;
-   state->color_transform_values[1] = 1.0f;
-   state->color_transform_values[2] = 1.0f;
-   state->color_transform_values[3] = 1.0f;
-   state->color_transform_values[4] = 0.0f;
-   state->color_transform_values[5] = 0.0f;
-   state->color_transform_values[6] = 0.0f;
-   state->color_transform_values[7] = 0.0f;
-
-   /* Stroke parameters */
-   state->stroke.line_width.f       = 1.0f;
-   state->stroke.line_width.i       = 1;
-   state->stroke.cap_style        = VG_CAP_BUTT;
-   state->stroke.join_style       = VG_JOIN_MITER;
-   state->stroke.miter_limit.f      = 4.0f;
-   state->stroke.miter_limit.i      = 4;
-   state->stroke.dash_pattern_num = 0;
-   state->stroke.dash_phase.f       = 0.0f;
-   state->stroke.dash_phase.i       = 0;
-   state->stroke.dash_phase_reset = VG_FALSE;
-
-   /* Edge fill color for VG_TILE_FILL tiling mode */
-   state->tile_fill_color[0] = 0.0f;
-   state->tile_fill_color[1] = 0.0f;
-   state->tile_fill_color[2] = 0.0f;
-   state->tile_fill_color[3] = 0.0f;
-
-   /* Color for vgClear */
-   state->clear_color[0] = 0.0f;
-   state->clear_color[1] = 0.0f;
-   state->clear_color[2] = 0.0f;
-   state->clear_color[3] = 0.0f;
-
-   /* Glyph origin */
-   state->glyph_origin[0].f = 0.0f;
-   state->glyph_origin[1].f = 0.0f;
-   state->glyph_origin[0].i = 0;
-   state->glyph_origin[1].i = 0;
-
-   /* Enable/disable alpha masking and scissoring */
-   state->masking = VG_FALSE;
-   state->scissoring = VG_FALSE;
-
-   /* Pixel layout information */
-   state->pixel_layout = VG_PIXEL_LAYOUT_UNKNOWN;
-   state->screen_layout = VG_PIXEL_LAYOUT_UNKNOWN;
-
-   /* Source format selection for image filters */
-   state->filter_format_linear = VG_FALSE;
-   state->filter_format_premultiplied = VG_FALSE;
-
-   /* Destination write enable mask for image filters */
-   state->filter_channel_mask = (VG_RED | VG_GREEN | VG_BLUE | VG_ALPHA);
-
-   matrix_load_identity(&state->path_user_to_surface_matrix);
-   matrix_load_identity(&state->image_user_to_surface_matrix);
-   matrix_load_identity(&state->fill_paint_to_user_matrix);
-   matrix_load_identity(&state->stroke_paint_to_user_matrix);
-   matrix_load_identity(&state->glyph_user_to_surface_matrix);
-}
-
-struct matrix *vg_state_matrix(struct vg_state *state)
-{
-    switch(state->matrix_mode) {
-    case VG_MATRIX_PATH_USER_TO_SURFACE:
-       return &state->path_user_to_surface_matrix;
-    case VG_MATRIX_IMAGE_USER_TO_SURFACE:
-       return &state->image_user_to_surface_matrix;
-    case VG_MATRIX_FILL_PAINT_TO_USER:
-       return &state->fill_paint_to_user_matrix;
-    case VG_MATRIX_STROKE_PAINT_TO_USER:
-       return &state->stroke_paint_to_user_matrix;
-#ifdef OPENVG_VERSION_1_1
-    case VG_MATRIX_GLYPH_USER_TO_SURFACE:
-       return &state->glyph_user_to_surface_matrix;
-#endif
-    default:
-       break;
-    }
-    return NULL;
-}
diff --git a/src/gallium/state_trackers/vega/vg_state.h b/src/gallium/state_trackers/vega/vg_state.h
deleted file mode 100644
index ed90689f917..00000000000
--- a/src/gallium/state_trackers/vega/vg_state.h
+++ /dev/null
@@ -1,109 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef VG_STATE_H
-#define VG_STATE_H
-
-#include "VG/openvg.h"
-
-#include "api_consts.h"
-#include "matrix.h"
-
-struct vg_value
-{
-   VGfloat f;
-   VGint   i;
-};
-
-struct vg_state {
-   /* Mode settings */
-   VGMatrixMode matrix_mode;
-   VGFillRule fill_rule;
-   VGImageQuality image_quality;
-   VGRenderingQuality rendering_quality;
-   VGBlendMode blend_mode;
-   VGImageMode image_mode;
-
-   /* Scissoring rectangles */
-   struct vg_value  scissor_rects[32*4];
-   VGint  scissor_rects_num;
-
-   /* Color Transformation */
-   VGboolean color_transform;
-   VGfloat color_transform_values[8];
-
-   /* Stroke parameters */
-   struct {
-      struct vg_value line_width;
-      VGCapStyle cap_style;
-      VGJoinStyle join_style;
-      struct vg_value miter_limit;
-      struct vg_value dash_pattern[VEGA_MAX_DASH_COUNT];
-      VGint   dash_pattern_num;
-      struct vg_value dash_phase;
-      VGboolean dash_phase_reset;
-   } stroke;
-
-   /* Edge fill color for VG_TILE_FILL tiling mode */
-   VGfloat tile_fill_color[4];
-   VGint tile_fill_colori[4];
-
-   /* Color for vgClear */
-   VGfloat clear_color[4];
-   VGint clear_colori[4];
-
-   /* Glyph origin */
-   struct vg_value glyph_origin[2];
-
-   /* Enable/disable alpha masking and scissoring */
-   VGboolean masking;
-   VGboolean scissoring;
-
-   /* Pixel layout information */
-   VGPixelLayout pixel_layout;
-   VGPixelLayout screen_layout;
-
-   /* Source format selection for image filters */
-   VGboolean filter_format_linear;
-   VGboolean filter_format_premultiplied;
-
-   /* Destination write enable mask for image filters */
-   VGbitfield filter_channel_mask;
-
-   struct matrix path_user_to_surface_matrix;
-   struct matrix image_user_to_surface_matrix;
-   struct matrix fill_paint_to_user_matrix;
-   struct matrix stroke_paint_to_user_matrix;
-   struct matrix glyph_user_to_surface_matrix;
-
-   struct vg_paint *stroke_paint;
-   struct vg_paint *fill_paint;
-};
-
-void vg_init_state(struct vg_state *state);
-struct matrix * vg_state_matrix(struct vg_state *state);
-
-#endif
diff --git a/src/gallium/state_trackers/vega/vg_translate.c b/src/gallium/state_trackers/vega/vg_translate.c
deleted file mode 100644
index 4aad8991bdd..00000000000
--- a/src/gallium/state_trackers/vega/vg_translate.c
+++ /dev/null
@@ -1,1097 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "vg_translate.h"
-
-#include "pipe/p_format.h"
-#include "util/u_pack_color.h"
-
-void _vega_pack_rgba_span_float(struct vg_context *ctx,
-                                VGuint n, VGfloat rgba[][4],
-                                VGImageFormat dstFormat,
-                                void *dstAddr)
-{
-   VGuint i;
-
-   switch (dstFormat) {
-   case VG_sRGBX_8888: {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = 255;
-         dst[i] = r << 24 | g << 16 | b << 8 | a;
-      }
-      return;
-   }
-      break;
-   case VG_sRGBA_8888: {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = float_to_ubyte(rgba[i][3]);
-         dst[i] = r << 24 | g << 16 | b << 8 | a;
-      }
-      return;
-   }
-      break;
-   case VG_sRGBA_8888_PRE: {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = float_to_ubyte(rgba[i][3]);
-         dst[i] = r << 24 | g << 16 | b << 8 | a;
-      }
-      return;
-   }
-      break;
-   case VG_sRGB_565: {
-      VGshort *dst = (VGshort *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         r = (r / 255.0) * 32;
-         g = (g / 255.0) * 32;
-         b = (b / 255.0) * 32;
-
-         dst[i] = b | g << 5 | r << 11;
-      }
-      return;
-   }
-      break;
-   case VG_sRGBA_5551: {
-      VGshort *dst = (VGshort *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b, a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = float_to_ubyte(rgba[i][3]);
-         r = (r / 255.0) * 32;
-         g = (g / 255.0) * 32;
-         b = (b / 255.0) * 32;
-         a = (a / 255.0);
-
-         dst[i] =  a | b << 1 | g << 6 | r << 11;
-      }
-      return;
-   }
-      break;
-   case VG_sRGBA_4444: {
-      VGshort *dst = (VGshort *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b, a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = float_to_ubyte(rgba[i][3]);
-         r = (r / 255.0) * 16;
-         g = (g / 255.0) * 16;
-         b = (b / 255.0) * 16;
-         a = (a / 255.0) * 16;
-
-         dst[i] =  a | b << 4 | g << 8 | r << 12;
-      }
-      return;
-   }
-      break;
-   case VG_sL_8: {
-      VGubyte *dst = (VGubyte *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte a;
-         a = float_to_ubyte(rgba[i][3]);
-
-         dst[i] =  a;
-      }
-      return;
-   }
-      break;
-   case VG_lRGBX_8888: {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = 255;
-         dst[i] = r << 24 | g << 16 | b << 8 | a;
-      }
-      return;
-   }
-      break;
-   case VG_lRGBA_8888: {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = float_to_ubyte(rgba[i][3]);
-         dst[i] = r << 24 | g << 16 | b << 8 | a;
-      }
-      return;
-   }
-   case VG_lRGBA_8888_PRE: {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = float_to_ubyte(rgba[i][3]);
-         dst[i] = r << 24 | g << 16 | b << 8 | a;
-      }
-      return;
-   }
-      break;
-   case VG_lL_8: {
-      VGubyte *dst = (VGubyte *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte a;
-         a = float_to_ubyte(rgba[i][3]);
-         dst[i] = a;
-      }
-      return;
-   }
-      break;
-   case VG_A_8: {
-      VGubyte *dst = (VGubyte *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte a;
-         a = float_to_ubyte(rgba[i][3]);
-
-         dst[i] = a;
-      }
-      return;
-   }
-      break;
-   case VG_BW_1: {
-      VGshort *dst = (VGshort *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b, a;
-         VGubyte res;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = float_to_ubyte(rgba[i][3]);
-
-         res = (r + g + b + a)/4;
-         dst[i] =   (res & (128));
-      }
-      return;
-   }
-      break;
-#ifdef OPENVG_VERSION_1_1
-   case VG_A_1: {
-      VGshort *dst = (VGshort *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte a;
-         a = float_to_ubyte(rgba[i][3]);
-
-         dst[i] =   (a & (128));
-      }
-      return;
-   }
-      break;
-   case VG_A_4: {
-      VGshort *dst = (VGshort *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte a;
-         VGubyte res;
-         a = float_to_ubyte(rgba[i][3]);
-
-         res = a/4;
-         dst[i] =   (res & (128));
-      }
-      return;
-   }
-      break;
-#endif
-   case VG_sXRGB_8888:
-      break;
-   case VG_sARGB_8888: {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = float_to_ubyte(rgba[i][3]);
-         dst[i] = a << 24 | r << 16 | g << 8 | b;
-      }
-      return;
-   }
-      break;
-   case VG_sARGB_8888_PRE:  {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = float_to_ubyte(rgba[i][3]);
-         dst[i] = a << 24 | r << 16 | g << 8 | b;
-      }
-      return;
-   }
-      break;
-   case VG_sARGB_1555:
-      break;
-   case VG_sARGB_4444:
-      break;
-   case VG_lXRGB_8888:
-      break;
-   case VG_lARGB_8888: {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = float_to_ubyte(rgba[i][3]);
-         dst[i] = a << 24 | r << 16 | g << 8 | b;
-      }
-      return;
-   }
-      break;
-   case VG_lARGB_8888_PRE: {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = float_to_ubyte(rgba[i][3]);
-         dst[i] = a << 24 | r << 16 | g << 8 | b;
-      }
-      return;
-   }
-      break;
-   case VG_sBGRX_8888: {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = 0xff;
-         dst[i] = b << 24 | g << 16 | r << 8 | a;
-      }
-      return;
-   }
-      break;
-   case VG_sBGRA_8888: {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = float_to_ubyte(rgba[i][3]);
-         dst[i] = b << 24 | g << 16 | r << 8 | a;
-      }
-      return;
-   }
-      break;
-   case VG_sBGRA_8888_PRE: {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = float_to_ubyte(rgba[i][3]);
-         dst[i] = b << 24 | g << 16 | r << 8 | a;
-      }
-      return;
-   }
-      break;
-   case VG_sBGR_565:
-      break;
-   case VG_sBGRA_5551:
-      break;
-   case VG_sBGRA_4444:
-      break;
-   case VG_lBGRX_8888: {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = 0xff;
-         dst[i] = b << 24 | g << 16 | r << 8 | a;
-      }
-      return;
-   }
-      break;
-   case VG_lBGRA_8888: {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = float_to_ubyte(rgba[i][3]);
-         dst[i] = b << 24 | g << 16 | r << 8 | a;
-      }
-      return;
-   }
-      break;
-   case VG_lBGRA_8888_PRE: {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = float_to_ubyte(rgba[i][3]);
-         dst[i] = b << 24 | g << 16 | r << 8 | a;
-      }
-      return;
-   }
-      break;
-   case VG_sXBGR_8888:
-      break;
-   case VG_sABGR_8888: {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = float_to_ubyte(rgba[i][3]);
-         dst[i] = a << 24 | b << 16 | g << 8 | r;
-      }
-      return;
-   }
-      break;
-   case VG_sABGR_8888_PRE: {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = float_to_ubyte(rgba[i][3]);
-         dst[i] = a << 24 | b << 16 | g << 8 | r;
-      }
-      return;
-   }
-      break;
-   case VG_sABGR_1555:
-      break;
-   case VG_sABGR_4444:
-      break;
-   case VG_lXBGR_8888:
-      break;
-   case VG_lABGR_8888: {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = float_to_ubyte(rgba[i][3]);
-         dst[i] = a << 24 | b << 16 | g << 8 | r;
-      }
-      return;
-   }
-      break;
-   case VG_lABGR_8888_PRE: {
-      VGint *dst = (VGint *)dstAddr;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = float_to_ubyte(rgba[i][0]);
-         g = float_to_ubyte(rgba[i][1]);
-         b = float_to_ubyte(rgba[i][2]);
-         a = float_to_ubyte(rgba[i][3]);
-         dst[i] = a << 24 | b << 16 | g << 8 | r;
-      }
-      return;
-   }
-      break;
-   default:
-      assert(!"Unknown ReadPixels format");
-      break;
-   }
-   assert(!"Not implemented ReadPixels format");
-}
-
-void _vega_unpack_float_span_rgba(struct vg_context *ctx,
-                                  VGuint n,
-                                  VGuint offset,
-                                  const void * data,
-                                  VGImageFormat dataFormat,
-                                  VGfloat rgba[][4])
-{
-   VGuint i;
-   union util_color uc;
-
-   switch (dataFormat) {
-   case VG_sRGBX_8888: {
-      VGuint *src = (VGuint *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = (*src >> 24) & 0xff;
-         g = (*src >> 16) & 0xff;
-         b = (*src >>  8) & 0xff;
-         a = 0xff;
-
-         util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-   }
-      return;
-   case VG_sRGBA_8888: {
-      VGuint *src = (VGuint *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = (*src >> 24) & 0xff;
-         g = (*src >> 16) & 0xff;
-         b = (*src >>  8) & 0xff;
-         a = (*src >>  0) & 0xff;
-
-         util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-      return;
-   }
-      break;
-   case VG_sRGBA_8888_PRE: {
-      VGint *src = (VGint *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = (*src >> 24) & 0xff;
-         g = (*src >> 16) & 0xff;
-         b = (*src >>  8) & 0xff;
-         a = (*src >>  0) & 0xff;
-
-         util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-      return;
-   }
-      break;
-   case VG_sRGB_565: {
-      VGshort *src = (VGshort *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGfloat clr[4];
-         clr[0] = ((*src >> 11) & 31)/31.;
-         clr[1] = ((*src >>  5) & 63)/63.;
-         clr[2] = ((*src >>  0) & 31)/31.;
-         clr[3] = 1.f;
-
-         util_pack_color(clr, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-   }
-      return;
-   case VG_sRGBA_5551: {
-      VGshort *src = (VGshort *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGfloat clr[4];
-         clr[0] = ((*src >> 10) & 31)/31.;
-         clr[1] = ((*src >>  5) & 31)/31.;
-         clr[2] = ((*src >>  1) & 31)/31.;
-         clr[3] = ((*src >>  0) & 1)/1.;
-
-         util_pack_color(clr, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-   }
-      return;
-   case VG_sRGBA_4444: {
-      VGshort *src = (VGshort *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGfloat clr[4];
-         clr[0] = ((*src >> 12) & 15)/15.;
-         clr[1] = ((*src >>  8) & 15)/15.;
-         clr[2] = ((*src >>  4) & 15)/15.;
-         clr[3] = ((*src >>  0) & 15)/15.;
-
-         util_pack_color(clr, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-   }
-      return;
-   case VG_sL_8: {
-      VGubyte *src = (VGubyte *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         util_pack_color_ub(0xff, 0xff, 0xff, *src, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-   }
-      return;
-   case VG_lRGBX_8888: {
-      VGuint *src = (VGuint *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = (*src >> 24) & 0xff;
-         g = (*src >> 16) & 0xff;
-         b = (*src >>  8) & 0xff;
-         a = 0xff;
-
-         util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-   }
-      return;
-   case VG_lRGBA_8888: {
-      VGint *src = (VGint *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = (*src >> 24) & 0xff;
-         g = (*src >> 16) & 0xff;
-         b = (*src >>  8) & 0xff;
-         a = (*src >>  0) & 0xff;
-
-         util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-      return;
-   }
-      break;
-   case VG_lRGBA_8888_PRE: {
-      VGint *src = (VGint *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         r = (*src >> 24) & 0xff;
-         g = (*src >> 16) & 0xff;
-         b = (*src >>  8) & 0xff;
-         a = (*src >>  0) & 0xff;
-
-         util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-      return;
-   }
-      break;
-   case VG_lL_8: {
-      VGubyte *src = (VGubyte *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         util_pack_color_ub(0xff, 0xff, 0xff, *src, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-   }
-      return;
-   case VG_A_8: {
-      VGubyte *src = (VGubyte *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         util_pack_color_ub(0xff, 0xff, 0xff, *src, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-   }
-      return;
-   case VG_BW_1: {
-      VGubyte *src = (VGubyte *)data;
-      src += offset;
-      for (i = 0; i < n; i += 8) {
-         VGfloat clr[4];
-         VGuint j;
-         for (j = 0; j < 8 && j < n ; ++j) {
-            VGint shift = j;
-            clr[0] = (((*src) & (1<<shift)) >> shift);
-            clr[1] = clr[0];
-            clr[2] = clr[0];
-            clr[3] = 1.f;
-
-            util_pack_color(clr, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-            rgba[i+j][0] = uc.f[0];
-            rgba[i+j][1] = uc.f[1];
-            rgba[i+j][2] = uc.f[2];
-            rgba[i+j][3] = uc.f[3];
-         }
-         ++src;
-      }
-   }
-      return;
-#ifdef OPENVG_VERSION_1_1
-   case VG_A_1: {
-      VGubyte *src = (VGubyte *)data;
-      src += offset;
-      for (i = 0; i < n; i += 8) {
-         VGfloat clr[4];
-         VGuint j;
-         for (j = 0; j < 8 && j < n ; ++j) {
-            VGint shift = j;
-            clr[0] = 0.f;
-            clr[1] = 0.f;
-            clr[2] = 0.f;
-            clr[3] = (((*src) & (1<<shift)) >> shift);
-
-            util_pack_color(clr, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-            rgba[i+j][0] = uc.f[0];
-            rgba[i+j][1] = uc.f[1];
-            rgba[i+j][2] = uc.f[2];
-            rgba[i+j][3] = uc.f[3];
-         }
-         ++src;
-      }
-   }
-      return;
-   case VG_A_4: {
-      VGubyte *src = (VGubyte *)data;
-      src += offset/2;
-      for (i = 0; i < n; i += 2) {
-         VGfloat clr[4];
-         VGuint j;
-         for (j = 0; j < n && j < 2; ++j) {
-            VGint bitter, shift;
-            if (j == 0) {
-               bitter = 0x0f;
-               shift = 0;
-            } else {
-               bitter = 0xf0;
-               shift = 4;
-            }
-            clr[0] = 0.f;
-            clr[1] = 0.f;
-            clr[2] = 0.f;
-            clr[3] = ((*src) & (bitter)) >> shift;
-
-            util_pack_color(clr, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-            rgba[i+j][0] = uc.f[0];
-            rgba[i+j][1] = uc.f[1];
-            rgba[i+j][2] = uc.f[2];
-            rgba[i+j][3] = uc.f[3];
-         }
-         ++src;
-      }
-   }
-      return;
-#endif
-   case VG_sXRGB_8888:
-      break;
-   case VG_sARGB_8888: {
-      VGuint *src = (VGuint *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         a = (*src >> 24) & 0xff;
-         r = (*src >> 16) & 0xff;
-         g = (*src >>  8) & 0xff;
-         b = (*src >>  0) & 0xff;
-
-         util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-      return;
-   }
-      break;
-   case VG_sARGB_8888_PRE: {
-      VGuint *src = (VGuint *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         a = (*src >> 24) & 0xff;
-         r = (*src >> 16) & 0xff;
-         g = (*src >>  8) & 0xff;
-         b = (*src >>  0) & 0xff;
-
-         util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-      return;
-   }
-      break;
-   case VG_sARGB_1555:
-      break;
-   case VG_sARGB_4444:
-      break;
-   case VG_lXRGB_8888:
-      break;
-   case VG_lARGB_8888: {
-      VGint *src = (VGint *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         a = (*src >> 24) & 0xff;
-         r = (*src >> 16) & 0xff;
-         g = (*src >>  8) & 0xff;
-         b = (*src >>  0) & 0xff;
-
-         util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-      return;
-   }
-      break;
-   case VG_lARGB_8888_PRE: {
-      VGint *src = (VGint *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         a = (*src >> 24) & 0xff;
-         r = (*src >> 16) & 0xff;
-         g = (*src >>  8) & 0xff;
-         b = (*src >>  0) & 0xff;
-
-         util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-      return;
-   }
-      break;
-   case VG_sBGRX_8888:
-      break;
-   case VG_sBGRA_8888:  {
-      VGuint *src = (VGuint *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         b = (*src >> 24) & 0xff;
-         g = (*src >> 16) & 0xff;
-         r = (*src >>  8) & 0xff;
-         a = (*src >>  0) & 0xff;
-
-         util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-      return;
-   }
-      break;
-   case VG_sBGRA_8888_PRE:  {
-      VGuint *src = (VGuint *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         b = (*src >> 24) & 0xff;
-         g = (*src >> 16) & 0xff;
-         r = (*src >>  8) & 0xff;
-         a = (*src >>  0) & 0xff;
-
-         util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-      return;
-   }
-      break;
-   case VG_sBGR_565:
-      break;
-   case VG_sBGRA_5551:
-      break;
-   case VG_sBGRA_4444:
-      break;
-   case VG_lBGRX_8888:
-      break;
-   case VG_lBGRA_8888:  {
-      VGuint *src = (VGuint *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         b = (*src >> 24) & 0xff;
-         g = (*src >> 16) & 0xff;
-         r = (*src >>  8) & 0xff;
-         a = (*src >>  0) & 0xff;
-
-         util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-      return;
-   }
-      break;
-   case VG_lBGRA_8888_PRE:  {
-      VGuint *src = (VGuint *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         b = (*src >> 24) & 0xff;
-         g = (*src >> 16) & 0xff;
-         r = (*src >>  8) & 0xff;
-         a = (*src >>  0) & 0xff;
-
-         util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-      return;
-   }
-      break;
-   case VG_sXBGR_8888:
-      break;
-   case VG_sABGR_8888: {
-      VGuint *src = (VGuint *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         a = (*src >> 24) & 0xff;
-         b = (*src >> 16) & 0xff;
-         g = (*src >>  8) & 0xff;
-         r = (*src >>  0) & 0xff;
-
-         util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-      return;
-   }
-      break;
-   case VG_sABGR_8888_PRE: {
-      VGuint *src = (VGuint *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         a = (*src >> 24) & 0xff;
-         b = (*src >> 16) & 0xff;
-         g = (*src >>  8) & 0xff;
-         r = (*src >>  0) & 0xff;
-
-         util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-      return;
-   }
-      break;
-   case VG_sABGR_1555:
-      break;
-   case VG_sABGR_4444:
-      break;
-   case VG_lXBGR_8888:
-      break;
-   case VG_lABGR_8888: {
-      VGuint *src = (VGuint *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         a = (*src >> 24) & 0xff;
-         b = (*src >> 16) & 0xff;
-         g = (*src >>  8) & 0xff;
-         r = (*src >>  0) & 0xff;
-
-         util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-      return;
-   }
-      break;
-   case VG_lABGR_8888_PRE: {
-      VGuint *src = (VGuint *)data;
-      src += offset;
-      for (i = 0; i < n; ++i) {
-         VGubyte r, g, b ,a;
-         a = (*src >> 24) & 0xff;
-         b = (*src >> 16) & 0xff;
-         g = (*src >>  8) & 0xff;
-         r = (*src >>  0) & 0xff;
-
-         util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
-         rgba[i][0] = uc.f[0];
-         rgba[i][1] = uc.f[1];
-         rgba[i][2] = uc.f[2];
-         rgba[i][3] = uc.f[3];
-         ++src;
-      }
-      return;
-   }
-      break;
-   default:
-      assert(!"Unknown ReadPixels format");
-      break;
-   }
-   assert(!"Not implemented ReadPixels format");
-}
-
-VGint _vega_size_for_format(VGImageFormat dataFormat)
-{
-   switch (dataFormat) {
-   case VG_sRGBX_8888:
-   case VG_sRGBA_8888:
-   case VG_sRGBA_8888_PRE:
-      return 4;
-   case VG_sRGB_565:
-   case VG_sRGBA_5551:
-   case VG_sRGBA_4444:
-      return 2;
-   case VG_sL_8:
-      return 1;
-   case VG_lRGBX_8888:
-   case VG_lRGBA_8888:
-   case VG_lRGBA_8888_PRE:
-      return 4;
-   case VG_lL_8:
-      return 1;
-   case VG_A_8:
-      return 1;
-   case VG_BW_1:
-      return 1;
-#ifdef OPENVG_VERSION_1_1
-   case VG_A_1:
-      break;
-   case VG_A_4:
-      break;
-#endif
-   case VG_sXRGB_8888:
-   case VG_sARGB_8888:
-   case VG_sARGB_8888_PRE:
-      return 4;
-   case VG_sARGB_1555:
-   case VG_sARGB_4444:
-      return 2;
-   case VG_lXRGB_8888:
-   case VG_lARGB_8888:
-   case VG_lARGB_8888_PRE:
-   case VG_sBGRX_8888:
-   case VG_sBGRA_8888:
-   case VG_sBGRA_8888_PRE:
-      return 4;
-   case VG_sBGR_565:
-   case VG_sBGRA_5551:
-   case VG_sBGRA_4444:
-      return 2;
-   case VG_lBGRX_8888:
-   case VG_lBGRA_8888:
-   case VG_lBGRA_8888_PRE:
-   case VG_sXBGR_8888:
-   case VG_sABGR_8888:
-   case VG_sABGR_8888_PRE:
-      return 4;
-   case VG_sABGR_1555:
-   case VG_sABGR_4444:
-      return 2;
-   case VG_lXBGR_8888:
-   case VG_lABGR_8888:
-   case VG_lABGR_8888_PRE:
-      return 4;
-   default:
-      assert(!"Unknown ReadPixels format");
-      break;
-   }
-   assert(!"Not implemented ReadPixels format");
-   return 0;
-}
diff --git a/src/gallium/state_trackers/vega/vg_translate.h b/src/gallium/state_trackers/vega/vg_translate.h
deleted file mode 100644
index 70815bacbcb..00000000000
--- a/src/gallium/state_trackers/vega/vg_translate.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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.
- *
- **************************************************************************/
-
-#ifndef VG_TRANSLATE_H
-#define VG_TRANSLATE_H
-
-#include "VG/openvg.h"
-#include "vg_context.h"
-
-/*FIXME: we really should be using translate module
- * but pipe_format can't express some of the VG formats
- * (the premultiplied ones) so currently it won't work */
-
-void _vega_pack_rgba_span_float(struct vg_context *ctx,
-                                VGuint n, VGfloat rgba[][4],
-                                VGImageFormat dstFormat,
-                                void *dstAddr);
-void _vega_unpack_float_span_rgba(struct vg_context *ctx,
-                                  VGuint n,
-                                  VGuint offset,
-                                  const void * data,
-                                  VGImageFormat dataFormat,
-                                  VGfloat rgba[][4]);
-VGint _vega_size_for_format(VGImageFormat format);
-
-#endif
diff --git a/src/gallium/state_trackers/vega/vgu.c b/src/gallium/state_trackers/vega/vgu.c
deleted file mode 100644
index 4206a91e006..00000000000
--- a/src/gallium/state_trackers/vega/vgu.c
+++ /dev/null
@@ -1,441 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 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 "VG/openvg.h"
-#include "VG/vgu.h"
-
-#include "matrix.h"
-#include "path.h"
-#include "handle.h"
-
-#include "util/u_debug.h"
-#include "util/u_pointer.h"
-
-#include <math.h>
-#include <assert.h>
-
-
-static void vgu_append_float_coords(VGPath path,
-                                    const VGubyte *cmds,
-                                    VGint num_cmds,
-                                    const VGfloat *coords,
-                                    VGint num_coords)
-{
-   VGubyte common_data[40 * sizeof(VGfloat)];
-   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);
-}
-
-VGUErrorCode vguLine(VGPath path,
-                     VGfloat x0, VGfloat y0,
-                     VGfloat x1, VGfloat y1)
-{
-   static const VGubyte cmds[] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS};
-   VGfloat coords[4];
-   VGbitfield caps;
-
-   if (path == VG_INVALID_HANDLE) {
-      return VGU_BAD_HANDLE_ERROR;
-   }
-   caps = vgGetPathCapabilities(path);
-   if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
-      return VGU_PATH_CAPABILITY_ERROR;
-   }
-
-   coords[0] = x0;
-   coords[1] = y0;
-   coords[2] = x1;
-   coords[3] = y1;
-
-   vgu_append_float_coords(path, cmds, 2, coords, 4);
-
-   return VGU_NO_ERROR;
-}
-
-VGUErrorCode vguPolygon(VGPath path,
-                        const VGfloat * points,
-                        VGint count,
-                        VGboolean closed)
-{
-   VGubyte *cmds;
-   VGfloat *coords;
-   VGbitfield caps;
-   VGint i;
-
-   if (path == VG_INVALID_HANDLE) {
-      return VGU_BAD_HANDLE_ERROR;
-   }
-
-   if (!points || count <= 0 || !is_aligned(points)) {
-      return VGU_ILLEGAL_ARGUMENT_ERROR;
-   }
-
-   caps = vgGetPathCapabilities(path);
-   if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
-      return VGU_PATH_CAPABILITY_ERROR;
-   }
-
-   cmds   = malloc(sizeof(VGubyte) * count + 1);
-   coords = malloc(sizeof(VGfloat) * count * 2);
-
-   cmds[0] = VG_MOVE_TO_ABS;
-   coords[0] = points[0];
-   coords[1] = points[1];
-   for (i = 1; i < count; ++i) {
-      cmds[i] = VG_LINE_TO_ABS;
-      coords[2*i + 0] = points[2*i + 0];
-      coords[2*i + 1] = points[2*i + 1];
-   }
-
-   if (closed) {
-      cmds[i] = VG_CLOSE_PATH;
-      ++i;
-   }
-
-   vgu_append_float_coords(path, cmds, i, coords, 2*i);
-
-   free(cmds);
-   free(coords);
-
-   return VGU_NO_ERROR;
-}
-
-VGUErrorCode  vguRect(VGPath path,
-                      VGfloat x, VGfloat y,
-                      VGfloat width, VGfloat height)
-{
-   static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
-                                  VG_HLINE_TO_REL,
-                                  VG_VLINE_TO_REL,
-                                  VG_HLINE_TO_REL,
-                                  VG_CLOSE_PATH
-   };
-   VGfloat coords[5];
-   VGbitfield caps;
-
-   if (path == VG_INVALID_HANDLE) {
-      return VGU_BAD_HANDLE_ERROR;
-   }
-   caps = vgGetPathCapabilities(path);
-   if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
-      return VGU_PATH_CAPABILITY_ERROR;
-   }
-   if (width <= 0 || height <= 0) {
-      return VGU_ILLEGAL_ARGUMENT_ERROR;
-   }
-
-   coords[0] =  x;
-   coords[1] =  y;
-   coords[2] =  width;
-   coords[3] =  height;
-   coords[4] = -width;
-
-   vgu_append_float_coords(path, cmds, 5, coords, 5);
-
-   return VGU_NO_ERROR;
-}
-
-VGUErrorCode vguRoundRect(VGPath path,
-                          VGfloat x, VGfloat y,
-                          VGfloat width,
-                          VGfloat height,
-                          VGfloat arcWidth,
-                          VGfloat arcHeight)
-{
-   static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
-                                  VG_HLINE_TO_REL,
-                                  VG_SCCWARC_TO_REL,
-                                  VG_VLINE_TO_REL,
-                                  VG_SCCWARC_TO_REL,
-                                  VG_HLINE_TO_REL,
-                                  VG_SCCWARC_TO_REL,
-                                  VG_VLINE_TO_REL,
-                                  VG_SCCWARC_TO_REL,
-                                  VG_CLOSE_PATH
-   };
-   VGfloat c[26];
-   VGbitfield caps;
-
-   if (path == VG_INVALID_HANDLE) {
-      return VGU_BAD_HANDLE_ERROR;
-   }
-   caps = vgGetPathCapabilities(path);
-   if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
-      return VGU_PATH_CAPABILITY_ERROR;
-   }
-   if (width <= 0 || height <= 0) {
-      return VGU_ILLEGAL_ARGUMENT_ERROR;
-   }
-
-   c[0] =  x + arcWidth/2; c[1] =  y;
-
-   c[2] = width - arcWidth;
-
-   c[3] = arcWidth/2; c[4] = arcHeight/2; c[5] = 0;
-   c[6] = arcWidth/2; c[7] = arcHeight/2;
-
-   c[8] = height - arcHeight;
-
-   c[9] = arcWidth/2; c[10] = arcHeight/2; c[11] = 0;
-   c[12] = -arcWidth/2; c[13] = arcHeight/2;
-
-   c[14] = -(width - arcWidth);
-
-   c[15] = arcWidth/2; c[16] = arcHeight/2; c[17] = 0;
-   c[18] = -arcWidth/2; c[19] = -arcHeight/2;
-
-   c[20] = -(height - arcHeight);
-
-   c[21] = arcWidth/2; c[22] = arcHeight/2; c[23] = 0;
-   c[24] = arcWidth/2; c[25] = -arcHeight/2;
-
-   vgu_append_float_coords(path, cmds, 10, c, 26);
-
-   return VGU_NO_ERROR;
-}
-
-VGUErrorCode vguEllipse(VGPath path,
-                        VGfloat cx, VGfloat cy,
-                        VGfloat width,
-                        VGfloat height)
-{
-   static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
-                                  VG_SCCWARC_TO_REL,
-                                  VG_SCCWARC_TO_REL,
-                                  VG_CLOSE_PATH
-   };
-   VGfloat coords[12];
-   VGbitfield caps;
-
-   if (path == VG_INVALID_HANDLE) {
-      return VGU_BAD_HANDLE_ERROR;
-   }
-   caps = vgGetPathCapabilities(path);
-   if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
-      return VGU_PATH_CAPABILITY_ERROR;
-   }
-   if (width <= 0 || height <= 0) {
-      return VGU_ILLEGAL_ARGUMENT_ERROR;
-   }
-
-   coords[0] = cx + width/2; coords[1] = cy;
-
-   coords[2] = width/2; coords[3] = height/2; coords[4] = 0;
-   coords[5] = -width; coords[6] = 0;
-
-   coords[7] = width/2; coords[8] = height/2; coords[9] = 0;
-   coords[10] = width; coords[11] = 0;
-
-   vgu_append_float_coords(path, cmds, 4, coords, 11);
-
-   return VGU_NO_ERROR;
-}
-
-VGUErrorCode vguArc(VGPath path,
-                    VGfloat x, VGfloat y,
-                    VGfloat width, VGfloat height,
-                    VGfloat startAngle,
-                    VGfloat angleExtent,
-                    VGUArcType arcType)
-{
-   VGubyte cmds[11];
-   VGfloat coords[40];
-   VGbitfield caps;
-   VGfloat last = startAngle + angleExtent;
-   VGint i, c = 0;
-
-   if (path == VG_INVALID_HANDLE) {
-      return VGU_BAD_HANDLE_ERROR;
-   }
-   caps = vgGetPathCapabilities(path);
-   if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
-      return VGU_PATH_CAPABILITY_ERROR;
-   }
-   if (width <= 0 || height <= 0) {
-      return VGU_ILLEGAL_ARGUMENT_ERROR;
-   }
-   if (arcType != VGU_ARC_OPEN &&
-       arcType != VGU_ARC_CHORD &&
-       arcType != VGU_ARC_PIE) {
-      return VGU_ILLEGAL_ARGUMENT_ERROR;
-   }
-
-   cmds[c] = VG_MOVE_TO_ABS; ++c;
-   coords[0] = x+cos(DEGREES_TO_RADIANS(startAngle))*width/2;
-   coords[1] = y+sin(DEGREES_TO_RADIANS(startAngle))*height/2;
-#ifdef DEBUG_VGUARC
-   debug_printf("start [%f, %f]\n", coords[0], coords[1]);
-#endif
-   i = 2;
-   if (angleExtent > 0) {
-      VGfloat angle = startAngle + 180;
-      while (angle < last) {
-         cmds[c] = VG_SCCWARC_TO_ABS; ++c;
-         coords[i] = width/2; coords[i+1] = height/2; coords[i+2] = 0;
-         coords[i+3] = x + cos(DEGREES_TO_RADIANS(angle))*width/2;
-         coords[i+4] = y + sin(DEGREES_TO_RADIANS(angle))*height/2;
-#ifdef DEBUG_VGUARC
-         debug_printf("1 [%f, %f]\n", coords[i+3],
-                      coords[i+4]);
-#endif
-         i += 5;
-         angle += 180;
-      }
-      cmds[c] = VG_SCCWARC_TO_ABS; ++c;
-      coords[i] = width/2; coords[i+1] = height/2; coords[i+2] = 0;
-      coords[i+3] = x+cos(DEGREES_TO_RADIANS(last))*width/2;
-      coords[i+4] = y+sin(DEGREES_TO_RADIANS(last))*height/2;
-#ifdef DEBUG_VGUARC
-      debug_printf("2 [%f, %f]\n", coords[i+3],
-                   coords[i+4]);
-#endif
-      i += 5;
-   } else {
-      VGfloat angle = startAngle - 180;
-      while (angle > last) {
-         cmds[c] = VG_SCWARC_TO_ABS; ++c;
-         coords[i] =  width/2; coords[i+1] = height/2; coords[i+2] = 0;
-         coords[i+3] = x + cos(DEGREES_TO_RADIANS(angle)) * width/2;
-         coords[i+4] = y + sin(DEGREES_TO_RADIANS(angle)) * height/2;
-#ifdef DEBUG_VGUARC
-         debug_printf("3 [%f, %f]\n", coords[i+3],
-                      coords[i+4]);
-#endif
-         angle -= 180;
-         i += 5;
-      }
-      cmds[c] = VG_SCWARC_TO_ABS; ++c;
-      coords[i] = width/2; coords[i+1] = height/2; coords[i+2] = 0;
-      coords[i+3] = x + cos(DEGREES_TO_RADIANS(last)) * width/2;
-      coords[i+4] = y + sin(DEGREES_TO_RADIANS(last)) * height/2;
-#ifdef DEBUG_VGUARC
-      debug_printf("4 [%f, %f]\n", coords[i+3],
-                   coords[i+4]);
-#endif
-      i += 5;
-   }
-
-   if (arcType == VGU_ARC_PIE) {
-      cmds[c] = VG_LINE_TO_ABS; ++c;
-      coords[i] = x; coords[i + 1] = y;
-      i += 2;
-   }
-   if (arcType == VGU_ARC_PIE || arcType == VGU_ARC_CHORD) {
-      cmds[c] = VG_CLOSE_PATH;
-      ++c;
-   }
-
-   assert(c < 11);
-
-   vgu_append_float_coords(path, cmds, c, coords, i);
-
-   return VGU_NO_ERROR;
-}
-
-VGUErrorCode vguComputeWarpQuadToSquare(VGfloat sx0, VGfloat sy0,
-                                        VGfloat sx1, VGfloat sy1,
-                                        VGfloat sx2, VGfloat sy2,
-                                        VGfloat sx3, VGfloat sy3,
-                                        VGfloat * matrix)
-{
-   struct matrix mat;
-
-   if (!matrix || !is_aligned(matrix))
-      return VGU_ILLEGAL_ARGUMENT_ERROR;
-
-   if (!matrix_quad_to_square(sx0, sy0,
-                              sx1, sy1,
-                              sx2, sy2,
-                              sx3, sy3,
-                              &mat))
-      return VGU_BAD_WARP_ERROR;
-
-   if (!matrix_is_invertible(&mat))
-      return VGU_BAD_WARP_ERROR;
-
-   memcpy(matrix, mat.m, sizeof(VGfloat) * 9);
-
-   return VGU_NO_ERROR;
-}
-
-VGUErrorCode vguComputeWarpSquareToQuad(VGfloat dx0, VGfloat dy0,
-                                        VGfloat dx1, VGfloat dy1,
-                                        VGfloat dx2, VGfloat dy2,
-                                        VGfloat dx3, VGfloat dy3,
-                                        VGfloat * matrix)
-{
-   struct matrix mat;
-
-   if (!matrix || !is_aligned(matrix))
-      return VGU_ILLEGAL_ARGUMENT_ERROR;
-
-   if (!matrix_square_to_quad(dx0, dy0,
-                              dx1, dy1,
-                              dx2, dy2,
-                              dx3, dy3,
-                              &mat))
-      return VGU_BAD_WARP_ERROR;
-
-   if (!matrix_is_invertible(&mat))
-      return VGU_BAD_WARP_ERROR;
-
-   memcpy(matrix, mat.m, sizeof(VGfloat) * 9);
-
-   return VGU_NO_ERROR;
-}
-
-VGUErrorCode vguComputeWarpQuadToQuad(VGfloat dx0, VGfloat dy0,
-                                      VGfloat dx1, VGfloat dy1,
-                                      VGfloat dx2, VGfloat dy2,
-                                      VGfloat dx3, VGfloat dy3,
-                                      VGfloat sx0, VGfloat sy0,
-                                      VGfloat sx1, VGfloat sy1,
-                                      VGfloat sx2, VGfloat sy2,
-                                      VGfloat sx3, VGfloat sy3,
-                                      VGfloat * matrix)
-{
-   struct matrix mat;
-
-   if (!matrix || !is_aligned(matrix))
-      return VGU_ILLEGAL_ARGUMENT_ERROR;
-
-   if (!matrix_quad_to_quad(dx0, dy0,
-                            dx1, dy1,
-                            dx2, dy2,
-                            dx3, dy3,
-                            sx0, sy0,
-                            sx1, sy1,
-                            sx2, sy2,
-                            sx3, sy3,
-                            &mat))
-      return VGU_BAD_WARP_ERROR;
-
-   memcpy(matrix, mat.m, sizeof(VGfloat) * 9);
-
-   return VGU_NO_ERROR;
-}