Merge remote branch 'origin/master' into pipe-video

Conflicts:
	configure.ac
	src/gallium/auxiliary/Makefile
	src/gallium/auxiliary/SConscript
	src/gallium/drivers/r600/r600_asm.c
	src/gallium/drivers/r600/r600_asm.h
	src/gallium/drivers/r600/r600_shader.c
	src/gallium/drivers/r600/r600_state_inlines.h
	src/gallium/drivers/r600/r600_texture.c

21 files changed, 565 insertions, 250 deletions

diff --git a/src/gallium/state_trackers/vega/Makefile b/src/gallium/state_trackers/vega/Makefile
index 7342c124c28..3e8ad49b767 100644
--- a/src/gallium/state_trackers/vega/Makefile
+++ b/src/gallium/state_trackers/vega/Makefile
@@ -24,23 +24,25 @@ C_SOURCES = \
            api_path.c      \
            api_text.c      \
            api_transform.c \
-           vgu.c        \
-           vg_context.c \
-           vg_manager.c \
-           vg_state.c   \
-           vg_translate.c \
-           polygon.c    \
-           bezier.c     \
-           path.c       \
-           paint.c      \
            arc.c \
+           bezier.c \
+           handle.c \
            image.c \
+           mask.c \
+           paint.c \
+           path.c \
+           polygon.c \
            renderer.c \
+           shader.c \
+           shaders_cache.c \
            stroker.c \
-           mask.c \
            text.c \
-           shader.c \
-           shaders_cache.c
+           vg_context.c \
+           vg_manager.c \
+           vg_state.c \
+           vg_translate.c \
+           vgu.c
+
 
 GENERATED_SOURCES := api_tmp.h
 
