OpenVG 1.0 State Tracker

Import of the OpenVG 1.0 state tracker for Gallium.

25 files changed, 2417 insertions, 0 deletions

diff --git a/progs/openvg/trivial/Makefile b/progs/openvg/trivial/Makefile
new file mode 100644
index 0000000000..362360e596
--- /dev/null
+++ b/progs/openvg/trivial/Makefile
@@ -0,0 +1,127 @@
+# These programs aren't intended to be included with the normal distro.
+# They're not too interesting but they're good for testing.
+
+TOP = ../../../
+include $(TOP)/configs/current
+
+INCLUDES = -I. -I$(TOP)/include
+LIBS=-L$(TOP)/$(LIB_DIR) -lm -lEGL -lOpenVG -lpthread
+CFLAGS += $(INCLUDES)
+
+HEADERS=eglcommon.h
+
+PROGRAMS = \
+        arc \
+        cap \
+        clear \
+        coord \
+        dash \
+        ellipse \
+        filter \
+        gradorigin \
+        lineto \
+        lingrad \
+        lookup \
+        mask4 \
+        mask \
+        path3 \
+        radialgrad \
+        readpixels \
+        roundedrect \
+        star-nonzero \
+        star-oddeven \
+        stroke2 \
+        stroke \
+        vguarc
+
+
+.c.o:
+	$(CC) -c $(INCLUDE_DIRS) $(CFLAGS) $< -o $@
+
+
+
+default: $(PROGRAMS)
+
+
+arc: arc.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+cap: cap.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+clear: clear.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+coord: coord.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+dash: dash.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+ellipse: ellipse.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+filter: filter.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+gradorigin: gradorigin.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+image: image.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+lineto: lineto.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+lingrad: lingrad.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+lookup: lookup.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+mask: mask.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+mask4: mask4.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+path3: path3.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+pattern: pattern.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+radialgrad: radialgrad.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+readpixels: readpixels.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+roundedrect: roundedrect.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+star-nonzero: star-nonzero.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+star-oddeven: star-oddeven.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+stroke: stroke.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+stroke2: stroke2.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+vguarc: vguarc.c eglcommon.o
+	$(CC) $(CFLAGS) $^ $(LIBS)  $(APP_LIB_DEPS) -o $@
+
+
+
+eglcommon.o: eglcommon.c $(HEADERS)
+	$(CC) -c $(CFLAGS) eglcommon.c
+
+
+clean:
+	rm -f *.o *~
+	rm -f *.so
+	rm -f $(PROGRAMS)
diff --git a/progs/openvg/trivial/arc.c b/progs/openvg/trivial/arc.c
new file mode 100644
index 0000000000..db686bea6b
--- /dev/null
+++ b/progs/openvg/trivial/arc.c
@@ -0,0 +1,139 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+#include <math.h>
+
+const VGfloat clear_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {1.0, 1.0, 1.0, 0.5};
+
+VGPath vgPath;
+
+static void ellipse(VGPath vgPath, VGfloat rx, VGfloat ry, VGfloat angle)
+{
+    static const VGubyte cmd[] =
+    { VG_MOVE_TO_ABS, VG_SCCWARC_TO_REL, VG_SCCWARC_TO_REL, VG_CLOSE_PATH };
+
+    VGfloat val[12];
+    VGfloat c = cos(angle) * rx;
+    VGfloat s = sin(angle) * rx;
+
+    val[0] = c;
+    val[1] = s;
+    val[2] = rx;
+    val[3] = ry;
+    val[4] = angle;
+    val[5] = -2.0f * c;
+    val[6] = -2.0f * s;
+    val[7] = rx;
+    val[8] = ry;
+    val[9] = angle;
+    val[10] = 2.0f * c;
+    val[11] = 2.0f * s;
+
+    vgClearPath(vgPath, VG_PATH_CAPABILITY_ALL);
+    vgAppendPathData(vgPath, sizeof(cmd), cmd, val);
+    vgDrawPath(vgPath, VG_FILL_PATH | VG_STROKE_PATH);
+}
+
+static void
+init(void)
+{
+    VGPaint vgPaint;
+
+    vgSetfv(VG_CLEAR_COLOR, 4, clear_color);
+    vgPath = vgCreatePath(VG_PATH_FORMAT_STANDARD,
+                          VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0,
+                          VG_PATH_CAPABILITY_ALL);
+
+    vgPaint = vgCreatePaint();
+    vgSetParameteri(vgPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
+    vgSetColor(vgPaint, 0x00ff00ff);
+    vgSetPaint(vgPaint, VG_FILL_PATH);
+
+    vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
+    vgSeti(VG_BLEND_MODE, VG_BLEND_SRC_OVER);
+    vgSetf(VG_STROKE_LINE_WIDTH, 2.0f);
+    vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_SQUARE);
+    vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_MITER);
+    vgSetf(VG_STROKE_MITER_LIMIT, 4.0f);
+    vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+}
+
+static void
+draw(void)
+{
+    vgClear(0, 0, window_width(), window_height());
+
+#if 0
+    vgLoadIdentity();
+    vgTranslate(40.0f, 24.0f);
+    vgScale(0.61804f, 0.61804f);
+    vgShear(-1.0f, 0.0f);
+    vgDrawPath(vgPath, VG_FILL_PATH | VG_STROKE_PATH);
+#else
+
+    /* row 1, col 1: Identity transform. */
+
+    vgLoadIdentity();
+    vgTranslate(8.0f, 8.0f);
+    ellipse(vgPath, 4.0f, 4.0f, 0.0f);
+
+    /* row 1, col 2: 10^3 horizontal squeeze. */
+
+    vgLoadIdentity();
+    vgTranslate(24.0f, 8.0f);
+    vgScale(1.0e-3f, 1.0f);
+    ellipse(vgPath, 4.0e3f, 4.0f, 0.0f);
+
+    /* row 1, col 3: 10^6 horizontal squeeze. */
+
+    vgLoadIdentity();
+    vgTranslate(40.0f, 8.0f);
+    vgScale(1.0e-6f, 1.0f);
+    ellipse(vgPath, 4.0e6f, 4.0f, 0.0f);
+
+    /* row 1, col 4: 10^9 horizontal squeeze. */
+
+    vgLoadIdentity();
+    vgTranslate(56.0f, 8.0f);
+    vgScale(1.0e-9f, 1.0f);
+    ellipse(vgPath, 4.0e9f, 4.0f, 0.0f);
+
+    /* row 2, col 1: 10^3 vertical squeeze. */
+
+    vgLoadIdentity();
+    vgTranslate(8.0f, 24.0f);
+    vgScale(1.0f, 1.0e-3f);
+    ellipse(vgPath, 4.0f, 4.0e3f, 0.0f);
+
+    /* row 2, col 2: Shear 0. */
+
+    vgLoadIdentity();
+    vgTranslate(24.0f, 24.0f);
+    vgShear(0.0f, 0.0f);
+    ellipse(vgPath, 4.0f, 4.0f, 0.0f);
+
+    /* row 2, col 3: Horizontal shear -1. */
+
+    vgLoadIdentity();
+    vgTranslate(40.0f, 24.0f);
+    vgScale(0.61804f, 0.61804f);
+    vgShear(-1.0f, 0.0f);
+    ellipse(vgPath, 10.47213f, 4.0f, 31.717f);
+#endif
+    vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+    set_window_size(64, 64);
+   return run(argc, argv, init, reshape,
+              draw, 0);
+}
diff --git a/progs/openvg/trivial/cap.c b/progs/openvg/trivial/cap.c
new file mode 100644
index 0000000000..cd84fe3ac0
--- /dev/null
+++ b/progs/openvg/trivial/cap.c
@@ -0,0 +1,75 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+static void
+init(void)
+{
+
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+}
+
+const int subtest = 0;
+static void
+draw(void)
+{
+    VGPath line;
+    VGPaint fillPaint;
+    VGubyte lineCommands[3] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS};
+    VGfloat lineCoords[] =   {-2.0f,-1.0f, 0.0f,0.0f, -1.0f, -2.0f};
+    VGfloat clearColor[] = {0.0f, 0.0f, 0.0f, 1.0f};/* black color */
+    VGfloat fillColor[] = {1.0f, 1.0f, 1.0f, 1.0f};/* white color */
+    //VGfloat testRadius = 60.0f;
+    VGfloat testRadius = 10.0f;
+    int WINDSIZEX = window_width();
+    int WINDSIZEY = window_height();
+
+    line = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
+                        1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
+    fillPaint = vgCreatePaint();
+
+    vgSetf(VG_STROKE_LINE_WIDTH, 1.0f);
+    //vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_ROUND);
+    vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
+    vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
+    //vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_BEVEL);
+
+    vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER);
+
+    vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
+    vgLoadIdentity();
+    vgTranslate(60, 60);
+    vgScale(testRadius * 2, testRadius * 2);
+
+    vgAppendPathData(line, 3, lineCommands, lineCoords);
+
+    vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
+
+    vgSetPaint(fillPaint, VG_STROKE_PATH);
+
+    vgSetParameterfv(fillPaint, VG_PAINT_COLOR, 4, fillColor);
+    vgSetParameteri( fillPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
+
+    vgClear(0, 0, WINDSIZEX, WINDSIZEY);
+    vgDrawPath(line, VG_STROKE_PATH);
+
+    vgDestroyPath(line);
+    vgDestroyPaint(fillPaint);
+}
+
+
+int main(int argc, char **argv)
+{
+   set_window_size(100, 100);
+   return run(argc, argv, init, reshape,
+              draw, 0);
+}
diff --git a/progs/openvg/trivial/clear.c b/progs/openvg/trivial/clear.c
new file mode 100644
index 0000000000..efb6bf4182
--- /dev/null
+++ b/progs/openvg/trivial/clear.c
@@ -0,0 +1,42 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+#include <stdio.h>
+
+float red_color[4] = {1.0, 0.0, 0.0, 1.0};
+float blue_color[4] = {0.0, 0.0, 1.0, 1.0};
+
+static void
+init(void)
+{
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+   vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+    VGint scissor[4] = {100, 100, 25, 25};
+    vgSetfv(VG_CLEAR_COLOR, 4, red_color);
+    vgClear(0, 0, window_width(), window_height());
+
+    vgSetfv(VG_CLEAR_COLOR, 4, blue_color);
+    vgClear(50, 50, 50, 50);
+
+    //vgSetiv(VG_SCISSOR_RECTS, 4, scissor);
+    //vgSeti(VG_SCISSORING, VG_TRUE);
+    vgCopyPixels(100, 100, 50, 50, 50, 50);
+    vgClear(150, 150, 50, 50);
+}
+
+
+int main(int argc, char **argv)
+{
+   return run(argc, argv, init, reshape,
+              draw, 0);
+}
diff --git a/progs/openvg/trivial/coord.c b/progs/openvg/trivial/coord.c
new file mode 100644
index 0000000000..81f7cb6fc9
--- /dev/null
+++ b/progs/openvg/trivial/coord.c
@@ -0,0 +1,66 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {0.4, 0.1, 1.0, 1.0};
+
+VGPath path;
+VGPaint fill;
+
+
+static void
+init(void)
+{
+   /* Absent VG_CLOSE_PATH */
+   VGubyte commands[] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS,
+                         VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS};
+   VGfloat clearColor[] = {1.0f, 1.0f, 1.0f, 1.0f};/* white color */
+   VGfloat fillColor[] = {1.0f, 0.0f, 0.0f, 1.0f};/* red color */
+   VGfloat coords[] = {-16.0f, -16.0f, 0.0f, -16.0f, 0.0f, 0.0f, -16.0f, 0.0f,
+                       0.0f, 0.0f, 16.0f, 0.0f, 16.0f, 16.0f, 0.0f, 16.0f};
+
+   vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
+   vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
+
+   vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
+   vgLoadIdentity();
+   vgTranslate(32.0f, 32.0f);
+
+   path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0,
+                       VG_PATH_CAPABILITY_ALL);
+   if (path == VG_INVALID_HANDLE)
+      return;
+   fill = vgCreatePaint();
+   if (fill == VG_INVALID_HANDLE) {
+      vgDestroyPath(path);
+      return;
+   }
+   vgAppendPathData(path, 8, commands, coords);
+   vgSetPaint(fill, VG_FILL_PATH);
+   vgSetParameterfv(fill, VG_PAINT_COLOR, 4, fillColor);
+   vgSetParameteri(fill, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+}
+
+static void
+draw(void)
+{
+   vgClear(0, 0, window_width(), window_height());
+   vgDrawPath(path, VG_FILL_PATH);
+
+   vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+   set_window_size(64, 64);
+   return run(argc, argv, init, reshape,
+              draw, 0);
+}
diff --git a/progs/openvg/trivial/dash.c b/progs/openvg/trivial/dash.c
new file mode 100644
index 0000000000..2e84ddbd4e
--- /dev/null
+++ b/progs/openvg/trivial/dash.c
@@ -0,0 +1,95 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+#include <X11/keysym.h>
+#include <stdio.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {0.4, 0.1, 1.0, 1.0};
+
+VGPath path;
+VGPaint fill;
+
+VGint cap_style = VG_CAP_BUTT;
+
+static void
+init(void)
+{
+   static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
+                                  VG_LINE_TO_ABS,
+                                  VG_LINE_TO_ABS
+   };
+#if 1
+   static const VGfloat coords[]   = {100, 100, 150, 100,
+                                      150, 200
+   };
+#else
+   static const VGfloat coords[]   = {100, 20, 100, 220,
+   };
+#endif
+   VGfloat dash_pattern[2] = { 20.f, 20.f };
+   path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+                       VG_PATH_CAPABILITY_APPEND_TO);
+   vgAppendPathData(path, 3, cmds, coords);
+
+   fill = vgCreatePaint();
+   vgSetParameterfv(fill, VG_PAINT_COLOR, 4, color);
+   vgSetPaint(fill, VG_FILL_PATH);
+
+   vgSetfv(VG_CLEAR_COLOR, 4, white_color);
+   vgSetf(VG_STROKE_LINE_WIDTH, 20);
+   vgSeti(VG_STROKE_CAP_STYLE, cap_style);
+   vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
+   vgSetfv(VG_STROKE_DASH_PATTERN, 2, dash_pattern);
+   vgSetf(VG_STROKE_DASH_PHASE, 0.0f);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+   vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+   vgClear(0, 0, window_width(), window_height());
+   vgDrawPath(path, VG_STROKE_PATH);
+
+   vgFlush();
+}
+
+static int  key_press(unsigned key)
+{
+    switch(key) {
+    case XK_c:
+    case XK_C:
+        ++cap_style;
+        if (cap_style > VG_CAP_SQUARE)
+            cap_style = VG_CAP_BUTT;
+        switch(cap_style) {
+        case VG_CAP_BUTT:
+            fprintf(stderr, "Cap style 'butt'\n");
+            break;
+        case VG_CAP_ROUND:
+            fprintf(stderr, "Cap style 'round'\n");
+            break;
+        case VG_CAP_SQUARE:
+            fprintf(stderr, "Cap style 'square'\n");
+            break;
+        }
+        vgSeti(VG_STROKE_CAP_STYLE, cap_style);
+        break;
+    default:
+        break;
+    }
+
+    return VG_TRUE;
+}
+
+int main(int argc, char **argv)
+{
+   return run(argc, argv, init, reshape,
+              draw, key_press);
+}
diff --git a/progs/openvg/trivial/eglcommon.c b/progs/openvg/trivial/eglcommon.c
new file mode 100644
index 0000000000..bacd5685d7
--- /dev/null
+++ b/progs/openvg/trivial/eglcommon.c
@@ -0,0 +1,288 @@
+#include "eglcommon.h"
+
+
+#include <assert.h>
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/keysym.h>
+#include <VG/openvg.h>  /* using full OpenGL for now */
+#include <GLES/egl.h>
+
+
+static init_func    init = 0;
+static draw_func    draw = 0;
+static reshape_func reshape = 0;
+static key_func     keyPress = 0;
+static VGint width = 300, height = 300;
+
+
+void set_window_size(int w, int h)
+{
+   width = w;
+   height = h;
+}
+
+/*
+ * Create an RGB, double-buffered X window.
+ * Return the window and context handles.
+ */
+static void
+make_x_window(Display *x_dpy, EGLDisplay egl_dpy,
+              const char *name,
+              int x, int y, int width, int height,
+              Window *winRet,
+              EGLContext *ctxRet,
+              EGLSurface *surfRet)
+{
+   static const EGLint attribs[] = {
+      EGL_RED_SIZE, 1,
+      EGL_GREEN_SIZE, 1,
+      EGL_BLUE_SIZE, 1,
+      EGL_NONE
+   };
+
+   int scrnum;
+   XSetWindowAttributes attr;
+   unsigned long mask;
+   Window root;
+   Window win;
+   XVisualInfo *visInfo, visTemplate;
+   int num_visuals;
+   EGLContext ctx;
+   EGLConfig config;
+   EGLint num_configs;
+   EGLint vid;
+
+   scrnum = DefaultScreen( x_dpy );
+   root = RootWindow( x_dpy, scrnum );
+
+   if (!eglChooseConfig( egl_dpy, attribs, &config, 1, &num_configs)) {
+      printf("Error: couldn't get an EGL visual config\n");
+      exit(1);
+   }
+
+   assert(config);
+   assert(num_configs > 0);
+
+   if (!eglGetConfigAttrib(egl_dpy, config, EGL_NATIVE_VISUAL_ID, &vid)) {
+      printf("Error: eglGetConfigAttrib() failed\n");
+      exit(1);
+   }
+
+   /* The X window visual must match the EGL config */
+   visTemplate.visualid = vid;
+   visInfo = XGetVisualInfo(x_dpy, VisualIDMask, &visTemplate, &num_visuals);
+   if (!visInfo) {
+      printf("Error: couldn't get X visual\n");
+      exit(1);
+   }
+
+   /* window attributes */
+   attr.background_pixel = 0;
+   attr.border_pixel = 0;
+   attr.colormap = XCreateColormap( x_dpy, root, visInfo->visual, AllocNone);
+   attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
+   mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
+
+   win = XCreateWindow( x_dpy, root, 0, 0, width, height,
+		        0, visInfo->depth, InputOutput,
+		        visInfo->visual, mask, &attr );
+
+   /* set hints and properties */
+   {
+      XSizeHints sizehints;
+      sizehints.x = x;
+      sizehints.y = y;
+      sizehints.width  = width;
+      sizehints.height = height;
+      sizehints.flags = USSize | USPosition;
+      XSetNormalHints(x_dpy, win, &sizehints);
+      XSetStandardProperties(x_dpy, win, name, name,
+                              None, (char **)NULL, 0, &sizehints);
+   }
+
+   eglBindAPI(EGL_OPENVG_API);
+
+   ctx = eglCreateContext(egl_dpy, config, EGL_NO_CONTEXT, NULL );
+   if (!ctx) {
+      printf("Error: eglCreateContext failed\n");
+      exit(1);
+   }
+
+   *surfRet = eglCreateWindowSurface(egl_dpy, config, win, NULL);
+
+   if (!*surfRet) {
+      printf("Error: eglCreateWindowSurface failed\n");
+      exit(1);
+   }
+
+   XFree(visInfo);
+
+   *winRet = win;
+   *ctxRet = ctx;
+}
+
+static void
+event_loop(Display *dpy, Window win,
+           EGLDisplay egl_dpy, EGLSurface egl_surf)
+{
+   while (1) {
+      int redraw = 0;
+      XEvent event;
+
+      XNextEvent(dpy, &event);
+
+      switch (event.type) {
+      case Expose:
+         redraw = 1;
+         break;
+      case ConfigureNotify:
+         if (reshape) {
+            width = event.xconfigure.width;
+            height = event.xconfigure.height;
+            reshape(event.xconfigure.width, event.xconfigure.height);
+         }
+         break;
+      case KeyPress:
+      {
+         char buffer[10];
+         int r, code;
+         code = XLookupKeysym(&event.xkey, 0);
+         if (!keyPress || !keyPress(code)) {
+            r = XLookupString(&event.xkey, buffer, sizeof(buffer),
+                              NULL, NULL);
+            if (buffer[0] == 27) {
+               /* escape */
+               return;
+            }
+         }
+      }
+      redraw = 1;
+      break;
+      default:
+         ; /*no-op*/
+      }
+
+      if (redraw) {
+         draw();
+         eglSwapBuffers(egl_dpy, egl_surf);
+      }
+   }
+}
+
+int window_width(void)
+{
+   return width;
+}
+
+int window_height(void)
+{
+   return height;
+}
+
+static void
+usage(void)
+{
+   printf("Usage:\n");
+   printf("  -display <displayname>  set the display to run on\n");
+   printf("  -info                   display OpenGL renderer info\n");
+}
+
+int run(int argc, char **argv,
+        init_func init_f,
+        reshape_func resh_f,
+        draw_func draw_f,
+        key_func key_f)
+{
+   const int winWidth = width, winHeight = height;
+   Display *x_dpy;
+   Window win;
+   EGLSurface egl_surf;
+   EGLContext egl_ctx;
+   EGLDisplay egl_dpy;
+   char *dpyName = NULL;
+   GLboolean printInfo = GL_FALSE;
+   EGLint egl_major, egl_minor;
+   int i;
+   const char *s;
+
+   init = init_f;
+   draw = draw_f;
+   reshape = resh_f;
+   keyPress = key_f;
+
+   for (i = 1; i < argc; i++) {
+      if (strcmp(argv[i], "-display") == 0) {
+         dpyName = argv[i+1];
+         i++;
+      }
+      else if (strcmp(argv[i], "-info") == 0) {
+         printInfo = GL_TRUE;
+      }
+   }
+
+   x_dpy = XOpenDisplay(dpyName);
+   if (!x_dpy) {
+      printf("Error: couldn't open display %s\n",
+	     dpyName ? dpyName : getenv("DISPLAY"));
+      return -1;
+   }
+
+   egl_dpy = eglGetDisplay(x_dpy);
+   if (!egl_dpy) {
+      printf("Error: eglGetDisplay() failed\n");
+      return -1;
+   }
+
+   if (!eglInitialize(egl_dpy, &egl_major, &egl_minor)) {
+      printf("Error: eglInitialize() failed\n");
+      return -1;
+   }
+
+   s = eglQueryString(egl_dpy, EGL_VERSION);
+   printf("EGL_VERSION = %s\n", s);
+
+   make_x_window(x_dpy, egl_dpy,
+                 "OpenVG Example", 0, 0, winWidth, winHeight,
+                 &win, &egl_ctx, &egl_surf);
+
+   XMapWindow(x_dpy, win);
+   if (!eglMakeCurrent(egl_dpy, egl_surf, egl_surf, egl_ctx)) {
+      printf("Error: eglMakeCurrent() failed\n");
+      return -1;
+   }
+
+   if (printInfo) {
+      printf("VG_RENDERER   = %s\n", (char *) vgGetString(VG_RENDERER));
+      printf("VG_VERSION    = %s\n", (char *) vgGetString(VG_VERSION));
+      printf("VG_VENDOR     = %s\n", (char *) vgGetString(VG_VENDOR));
+   }
+
+   if (init)
+      init();
+
+   /* Set initial projection/viewing transformation.
+    * We can't be sure we'll get a ConfigureNotify event when the window
+    * first appears.
+    */
+   if (reshape)
+      reshape(winWidth, winHeight);
+
+   event_loop(x_dpy, win, egl_dpy, egl_surf);
+
+   eglMakeCurrent(egl_dpy, 0, 0, 0);
+   eglDestroyContext(egl_dpy, egl_ctx);
+   eglDestroySurface(egl_dpy, egl_surf);
+   eglTerminate(egl_dpy);
+
+
+   XDestroyWindow(x_dpy, win);
+   XCloseDisplay(x_dpy);
+
+   return 0;
+}
+
diff --git a/progs/openvg/trivial/eglcommon.h b/progs/openvg/trivial/eglcommon.h
new file mode 100644
index 0000000000..958dae9f98
--- /dev/null
+++ b/progs/openvg/trivial/eglcommon.h
@@ -0,0 +1,20 @@
+#ifndef EGLCOMMON_H
+#define EGLCOMMON_H
+
+typedef void (*init_func)();
+typedef void (*reshape_func)(int, int);
+typedef void (*draw_func)();
+typedef int  (*key_func)(unsigned key);
+
+
+void set_window_size(int width, int height);
+int window_width(void);
+int window_height(void);
+
+int run(int argc, char **argv,
+        init_func init,
+        reshape_func resh,
+        draw_func draw,
+        key_func key);
+
+#endif
diff --git a/progs/openvg/trivial/ellipse.c b/progs/openvg/trivial/ellipse.c
new file mode 100644
index 0000000000..4c7d4904f8
--- /dev/null
+++ b/progs/openvg/trivial/ellipse.c
@@ -0,0 +1,84 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+#include <math.h>
+#include <stdlib.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {0.0, 0.0, 0.0, 1.0};
+
+VGPath path;
+VGPaint paint;
+
+static void
+init(void)
+{
+   VGfloat clearColor[] = {1.0f, 1.0f, 1.0f, 1.0f};/* white color */
+   VGfloat fillColor[] = {1.0f, 0.0f, 0.0f, 1.0f};/* red color */
+   static const VGubyte segments[4] = {VG_MOVE_TO_ABS,
+                                       VG_SCCWARC_TO_ABS,
+                                       VG_SCCWARC_TO_ABS,
+                                       VG_CLOSE_PATH};
+   VGfloat data[12];
+   const VGfloat cx = 0, cy=29, width=80, height=40;
+   const VGfloat hw = width * 0.5f;
+   const VGfloat hh = height * 0.5f;
+
+   data[0] = cx + hw;
+   data[1] = cy;
+   data[2] = hw;
+   data[3] = hh;
+   data[4] = 0;
+   data[5] = cx - hw;
+   data[6] = cy;
+   data[7] = hw;
+   data[8] = hh;
+   data[9] = 0;
+   data[10] = data[0];
+   data[11] = cy;
+
+   vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
+   vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
+
+
+   path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
+                       1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
+   if (path == VG_INVALID_HANDLE) {
+      return;
+   }
+   paint = vgCreatePaint();
+   if (paint == VG_INVALID_HANDLE) {
+      vgDestroyPath(path);
+      return;
+   }
+
+   vgAppendPathData(path, 4, segments, data);
+   vgSetParameterfv(paint, VG_PAINT_COLOR, 4, fillColor);
+   vgSetParameteri( paint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
+   vgSetPaint(paint, VG_FILL_PATH);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+}
+
+static void
+draw(void)
+{
+   vgClear(0, 0, window_width(), window_height());
+   vgLoadIdentity();
+   vgTranslate(50, 21);
+   vgDrawPath(path, VG_FILL_PATH);
+   vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+   set_window_size(100, 100);
+   return run(argc, argv, init, reshape,
+              draw, 0);
+}
diff --git a/progs/openvg/trivial/filter.c b/progs/openvg/trivial/filter.c
new file mode 100644
index 0000000000..d96257a933
--- /dev/null
+++ b/progs/openvg/trivial/filter.c
@@ -0,0 +1,107 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {1.0, 1.0, 1.0, 0.5};
+
+VGImage srcImg;
+VGImage dstImg;
+
+VGPaint fill;
+
+VGfloat bgCol[4] = {0.906f, 0.914f, 0.761f, 1.0f};
+
+static void
+init(void)
+{
+    VGfloat red[4];
+    VGfloat grey[4];
+    VGfloat orange[4];
+    VGfloat blue[4];
+    VGfloat black[4];
+    VGfloat white[4];
+    VGshort transKernel[49] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+    red[0] = 0.6710f;
+    red[1] = 0.1060f;
+    red[2] = 0.1330f;
+    red[3] = 1.0f;
+
+    grey[0] = 0.6347f;
+    grey[1] = 0.6561f;
+    grey[2] = 0.6057f;
+    grey[3] = 1.0f;
+
+    orange[0] = 1.0000f;
+    orange[1] = 0.8227f;
+    orange[2] = 0.5057f;
+    orange[3] = 1.0f;
+
+    blue[0] = 0.0000f;
+    blue[1] = 0.6908f;
+    blue[2] = 0.8595f;
+    blue[3] = 1.0f;
+
+    black[0] = 0;
+    black[1] = 0;
+    black[2] = 0;
+    black[3] = 1.0f;
+
+    white[0] = 1;
+    white[1] = 1;
+    white[2] = 1;
+    white[3] = 1.0f;
+
+    vgSetfv(VG_TILE_FILL_COLOR, 4, blue);
+
+    vgSeti(VG_FILTER_CHANNEL_MASK, 14);
+
+    /* Setup images */
+    srcImg = vgCreateImage(VG_sRGBA_8888, 32, 32,
+                           VG_IMAGE_QUALITY_NONANTIALIASED);
+    dstImg = vgCreateImage(VG_sRGBA_8888, 32, 32,
+                           VG_IMAGE_QUALITY_NONANTIALIASED);
+
+    vgSetfv(VG_CLEAR_COLOR, 4, black);
+    vgClearImage(srcImg, 0, 0, 32, 32);
+    vgSetfv(VG_CLEAR_COLOR, 4, red);
+    vgClearImage(srcImg, 3, 3, 27, 27);
+
+    vgSetfv(VG_CLEAR_COLOR, 4, orange);
+    vgClearImage(dstImg, 0, 0, 32, 32);
+
+    transKernel[8] = 1;
+    vgConvolve(dstImg, srcImg, 3, 3, 3, 0, transKernel,
+               1, 0, VG_TILE_FILL);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+}
+
+static void
+draw(void)
+{
+   vgSetfv(VG_CLEAR_COLOR, 4, bgCol);
+   vgClear(0, 0, window_width(), window_height());
+   vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);
+   vgLoadIdentity();
+   vgTranslate(10, 10);
+   vgDrawImage(dstImg);
+   vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+   set_window_size(64, 64);
+   return run(argc, argv, init, reshape,
+              draw, 0);
+}
diff --git a/progs/openvg/trivial/gradorigin.c b/progs/openvg/trivial/gradorigin.c
new file mode 100644
index 0000000000..b376263fe5
--- /dev/null
+++ b/progs/openvg/trivial/gradorigin.c
@@ -0,0 +1,98 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+#include <stdio.h>
+#include <string.h>
+
+static const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+
+static VGPath path;
+static VGPaint fill;
+
+VGColorRampSpreadMode spread = VG_COLOR_RAMP_SPREAD_PAD;
+
+static void
+init(void)
+{
+   VGubyte commands[5] =  {VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS, VG_CLOSE_PATH};
+   VGfloat coords[8] =    {0.0f,0.0f, 32.0f,0.0f, 32.0f,32.0f, 0.0f,32.0f };
+
+   VGfloat rampStop[20] = {-0.5f,  1.0f, 1.0f, 1.0f, 1.0f,
+                           0.25f, 1.0f, 0.0f, 0.0f, 1.0f,
+                           0.75f, 0.0f, 0.0f, 1.0f, 1.0f,
+                           1.5f,  0.0f, 0.0f, 0.0f, 0.0f};
+
+   VGfloat defaultColor[] = {1.0f, 1.0f, 1.0f, 1.0f};
+   VGfloat linearGradient[4] = {0.0f, 0.0f, 0.0f, 32.0f};
+
+   path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
+                       1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
+   if (path == VG_INVALID_HANDLE)
+      return;
+
+   fill = vgCreatePaint();
+   if (fill == VG_INVALID_HANDLE) {
+      vgDestroyPath(path);
+      return;
+   }
+
+   vgSetfv(VG_CLEAR_COLOR, 4, defaultColor);
+   vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
+
+   vgAppendPathData(path, 5, commands, coords);
+
+   vgSetPaint(fill, VG_FILL_PATH);
+   vgSetParameteri(fill, VG_PAINT_TYPE, VG_PAINT_TYPE_LINEAR_GRADIENT);
+   vgSetParameteri(fill, VG_PAINT_COLOR_RAMP_SPREAD_MODE,
+                   VG_COLOR_RAMP_SPREAD_REPEAT);
+   vgSetParameterfv(fill, VG_PAINT_LINEAR_GRADIENT, 4, linearGradient);
+   vgSetParameterfv(fill, VG_PAINT_COLOR_RAMP_STOPS, 20, rampStop);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+   vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+   vgClear(0, 0, window_width(), window_height());
+
+   vgDrawPath(path, VG_FILL_PATH);
+
+   vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+   if (argc > 1) {
+      const char *arg = argv[1];
+      if (!strcmp("-pad", arg))
+         spread = VG_COLOR_RAMP_SPREAD_PAD;
+      else if (!strcmp("-repeat", arg))
+         spread = VG_COLOR_RAMP_SPREAD_REPEAT;
+      else if (!strcmp("-reflect", arg))
+         spread = VG_COLOR_RAMP_SPREAD_REFLECT;
+   }
+
+   switch(spread) {
+   case VG_COLOR_RAMP_SPREAD_PAD:
+      printf("Using spread mode: pad\n");
+      break;
+   case VG_COLOR_RAMP_SPREAD_REPEAT:
+      printf("Using spread mode: repeat\n");
+      break;
+   case VG_COLOR_RAMP_SPREAD_REFLECT:
+      printf("Using spread mode: reflect\n");
+   }
+
+   set_window_size(200, 200);
+
+   return run(argc, argv, init, reshape,
+              draw, 0);
+}
diff --git a/progs/openvg/trivial/lineto.c b/progs/openvg/trivial/lineto.c
new file mode 100644
index 0000000000..94e2981811
--- /dev/null
+++ b/progs/openvg/trivial/lineto.c
@@ -0,0 +1,56 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {0.4, 0.1, 1.0, 1.0};
+
+VGPath path;
+VGPaint fill;
+
+
+static void
+init(void)
+{
+   static const VGubyte sqrCmds[5] = {VG_MOVE_TO_ABS, VG_HLINE_TO_ABS, VG_VLINE_TO_ABS, VG_HLINE_TO_ABS, VG_CLOSE_PATH};
+   static const VGfloat sqrCoords[5]   = {50.0f, 50.0f, 250.0f, 250.0f, 50.0f};
+   path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+                       VG_PATH_CAPABILITY_APPEND_TO);
+   vgAppendPathData(path, 5, sqrCmds, sqrCoords);
+
+   fill = vgCreatePaint();
+   vgSetParameterfv(fill, VG_PAINT_COLOR, 4, color);
+   vgSetPaint(fill, VG_FILL_PATH);
+
+   vgSetfv(VG_CLEAR_COLOR, 4, white_color);
+   vgSetf(VG_STROKE_LINE_WIDTH, 10);
+   vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
+   vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
+   vgSetf(VG_STROKE_MITER_LIMIT, 4.0f);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+   vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+   vgClear(0, 0, window_width(), window_height());
+   vgSeti(VG_MATRIX_MODE, VG_MATRIX_STROKE_PAINT_TO_USER);
+   vgLoadIdentity();
+   vgScale(2.25, 2.25);
+   vgDrawPath(path, VG_STROKE_PATH);
+
+   vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+   return run(argc, argv, init, reshape,
+              draw, 0);
+}
diff --git a/progs/openvg/trivial/lingrad.c b/progs/openvg/trivial/lingrad.c
new file mode 100644
index 0000000000..bcaad1f101
--- /dev/null
+++ b/progs/openvg/trivial/lingrad.c
@@ -0,0 +1,87 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+#include <stdio.h>
+#include <string.h>
+
+static const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+
+static VGPath path;
+static VGPaint fill;
+
+VGColorRampSpreadMode spread = VG_COLOR_RAMP_SPREAD_PAD;
+
+static void
+init(void)
+{
+   static const VGubyte sqrCmds[5] = {VG_MOVE_TO_ABS, VG_HLINE_TO_ABS, VG_VLINE_TO_ABS, VG_HLINE_TO_ABS, VG_CLOSE_PATH};
+   static const VGfloat sqrCoords[5]   = {0.0f, 0.0f, 400.0f, 400.0f, 0.0f};
+
+   VGfloat rampStop[] = {0.00f, 1.0f, 1.0f, 1.0f, 1.0f,
+                         0.33f, 1.0f, 0.0f, 0.0f, 1.0f,
+                         0.66f, 0.0f, 1.0f, 0.0f, 1.0f,
+                         1.00f, 0.0f, 0.0f,  1.0f, 1.0f};
+   VGfloat linearGradient[4] = {100.0f, 100.0f, 300.0f, 300.0f};
+
+   path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+                       VG_PATH_CAPABILITY_APPEND_TO);
+   vgAppendPathData(path, 5, sqrCmds, sqrCoords);
+
+   fill = vgCreatePaint();
+   vgSetPaint(fill, VG_FILL_PATH);
+
+   vgSetParameteri(fill, VG_PAINT_TYPE, VG_PAINT_TYPE_LINEAR_GRADIENT);
+   vgSetParameteri(fill, VG_PAINT_COLOR_RAMP_SPREAD_MODE, spread);
+   vgSetParameterfv(fill, VG_PAINT_LINEAR_GRADIENT, 4, linearGradient);
+   vgSetParameterfv(fill, VG_PAINT_COLOR_RAMP_STOPS, 20, rampStop);
+
+   vgSetfv(VG_CLEAR_COLOR, 4, white_color);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+   vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+   vgClear(0, 0, window_width(), window_height());
+
+   vgDrawPath(path, VG_FILL_PATH);
+
+   vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+   if (argc > 1) {
+      const char *arg = argv[1];
+      if (!strcmp("-pad", arg))
+         spread = VG_COLOR_RAMP_SPREAD_PAD;
+      else if (!strcmp("-repeat", arg))
+         spread = VG_COLOR_RAMP_SPREAD_REPEAT;
+      else if (!strcmp("-reflect", arg))
+         spread = VG_COLOR_RAMP_SPREAD_REFLECT;
+   }
+
+   switch(spread) {
+   case VG_COLOR_RAMP_SPREAD_PAD:
+      printf("Using spread mode: pad\n");
+      break;
+   case VG_COLOR_RAMP_SPREAD_REPEAT:
+      printf("Using spread mode: repeat\n");
+      break;
+   case VG_COLOR_RAMP_SPREAD_REFLECT:
+      printf("Using spread mode: reflect\n");
+   }
+
+   set_window_size(400, 400);
+
+   return run(argc, argv, init, reshape,
+              draw, 0);
+}
diff --git a/progs/openvg/trivial/lookup.c b/progs/openvg/trivial/lookup.c
new file mode 100644
index 0000000000..a103ba4488
--- /dev/null
+++ b/progs/openvg/trivial/lookup.c
@@ -0,0 +1,71 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {1.0, 1.0, 1.0, 0.5};
+VGfloat clearColor[] = {1.0f, 0.0f, 0.0f, 1.0f};/* red color */
+VGImage parent;
+
+VGPaint fill;
+
+static void
+init(void)
+{
+    VGImage child1, child2;
+    VGubyte *data;
+    VGuint  LUT[256];
+    VGint i;
+
+    data = (VGubyte *)malloc(sizeof(VGubyte)*window_width()*window_height());
+
+    for (i=0;i<window_width()*window_height();i++) {
+        data[i] = 0x00;
+    }
+
+    for (i=0; i<256; i++) {
+        if ( i == 0 )
+            LUT[0] = 0xFFFFFFFF;
+        else
+            LUT[i] = 0xFF00FFFF;
+    }
+
+    parent = vgCreateImage( VG_A_8, 64, 64, VG_IMAGE_QUALITY_NONANTIALIASED );
+
+    vgImageSubData(parent, data, window_width(), VG_A_8, 0, 0,
+                   window_width(), window_height());
+    child1 = vgChildImage(parent, 0, 0, 32, 64);
+    child2 = vgChildImage(parent, 32, 0, 32, 64);
+
+    vgLookupSingle(child2, child1, LUT, VG_GREEN, VG_FALSE, VG_TRUE);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+}
+
+static void
+draw(void)
+{
+   vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
+   vgClear(0, 0, window_width(), window_height());
+   //vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);
+   //vgLoadIdentity();
+   //vgTranslate(10, 10);
+   vgDrawImage(parent);
+   vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+   set_window_size(64, 64);
+   return run(argc, argv, init, reshape,
+              draw, 0);
+}
diff --git a/progs/openvg/trivial/mask.c b/progs/openvg/trivial/mask.c
new file mode 100644
index 0000000000..e5c00c5699
--- /dev/null
+++ b/progs/openvg/trivial/mask.c
@@ -0,0 +1,58 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {0.4, 0.1, 1.0, 1.0};
+
+VGPath path;
+VGPaint fill;
+
+
+static void
+init(void)
+{
+   static const VGubyte sqrCmds[5] = {VG_MOVE_TO_ABS, VG_HLINE_TO_ABS, VG_VLINE_TO_ABS, VG_HLINE_TO_ABS, VG_CLOSE_PATH};
+   static const VGfloat sqrCoords[5]   = {50.0f, 50.0f, 250.0f, 250.0f, 50.0f};
+   path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+                       VG_PATH_CAPABILITY_APPEND_TO);
+   vgAppendPathData(path, 5, sqrCmds, sqrCoords);
+
+   fill = vgCreatePaint();
+   vgSetParameterfv(fill, VG_PAINT_COLOR, 4, color);
+   vgSetPaint(fill, VG_FILL_PATH);
+
+   vgSetfv(VG_CLEAR_COLOR, 4, white_color);
+   vgSetf(VG_STROKE_LINE_WIDTH, 10);
+   vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
+   vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
+   vgSetf(VG_STROKE_MITER_LIMIT, 4.0f);
+
+   vgSeti(VG_MASKING, VG_TRUE);
+
+   vgMask(VG_INVALID_HANDLE, VG_CLEAR_MASK,
+          25, 25, 100, 100);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+   vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+   vgClear(0, 0, window_width(), window_height());
+   vgDrawPath(path, VG_FILL_PATH);
+
+   vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+   return run(argc, argv, init, reshape,
+              draw, 0);
+}
diff --git a/progs/openvg/trivial/mask4.c b/progs/openvg/trivial/mask4.c
new file mode 100644
index 0000000000..fe6db39648
--- /dev/null
+++ b/progs/openvg/trivial/mask4.c
@@ -0,0 +1,132 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+#include <VG/vgu.h>
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+
+#include <X11/keysym.h>
+
+//VGint x_pos = -10, y_pos = -10;
+VGint x_pos = 0, y_pos = 4;
+VGint img_width = 120, img_height = 120;
+
+static void RectToPath(VGPath path, VGfloat x, VGfloat y, VGfloat width, VGfloat height)
+{
+    static const VGubyte segments[5] = {VG_MOVE_TO_ABS,
+                                        VG_HLINE_TO_ABS,
+                                        VG_VLINE_TO_ABS,
+                                        VG_HLINE_TO_ABS,
+                                        VG_CLOSE_PATH};
+    VGfloat data[5];
+
+    data[0] = x;
+    data[1] = y;
+    data[2] = x + width;
+    data[3] = y + height;
+    data[4] = x;
+
+    vgAppendPathData(path, 5, segments, data);
+}
+
+static void
+init(void)
+{
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+}
+
+int  key_press(unsigned key)
+{
+    switch(key) {
+    case XK_Right:
+        x_pos +=1;
+        break;
+    case XK_Left:
+        x_pos -=1;
+        break;
+    case XK_Up:
+        y_pos +=1;
+        break;
+    case XK_Down:
+        y_pos -=1;
+        break;
+    case 'a':
+        img_width  -= 5;
+        img_height -= 5;
+        break;
+    case 's':
+        img_width  += 5;
+        img_height += 5;
+        break;
+    default:
+        break;
+    }
+    fprintf(stderr, "Posi = %dx%d\n", x_pos, y_pos);
+    fprintf(stderr, "Size = %dx%d\n", img_width, img_height);
+    return VG_FALSE;
+}
+
+static void
+draw(void)
+{
+    VGint WINDSIZEX = window_width();
+    VGint WINDSIZEY = window_height();
+
+    VGPaint fill;
+    VGPath box;
+    VGfloat color[4]		= {1.f, 0.f, 0.f, 1.f};
+    VGfloat bgCol[4]		= {0.7f, 0.7f, 0.7f, 1.0f};
+    VGfloat transCol[4]         = {0.f, 0.f, 0.f, 0.f};
+    VGImage image = vgCreateImage(VG_sRGBA_8888, img_width, img_height,
+                                  VG_IMAGE_QUALITY_NONANTIALIASED);
+
+    /* Background clear */
+    fill = vgCreatePaint();
+    vgSetParameterfv(fill, VG_PAINT_COLOR, 4, color);
+    vgSetPaint(fill, VG_FILL_PATH);
+
+    box = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
+                       1, 0, 0, 0, VG_PATH_CAPABILITY_ALL);
+    /* Rectangle to cover completely 16x16 pixel area. */
+    RectToPath(box, 0, 0, 64, 64);
+
+    vgSetfv(VG_CLEAR_COLOR, 4, transCol);
+    vgClearImage(image, 0, 0, img_width, img_height);
+    vgSetfv(VG_CLEAR_COLOR, 4, color);
+    vgClearImage(image, 10, 10, 12, 12);
+    //vgImageSubData(image, pukki_64x64_data, pukki_64x64_stride,
+    //               VG_sRGBA_8888, 0, 0, 32, 32);
+    vgSeti(VG_MASKING, VG_TRUE);
+    vgLoadIdentity();
+
+    vgSetfv(VG_CLEAR_COLOR, 4, bgCol);
+    vgClear(0, 0, WINDSIZEX, WINDSIZEY);
+
+
+    vgMask(image, VG_FILL_MASK, 0, 0, window_width(), window_height());
+    vgMask(image, VG_SET_MASK, x_pos, y_pos, 100, 100);
+
+    vgDrawPath(box, VG_FILL_PATH);
+
+    //vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);
+    //vgTranslate(-10, -10);
+    //vgDrawImage(image);
+
+
+    vgDestroyPaint(fill);
+    vgDestroyPath(box);
+}
+
+
+int main(int argc, char **argv)
+{
+    set_window_size(64, 64);
+    return run(argc, argv, init, reshape,
+               draw, key_press);
+}
diff --git a/progs/openvg/trivial/path3.c b/progs/openvg/trivial/path3.c
new file mode 100644
index 0000000000..5ce600f65a
--- /dev/null
+++ b/progs/openvg/trivial/path3.c
@@ -0,0 +1,77 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+#include <VG/vgu.h>
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+
+static void
+init(void)
+{
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+}
+
+
+static void
+draw(void)
+{
+    VGint WINDSIZEX = window_width();
+    VGint WINDSIZEY = window_height();
+    VGPath path;
+    VGPaint paint;
+
+    VGfloat clearColor[] = {1.0f, 1.0f, 1.0f, 0.0f};/* white color */
+    VGfloat fillColor[] = {1.0f, 0.0f, 0.0f, 1.0f};/* red color */
+
+#if 1
+    VGubyte commands[4] = {VG_MOVE_TO_ABS, VG_LCWARC_TO_ABS, VG_SCWARC_TO_ABS, VG_CLOSE_PATH};
+#else
+    VGubyte commands[4] = {VG_MOVE_TO_ABS, VG_SCCWARC_TO_ABS, VG_LCCWARC_TO_ABS,VG_CLOSE_PATH};
+#endif
+    VGfloat coords[] = {32.0f,   0.0f,
+                        -32.0f, -32.0f, 0.0f, 64.0f, 32.0f,
+                        -32.0f, -32.0f, 0.0f, 32.0f, 0.0f};
+
+
+    vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
+    vgClear(0, 0, WINDSIZEX, WINDSIZEY);
+    vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
+
+    vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
+    vgLoadIdentity();
+    //vgTranslate(32.0f, 32.0f);
+
+    path = vgCreatePath( VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
+                         1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL );
+    if ( path == VG_INVALID_HANDLE ) {
+        return;
+    }
+    paint = vgCreatePaint();
+    if ( paint == VG_INVALID_HANDLE ) {
+        vgDestroyPath(path);
+        return;
+    }
+
+    vgAppendPathData(path, 4, commands, coords);
+    vgSetParameterfv(paint, VG_PAINT_COLOR, 4, fillColor);
+    vgSetParameteri( paint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
+    vgSetPaint(paint, VG_FILL_PATH);
+    vgDrawPath(path, VG_FILL_PATH);
+
+    vgDestroyPath(path);
+    vgDestroyPaint(paint);
+}
+
+
+int main(int argc, char **argv)
+{
+    set_window_size(64, 64);
+    return run(argc, argv, init, reshape,
+               draw, 0);
+}
diff --git a/progs/openvg/trivial/radialgrad.c b/progs/openvg/trivial/radialgrad.c
new file mode 100644
index 0000000000..cf3b1d522d
--- /dev/null
+++ b/progs/openvg/trivial/radialgrad.c
@@ -0,0 +1,99 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+#include <stdio.h>
+#include <string.h>
+
+static const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+
+static VGPath path;
+static VGPaint fill;
+
+
+VGfloat centeredGradient[5] = {200.0f, 200.0f, 200.0f, 200.0f, 100};
+VGfloat noncenteredGradient[5] = {200.0f, 200.0f, 250.0f, 250.0f, 100};
+VGfloat *radialGradient = centeredGradient;
+
+VGColorRampSpreadMode spread = VG_COLOR_RAMP_SPREAD_PAD;
+
+static void
+init(void)
+{
+   static const VGubyte sqrCmds[5] = {VG_MOVE_TO_ABS, VG_HLINE_TO_ABS, VG_VLINE_TO_ABS, VG_HLINE_TO_ABS, VG_CLOSE_PATH};
+   static const VGfloat sqrCoords[5]   = {0.0f, 0.0f, 400.0f, 400.0f, 0.0f};
+
+   VGfloat rampStop[] = {0.00f, 1.0f, 1.0f, 1.0f, 1.0f,
+                         0.33f, 1.0f, 0.0f, 0.0f, 1.0f,
+                         0.66f, 0.0f, 1.0f, 0.0f, 1.0f,
+                         1.00f, 0.0f, 0.0f,  1.0f, 1.0f};
+
+   path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+                       VG_PATH_CAPABILITY_APPEND_TO);
+   vgAppendPathData(path, 5, sqrCmds, sqrCoords);
+
+   fill = vgCreatePaint();
+   vgSetPaint(fill, VG_FILL_PATH);
+
+   vgSetParameteri(fill, VG_PAINT_TYPE, VG_PAINT_TYPE_RADIAL_GRADIENT);
+   vgSetParameteri(fill, VG_PAINT_COLOR_RAMP_SPREAD_MODE, spread);
+   vgSetParameterfv(fill, VG_PAINT_RADIAL_GRADIENT, 5, radialGradient);
+   vgSetParameterfv(fill, VG_PAINT_COLOR_RAMP_STOPS, 20, rampStop);
+
+   vgSetfv(VG_CLEAR_COLOR, 4, white_color);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+   vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+   vgClear(0, 0, window_width(), window_height());
+
+   vgDrawPath(path, VG_FILL_PATH);
+
+   vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+   VGint i;
+   for (i = 1; i < argc; ++i) {
+      const char *arg = argv[i];
+      if (!strcmp("-pad", arg))
+         spread = VG_COLOR_RAMP_SPREAD_PAD;
+      else if (!strcmp("-repeat", arg))
+         spread = VG_COLOR_RAMP_SPREAD_REPEAT;
+      else if (!strcmp("-reflect", arg))
+         spread = VG_COLOR_RAMP_SPREAD_REFLECT;
+      else if (!strcmp("-center", arg)) {
+         printf("Centered radial gradient\n");
+         radialGradient = centeredGradient;
+      } else if (!strcmp("-noncenter", arg)) {
+         printf("Non centered radial gradient\n");
+         radialGradient = noncenteredGradient;
+      }
+   }
+
+   switch(spread) {
+   case VG_COLOR_RAMP_SPREAD_PAD:
+      printf("Using spread mode: pad\n");
+      break;
+   case VG_COLOR_RAMP_SPREAD_REPEAT:
+      printf("Using spread mode: repeat\n");
+      break;
+   case VG_COLOR_RAMP_SPREAD_REFLECT:
+      printf("Using spread mode: reflect\n");
+   }
+
+   set_window_size(400, 400);
+
+   return run(argc, argv, init, reshape,
+              draw, 0);
+}
diff --git a/progs/openvg/trivial/readpixels.c b/progs/openvg/trivial/readpixels.c
new file mode 100644
index 0000000000..c8e286db9a
--- /dev/null
+++ b/progs/openvg/trivial/readpixels.c
@@ -0,0 +1,75 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+float red_color[4] = {1.0, 0.0, 0.0, 1.0};
+float blue_color[4] = {0.0, 0.0, 1.0, 1.0};
+VGint *data;
+
+static void
+init(void)
+{
+   data = malloc(sizeof(VGint)*2048*2048);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+   vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+   static const VGint red_pixel  = 255 << 24 | 255 << 16 | 0 << 8 |   0;
+   static const VGint blue_pixel = 255 << 24 |   0 << 16 | 0 << 8 | 255;
+   VGint i;
+
+   vgSetfv(VG_CLEAR_COLOR, 4, red_color);
+   vgClear(0, 0, window_width(), window_height());
+   vgFlush();
+
+   memset(data, 0, window_width() * window_height() * sizeof(VGint));
+
+   vgReadPixels(data, window_width() * sizeof(VGint),
+                VG_lARGB_8888,
+                0, 0, window_width(), window_height());
+
+   fprintf(stderr, "Red 0 = 0x%x and at 600 = 0x%x\n",
+           data[0], data[600]);
+   for (i = 0; i < window_width() * window_height(); ++i) {
+      assert(data[i] == red_pixel);
+   }
+
+   vgSetfv(VG_CLEAR_COLOR, 4, blue_color);
+   vgClear(50, 50, 50, 50);
+   vgFlush();
+
+   memset(data, 0, window_width() * window_height() * sizeof(VGint));
+
+   vgReadPixels(data, 50 * sizeof(VGint),
+                VG_lARGB_8888,
+                50, 50, 50, 50);
+
+   fprintf(stderr, "Blue 0 = 0x%x and at 100 = 0x%x\n",
+           data[0], data[100]);
+   for (i = 0; i < 50 * 50; ++i) {
+      assert(data[i] == blue_pixel);
+   }
+}
+
+
+int main(int argc, char **argv)
+{
+   int ret = run(argc, argv, init, reshape,
+                 draw, 0);
+
+   free(data);
+   return ret;
+}
diff --git a/progs/openvg/trivial/roundedrect.c b/progs/openvg/trivial/roundedrect.c
new file mode 100644
index 0000000000..c80a4ed299
--- /dev/null
+++ b/progs/openvg/trivial/roundedrect.c
@@ -0,0 +1,67 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {0.9, 0.1, 0.1, 0.8};
+
+VGPath path;
+VGPaint fill;
+
+
+static void
+init(void)
+{
+   static const VGubyte sqrCmds[10] = {VG_MOVE_TO_ABS,
+                                       VG_LINE_TO_ABS,
+                                       VG_CUBIC_TO_ABS,
+                                       VG_LINE_TO_ABS,
+                                       VG_CUBIC_TO_ABS,
+                                       VG_LINE_TO_ABS,
+                                       VG_CUBIC_TO_ABS,
+                                       VG_LINE_TO_ABS,
+                                       VG_CUBIC_TO_ABS,
+                                       VG_CLOSE_PATH};
+   static const VGfloat sqrCoords[]   = {
+      45.885571, 62.857143,
+      154.11442, 62.857143,
+      162.1236, 62.857143, 168.57142, 70.260744, 168.57142, 79.457144,
+      168.57142, 123.4,
+      168.57142, 132.5964, 162.1236,  140, 154.11442, 140,
+      45.885571, 140,
+      37.876394, 140, 31.428572, 132.5964, 31.428572, 123.4,
+      31.428572, 79.457144,
+      31.428572, 70.260744, 37.876394,62.857143, 45.885571,62.857143
+   };
+   path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+                       VG_PATH_CAPABILITY_APPEND_TO);
+   vgAppendPathData(path, 10, sqrCmds, sqrCoords);
+
+   fill = vgCreatePaint();
+   vgSetParameterfv(fill, VG_PAINT_COLOR, 4, color);
+   vgSetPaint(fill, VG_FILL_PATH);
+
+   vgSetfv(VG_CLEAR_COLOR, 4, white_color);
+   vgSetf(VG_STROKE_LINE_WIDTH, 6);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+   vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+   vgClear(0, 0, window_width(), window_height());
+   vgDrawPath(path, VG_STROKE_PATH);
+}
+
+
+int main(int argc, char **argv)
+{
+   return run(argc, argv, init, reshape,
+              draw, 0);
+}
diff --git a/progs/openvg/trivial/star-nonzero.c b/progs/openvg/trivial/star-nonzero.c
new file mode 100644
index 0000000000..012fbd3929
--- /dev/null
+++ b/progs/openvg/trivial/star-nonzero.c
@@ -0,0 +1,55 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat green_color[4] = {0.0, 1.0, 0.0, 0.8};
+
+VGPath path;
+VGPaint fill;
+
+
+static void
+init(void)
+{
+   static const VGubyte cmds[6] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS,
+                                   VG_LINE_TO_ABS, VG_CLOSE_PATH};
+   static const VGfloat coords[]   = {  0,  200,
+                                        300,  200,
+                                        50,   0,
+                                        150, 300,
+                                        250,   0};
+   path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+                       VG_PATH_CAPABILITY_APPEND_TO);
+   vgAppendPathData(path, 6, cmds, coords);
+
+   fill = vgCreatePaint();
+   vgSetParameterfv(fill, VG_PAINT_COLOR, 4, green_color);
+   vgSetPaint(fill, VG_FILL_PATH);
+
+   vgSetfv(VG_CLEAR_COLOR, 4, white_color);
+   vgSeti(VG_FILL_RULE, VG_NON_ZERO);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+   vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+   vgClear(0, 0, window_width(), window_height());
+   vgDrawPath(path, VG_FILL_PATH | VG_STROKE_PATH);
+
+   vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+   return run(argc, argv, init, reshape,
+              draw, 0);
+}
diff --git a/progs/openvg/trivial/star-oddeven.c b/progs/openvg/trivial/star-oddeven.c
new file mode 100644
index 0000000000..17311cf720
--- /dev/null
+++ b/progs/openvg/trivial/star-oddeven.c
@@ -0,0 +1,102 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat green_color[4] = {0.0, 1.0, 0.0, 0.8};
+const VGfloat black_color[4] = {0.0, 0.0, 0.0, 1.0};
+
+VGPath path;
+VGPaint fill;
+
+
+static void draw_point(VGfloat x, VGfloat y)
+{
+
+   static const VGubyte cmds[] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS,
+                                  VG_LINE_TO_ABS, VG_CLOSE_PATH};
+   const VGfloat coords[]   = {  x - 2,  y - 2,
+                                 x + 2,  y - 2,
+                                 x + 2,  y + 2,
+                                 x - 2,  y + 2};
+   VGPath path;
+   VGPaint fill;
+
+   path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+                       VG_PATH_CAPABILITY_ALL);
+   vgAppendPathData(path, 5, cmds, coords);
+
+   fill = vgCreatePaint();
+   vgSetParameterfv(fill, VG_PAINT_COLOR, 4, black_color);
+   vgSetPaint(fill, VG_FILL_PATH);
+
+   vgDrawPath(path, VG_FILL_PATH);
+
+   vgDestroyPath(path);
+   vgDestroyPaint(fill);
+}
+
+static void draw_marks(VGPath path)
+{
+    VGfloat point[2], tangent[2];
+    int i = 0;
+
+    for (i = 0; i < 1300; i += 50) {
+        vgPointAlongPath(path, 0, 6, i,
+                         point + 0, point + 1,
+                         tangent + 0, tangent + 1);
+        draw_point(point[0], point[1]);
+    }
+}
+
+static void
+init(void)
+{
+   static const VGubyte cmds[6] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS,
+                                   VG_LINE_TO_ABS, VG_CLOSE_PATH};
+   static const VGfloat coords[]   = {  0,  200,
+                                        300,  200,
+                                        50,   0,
+                                        150, 300,
+                                        250,   0};
+   path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+                       VG_PATH_CAPABILITY_ALL);
+   vgAppendPathData(path, 6, cmds, coords);
+
+   fill = vgCreatePaint();
+   vgSetParameterfv(fill, VG_PAINT_COLOR, 4, green_color);
+   vgSetPaint(fill, VG_FILL_PATH);
+
+   vgSetfv(VG_CLEAR_COLOR, 4, white_color);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+   vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+    VGfloat point[2], tangent[2];
+    int i = 0;
+
+    vgClear(0, 0, window_width(), window_height());
+
+    vgSetPaint(fill, VG_FILL_PATH);
+    vgDrawPath(path, VG_FILL_PATH);
+
+    draw_marks(path);
+
+
+    vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+   return run(argc, argv, init, reshape,
+              draw, 0);
+}
diff --git a/progs/openvg/trivial/stroke.c b/progs/openvg/trivial/stroke.c
new file mode 100644
index 0000000000..58ae5b7bc8
--- /dev/null
+++ b/progs/openvg/trivial/stroke.c
@@ -0,0 +1,116 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+#include <X11/keysym.h>
+#include <stdio.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {0.4, 0.1, 1.0, 1.0};
+
+VGPath path;
+VGPaint fill;
+
+VGint cap_style = VG_CAP_BUTT;
+VGint join_style = VG_JOIN_MITER;
+
+static void
+init(void)
+{
+#if 0
+   static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
+                                  VG_CUBIC_TO_ABS,
+   };
+   static const VGfloat coords[]   = {30, 30, 264, 0, 0, 264, 234, 234
+   };
+#else
+   static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
+                                  VG_LINE_TO_ABS,
+                                  VG_LINE_TO_ABS
+   };
+   static const VGfloat coords[]   = {30, 30, 202, 30, 150, 224
+   };
+#endif
+   VGfloat dash_pattern[2] = { 20.f, 20.f };
+   path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
+                       VG_PATH_CAPABILITY_APPEND_TO);
+   vgAppendPathData(path, 3, cmds, coords);
+
+   fill = vgCreatePaint();
+   vgSetParameterfv(fill, VG_PAINT_COLOR, 4, color);
+   vgSetPaint(fill, VG_FILL_PATH);
+
+   vgSetfv(VG_CLEAR_COLOR, 4, white_color);
+   vgSetf(VG_STROKE_LINE_WIDTH, 20);
+   vgSeti(VG_STROKE_CAP_STYLE, cap_style);
+   vgSeti(VG_STROKE_JOIN_STYLE, join_style);
+   vgSetfv(VG_STROKE_DASH_PATTERN, 2, dash_pattern);
+   vgSetf(VG_STROKE_DASH_PHASE, 0.0f);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+   vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+   vgClear(0, 0, window_width(), window_height());
+   vgDrawPath(path, VG_STROKE_PATH);
+
+   vgFlush();
+}
+
+static int  key_press(unsigned key)
+{
+    switch(key) {
+    case XK_c:
+    case XK_C:
+        ++cap_style;
+        if (cap_style > VG_CAP_SQUARE)
+            cap_style = VG_CAP_BUTT;
+        switch(cap_style) {
+        case VG_CAP_BUTT:
+            fprintf(stderr, "Cap style 'butt'\n");
+            break;
+        case VG_CAP_ROUND:
+            fprintf(stderr, "Cap style 'round'\n");
+            break;
+        case VG_CAP_SQUARE:
+            fprintf(stderr, "Cap style 'square'\n");
+            break;
+        }
+        vgSeti(VG_STROKE_CAP_STYLE, cap_style);
+        break;
+    case XK_j:
+    case XK_J:
+        ++join_style;
+        if (join_style > VG_JOIN_BEVEL)
+            join_style = VG_JOIN_MITER;
+        switch(join_style) {
+        case VG_JOIN_MITER:
+            fprintf(stderr, "Join style 'miter'\n");
+            break;
+        case VG_JOIN_ROUND:
+            fprintf(stderr, "Join style 'round'\n");
+            break;
+        case VG_JOIN_BEVEL:
+            fprintf(stderr, "Join style 'bevel'\n");
+            break;
+        }
+        vgSeti(VG_STROKE_JOIN_STYLE, join_style);
+        break;
+    default:
+        break;
+    }
+
+    return VG_TRUE;
+}
+
+int main(int argc, char **argv)
+{
+   return run(argc, argv, init, reshape,
+              draw, key_press);
+}
diff --git a/progs/openvg/trivial/stroke2.c b/progs/openvg/trivial/stroke2.c
new file mode 100644
index 0000000000..ce950c1886
--- /dev/null
+++ b/progs/openvg/trivial/stroke2.c
@@ -0,0 +1,207 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+#include <X11/keysym.h>
+#include <stdio.h>
+
+VGPaint stroke;
+VGPath target;
+VGPath lines;
+
+VGfloat xform[9];
+VGfloat color1[4];
+VGfloat color2[4];
+VGfloat bgCol[4];
+
+static void
+init(void)
+{
+    VGubyte lineCmds[6];
+    VGfloat lineCoords[8];
+    VGfloat arcCoords[5];
+    VGubyte sccCmd[1];
+    VGubyte scCmd[1];
+    VGubyte lccCmd[1];
+    VGubyte lcCmd[1];
+    VGubyte moveCmd[1];
+    VGfloat moveCoords[2];
+    VGint i;
+
+    bgCol[0] = 1.0f;
+    bgCol[1] = 1.0f;
+    bgCol[2] = 1.0f;
+    bgCol[3] = 1.0f;
+
+    vgSetfv(VG_CLEAR_COLOR, 4, bgCol);
+    vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
+
+    stroke = vgCreatePaint();
+    /* Red */
+    color1[0] = 1.0f;
+    color1[1] = 0.0f;
+    color1[2] = 0.0f;
+    color1[3] = 1.0f;
+
+    /* Orange */
+    color2[0] = 1.0000f;
+    color2[1] = 1.0f;
+    color2[2] = 0.0f;
+    color2[3] = 1.0f;
+    vgSetPaint(stroke, VG_STROKE_PATH);
+
+    vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_SQUARE);
+
+    {
+        VGfloat temp[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
+        for (i = 0; i < 9; i++)
+        {
+            xform[i] = temp[i];
+        }
+    }
+    vgGetMatrix(xform);
+
+    target = vgCreatePath(VG_PATH_FORMAT_STANDARD,
+                          VG_PATH_DATATYPE_F, 1, 0, 0, 0, VG_PATH_CAPABILITY_TRANSFORM_TO);
+
+#if 0
+    /* Line path */
+    {
+        VGubyte temp[6] = {VG_MOVE_TO_ABS, VG_VLINE_TO_REL,
+                           VG_MOVE_TO_ABS, VG_VLINE_TO_REL,
+                           VG_HLINE_TO_REL, VG_VLINE_TO_REL};
+        for (i = 0; i < 6; i++)
+        {
+            lineCmds[i] = temp[i];
+        }
+    }
+    {
+        VGfloat temp[8] = {0.5f, 0.8f, -0.6f, 0.28f, 0.6f, -0.4f, 0.44f, 0.4f};
+        for (i = 0; i < 8; i++)
+        {
+            lineCoords[i] = temp[i] * window_width();
+        }
+    }
+#else
+    {
+        VGfloat temp[5] = {0.35f, 0.15f, 29, 0.3f, 0.4f};
+        for (i = 0; i < 5; i++)
+        {
+            arcCoords[i] = temp[i] * window_width();
+        }
+        arcCoords[2] = 29;
+    }
+
+    {
+        VGubyte temp[1] = {VG_SCCWARC_TO_ABS};
+        for (i = 0; i < 1; i++)
+        {
+            sccCmd[i] = temp[i];
+        }
+    }
+    {
+        VGubyte temp[1] = {VG_SCWARC_TO_ABS};
+        for (i = 0; i < 1; i++)
+        {
+            scCmd[i] = temp[i];
+        }
+    }
+    {
+        VGubyte temp[1] = {VG_LCCWARC_TO_ABS};
+        for (i = 0; i < 1; i++)
+        {
+            lccCmd[i] = temp[i];
+        }
+    }
+    {
+        VGubyte temp[1] = {VG_LCWARC_TO_ABS};
+        for (i = 0; i < 1; i++)
+        {
+            lcCmd[i] = temp[i];
+        }
+    }
+
+    {
+        VGubyte temp[1] = {VG_MOVE_TO_ABS};
+        for (i = 0; i < 1; i++)
+        {
+            moveCmd[i] = temp[i];
+        }
+    }
+    {
+        VGfloat temp[2] = {0.7f, 0.6f};
+        for (i = 0; i < 2; i++)
+        {
+            moveCoords[i] = temp[i] * window_width();
+        }
+    }
+#endif
+
+    lines = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1,
+                         0, 0, 0,
+                         VG_PATH_CAPABILITY_APPEND_TO|
+                         VG_PATH_CAPABILITY_TRANSFORM_FROM);
+#if 0
+    vgAppendPathData(lines, 6, lineCmds, lineCoords);
+#else
+    vgAppendPathData(lines, 1, moveCmd, moveCoords);
+    vgAppendPathData(lines, 1, sccCmd, arcCoords);
+    vgAppendPathData(lines, 1, moveCmd, moveCoords);
+    vgAppendPathData(lines, 1, scCmd, arcCoords);
+    vgAppendPathData(lines, 1, moveCmd, moveCoords);
+    vgAppendPathData(lines, 1, lccCmd, arcCoords);
+    vgAppendPathData(lines, 1, moveCmd, moveCoords);
+    vgAppendPathData(lines, 1, lcCmd, arcCoords);
+#endif
+
+    vgLoadIdentity();
+    vgTranslate(0.25f * window_width(), 0.25f * window_height());
+    vgRotate(30);
+    vgTranslate(-0.25f * window_width(), -0.25f * window_height());
+    vgTransformPath(target, lines);}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+}
+
+static void
+draw(void)
+{
+    vgClear(0, 0, window_width(), window_height());
+    vgLoadMatrix(xform);
+    vgLoadIdentity();
+    vgTranslate(0.25f * window_width(), 0.25f * window_height());
+    vgRotate(30);
+    vgTranslate(-0.25f * window_width(), -0.25f * window_height());
+    vgSetf(VG_STROKE_LINE_WIDTH, 7);
+    vgSetParameterfv(stroke, VG_PAINT_COLOR, 4, color1);
+    vgDrawPath(lines, VG_STROKE_PATH);
+
+    vgLoadMatrix(xform);
+    vgSetParameterfv(stroke, VG_PAINT_COLOR, 4, color2);
+    vgSetf(VG_STROKE_LINE_WIDTH, 3);
+    vgDrawPath(target, VG_STROKE_PATH);
+}
+
+static int  key_press(unsigned key)
+{
+    switch(key) {
+    case XK_c:
+    case XK_C:
+        break;
+    case XK_j:
+    case XK_J:
+        break;
+    default:
+        break;
+    }
+
+    return VG_TRUE;
+}
+
+int main(int argc, char **argv)
+{
+   return run(argc, argv, init, reshape,
+              draw, key_press);
+}
diff --git a/progs/openvg/trivial/vguarc.c b/progs/openvg/trivial/vguarc.c
new file mode 100644
index 0000000000..8d971d5c09
--- /dev/null
+++ b/progs/openvg/trivial/vguarc.c
@@ -0,0 +1,74 @@
+#include "eglcommon.h"
+
+#include <VG/openvg.h>
+#include <VG/vgu.h>
+
+const VGfloat white_color[4] = {1.0, 1.0, 1.0, 1.0};
+const VGfloat color[4] = {0.4, 0.1, 1.0, 1.0};
+
+VGPath path;
+VGPaint paint;
+
+
+static void
+init(void)
+{
+    VGfloat clearColor[] = {0.0f, 0.0f, 0.0f, 1.0f};/* black color */
+    VGfloat greenColor[] = {0.0f, 1.0f, 0.0f, 1.0f};/* green color */
+    VGint arcType = VGU_ARC_OPEN;
+    VGfloat x, y, w, h, startAngle, angleExtent;
+
+    x = 150;
+    y = 150;
+    w = 150;
+    h = 150;
+#if 0
+    startAngle  = -540.0f;
+    angleExtent = 270.0f;
+#else
+    startAngle  = 270.0f;
+    angleExtent = 90.0f;
+#endif
+
+    paint = vgCreatePaint();
+
+    vgSetPaint(paint, VG_STROKE_PATH);
+    vgSetParameterfv(paint, VG_PAINT_COLOR, 4, greenColor);
+    vgSetParameteri( paint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
+    vgSetf(VG_STROKE_LINE_WIDTH, 6.0f);
+    vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
+    vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
+
+    path  = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
+                         1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
+
+    vguArc(path, x, y, w, h, startAngle, angleExtent, arcType);
+
+    vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
+    vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_BEVEL);
+    vgSetf(VG_STROKE_MITER_LIMIT, 4.0f);
+}
+
+/* new window size or exposure */
+static void
+reshape(int w, int h)
+{
+   vgLoadIdentity();
+}
+
+static void
+draw(void)
+{
+   vgClear(0, 0, window_width(), window_height());
+   vgDrawPath(path, VG_STROKE_PATH);
+
+   vgFlush();
+}
+
+
+int main(int argc, char **argv)
+{
+    // set_window_size(64, 63);
+   return run(argc, argv, init, reshape,
+              draw, 0);
+}