diff --git a/src/gallium/state_trackers/vega/SConscript b/src/gallium/state_trackers/vega/SConscript
index 4900135a1c5..f3732aa1577 100644
--- a/src/gallium/state_trackers/vega/SConscript
+++ b/src/gallium/state_trackers/vega/SConscript
@@ -26,23 +26,24 @@ vega_sources = [
     'api_path.c',
     'api_text.c',
     'api_transform.c',
-    'vgu.c',
-    'vg_context.c',
-    'vg_manager.c',
-    'vg_state.c',
-    'vg_translate.c',
-    'polygon.c',
-    'bezier.c',
-    'path.c',
-    'paint.c',
     'arc.c',
+    'bezier.c',
+    'handle.c',
     'image.c',
-    'renderer.c',
-    'stroker.c',
     'mask.c',
+    'paint.c',
+    'path.c',
+    'polygon.c',
+    'renderer.c',
     'shader.c',
     'shaders_cache.c',
+    'stroker.c',
     'text.c',
+    'vg_context.c',
+    'vg_manager.c',
+    'vg_state.c',
+    'vg_translate.c',
+    'vgu.c'
 ]
 
 api_tmp = env.CodeGenerate(
diff --git a/src/gallium/state_trackers/vega/api_filters.c b/src/gallium/state_trackers/vega/api_filters.c
index 724e38241b5..6be460c495c 100644
--- a/src/gallium/state_trackers/vega/api_filters.c
+++ b/src/gallium/state_trackers/vega/api_filters.c
@@ -29,6 +29,7 @@
 #include "vg_context.h"
 #include "image.h"
 #include "api.h"
+#include "handle.h"
 #include "renderer.h"
 #include "shaders_cache.h"
 
@@ -251,8 +252,8 @@ void vegaColorMatrix(VGImage dst, VGImage src,
       return;
    }
 
-   d = (struct vg_image*)dst;
-   s = (struct vg_image*)src;
+   d = handle_to_image(dst);
+   s = handle_to_image(src);
 
    if (vg_image_overlaps(d, s)) {
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
@@ -293,7 +294,7 @@ void vegaConvolve(VGImage dst, VGImage src,
    struct vg_image *d, *s;
    VGint kernel_size = kernelWidth * kernelHeight;
    struct filter_info info;
-   const VGint max_kernel_size = vgGeti(VG_MAX_KERNEL_SIZE);
+   const VGint max_kernel_size = vegaGeti(VG_MAX_KERNEL_SIZE);
 
    if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
@@ -317,8 +318,8 @@ void vegaConvolve(VGImage dst, VGImage src,
       return;
    }
 
-   d = (struct vg_image*)dst;
-   s = (struct vg_image*)src;
+   d = handle_to_image(dst);
+   s = handle_to_image(src);
 
    if (vg_image_overlaps(d, s)) {
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
@@ -395,7 +396,7 @@ void vegaSeparableConvolve(VGImage dst, VGImage src,
    struct vg_context *ctx = vg_current_context();
    VGshort *kernel;
    VGint i, j, idx = 0;
-   const VGint max_kernel_size = vgGeti(VG_MAX_SEPARABLE_KERNEL_SIZE);
+   const VGint max_kernel_size = vegaGeti(VG_MAX_SEPARABLE_KERNEL_SIZE);
 
    if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
@@ -425,8 +426,8 @@ void vegaSeparableConvolve(VGImage dst, VGImage src,
          ++idx;
       }
    }
-   vgConvolve(dst, src, kernelWidth, kernelHeight, shiftX, shiftY,
-              kernel, scale, bias, tilingMode);
+   vegaConvolve(dst, src, kernelWidth, kernelHeight, shiftX, shiftY,
+                kernel, scale, bias, tilingMode);
    free(kernel);
 }
 
@@ -502,8 +503,8 @@ void vegaGaussianBlur(VGImage dst, VGImage src,
       return;
    }
 
-   d = (struct vg_image*)dst;
-   s = (struct vg_image*)src;
+   d = handle_to_image(dst);
+   s = handle_to_image(src);
 
    if (vg_image_overlaps(d, s)) {
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
@@ -599,8 +600,8 @@ void vegaLookup(VGImage dst, VGImage src,
       return;
    }
 
-   d = (struct vg_image*)dst;
-   s = (struct vg_image*)src;
+   d = handle_to_image(dst);
+   s = handle_to_image(src);
 
    if (vg_image_overlaps(d, s)) {
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
@@ -662,8 +663,8 @@ void vegaLookupSingle(VGImage dst, VGImage src,
       return;
    }
 
-   d = (struct vg_image*)dst;
-   s = (struct vg_image*)src;
+   d = handle_to_image(dst);
+   s = handle_to_image(src);
 
    if (vg_image_overlaps(d, s)) {
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
diff --git a/src/gallium/state_trackers/vega/api_images.c b/src/gallium/state_trackers/vega/api_images.c
index ad95409cd00..b993ba62c26 100644
--- a/src/gallium/state_trackers/vega/api_images.c
+++ b/src/gallium/state_trackers/vega/api_images.c
@@ -32,6 +32,7 @@
 #include "vg_translate.h"
 #include "api_consts.h"
 #include "api.h"
+#include "handle.h"
 
 #include "pipe/p_context.h"
 #include "pipe/p_screen.h"
@@ -105,12 +106,12 @@ VGImage vegaCreateImage(VGImageFormat format,
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       return VG_INVALID_HANDLE;
    }
-   if (width > vgGeti(VG_MAX_IMAGE_WIDTH) ||
-       height > vgGeti(VG_MAX_IMAGE_HEIGHT)) {
+   if (width > vegaGeti(VG_MAX_IMAGE_WIDTH) ||
+       height > vegaGeti(VG_MAX_IMAGE_HEIGHT)) {
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       return VG_INVALID_HANDLE;
    }
-   if (width * height > vgGeti(VG_MAX_IMAGE_PIXELS)) {
+   if (width * height > vegaGeti(VG_MAX_IMAGE_PIXELS)) {
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       return VG_INVALID_HANDLE;
    }
@@ -122,19 +123,19 @@ VGImage vegaCreateImage(VGImageFormat format,
       return VG_INVALID_HANDLE;
    }
 
-   return (VGImage)image_create(format, width, height);
+   return image_to_handle(image_create(format, width, height));
 }
 
 void vegaDestroyImage(VGImage image)
 {
    struct vg_context *ctx = vg_current_context();
-   struct vg_image *img = (struct vg_image *)image;
+   struct vg_image *img = handle_to_image(image);
 
    if (image == VG_INVALID_HANDLE) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
-   if (!vg_object_is_valid((void*)image, VG_OBJECT_IMAGE)) {
+   if (!vg_object_is_valid(image, VG_OBJECT_IMAGE)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
@@ -157,7 +158,7 @@ void vegaClearImage(VGImage image,
       return;
    }
 
-   img = (struct vg_image*)image;
+   img = handle_to_image(image);
 
    if (x + width < 0 || y + height < 0)
       return;
@@ -189,7 +190,7 @@ void vegaImageSubData(VGImage image,
       return;
    }
 
-   img = (struct vg_image*)(image);
+   img = handle_to_image(image);
    image_sub_data(img, data, dataStride, dataFormat,
                   x, y, width, height);
 }
@@ -216,7 +217,7 @@ void vegaGetImageSubData(VGImage image,
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       return;
    }
-   img = (struct vg_image*)image;
+   img = handle_to_image(image);
    image_get_sub_data(img, data, dataStride, dataFormat,
                       x, y, width, height);
 }
@@ -229,8 +230,8 @@ VGImage vegaChildImage(VGImage parent,
    struct vg_image *p;
 
    if (parent == VG_INVALID_HANDLE ||
-       !vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, (void*)parent) ||
-       !vg_object_is_valid((void*)parent, VG_OBJECT_IMAGE)) {
+       !vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, parent) ||
+       !vg_object_is_valid(parent, VG_OBJECT_IMAGE)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return VG_INVALID_HANDLE;
    }
@@ -238,7 +239,7 @@ VGImage vegaChildImage(VGImage parent,
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       return VG_INVALID_HANDLE;
    }
-   p = (struct vg_image *)parent;
+   p = handle_to_image(parent);
    if (x > p->width  || y > p->height) {
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       return VG_INVALID_HANDLE;
@@ -248,7 +249,7 @@ VGImage vegaChildImage(VGImage parent,
       return VG_INVALID_HANDLE;
    }
 
-   return (VGImage)image_child_image(p, x, y, width, height);
+   return image_to_handle(image_child_image(p, x, y, width, height));
 }
 
 VGImage vegaGetParent(VGImage image)
@@ -261,9 +262,9 @@ VGImage vegaGetParent(VGImage image)
       return VG_INVALID_HANDLE;
    }
 
-   img = (struct vg_image*)image;
+   img = handle_to_image(image);
    if (img->parent)
-      return (VGImage)img->parent;
+      return image_to_handle(img->parent);
    else
       return image;
 }
@@ -285,8 +286,8 @@ void vegaCopyImage(VGImage dst, VGint dx, VGint dy,
       return;
    }
    vg_validate_state(ctx);
-   image_copy((struct vg_image*)dst, dx, dy,
-              (struct vg_image*)src, sx, sy,
+   image_copy(handle_to_image(dst), dx, dy,
+              handle_to_image(src), sx, sy,
               width, height, dither);
 }
 
@@ -303,7 +304,7 @@ void vegaDrawImage(VGImage image)
    }
 
    vg_validate_state(ctx);
-   image_draw((struct vg_image*)image,
+   image_draw(handle_to_image(image),
          &ctx->state.vg.image_user_to_surface_matrix);
 }
 
@@ -323,7 +324,7 @@ void vegaSetPixels(VGint dx, VGint dy,
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       return;
    }
-   image_set_pixels(dx, dy, (struct vg_image*)src, sx, sy, width,
+   image_set_pixels(dx, dy, handle_to_image(src), sx, sy, width,
                     height);
 }
 
@@ -343,7 +344,7 @@ void vegaGetPixels(VGImage dst, VGint dx, VGint dy,
       return;
    }
 
-   img = (struct vg_image*)dst;
+   img = handle_to_image(dst);
 
    image_get_pixels(img, dx, dy,
                     sx, sy, width, height);
@@ -487,7 +488,7 @@ void vegaCopyPixels(VGint dx, VGint dy,
 
    vg_validate_state(ctx);
    /* make sure rendering has completed */
-   vgFinish();
+   vegaFinish();
 
    vg_copy_surface(ctx, strb->surface, dx, dy,
                    strb->surface, sx, sy, width, height);
diff --git a/src/gallium/state_trackers/vega/api_masks.c b/src/gallium/state_trackers/vega/api_masks.c
index d96afe66387..cdbf0026e89 100644
--- a/src/gallium/state_trackers/vega/api_masks.c
+++ b/src/gallium/state_trackers/vega/api_masks.c
@@ -28,6 +28,7 @@
 
 #include "mask.h"
 #include "api.h"
+#include "handle.h"
 #include "renderer.h"
 
 #include "vg_context.h"
@@ -56,11 +57,11 @@ void vegaMask(VGHandle mask, VGMaskOperation operation,
       mask_fill(x, y, width, height, 0.f);
    } else if (operation == VG_FILL_MASK) {
       mask_fill(x, y, width, height, 1.f);
-   } else if (vg_object_is_valid((void*)mask, VG_OBJECT_IMAGE)) {
-      struct vg_image *image = (struct vg_image *)mask;
+   } else if (vg_object_is_valid(mask, VG_OBJECT_IMAGE)) {
+      struct vg_image *image = handle_to_image(mask);
       mask_using_image(image, operation, x, y, width, height);
-   } else if (vg_object_is_valid((void*)mask, VG_OBJECT_MASK)) {
-      struct vg_mask_layer *layer = (struct vg_mask_layer *)mask;
+   } else if (vg_object_is_valid(mask, VG_OBJECT_MASK)) {
+      struct vg_mask_layer *layer = handle_to_masklayer(mask);
       mask_using_layer(layer, operation, x, y, width, height);
    } else {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
@@ -123,14 +124,14 @@ void vegaRenderToMask(VGPath path,
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       return;
    }
-   if (!vg_object_is_valid((void*)path, VG_OBJECT_PATH)) {
+   if (!vg_object_is_valid(path, VG_OBJECT_PATH)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
 
    vg_validate_state(ctx);
 
-   mask_render_to((struct path *)path, paintModes, operation);
+   mask_render_to(handle_to_path(path), paintModes, operation);
 }
 
 VGMaskLayer vegaCreateMaskLayer(VGint width, VGint height)
@@ -138,13 +139,13 @@ VGMaskLayer vegaCreateMaskLayer(VGint width, VGint height)
    struct vg_context *ctx = vg_current_context();
 
    if (width <= 0 || height <= 0 ||
-       width > vgGeti(VG_MAX_IMAGE_WIDTH) ||
-       height > vgGeti(VG_MAX_IMAGE_HEIGHT)) {
+       width > vegaGeti(VG_MAX_IMAGE_WIDTH) ||
+       height > vegaGeti(VG_MAX_IMAGE_HEIGHT)) {
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       return VG_INVALID_HANDLE;
    }
 
-   return (VGMaskLayer)mask_layer_create(width, height);
+   return masklayer_to_handle(mask_layer_create(width, height));
 }
 
 void vegaDestroyMaskLayer(VGMaskLayer maskLayer)
@@ -156,12 +157,12 @@ void vegaDestroyMaskLayer(VGMaskLayer maskLayer)
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
-   if (!vg_object_is_valid((void*)maskLayer, VG_OBJECT_MASK)) {
+   if (!vg_object_is_valid(maskLayer, VG_OBJECT_MASK)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
 
-   mask = (struct vg_mask_layer *)maskLayer;
+   mask = handle_to_masklayer(maskLayer);
    mask_layer_destroy(mask);
 }
 
@@ -192,12 +193,12 @@ void vegaFillMaskLayer(VGMaskLayer maskLayer,
       return;
    }
 
-   if (!vg_object_is_valid((void*)maskLayer, VG_OBJECT_MASK)) {
+   if (!vg_object_is_valid(maskLayer, VG_OBJECT_MASK)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
 
-   mask = (struct vg_mask_layer*)maskLayer;
+   mask = handle_to_masklayer(maskLayer);
 
    if (x + width > mask_layer_width(mask) ||
        y + height > mask_layer_height(mask)) {
@@ -226,14 +227,14 @@ void vegaCopyMask(VGMaskLayer maskLayer,
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       return;
    }
-   if (!vg_object_is_valid((void*)maskLayer, VG_OBJECT_MASK)) {
+   if (!vg_object_is_valid(maskLayer, VG_OBJECT_MASK)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
 
    vg_validate_state(ctx);
 
-   mask = (struct vg_mask_layer*)maskLayer;
+   mask = handle_to_masklayer(maskLayer);
    mask_copy(mask, sx, sy, dx, dy, width, height);
 }
 
diff --git a/src/gallium/state_trackers/vega/api_paint.c b/src/gallium/state_trackers/vega/api_paint.c
index 1411806455c..2610ebe0576 100644
--- a/src/gallium/state_trackers/vega/api_paint.c
+++ b/src/gallium/state_trackers/vega/api_paint.c
@@ -29,24 +29,24 @@
 #include "vg_context.h"
 #include "paint.h"
 #include "api.h"
+#include "handle.h"
+
 
 VGPaint vegaCreatePaint(void)
 {
-   return (VGPaint) paint_create(vg_current_context());
+   return paint_to_handle(paint_create(vg_current_context()));
 }
 
 void vegaDestroyPaint(VGPaint p)
 {
    struct vg_context *ctx = vg_current_context();
-   struct vg_paint *paint;
 
    if (p == VG_INVALID_HANDLE) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
 
-   paint = (struct vg_paint *)p;
-   paint_destroy(paint);
+   paint_destroy(handle_to_paint(p));
 }
 
 void vegaSetPaint(VGPaint paint, VGbitfield paintModes)
@@ -55,8 +55,8 @@ void vegaSetPaint(VGPaint paint, VGbitfield paintModes)
 
    if (paint == VG_INVALID_HANDLE) {
       /* restore the default */
-      paint = (VGPaint)ctx->default_paint;
-   } else if (!vg_object_is_valid((void*)paint, VG_OBJECT_PAINT)) {
+      paint = paint_to_handle(ctx->default_paint);
+   } else if (!vg_object_is_valid(paint, VG_OBJECT_PAINT)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
@@ -67,11 +67,13 @@ void vegaSetPaint(VGPaint paint, VGbitfield paintModes)
    }
 
    if (paintModes & VG_FILL_PATH) {
-      ctx->state.vg.fill_paint = (struct vg_paint *)paint;
+      ctx->state.vg.fill_paint = handle_to_paint(paint);
    }
    if (paintModes & VG_STROKE_PATH) {
-      ctx->state.vg.stroke_paint = (struct vg_paint *)paint;
+      ctx->state.vg.stroke_paint = handle_to_paint(paint);
    }
+
+   ctx->state.dirty |= PAINT_DIRTY;
 }
 
 VGPaint vegaGetPaint(VGPaintMode paintMode)
@@ -85,11 +87,11 @@ VGPaint vegaGetPaint(VGPaintMode paintMode)
    }
 
    if (paintMode == VG_FILL_PATH)
-      paint = (VGPaint)ctx->state.vg.fill_paint;
+      paint = paint_to_handle(ctx->state.vg.fill_paint);
    else if (paintMode == VG_STROKE_PATH)
-      paint = (VGPaint)ctx->state.vg.stroke_paint;
+      paint = paint_to_handle(ctx->state.vg.stroke_paint);
 
-   if (paint == (VGPaint)ctx->default_paint)
+   if (paint == paint_to_handle(ctx->default_paint))
       paint = VG_INVALID_HANDLE;
 
    return paint;
@@ -98,20 +100,24 @@ VGPaint vegaGetPaint(VGPaintMode paintMode)
 void vegaSetColor(VGPaint paint, VGuint rgba)
 {
    struct vg_context *ctx = vg_current_context();
+   struct vg_paint *p;
 
    if (paint == VG_INVALID_HANDLE) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
 
-   if (!vg_object_is_valid((void*)paint, VG_OBJECT_PAINT)) {
+   if (!vg_object_is_valid(paint, VG_OBJECT_PAINT)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
-   {
-      struct vg_paint *p = (struct vg_paint *)paint;
-      paint_set_colori(p, rgba);
-   }
+
+   p = handle_to_paint(paint);
+   paint_set_colori(p, rgba);
+
+   if (ctx->state.vg.fill_paint == p ||
+       ctx->state.vg.stroke_paint == p)
+      ctx->state.dirty |= PAINT_DIRTY;
 }
 
 VGuint vegaGetColor(VGPaint paint)
@@ -125,11 +131,11 @@ VGuint vegaGetColor(VGPaint paint)
       return rgba;
    }
 
-   if (!vg_object_is_valid((void*)paint, VG_OBJECT_PAINT)) {
+   if (!vg_object_is_valid(paint, VG_OBJECT_PAINT)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return rgba;
    }
-   p = (struct vg_paint *)paint;
+   p = handle_to_paint(paint);
 
    return paint_colori(p);
 }
@@ -139,28 +145,28 @@ void vegaPaintPattern(VGPaint paint, VGImage pattern)
    struct vg_context *ctx = vg_current_context();
 
    if (paint == VG_INVALID_HANDLE ||
-       !vg_context_is_object_valid(ctx, VG_OBJECT_PAINT, (void *)paint)) {
+       !vg_context_is_object_valid(ctx, VG_OBJECT_PAINT, paint)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
 
    if (pattern == VG_INVALID_HANDLE) {
-      paint_set_type((struct vg_paint*)paint, VG_PAINT_TYPE_COLOR);
+      paint_set_type(handle_to_paint(paint), VG_PAINT_TYPE_COLOR);
       return;
    }
 
-   if (!vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, (void *)pattern)) {
+   if (!vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, pattern)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
 
 
-   if (!vg_object_is_valid((void*)paint, VG_OBJECT_PAINT) ||
-       !vg_object_is_valid((void*)pattern, VG_OBJECT_IMAGE)) {
+   if (!vg_object_is_valid(paint, VG_OBJECT_PAINT) ||
+       !vg_object_is_valid(pattern, VG_OBJECT_IMAGE)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
-   paint_set_pattern((struct vg_paint*)paint,
-                     (struct vg_image*)pattern);
+   paint_set_pattern(handle_to_paint(paint),
+                     handle_to_image(pattern));
 }
 
diff --git a/src/gallium/state_trackers/vega/api_params.c b/src/gallium/state_trackers/vega/api_params.c
index a73b6c3effe..aa1e5dd280a 100644
--- a/src/gallium/state_trackers/vega/api_params.c
+++ b/src/gallium/state_trackers/vega/api_params.c
@@ -29,6 +29,7 @@
 #include "vg_context.h"
 #include "paint.h"
 #include "path.h"
+#include "handle.h"
 #include "image.h"
 #include "text.h"
 #include "matrix.h"
@@ -60,7 +61,7 @@ static INLINE VGboolean count_in_bounds(VGParamType type, VGint count)
    else if (type == VG_STROKE_DASH_PATTERN) {
       return count <= VEGA_MAX_DASH_COUNT;
    } else {
-      VGint real_count = vgGetVectorSize(type);
+      VGint real_count = vegaGetVectorSize(type);
       return count == real_count;
    }
 }
@@ -103,7 +104,7 @@ void vegaSetf (VGParamType type, VGfloat value)
    case VG_MAX_IMAGE_BYTES:
    case VG_MAX_GAUSSIAN_STD_DEVIATION:
    case VG_MAX_FLOAT:
-      vgSeti(type, floor(value));
+      vegaSeti(type, floor(value));
       return;
       break;
    case VG_STROKE_LINE_WIDTH:
@@ -289,7 +290,7 @@ void vegaSetfv(VGParamType type, VGint count,
    case VG_FILTER_FORMAT_LINEAR:
    case VG_FILTER_FORMAT_PREMULTIPLIED:
    case VG_FILTER_CHANNEL_MASK:
-      vgSeti(type, floor(values[0]));
+      vegaSeti(type, floor(values[0]));
       return;
       break;
    case VG_SCISSOR_RECTS: {
@@ -416,7 +417,7 @@ void vegaSetiv(VGParamType type, VGint count,
    case VG_FILTER_FORMAT_LINEAR:
    case VG_FILTER_FORMAT_PREMULTIPLIED:
    case VG_FILTER_CHANNEL_MASK:
-      vgSeti(type, values[0]);
+      vegaSeti(type, values[0]);
       return;
       break;
    case VG_SCISSOR_RECTS: {
@@ -536,7 +537,7 @@ VGfloat vegaGetf(VGParamType type)
    case VG_FILTER_FORMAT_LINEAR:
    case VG_FILTER_FORMAT_PREMULTIPLIED:
    case VG_FILTER_CHANNEL_MASK:
-      return vgGeti(type);
+      return vegaGeti(type);
       break;
    case VG_STROKE_LINE_WIDTH:
       value = state->stroke.line_width.f;
@@ -558,7 +559,7 @@ VGfloat vegaGetf(VGParamType type)
    case VG_MAX_IMAGE_PIXELS:
    case VG_MAX_IMAGE_BYTES:
    case VG_MAX_GAUSSIAN_STD_DEVIATION:
-      return vgGeti(type);
+      return vegaGeti(type);
       break;
    case VG_MAX_FLOAT:
       value = 1e+10;/*must be at least 1e+10*/
@@ -674,7 +675,7 @@ VGint vegaGeti(VGParamType type)
       break;
 
    case VG_MAX_FLOAT: {
-      VGfloat val = vgGetf(type);
+      VGfloat val = vegaGetf(type);
       value = float_to_int_floor(*((VGuint*)&val));
    }
       break;
@@ -765,7 +766,7 @@ void vegaGetfv(VGParamType type, VGint count,
 {
    const struct vg_state *state = current_state();
    struct vg_context *ctx = vg_current_context();
-   VGint real_count = vgGetVectorSize(type);
+   VGint real_count = vegaGetVectorSize(type);
 
    if (!values || count <= 0 || count > real_count || !is_aligned(values)) {
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
@@ -802,10 +803,10 @@ void vegaGetfv(VGParamType type, VGint count,
    case VG_MAX_IMAGE_PIXELS:
    case VG_MAX_IMAGE_BYTES:
    case VG_MAX_GAUSSIAN_STD_DEVIATION:
-      values[0] = vgGeti(type);
+      values[0] = vegaGeti(type);
       break;
    case VG_MAX_FLOAT:
-      values[0] = vgGetf(type);
+      values[0] = vegaGetf(type);
       break;
    case VG_SCISSOR_RECTS: {
       VGint i;
@@ -866,7 +867,7 @@ void vegaGetiv(VGParamType type, VGint count,
 {
    const struct vg_state *state = current_state();
    struct vg_context *ctx = vg_current_context();
-   VGint real_count = vgGetVectorSize(type);
+   VGint real_count = vegaGetVectorSize(type);
 
    if (!values || count <= 0 || count > real_count || !is_aligned(values)) {
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
@@ -903,10 +904,10 @@ void vegaGetiv(VGParamType type, VGint count,
    case VG_MAX_IMAGE_PIXELS:
    case VG_MAX_IMAGE_BYTES:
    case VG_MAX_GAUSSIAN_STD_DEVIATION:
-      values[0] = vgGeti(type);
+      values[0] = vegaGeti(type);
       break;
    case VG_MAX_FLOAT: {
-      VGfloat val = vgGetf(type);
+      VGfloat val = vegaGetf(type);
       values[0] = float_to_int_floor(*((VGuint*)&val));
    }
       break;
@@ -972,9 +973,9 @@ void vegaSetParameterf(VGHandle object,
                        VGfloat value)
 {
    struct vg_context *ctx = vg_current_context();
-   void *ptr = (void*)object;
+   void *ptr = handle_to_pointer(object);
 
-   if (!object || object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
+   if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
@@ -983,7 +984,7 @@ void vegaSetParameterf(VGHandle object,
    case VG_PAINT_TYPE:
    case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
    case VG_PAINT_PATTERN_TILING_MODE:
-      vgSetParameteri(object, paramType, floor(value));
+      vegaSetParameteri(object, paramType, floor(value));
       return;
       break;
    case VG_PAINT_COLOR:
@@ -994,7 +995,7 @@ void vegaSetParameterf(VGHandle object,
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       break;
    case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: {
-      struct vg_paint *p = (struct vg_paint *)object;
+      struct vg_paint *p = handle_to_paint(object);
       paint_set_color_ramp_premultiplied(p, value);
    }
       break;
@@ -1026,9 +1027,9 @@ void vegaSetParameteri(VGHandle object,
                        VGint value)
 {
    struct vg_context *ctx = vg_current_context();
-   void *ptr = (void*)object;
+   void *ptr = handle_to_pointer(object);
 
-   if (!object || object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
+   if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
@@ -1039,7 +1040,7 @@ void vegaSetParameteri(VGHandle object,
           value > VG_PAINT_TYPE_PATTERN)
          vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       else {
-         struct vg_paint *paint = (struct vg_paint *)ptr;
+         struct vg_paint *paint = handle_to_paint(object);
          paint_set_type(paint, value);
       }
       break;
@@ -1055,12 +1056,12 @@ void vegaSetParameteri(VGHandle object,
           value > VG_COLOR_RAMP_SPREAD_REFLECT)
          vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       else {
-         struct vg_paint *paint = (struct vg_paint *)ptr;
+         struct vg_paint *paint = handle_to_paint(object);
          paint_set_spread_mode(paint, value);
       }
       break;
    case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: {
-      struct vg_paint *p = (struct vg_paint *)object;
+      struct vg_paint *p = handle_to_paint(object);
       paint_set_color_ramp_premultiplied(p, value);
    }
       break;
@@ -1069,7 +1070,7 @@ void vegaSetParameteri(VGHandle object,
           value > VG_TILE_REFLECT)
          vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       else {
-         struct vg_paint *paint = (struct vg_paint *)ptr;
+         struct vg_paint *paint = handle_to_paint(object);
          paint_set_pattern_tiling(paint, value);
       }
       break;
@@ -1102,10 +1103,10 @@ void vegaSetParameterfv(VGHandle object,
                         const VGfloat * values)
 {
    struct vg_context *ctx = vg_current_context();
-   void *ptr = (void*)object;
-   VGint real_count = vgGetParameterVectorSize(object, paramType);
+   void *ptr = handle_to_pointer(object);
+   VGint real_count = vegaGetParameterVectorSize(object, paramType);
 
-   if (!object || object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
+   if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
@@ -1125,15 +1126,18 @@ void vegaSetParameterfv(VGHandle object,
       if (count != 1)
          vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       else
-         vgSetParameterf(object, paramType, values[0]);
+         vegaSetParameterf(object, paramType, values[0]);
       return;
       break;
    case VG_PAINT_COLOR: {
       if (count != 4)
          vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       else {
-         struct vg_paint *paint = (struct vg_paint *)object;
+         struct vg_paint *paint = handle_to_paint(object);
          paint_set_color(paint, values);
+         if (ctx->state.vg.fill_paint == paint ||
+             ctx->state.vg.stroke_paint == paint)
+            ctx->state.dirty |= PAINT_DIRTY;
       }
    }
       break;
@@ -1141,7 +1145,7 @@ void vegaSetParameterfv(VGHandle object,
       if (count && count < 4)
          vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       else {
-         struct vg_paint *paint = (struct vg_paint *)object;
+         struct vg_paint *paint = handle_to_paint(object);
          count = MIN2(count, VEGA_MAX_COLOR_RAMP_STOPS);
          paint_set_ramp_stops(paint, values, count);
          {
@@ -1159,7 +1163,7 @@ void vegaSetParameterfv(VGHandle object,
       if (count != 4)
          vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       else {
-         struct vg_paint *paint = (struct vg_paint *)object;
+         struct vg_paint *paint = handle_to_paint(object);
          paint_set_linear_gradient(paint, values);
          {
             VGint vals[4];
@@ -1176,7 +1180,7 @@ void vegaSetParameterfv(VGHandle object,
       if (count != 5)
          vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       else {
-         struct vg_paint *paint = (struct vg_paint *)object;
+         struct vg_paint *paint = handle_to_paint(object);
          paint_set_radial_gradient(paint, values);
          {
             VGint vals[5];
@@ -1215,10 +1219,10 @@ void vegaSetParameteriv(VGHandle object,
                         const VGint * values)
 {
    struct vg_context *ctx = vg_current_context();
-   void *ptr = (void*)object;
-   VGint real_count = vgGetParameterVectorSize(object, paramType);
+   void *ptr = handle_to_pointer(object);
+   VGint real_count = vegaGetParameterVectorSize(object, paramType);
 
-   if (!object || object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
+   if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
@@ -1238,15 +1242,18 @@ void vegaSetParameteriv(VGHandle object,
       if (count != 1)
          vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       else
-         vgSetParameteri(object, paramType, values[0]);
+         vegaSetParameteri(object, paramType, values[0]);
       return;
       break;
    case VG_PAINT_COLOR: {
       if (count != 4)
          vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       else {
-         struct vg_paint *paint = (struct vg_paint *)object;
+         struct vg_paint *paint = handle_to_paint(object);
          paint_set_coloriv(paint, values);
+         if (ctx->state.vg.fill_paint == paint ||
+             ctx->state.vg.stroke_paint == paint)
+            ctx->state.dirty |= PAINT_DIRTY;
       }
    }
       break;
@@ -1256,7 +1263,7 @@ void vegaSetParameteriv(VGHandle object,
       else {
          VGfloat *vals = 0;
          int i;
-         struct vg_paint *paint = (struct vg_paint *)object;
+         struct vg_paint *paint = handle_to_paint(object);
          if (count) {
             vals = malloc(sizeof(VGfloat)*count);
             for (i = 0; i < count; ++i)
@@ -1274,7 +1281,7 @@ void vegaSetParameteriv(VGHandle object,
          vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       else {
          VGfloat vals[4];
-         struct vg_paint *paint = (struct vg_paint *)object;
+         struct vg_paint *paint = handle_to_paint(object);
          vals[0] = values[0];
          vals[1] = values[1];
          vals[2] = values[2];
@@ -1289,7 +1296,7 @@ void vegaSetParameteriv(VGHandle object,
          vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       else {
          VGfloat vals[5];
-         struct vg_paint *paint = (struct vg_paint *)object;
+         struct vg_paint *paint = handle_to_paint(object);
          vals[0] = values[0];
          vals[1] = values[1];
          vals[2] = values[2];
@@ -1318,9 +1325,8 @@ VGint vegaGetParameterVectorSize(VGHandle object,
                                  VGint paramType)
 {
    struct vg_context *ctx = vg_current_context();
-   void *ptr = (void*)object;
 
-   if (!ptr || object == VG_INVALID_HANDLE) {
+   if (object == VG_INVALID_HANDLE) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return 0;
    }
@@ -1334,7 +1340,7 @@ VGint vegaGetParameterVectorSize(VGHandle object,
    case VG_PAINT_COLOR:
       return 4;
    case VG_PAINT_COLOR_RAMP_STOPS: {
-      struct vg_paint *p = (struct vg_paint *)object;
+      struct vg_paint *p = handle_to_paint(object);
       return paint_num_ramp_stops(p);
    }
       break;
@@ -1374,9 +1380,8 @@ VGfloat vegaGetParameterf(VGHandle object,
                           VGint paramType)
 {
    struct vg_context *ctx = vg_current_context();
-   void *ptr = (void*)object;
 
-   if (!ptr || object == VG_INVALID_HANDLE) {
+   if (object == VG_INVALID_HANDLE) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return 0;
    }
@@ -1386,7 +1391,7 @@ VGfloat vegaGetParameterf(VGHandle object,
    case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
    case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:
    case VG_PAINT_PATTERN_TILING_MODE:
-      return vgGetParameteri(object, paramType);
+      return vegaGetParameteri(object, paramType);
       break;
    case VG_PAINT_COLOR:
    case VG_PAINT_COLOR_RAMP_STOPS:
@@ -1398,17 +1403,17 @@ VGfloat vegaGetParameterf(VGHandle object,
    case VG_PATH_FORMAT:
       return VG_PATH_FORMAT_STANDARD;
    case VG_PATH_SCALE: {
-      struct path *p = (struct path*)object;
+      struct path *p = handle_to_path(object);
       return path_scale(p);
    }
    case VG_PATH_BIAS: {
-      struct path *p = (struct path*)object;
+      struct path *p = handle_to_path(object);
       return path_bias(p);
    }
    case VG_PATH_DATATYPE:
    case VG_PATH_NUM_SEGMENTS:
    case VG_PATH_NUM_COORDS:
-      return vgGetParameteri(object, paramType);
+      return vegaGetParameteri(object, paramType);
       break;
 
    case VG_IMAGE_FORMAT:
@@ -1416,7 +1421,7 @@ VGfloat vegaGetParameterf(VGHandle object,
    case VG_IMAGE_HEIGHT:
 #ifdef OPENVG_VERSION_1_1
    case VG_FONT_NUM_GLYPHS: 
-      return vgGetParameteri(object, paramType);
+      return vegaGetParameteri(object, paramType);
       break;
 #endif
 
@@ -1431,30 +1436,29 @@ VGint vegaGetParameteri(VGHandle object,
                         VGint paramType)
 {
    struct vg_context *ctx = vg_current_context();
-   void *ptr = (void*)object;
 
-   if (!ptr || object == VG_INVALID_HANDLE) {
+   if (object == VG_INVALID_HANDLE) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return 0;
    }
 
    switch(paramType) {
    case VG_PAINT_TYPE: {
-         struct vg_paint *paint = (struct vg_paint *)ptr;
+         struct vg_paint *paint = handle_to_paint(object);
          return paint_type(paint);
    }
       break;
    case VG_PAINT_COLOR_RAMP_SPREAD_MODE: {
-      struct vg_paint *p = (struct vg_paint *)object;
+      struct vg_paint *p = handle_to_paint(object);
       return paint_spread_mode(p);
    }
    case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: {
-      struct vg_paint *p = (struct vg_paint *)object;
+      struct vg_paint *p = handle_to_paint(object);
       return paint_color_ramp_premultiplied(p);
    }
       break;
    case VG_PAINT_PATTERN_TILING_MODE: {
-      struct vg_paint *p = (struct vg_paint *)object;
+      struct vg_paint *p = handle_to_paint(object);
       return paint_pattern_tiling(p);
    }
       break;
@@ -1469,40 +1473,40 @@ VGint vegaGetParameteri(VGHandle object,
       return VG_PATH_FORMAT_STANDARD;
    case VG_PATH_SCALE:
    case VG_PATH_BIAS:
-      return vgGetParameterf(object, paramType);
+      return vegaGetParameterf(object, paramType);
    case VG_PATH_DATATYPE: {
-      struct path *p = (struct path*)object;
+      struct path *p = handle_to_path(object);
       return path_datatype(p);
    }
    case VG_PATH_NUM_SEGMENTS: {
-      struct path *p = (struct path*)object;
+      struct path *p = handle_to_path(object);
       return path_num_segments(p);
    }
    case VG_PATH_NUM_COORDS: {
-      struct path *p = (struct path*)object;
+      struct path *p = handle_to_path(object);
       return path_num_coords(p);
    }
       break;
 
    case VG_IMAGE_FORMAT: {
-      struct vg_image *img = (struct vg_image*)object;
+      struct vg_image *img = handle_to_image(object);
       return img->format;
    }
       break;
    case VG_IMAGE_WIDTH: {
-      struct vg_image *img = (struct vg_image*)object;
+      struct vg_image *img = handle_to_image(object);
       return img->width;
    }
       break;
    case VG_IMAGE_HEIGHT: {
-      struct vg_image *img = (struct vg_image*)object;
+      struct vg_image *img = handle_to_image(object);
       return img->height;
    }
       break;
 
 #ifdef OPENVG_VERSION_1_1
    case VG_FONT_NUM_GLYPHS: {
-      struct vg_font *font = (struct vg_font*)object;
+      struct vg_font *font = handle_to_font(object);
       return font_num_glyphs(font);
    }
       break;
@@ -1521,10 +1525,9 @@ void vegaGetParameterfv(VGHandle object,
                         VGfloat * values)
 {
    struct vg_context *ctx = vg_current_context();
-   void *ptr = (void*)object;
-   VGint real_count = vgGetParameterVectorSize(object, paramType);
+   VGint real_count = vegaGetParameterVectorSize(object, paramType);
 
-   if (!ptr || object == VG_INVALID_HANDLE) {
+   if (object == VG_INVALID_HANDLE) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
@@ -1537,41 +1540,41 @@ void vegaGetParameterfv(VGHandle object,
 
    switch(paramType) {
    case VG_PAINT_TYPE: {
-      struct vg_paint *p = (struct vg_paint *)object;
+      struct vg_paint *p = handle_to_paint(object);
       values[0] = paint_type(p);
    }
       break;
    case VG_PAINT_COLOR_RAMP_SPREAD_MODE: {
-      struct vg_paint *p = (struct vg_paint *)object;
+      struct vg_paint *p = handle_to_paint(object);
       values[0] = paint_spread_mode(p);
    }
       break;
    case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: {
-      struct vg_paint *p = (struct vg_paint *)object;
+      struct vg_paint *p = handle_to_paint(object);
       values[0] = paint_color_ramp_premultiplied(p);
    }
       break;
    case VG_PAINT_PATTERN_TILING_MODE: {
-      values[0] = vgGetParameterf(object, paramType);
+      values[0] = vegaGetParameterf(object, paramType);
    }
       break;
    case VG_PAINT_COLOR: {
-      struct vg_paint *paint = (struct vg_paint *)object;
+      struct vg_paint *paint = handle_to_paint(object);
       paint_get_color(paint, values);
    }
       break;
    case VG_PAINT_COLOR_RAMP_STOPS: {
-      struct vg_paint *paint = (struct vg_paint *)object;
+      struct vg_paint *paint = handle_to_paint(object);
       paint_ramp_stops(paint, values, count);
    }
       break;
    case VG_PAINT_LINEAR_GRADIENT: {
-      struct vg_paint *paint = (struct vg_paint *)object;
+      struct vg_paint *paint = handle_to_paint(object);
       paint_linear_gradient(paint, values);
    }
       break;
    case VG_PAINT_RADIAL_GRADIENT: {
-      struct vg_paint *paint = (struct vg_paint *)object;
+      struct vg_paint *paint = handle_to_paint(object);
       paint_radial_gradient(paint, values);
    }
       break;
@@ -1580,11 +1583,11 @@ void vegaGetParameterfv(VGHandle object,
    case VG_PATH_DATATYPE:
    case VG_PATH_NUM_SEGMENTS:
    case VG_PATH_NUM_COORDS:
-      values[0] = vgGetParameteri(object, paramType);
+      values[0] = vegaGetParameteri(object, paramType);
       break;
    case VG_PATH_SCALE:
    case VG_PATH_BIAS:
-      values[0] = vgGetParameterf(object, paramType);
+      values[0] = vegaGetParameterf(object, paramType);
       break;
 
    case VG_IMAGE_FORMAT:
@@ -1592,7 +1595,7 @@ void vegaGetParameterfv(VGHandle object,
    case VG_IMAGE_HEIGHT:
 #ifdef OPENVG_VERSION_1_1
    case VG_FONT_NUM_GLYPHS:
-      values[0] = vgGetParameteri(object, paramType);
+      values[0] = vegaGetParameteri(object, paramType);
       break;
 #endif
 
@@ -1608,10 +1611,9 @@ void vegaGetParameteriv(VGHandle object,
                         VGint * values)
 {
    struct vg_context *ctx = vg_current_context();
-   void *ptr = (void*)object;
-   VGint real_count = vgGetParameterVectorSize(object, paramType);
+   VGint real_count = vegaGetParameterVectorSize(object, paramType);
 
-   if (!ptr || object == VG_INVALID_HANDLE) {
+   if (object || object == VG_INVALID_HANDLE) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
@@ -1629,45 +1631,45 @@ void vegaGetParameteriv(VGHandle object,
    case VG_PAINT_PATTERN_TILING_MODE:
 #ifdef OPENVG_VERSION_1_1
    case VG_FONT_NUM_GLYPHS:
-      values[0] = vgGetParameteri(object, paramType);
+      values[0] = vegaGetParameteri(object, paramType);
       break;
 #endif
    case VG_PAINT_COLOR: {
-      struct vg_paint *paint = (struct vg_paint *)object;
+      struct vg_paint *paint = handle_to_paint(object);
       paint_get_coloriv(paint, values);
    }
       break;
    case VG_PAINT_COLOR_RAMP_STOPS: {
-      struct vg_paint *paint = (struct vg_paint *)object;
+      struct vg_paint *paint = handle_to_paint(object);
       paint_ramp_stopsi(paint, values, count);
    }
       break;
    case VG_PAINT_LINEAR_GRADIENT: {
-      struct vg_paint *paint = (struct vg_paint *)object;
+      struct vg_paint *paint = handle_to_paint(object);
       paint_linear_gradienti(paint, values);
    }
       break;
    case VG_PAINT_RADIAL_GRADIENT: {
-      struct vg_paint *paint = (struct vg_paint *)object;
+      struct vg_paint *paint = handle_to_paint(object);
       paint_radial_gradienti(paint, values);
    }
       break;
 
    case VG_PATH_SCALE:
    case VG_PATH_BIAS:
-      values[0] = vgGetParameterf(object, paramType);
+      values[0] = vegaGetParameterf(object, paramType);
       break;
    case VG_PATH_FORMAT:
    case VG_PATH_DATATYPE:
    case VG_PATH_NUM_SEGMENTS:
    case VG_PATH_NUM_COORDS:
-      values[0] = vgGetParameteri(object, paramType);
+      values[0] = vegaGetParameteri(object, paramType);
       break;
 
    case VG_IMAGE_FORMAT:
    case VG_IMAGE_WIDTH:
    case VG_IMAGE_HEIGHT:
-      values[0] = vgGetParameteri(object, paramType);
+      values[0] = vegaGetParameteri(object, paramType);
       break;
 
    default:
diff --git a/src/gallium/state_trackers/vega/api_path.c b/src/gallium/state_trackers/vega/api_path.c
index fe57b7671d9..ab6ce958945 100644
--- a/src/gallium/state_trackers/vega/api_path.c
+++ b/src/gallium/state_trackers/vega/api_path.c
@@ -27,6 +27,7 @@
 #include "VG/openvg.h"
 
 #include "vg_context.h"
+#include "handle.h"
 #include "path.h"
 #include "api.h"
 
@@ -55,9 +56,9 @@ VGPath vegaCreatePath(VGint pathFormat,
       return VG_INVALID_HANDLE;
    }
 
-   return (VGPath)path_create(datatype, scale, bias,
-                              segmentCapacityHint, coordCapacityHint,
-                              capabilities);
+   return path_to_handle(path_create(datatype, scale, bias,
+                                     segmentCapacityHint, coordCapacityHint,
+                                     capabilities));
 }
 
 void vegaClearPath(VGPath path, VGbitfield capabilities)
@@ -70,7 +71,7 @@ void vegaClearPath(VGPath path, VGbitfield capabilities)
       return;
    }
 
-   p = (struct path *)path;
+   p = handle_to_path(path);
    path_clear(p, capabilities);
 }
 
@@ -84,7 +85,7 @@ void vegaDestroyPath(VGPath p)
       return;
    }
 
-   path = (struct path *)p;
+   path = handle_to_path(p);
    path_destroy(path);
 }
 
@@ -100,7 +101,7 @@ void vegaRemovePathCapabilities(VGPath path,
       return;
    }
 
-   p = (struct path*)path;
+   p = handle_to_path(path);
    current = path_capabilities(p);
    path_set_capabilities(p, (current &
                              (~(capabilities & VG_PATH_CAPABILITY_ALL))));
@@ -115,7 +116,7 @@ VGbitfield vegaGetPathCapabilities(VGPath path)
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return 0;
    }
-   p = (struct path*)path;
+   p = handle_to_path(path);
    return path_capabilities(p);
 }
 
@@ -128,8 +129,8 @@ void vegaAppendPath(VGPath dstPath, VGPath srcPath)
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
-   src = (struct path *)srcPath;
-   dst = (struct path *)dstPath;
+   src = handle_to_path(srcPath);
+   dst = handle_to_path(dstPath);
 
    if (!(path_capabilities(src) & VG_PATH_CAPABILITY_APPEND_FROM) ||
        !(path_capabilities(dst) & VG_PATH_CAPABILITY_APPEND_TO)) {
@@ -167,9 +168,9 @@ void vegaAppendPathData(VGPath dstPath,
       }
    }
 
-   p = (struct path*)dstPath;
+   p = handle_to_path(dstPath);
 
-   if (!pathData || !is_aligned_to(pathData, path_datatype_size(p))) {
+   if (!p || !is_aligned_to(p, path_datatype_size(p))) {
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       return;
    }
@@ -199,7 +200,7 @@ void vegaModifyPathCoords(VGPath dstPath,
       return;
    }
 
-   p = (struct path *)dstPath;
+   p = handle_to_path(dstPath);
 
    if (!pathData || !is_aligned_to(pathData, path_datatype_size(p))) {
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
@@ -226,8 +227,8 @@ void vegaTransformPath(VGPath dstPath, VGPath srcPath)
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
-   src = (struct path *)srcPath;
-   dst = (struct path *)dstPath;
+   src = handle_to_path(srcPath);
+   dst = handle_to_path(dstPath);
 
    if (!(path_capabilities(src) & VG_PATH_CAPABILITY_TRANSFORM_FROM) ||
        !(path_capabilities(dst) & VG_PATH_CAPABILITY_TRANSFORM_TO)) {
@@ -251,9 +252,9 @@ VGboolean vegaInterpolatePath(VGPath dstPath,
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return VG_FALSE;
    }
-   dst = (struct path *)dstPath;
-   start = (struct path *)startPath;
-   end = (struct path *)endPath;
+   dst = handle_to_path(dstPath);
+   start = handle_to_path(startPath);
+   end = handle_to_path(endPath);
 
    if (!(path_capabilities(dst) & VG_PATH_CAPABILITY_INTERPOLATE_TO) ||
        !(path_capabilities(start) & VG_PATH_CAPABILITY_INTERPOLATE_FROM) ||
@@ -285,7 +286,7 @@ VGfloat vegaPathLength(VGPath path,
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       return -1;
    }
-   p = (struct path*)path;
+   p = handle_to_path(path);
 
    if (!(path_capabilities(p) & VG_PATH_CAPABILITY_PATH_LENGTH)) {
       vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
@@ -330,7 +331,7 @@ void vegaPointAlongPath(VGPath path,
       return;
    }
 
-   p = (struct path*)path;
+   p = handle_to_path(path);
 
    caps = path_capabilities(p);
    if (!(caps & VG_PATH_CAPABILITY_POINT_ALONG_PATH) ||
@@ -385,7 +386,7 @@ void vegaPathBounds(VGPath path,
       return;
    }
 
-   p = (struct path*)path;
+   p = handle_to_path(path);
 
    caps = path_capabilities(p);
    if (!(caps & VG_PATH_CAPABILITY_PATH_BOUNDS)) {
@@ -422,7 +423,7 @@ void vegaPathTransformedBounds(VGPath path,
       return;
    }
 
-   p = (struct path*)path;
+   p = handle_to_path(path);
 
    caps = path_capabilities(p);
    if (!(caps & VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS)) {
@@ -466,6 +467,7 @@ void vegaPathTransformedBounds(VGPath path,
 void vegaDrawPath(VGPath path, VGbitfield paintModes)
 {
    struct vg_context *ctx = vg_current_context();
+   struct path *p = handle_to_path(path);
 
    if (path == VG_INVALID_HANDLE) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
@@ -477,9 +479,9 @@ void vegaDrawPath(VGPath path, VGbitfield paintModes)
       return;
    }
 
-   if (path_is_empty((struct path*)path))
+   if (path_is_empty(p))
       return;
-   path_render((struct path*)path, paintModes,
+   path_render(p, paintModes,
          &ctx->state.vg.path_user_to_surface_matrix);
 }
 
diff --git a/src/gallium/state_trackers/vega/api_text.c b/src/gallium/state_trackers/vega/api_text.c
index 7c6b4794099..824c7630403 100644
--- a/src/gallium/state_trackers/vega/api_text.c
+++ b/src/gallium/state_trackers/vega/api_text.c
@@ -29,6 +29,7 @@
 #include "vg_context.h"
 #include "text.h"
 #include "api.h"
+#include "handle.h"
 
 #include "util/u_memory.h"
 
@@ -43,19 +44,19 @@ VGFont vegaCreateFont(VGint glyphCapacityHint)
       return VG_INVALID_HANDLE;
    }
 
-   return (VGFont) font_create(glyphCapacityHint);
+   return font_to_handle(font_create(glyphCapacityHint));
 }
 
 void vegaDestroyFont(VGFont f)
 {
-   struct vg_font *font = (struct vg_font *)f;
+   struct vg_font *font = handle_to_font(f);
    struct vg_context *ctx = vg_current_context();
 
    if (f == VG_INVALID_HANDLE) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
-   if (!vg_object_is_valid((void *) font, VG_OBJECT_FONT)) {
+   if (!vg_object_is_valid(f, VG_OBJECT_FONT)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
@@ -75,7 +76,7 @@ void vegaSetGlyphToPath(VGFont font,
    struct vg_font *f;
 
    if (font == VG_INVALID_HANDLE ||
-       !vg_context_is_object_valid(ctx, VG_OBJECT_FONT, (void *)font)) {
+       !vg_context_is_object_valid(ctx, VG_OBJECT_FONT, font)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
@@ -85,13 +86,13 @@ void vegaSetGlyphToPath(VGFont font,
       return;
    }
    if (path != VG_INVALID_HANDLE &&
-       !vg_context_is_object_valid(ctx, VG_OBJECT_PATH, (void *)path)) {
+       !vg_context_is_object_valid(ctx, VG_OBJECT_PATH, path)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
 
-   pathObj = (struct path*) path;
-   f = (struct vg_font*) font;
+   pathObj = handle_to_path(path);
+   f = handle_to_font(font);
 
    font_set_glyph_to_path(f, glyphIndex, pathObj,
          isHinted, glyphOrigin, escapement);
@@ -108,7 +109,7 @@ void vegaSetGlyphToImage(VGFont font,
    struct vg_font *f;
 
    if (font == VG_INVALID_HANDLE ||
-       !vg_context_is_object_valid(ctx, VG_OBJECT_FONT, (void *)font)) {
+       !vg_context_is_object_valid(ctx, VG_OBJECT_FONT, font)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
@@ -118,13 +119,13 @@ void vegaSetGlyphToImage(VGFont font,
       return;
    }
    if (image != VG_INVALID_HANDLE &&
-       !vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, (void *)image)) {
+       !vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, image)) {
       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
       return;
    }
 
-   img_obj = (struct vg_image*)image;
-   f = (struct vg_font*)font;
+   img_obj = handle_to_image(image);
+   f = handle_to_font(font);
 
    font_set_glyph_to_image(f, glyphIndex, img_obj, glyphOrigin, escapement);
 }
@@ -140,7 +141,7 @@ void vegaClearGlyph(VGFont font,
       return;
    }
 
-   f = (struct vg_font*) font;
+   f = handle_to_font(font);
 
    font_clear_glyph(f, glyphIndex);
 }
@@ -161,7 +162,7 @@ void vegaDrawGlyph(VGFont font,
       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
       return;
    }
-   f = (struct vg_font*)font;
+   f = handle_to_font(font);
 
    font_draw_glyph(f, glyphIndex, paintModes, allowAutoHinting);
 }
@@ -199,7 +200,7 @@ void vegaDrawGlyphs(VGFont font,
       return;
    }
 
-   f = (struct vg_font*)font;
+   f = handle_to_font(font);
 
    font_draw_glyphs(f, glyphCount, glyphIndices,
          adjustments_x, adjustments_y, paintModes, allowAutoHinting);
diff --git a/src/gallium/state_trackers/vega/handle.c b/src/gallium/state_trackers/vega/handle.c
new file mode 100644
index 00000000000..11eedd923ed
--- /dev/null
+++ b/src/gallium/state_trackers/vega/handle.c
@@ -0,0 +1,93 @@
+/**************************************************************************
+ *
+ * Copyright 2010 VMware, Inc.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+
+#include "handle.h"
+#include "util/u_hash.h"
+#include "util/u_hash_table.h"
+
+
+/**
+ * Hash keys are 32-bit VGHandles
+ */
+
+struct util_hash_table *handle_hash = NULL;
+
+
+static unsigned next_handle = 1;
+
+
+static unsigned
+hash_func(void *key)
+{
+   /* XXX this kind of ugly */
+   intptr_t ip = pointer_to_intptr(key);
+   return (unsigned) (ip & 0xffffffff);
+}
+
+
+static int
+compare(void *key1, void *key2)
+{
+   if (key1 < key2)
+      return -1;
+   else if (key1 > key2)
+      return +1;
+   else
+      return 0;
+}
+
+
+void
+init_handles(void)
+{
+   if (!handle_hash)
+      handle_hash = util_hash_table_create(hash_func, compare);
+}
+
+
+void
+free_handles(void)
+{
+   /* XXX destroy */
+}
+
+
+VGHandle
+create_handle(void *object)
+{
+   VGHandle h = next_handle++;
+   util_hash_table_set(handle_hash, intptr_to_pointer(h), object);
+   return h;
+}
+
+
+void
+destroy_handle(VGHandle h)
+{
+   util_hash_table_remove(handle_hash, intptr_to_pointer(h));
+}
+
diff --git a/src/gallium/state_trackers/vega/handle.h b/src/gallium/state_trackers/vega/handle.h
new file mode 100644
index 00000000000..9ed326d5098
--- /dev/null
+++ b/src/gallium/state_trackers/vega/handle.h
@@ -0,0 +1,171 @@
+/**************************************************************************
+ *
+ * Copyright 2010 VMware, Inc.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+
+/**
+ * Convert opaque VG object handles into pointers and vice versa.
+ * XXX This is not yet 64-bit safe!  All VG handles are 32 bits in size.
+ */
+
+
+#ifndef HANDLE_H
+#define HANDLE_H
+
+#include "pipe/p_compiler.h"
+#include "util/u_hash_table.h"
+#include "util/u_pointer.h"
+
+#include "VG/openvg.h"
+#include "vg_context.h"
+
+
+extern struct util_hash_table *handle_hash;
+
+
+struct vg_mask_layer;
+struct vg_font;
+struct vg_image;
+struct vg_paint;
+struct path;
+
+
+extern void
+init_handles(void);
+
+
+extern void
+free_handles(void);
+
+
+extern VGHandle
+create_handle(void *object);
+
+
+extern void
+destroy_handle(VGHandle h);
+
+
+static INLINE VGHandle
+object_to_handle(struct vg_object *obj)
+{
+   return obj ? obj->handle : VG_INVALID_HANDLE;
+}
+
+
+static INLINE VGHandle
+image_to_handle(struct vg_image *img)
+{
+   /* vg_image is derived from vg_object */
+   return object_to_handle((struct vg_object *) img);
+}
+
+
+static INLINE VGHandle
+masklayer_to_handle(struct vg_mask_layer *mask)
+{
+   /* vg_object is derived from vg_object */
+   return object_to_handle((struct vg_object *) mask);
+}
+
+
+static INLINE VGHandle
+font_to_handle(struct vg_font *font)
+{
+   return object_to_handle((struct vg_object *) font);
+}
+
+
+static INLINE VGHandle
+paint_to_handle(struct vg_paint *paint)
+{
+   return object_to_handle((struct vg_object *) paint);
+}
+
+
+static INLINE VGHandle
+path_to_handle(struct path *path)
+{
+   return object_to_handle((struct vg_object *) path);
+}
+
+
+static INLINE void *
+handle_to_pointer(VGHandle h)
+{
+   void *v = util_hash_table_get(handle_hash, intptr_to_pointer(h));
+#ifdef DEBUG
+   if (v) {
+      struct vg_object *obj = (struct vg_object *) v;
+      assert(obj->handle == h);
+   }
+#endif
+   return v;
+}
+
+
+static INLINE struct vg_font *
+handle_to_font(VGHandle h)
+{
+   return (struct vg_font *) handle_to_pointer(h);
+}
+
+
+static INLINE struct vg_image *
+handle_to_image(VGHandle h)
+{
+   return (struct vg_image *) handle_to_pointer(h);
+}
+
+
+static INLINE struct vg_mask_layer *
+handle_to_masklayer(VGHandle h)
+{
+   return (struct vg_mask_layer *) handle_to_pointer(h);
+}
+
+
+static INLINE struct vg_object *
+handle_to_object(VGHandle h)
+{
+   return (struct vg_object *) handle_to_pointer(h);
+}
+
+
+static INLINE struct vg_paint *
+handle_to_paint(VGHandle h)
+{
+   return (struct vg_paint *) handle_to_pointer(h);
+}
+
+
+static INLINE struct path *
+handle_to_path(VGHandle h)
+{
+   return (struct path *) handle_to_pointer(h);
+}
+
+
+#endif /* HANDLE_H */
diff --git a/src/gallium/state_trackers/vega/image.c b/src/gallium/state_trackers/vega/image.c
index 318ea94bdfb..73351b671f9 100644
--- a/src/gallium/state_trackers/vega/image.c
+++ b/src/gallium/state_trackers/vega/image.c
@@ -349,6 +349,8 @@ void image_destroy(struct vg_image *img)
       array_destroy(img->children_array);
    }
 
+   vg_free_object(&img->base);
+
    pipe_sampler_view_reference(&img->sampler_view, NULL);
    FREE(img);
 }
diff --git a/src/gallium/state_trackers/vega/paint.c b/src/gallium/state_trackers/vega/paint.c
index 2db8cbcf7c8..6e5348a1ff2 100644
--- a/src/gallium/state_trackers/vega/paint.c
+++ b/src/gallium/state_trackers/vega/paint.c
@@ -748,3 +748,10 @@ void paint_fill_constant_buffer(struct vg_paint *paint,
       abort();
    }
 }
+
+VGboolean paint_is_opaque(struct vg_paint *paint)
+{
+   /* TODO add other paint types and make sure PAINT_DIRTY gets set */
+   return (paint->type == VG_PAINT_TYPE_COLOR &&
+           floatsEqual(paint->solid.color[3], 1.0f));
+}
diff --git a/src/gallium/state_trackers/vega/paint.h b/src/gallium/state_trackers/vega/paint.h
index 3de3bbe12ed..e5357763b89 100644
--- a/src/gallium/state_trackers/vega/paint.h
+++ b/src/gallium/state_trackers/vega/paint.h
@@ -118,5 +118,6 @@ void paint_fill_constant_buffer(struct vg_paint *paint,
                                 const struct matrix *mat,
                                 void *buffer);
 
+VGboolean paint_is_opaque(struct vg_paint *paint);
 
 #endif
diff --git a/src/gallium/state_trackers/vega/polygon.c b/src/gallium/state_trackers/vega/polygon.c
index a491de27fa6..bcc5cb272ca 100644
--- a/src/gallium/state_trackers/vega/polygon.c
+++ b/src/gallium/state_trackers/vega/polygon.c
@@ -303,7 +303,6 @@ void polygon_fill(struct polygon *poly, struct vg_context *ctx)
    vbuffer.buffer = poly->vbuf;
    vbuffer.stride = COMPONENTS * sizeof(float);  /* vertex size */
    vbuffer.buffer_offset = 0;
-   vbuffer.max_index = poly->num_verts - 1;
 
    renderer_polygon_stencil_begin(ctx->renderer,
          &velement, ctx->state.vg.fill_rule, VG_FALSE);
@@ -354,7 +353,6 @@ void polygon_array_fill(struct polygon_array *polyarray, struct vg_context *ctx)
 
       polygon_prepare_buffer(ctx, poly);
       vbuffer.buffer = poly->vbuf;
-      vbuffer.max_index = poly->num_verts - 1;
 
       renderer_polygon_stencil(ctx->renderer, &vbuffer,
             PIPE_PRIM_TRIANGLE_FAN, 0, (VGuint) poly->num_verts);
diff --git a/src/gallium/state_trackers/vega/renderer.c b/src/gallium/state_trackers/vega/renderer.c
index e42bad76492..9de2cb1014d 100644
--- a/src/gallium/state_trackers/vega/renderer.c
+++ b/src/gallium/state_trackers/vega/renderer.c
@@ -28,6 +28,7 @@
 #include "renderer.h"
 
 #include "vg_context.h"
+#include "paint.h" /* for paint_is_opaque */
 
 #include "pipe/p_context.h"
 #include "pipe/p_state.h"
@@ -173,6 +174,7 @@ static void renderer_set_mvp(struct renderer *renderer,
    pipe_resource_reference(&cbuf, NULL);
    cbuf = pipe_buffer_create(renderer->pipe->screen,
                              PIPE_BIND_CONSTANT_BUFFER,
+                             PIPE_USAGE_STATIC,
                              sizeof(consts));
    if (cbuf) {
       pipe_buffer_write(renderer->pipe, cbuf,
@@ -473,7 +475,8 @@ static void renderer_set_custom_fs(struct renderer *renderer,
          pipe_resource_reference(&cbuf, NULL);
 
          cbuf = pipe_buffer_create(renderer->pipe->screen,
-               PIPE_BIND_CONSTANT_BUFFER, const_buffer_len);
+               PIPE_BIND_CONSTANT_BUFFER, PIPE_USAGE_STATIC,
+               const_buffer_len);
          pipe_buffer_write(renderer->pipe, cbuf, 0,
                const_buffer_len, const_buffer);
          renderer->pipe->set_constant_buffer(renderer->pipe,
@@ -571,7 +574,7 @@ static void renderer_quad_draw(struct renderer *r)
                                  sizeof(r->vertices),
                                  PIPE_BIND_VERTEX_BUFFER);
    if (buf) {
-      util_draw_vertex_buffer(r->pipe, buf, 0,
+      util_draw_vertex_buffer(r->pipe, r->cso, buf, 0,
                               PIPE_PRIM_TRIANGLE_FAN,
                               Elements(r->vertices),     /* verts */
                               Elements(r->vertices[0])); /* attribs/vert */
@@ -1049,7 +1052,7 @@ void renderer_polygon_stencil(struct renderer *renderer,
 {
    assert(renderer->state == RENDERER_STATE_POLYGON_STENCIL);
 
-   renderer->pipe->set_vertex_buffers(renderer->pipe, 1, vbuf);
+   cso_set_vertex_buffers(renderer->cso, 1, vbuf);
 
    if (!renderer->u.polygon_stencil.manual_two_sides) {
       util_draw_arrays(renderer->pipe, mode, start, count);
@@ -1289,7 +1292,11 @@ static void renderer_validate_blend(struct renderer *renderer,
       blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
       break;
    case VG_BLEND_SRC_OVER:
-      if (!util_format_has_alpha(fb_format)) {
+      if (paint_is_opaque(state->fill_paint) &&
+          paint_is_opaque(state->stroke_paint)) {
+         /* no blending */
+      }
+      else if (!util_format_has_alpha(fb_format)) {
          blend.rt[0].rgb_src_factor   = PIPE_BLENDFACTOR_SRC_ALPHA;
          blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
          blend.rt[0].rgb_dst_factor   = PIPE_BLENDFACTOR_INV_SRC_ALPHA;
diff --git a/src/gallium/state_trackers/vega/shader.c b/src/gallium/state_trackers/vega/shader.c
index 2a6bae8a630..bee6d84001d 100644
--- a/src/gallium/state_trackers/vega/shader.c
+++ b/src/gallium/state_trackers/vega/shader.c
@@ -134,6 +134,8 @@ static VGboolean blend_use_shader(struct vg_context *ctx)
    switch (ctx->state.vg.blend_mode) {
    case VG_BLEND_SRC_OVER:
       advanced_blending =
+         (!paint_is_opaque(ctx->state.vg.fill_paint) ||
+          !paint_is_opaque(ctx->state.vg.stroke_paint)) &&
          util_format_has_alpha(ctx->draw_buffer->strb->format);
       break;
    case VG_BLEND_DST_OVER:
diff --git a/src/gallium/state_trackers/vega/vg_context.c b/src/gallium/state_trackers/vega/vg_context.c
index f36f55d6c89..83b42609e03 100644
--- a/src/gallium/state_trackers/vega/vg_context.c
+++ b/src/gallium/state_trackers/vega/vg_context.c
@@ -33,6 +33,7 @@
 #include "vg_manager.h"
 #include "api.h"
 #include "mask.h"
+#include "handle.h"
 
 #include "pipe/p_context.h"
 #include "util/u_inlines.h"
@@ -182,17 +183,26 @@ void vg_init_object(struct vg_object *obj, struct vg_context *ctx, enum vg_objec
 {
    obj->type = type;
    obj->ctx = ctx;
+   obj->handle = create_handle(obj);
+}
+
+/** free object resources, but not the object itself */
+void vg_free_object(struct vg_object *obj)
+{
+   obj->type = 0;
+   obj->ctx = NULL;
+   destroy_handle(obj->handle);
 }
 
 VGboolean vg_context_is_object_valid(struct vg_context *ctx,
                                 enum vg_object_type type,
-                                void *ptr)
+                                VGHandle object)
 {
     if (ctx) {
        struct cso_hash *hash = ctx->owned_objects[type];
        if (!hash)
           return VG_FALSE;
-       return cso_hash_contains(hash, (unsigned)(long)ptr);
+       return cso_hash_contains(hash, (unsigned)(long)object);
     }
     return VG_FALSE;
 }
@@ -398,8 +408,9 @@ void vg_validate_state(struct vg_context *ctx)
    if (vg_context_update_depth_stencil_rb(ctx, stfb->width, stfb->height))
       ctx->state.dirty |= DEPTH_STENCIL_DIRTY;
 
-   /* blend state depends on fb format */
-   if (ctx->state.dirty & FRAMEBUFFER_DIRTY)
+   /* blend state depends on fb format and paint color */
+   if ((ctx->state.dirty & FRAMEBUFFER_DIRTY) ||
+       (ctx->state.dirty & PAINT_DIRTY))
       ctx->state.dirty |= BLEND_DIRTY;
 
    renderer_validate(ctx->renderer, ctx->state.dirty,
@@ -412,10 +423,10 @@ void vg_validate_state(struct vg_context *ctx)
    shader_set_color_transform(ctx->shader, ctx->state.vg.color_transform);
 }
 
-VGboolean vg_object_is_valid(void *ptr, enum vg_object_type type)
+VGboolean vg_object_is_valid(VGHandle object, enum vg_object_type type)
 {
-   struct vg_object *obj = ptr;
-   if (ptr && is_aligned(obj) && obj->type == type)
+   struct vg_object *obj = handle_to_object(object);
+   if (obj && is_aligned(obj) && obj->type == type)
       return VG_TRUE;
    else
       return VG_FALSE;
diff --git a/src/gallium/state_trackers/vega/vg_context.h b/src/gallium/state_trackers/vega/vg_context.h
index d616a20a3d9..71491a5aa22 100644
--- a/src/gallium/state_trackers/vega/vg_context.h
+++ b/src/gallium/state_trackers/vega/vg_context.h
@@ -81,10 +81,12 @@ enum dirty_state {
    BLEND_DIRTY         = 1 << 0,
    FRAMEBUFFER_DIRTY   = 1 << 1,
    DEPTH_STENCIL_DIRTY = 1 << 2,
+   PAINT_DIRTY         = 1 << 3,
 
    ALL_DIRTY           = BLEND_DIRTY |
                          FRAMEBUFFER_DIRTY |
-                         DEPTH_STENCIL_DIRTY
+                         DEPTH_STENCIL_DIRTY |
+                         PAINT_DIRTY
 };
 
 struct vg_context
@@ -129,12 +131,21 @@ struct vg_context
    struct blit_state *blit;
 };
 
+
+/**
+ *  Base class for VG objects like paths, images, fonts.
+ */
 struct vg_object {
    enum vg_object_type type;
+   VGHandle handle;
    struct vg_context *ctx;
 };
+
+
 void vg_init_object(struct vg_object *obj, struct vg_context *ctx, enum vg_object_type type);
-VGboolean vg_object_is_valid(void *ptr, enum vg_object_type type);
+void vg_free_object(struct vg_object *obj);
+
+VGboolean vg_object_is_valid(VGHandle object, enum vg_object_type type);
 
 struct vg_context *vg_create_context(struct pipe_context *pipe,
                                      const void *visual,
@@ -145,7 +156,7 @@ void vg_set_current_context(struct vg_context *ctx);
 
 VGboolean vg_context_is_object_valid(struct vg_context *ctx,
                                      enum vg_object_type type,
-                                     void *ptr);
+                                     VGHandle object);
 void vg_context_add_object(struct vg_context *ctx,
                            enum vg_object_type type,
                            void *ptr);
diff --git a/src/gallium/state_trackers/vega/vg_manager.c b/src/gallium/state_trackers/vega/vg_manager.c
index ec713b7fb1d..44d2996bb45 100644
--- a/src/gallium/state_trackers/vega/vg_manager.c
+++ b/src/gallium/state_trackers/vega/vg_manager.c
@@ -40,6 +40,7 @@
 #include "vg_manager.h"
 #include "vg_context.h"
 #include "api.h"
+#include "handle.h"
 
 static boolean
 vg_context_update_color_rb(struct vg_context *ctx, struct pipe_resource *pt)
@@ -172,6 +173,9 @@ vg_api_create_context(struct st_api *stapi, struct st_manager *smapi,
    if (attribs->major > 1 || (attribs->major == 1 && attribs->minor > 0))
       return NULL;
 
+   /* for VGHandle / pointer lookups */
+   init_handles();
+
    pipe = smapi->screen->context_create(smapi->screen, NULL);
    if (!pipe)
       return NULL;
diff --git a/src/gallium/state_trackers/vega/vgu.c b/src/gallium/state_trackers/vega/vgu.c
index 7dc51c5599c..4206a91e006 100644
--- a/src/gallium/state_trackers/vega/vgu.c
+++ b/src/gallium/state_trackers/vega/vgu.c
@@ -29,6 +29,7 @@
 
 #include "matrix.h"
 #include "path.h"
+#include "handle.h"
 
 #include "util/u_debug.h"
 #include "util/u_pointer.h"
@@ -36,16 +37,6 @@
 #include <math.h>
 #include <assert.h>
 
-static VGboolean is_aligned_to(const void *ptr, VGbyte alignment)
-{
-   void *aligned = align_pointer(ptr, alignment);
-   return (ptr == aligned) ? VG_TRUE : VG_FALSE;
-}
-
-static VGboolean is_aligned(const void *ptr)
-{
-   return is_aligned_to(ptr, 4);
-}
 
 static void vgu_append_float_coords(VGPath path,
                                     const VGubyte *cmds,
@@ -54,7 +45,7 @@ static void vgu_append_float_coords(VGPath path,
                                     VGint num_coords)
 {
    VGubyte common_data[40 * sizeof(VGfloat)];
-   struct path *p = (struct path *)path;
+   struct path *p = handle_to_path(path);
 
    vg_float_to_datatype(path_datatype(p), common_data, coords, num_coords);
    vgAppendPathData(path, num_cmds, cmds, common_data);