Fix the issue that all files are moved into a sub-directory libva.

Signed-off-by: Austin Yuan <shengquan.yuan@intel.com>

5 files changed, 1685 insertions, 0 deletions

diff --git a/dummy_drv_video/Makefile.am b/dummy_drv_video/Makefile.am
new file mode 100644
index 0000000..f782c71
--- /dev/null
+++ b/dummy_drv_video/Makefile.am
@@ -0,0 +1,31 @@
+# Copyright (c) 2007 Intel Corporation. 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 PRECISION INSIGHT 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.
+
+dummy_drv_video_la_LTLIBRARIES = dummy_drv_video.la
+dummy_drv_video_ladir = /usr/lib/dri
+dummy_drv_video_la_LDFLAGS = -module -avoid-version -no-undefined -Wl,--no-undefined
+dummy_drv_video_la_LIBADD = ../src/libva.la
+
+AM_CFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/../../include/external/ -I$(top_srcdir)/../../include/kmd -DIN_LIBVA
+dummy_drv_video_la_SOURCES = dummy_drv_video.c object_heap.c
+
+noinst_HEADERS = dummy_drv_video.h object_heap.h
diff --git a/dummy_drv_video/dummy_drv_video.c b/dummy_drv_video/dummy_drv_video.c
new file mode 100644
index 0000000..4db2e46
--- /dev/null
+++ b/dummy_drv_video/dummy_drv_video.c
@@ -0,0 +1,1289 @@
+/*
+ * Copyright (c) 2007 Intel Corporation. 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 PRECISION INSIGHT 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 "va_backend.h"
+
+#include "dummy_drv_video.h"
+
+#include "assert.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
+#define ASSERT	assert
+
+#define INIT_DRIVER_DATA	struct dummy_driver_data *driver_data = (struct dummy_driver_data *) ctx->pDriverData;
+
+#define CONFIG(id)  ((object_config_p) object_heap_lookup( &driver_data->config_heap, id ))
+#define CONTEXT(id) ((object_context_p) object_heap_lookup( &driver_data->context_heap, id ))
+#define SURFACE(id)	((object_surface_p) object_heap_lookup( &driver_data->surface_heap, id ))
+#define BUFFER(id)  ((object_buffer_p) object_heap_lookup( &driver_data->buffer_heap, id ))
+
+#define CONFIG_ID_OFFSET		0x01000000
+#define CONTEXT_ID_OFFSET		0x02000000
+#define SURFACE_ID_OFFSET		0x04000000
+#define BUFFER_ID_OFFSET		0x08000000
+
+static void dummy__error_message(const char *msg, ...)
+{
+    va_list args;
+
+    fprintf(stderr, "dummy_drv_video error: ");
+    va_start(args, msg);
+    vfprintf(stderr, msg, args);
+    va_end(args);
+}
+
+static void dummy__information_message(const char *msg, ...)
+{
+    va_list args;
+
+    fprintf(stderr, "dummy_drv_video: ");
+    va_start(args, msg);
+    vfprintf(stderr, msg, args);
+    va_end(args);
+}
+
+VAStatus dummy_QueryConfigProfiles(
+		VADriverContextP ctx,
+		VAProfile *profile_list,	/* out */
+		int *num_profiles			/* out */
+	)
+{
+    INIT_DRIVER_DATA
+    int i = 0;
+
+    profile_list[i++] = VAProfileMPEG2Simple;
+    profile_list[i++] = VAProfileMPEG2Main;
+    profile_list[i++] = VAProfileMPEG4Simple;
+    profile_list[i++] = VAProfileMPEG4AdvancedSimple;
+    profile_list[i++] = VAProfileMPEG4Main;
+    profile_list[i++] = VAProfileH264Baseline;
+    profile_list[i++] = VAProfileH264Main;
+    profile_list[i++] = VAProfileH264High;
+    profile_list[i++] = VAProfileVC1Simple;
+    profile_list[i++] = VAProfileVC1Main;
+    profile_list[i++] = VAProfileVC1Advanced;
+
+    /* If the assert fails then DUMMY_MAX_PROFILES needs to be bigger */
+    ASSERT(i <= DUMMY_MAX_PROFILES);
+    *num_profiles = i;
+
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_QueryConfigEntrypoints(
+		VADriverContextP ctx,
+		VAProfile profile,
+		VAEntrypoint  *entrypoint_list,	/* out */
+		int *num_entrypoints		/* out */
+	)
+{
+    INIT_DRIVER_DATA
+
+    switch (profile) {
+        case VAProfileMPEG2Simple:
+        case VAProfileMPEG2Main:
+                *num_entrypoints = 2;
+                entrypoint_list[0] = VAEntrypointVLD;
+                entrypoint_list[1] = VAEntrypointMoComp;
+                break;
+
+        case VAProfileMPEG4Simple:
+        case VAProfileMPEG4AdvancedSimple:
+        case VAProfileMPEG4Main:
+                *num_entrypoints = 1;
+                entrypoint_list[0] = VAEntrypointVLD;
+                break;
+
+        case VAProfileH264Baseline:
+        case VAProfileH264Main:
+        case VAProfileH264High:
+                *num_entrypoints = 1;
+                entrypoint_list[0] = VAEntrypointVLD;
+                break;
+
+        case VAProfileVC1Simple:
+        case VAProfileVC1Main:
+        case VAProfileVC1Advanced:
+                *num_entrypoints = 1;
+                entrypoint_list[0] = VAEntrypointVLD;
+                break;
+
+        default:
+                *num_entrypoints = 0;
+                break;
+    }
+
+    /* If the assert fails then DUMMY_MAX_ENTRYPOINTS needs to be bigger */
+    ASSERT(*num_entrypoints <= DUMMY_MAX_ENTRYPOINTS);
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_GetConfigAttributes(
+		VADriverContextP ctx,
+		VAProfile profile,
+		VAEntrypoint entrypoint,
+		VAConfigAttrib *attrib_list,	/* in/out */
+		int num_attribs
+	)
+{
+    INIT_DRIVER_DATA
+
+    int i;
+
+    /* Other attributes don't seem to be defined */
+    /* What to do if we don't know the attribute? */
+    for (i = 0; i < num_attribs; i++)
+    {
+        switch (attrib_list[i].type)
+        {
+          case VAConfigAttribRTFormat:
+              attrib_list[i].value = VA_RT_FORMAT_YUV420;
+              break;
+
+          default:
+              /* Do nothing */
+              attrib_list[i].value = VA_ATTRIB_NOT_SUPPORTED;
+              break;
+        }
+    }
+
+    return VA_STATUS_SUCCESS;
+}
+
+static VAStatus dummy__update_attribute(object_config_p obj_config, VAConfigAttrib *attrib)
+{
+    int i;
+    /* Check existing attrbiutes */
+    for(i = 0; obj_config->attrib_count < i; i++)
+    {
+        if (obj_config->attrib_list[i].type == attrib->type)
+        {
+            /* Update existing attribute */
+            obj_config->attrib_list[i].value = attrib->value;
+            return VA_STATUS_SUCCESS;
+        }
+    }
+    if (obj_config->attrib_count < DUMMY_MAX_CONFIG_ATTRIBUTES)
+    {
+        i = obj_config->attrib_count;
+        obj_config->attrib_list[i].type = attrib->type;
+        obj_config->attrib_list[i].value = attrib->value;
+        obj_config->attrib_count++;
+        return VA_STATUS_SUCCESS;
+    }
+    return VA_STATUS_ERROR_MAX_NUM_EXCEEDED;
+}
+
+VAStatus dummy_CreateConfig(
+		VADriverContextP ctx,
+		VAProfile profile,
+		VAEntrypoint entrypoint,
+		VAConfigAttrib *attrib_list,
+		int num_attribs,
+		VAConfigID *config_id		/* out */
+	)
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus;
+    int configID;
+    object_config_p obj_config;
+    int i;
+
+    /* Validate profile & entrypoint */
+    switch (profile) {
+        case VAProfileMPEG2Simple:
+        case VAProfileMPEG2Main:
+                if ((VAEntrypointVLD == entrypoint) ||
+                    (VAEntrypointMoComp == entrypoint))
+                {
+                    vaStatus = VA_STATUS_SUCCESS;
+                }
+                else
+                {
+                    vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+                }
+                break;
+
+        case VAProfileMPEG4Simple:
+        case VAProfileMPEG4AdvancedSimple:
+        case VAProfileMPEG4Main:
+                if (VAEntrypointVLD == entrypoint)
+                {
+                    vaStatus = VA_STATUS_SUCCESS;
+                }
+                else
+                {
+                    vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+                }
+                break;
+
+        case VAProfileH264Baseline:
+        case VAProfileH264Main:
+        case VAProfileH264High:
+                if (VAEntrypointVLD == entrypoint)
+                {
+                    vaStatus = VA_STATUS_SUCCESS;
+                }
+                else
+                {
+                    vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+                }
+                break;
+
+        case VAProfileVC1Simple:
+        case VAProfileVC1Main:
+        case VAProfileVC1Advanced:
+                if (VAEntrypointVLD == entrypoint)
+                {
+                    vaStatus = VA_STATUS_SUCCESS;
+                }
+                else
+                {
+                    vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+                }
+                break;
+
+        default:
+                vaStatus = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
+                break;
+    }
+
+    if (VA_STATUS_SUCCESS != vaStatus)
+    {
+        return vaStatus;
+    }
+
+    configID = object_heap_allocate( &driver_data->config_heap );
+    obj_config = CONFIG(configID);
+    if (NULL == obj_config)
+    {
+        vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
+        return vaStatus;
+    }
+
+    obj_config->profile = profile;
+    obj_config->entrypoint = entrypoint;
+    obj_config->attrib_list[0].type = VAConfigAttribRTFormat;
+    obj_config->attrib_list[0].value = VA_RT_FORMAT_YUV420;
+    obj_config->attrib_count = 1;
+
+    for(i = 0; i < num_attribs; i++)
+    {
+        vaStatus = dummy__update_attribute(obj_config, &(attrib_list[i]));
+        if (VA_STATUS_SUCCESS != vaStatus)
+        {
+            break;
+        }
+    }
+
+    /* Error recovery */
+    if (VA_STATUS_SUCCESS != vaStatus)
+    {
+        object_heap_free( &driver_data->config_heap, (object_base_p) obj_config);
+    }
+    else
+    {
+        *config_id = configID;
+    }
+
+    return vaStatus;
+}
+
+VAStatus dummy_DestroyConfig(
+		VADriverContextP ctx,
+		VAConfigID config_id
+	)
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus;
+    object_config_p obj_config;
+
+    obj_config = CONFIG(config_id);
+    if (NULL == obj_config)
+    {
+        vaStatus = VA_STATUS_ERROR_INVALID_CONFIG;
+        return vaStatus;
+    }
+
+    object_heap_free( &driver_data->config_heap, (object_base_p) obj_config);
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_QueryConfigAttributes(
+		VADriverContextP ctx,
+		VAConfigID config_id,
+		VAProfile *profile,		/* out */
+		VAEntrypoint *entrypoint, 	/* out */
+		VAConfigAttrib *attrib_list,	/* out */
+		int *num_attribs		/* out */
+	)
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    object_config_p obj_config;
+    int i;
+
+    obj_config = CONFIG(config_id);
+    ASSERT(obj_config);
+
+    *profile = obj_config->profile;
+    *entrypoint = obj_config->entrypoint;
+    *num_attribs =  obj_config->attrib_count;
+    for(i = 0; i < obj_config->attrib_count; i++)
+    {
+        attrib_list[i] = obj_config->attrib_list[i];
+    }
+
+    return vaStatus;
+}
+
+VAStatus dummy_CreateSurfaces(
+		VADriverContextP ctx,
+		int width,
+		int height,
+		int format,
+		int num_surfaces,
+		VASurfaceID *surfaces		/* out */
+	)
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    int i;
+
+    /* We only support one format */
+    if (VA_RT_FORMAT_YUV420 != format)
+    {
+        return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
+    }
+
+    for (i = 0; i < num_surfaces; i++)
+    {
+        int surfaceID = object_heap_allocate( &driver_data->surface_heap );
+        object_surface_p obj_surface = SURFACE(surfaceID);
+        if (NULL == obj_surface)
+        {
+            vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
+            break;
+        }
+        obj_surface->surface_id = surfaceID;
+        surfaces[i] = surfaceID;
+    }
+
+    /* Error recovery */
+    if (VA_STATUS_SUCCESS != vaStatus)
+    {
+        /* surfaces[i-1] was the last successful allocation */
+        for(; i--; )
+        {
+            object_surface_p obj_surface = SURFACE(surfaces[i]);
+            surfaces[i] = VA_INVALID_SURFACE;
+            ASSERT(obj_surface);
+            object_heap_free( &driver_data->surface_heap, (object_base_p) obj_surface);
+        }
+    }
+
+    return vaStatus;
+}
+
+VAStatus dummy_DestroySurfaces(
+		VADriverContextP ctx,
+		VASurfaceID *surface_list,
+		int num_surfaces
+	)
+{
+    INIT_DRIVER_DATA
+    int i;
+    for(i = num_surfaces; i--; )
+    {
+        object_surface_p obj_surface = SURFACE(surface_list[i]);
+        ASSERT(obj_surface);
+        object_heap_free( &driver_data->surface_heap, (object_base_p) obj_surface);
+    }
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_QueryImageFormats(
+	VADriverContextP ctx,
+	VAImageFormat *format_list,        /* out */
+	int *num_formats           /* out */
+)
+{
+    INIT_DRIVER_DATA
+    
+    /* TODO */
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_CreateImage(
+	VADriverContextP ctx,
+	VAImageFormat *format,
+	int width,
+	int height,
+	VAImage *image     /* out */
+)
+{
+    INIT_DRIVER_DATA
+    
+    /* TODO */
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_DeriveImage(
+	VADriverContextP ctx,
+	VASurfaceID surface,
+	VAImage *image     /* out */
+)
+{
+    INIT_DRIVER_DATA
+    
+    /* TODO */
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_DestroyImage(
+	VADriverContextP ctx,
+	VAImageID image
+)
+{
+    INIT_DRIVER_DATA
+    
+    /* TODO */
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_SetImagePalette(
+	VADriverContextP ctx,
+	VAImageID image,
+	unsigned char *palette
+)
+{
+    INIT_DRIVER_DATA
+    
+    /* TODO */
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_GetImage(
+	VADriverContextP ctx,
+	VASurfaceID surface,
+	int x,     /* coordinates of the upper left source pixel */
+	int y,
+	unsigned int width, /* width and height of the region */
+	unsigned int height,
+	VAImageID image
+)
+{
+    INIT_DRIVER_DATA
+    
+    /* TODO */
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_PutImage(
+	VADriverContextP ctx,
+	VASurfaceID surface,
+	VAImageID image,
+	int src_x,
+	int src_y,
+	unsigned int width,
+	unsigned int height,
+	int dest_x,
+	int dest_y 
+)
+{
+    INIT_DRIVER_DATA
+    
+    /* TODO */
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_PutImage2(
+	VADriverContextP ctx,
+	VASurfaceID surface,
+	VAImageID image,
+	int src_x,
+	int src_y,
+	unsigned int src_width,
+	unsigned int src_height,
+	int dest_x,
+	int dest_y,
+	unsigned int dest_width,
+	unsigned int dest_height
+)
+{
+    INIT_DRIVER_DATA
+    
+    /* TODO */
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_QuerySubpictureFormats(
+	VADriverContextP ctx,
+	VAImageFormat *format_list,        /* out */
+	unsigned int *flags,       /* out */
+	unsigned int *num_formats  /* out */
+)
+{
+    INIT_DRIVER_DATA
+    
+    /* TODO */
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_CreateSubpicture(
+	VADriverContextP ctx,
+	VAImageID image,
+	VASubpictureID *subpicture   /* out */
+)
+{
+    INIT_DRIVER_DATA
+    
+    /* TODO */
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_DestroySubpicture(
+	VADriverContextP ctx,
+	VASubpictureID subpicture
+)
+{
+    INIT_DRIVER_DATA
+    
+    /* TODO */
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_SetSubpictureImage(
+        VADriverContextP ctx,
+        VASubpictureID subpicture,
+        VAImageID image
+)
+{
+    INIT_DRIVER_DATA
+    
+    /* TODO */
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_SetSubpicturePalette(
+	VADriverContextP ctx,
+	VASubpictureID subpicture,
+	/*
+	 * pointer to an array holding the palette data.  The size of the array is
+	 * num_palette_entries * entry_bytes in size.  The order of the components
+	 * in the palette is described by the component_order in VASubpicture struct
+	 */
+	unsigned char *palette
+)
+{
+    INIT_DRIVER_DATA
+    
+    /* TODO */
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_SetSubpictureChromakey(
+	VADriverContextP ctx,
+	VASubpictureID subpicture,
+	unsigned int chromakey_min,
+	unsigned int chromakey_max,
+	unsigned int chromakey_mask
+)
+{
+    INIT_DRIVER_DATA
+    
+    /* TODO */
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_SetSubpictureGlobalAlpha(
+	VADriverContextP ctx,
+	VASubpictureID subpicture,
+	float global_alpha 
+)
+{
+    INIT_DRIVER_DATA
+    
+    /* TODO */
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_AssociateSubpicture(
+	VADriverContextP ctx,
+	VASubpictureID subpicture,
+	VASurfaceID *target_surfaces,
+	int num_surfaces,
+	short src_x, /* upper left offset in subpicture */
+	short src_y,
+	short dest_x, /* upper left offset in surface */
+	short dest_y,
+	unsigned short width,
+	unsigned short height,
+	/*
+	 * whether to enable chroma-keying or global-alpha
+	 * see VA_SUBPICTURE_XXX values
+	 */
+	unsigned int flags
+)
+{
+    INIT_DRIVER_DATA
+    
+    /* TODO */
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_AssociateSubpicture2(
+	VADriverContextP ctx,
+	VASubpictureID subpicture,
+	VASurfaceID *target_surfaces,
+	int num_surfaces,
+	short src_x, /* upper left offset in subpicture */
+	short src_y,
+	unsigned short src_width,
+	unsigned short src_height,
+	short dest_x, /* upper left offset in surface */
+	short dest_y,
+	unsigned short dest_width,
+	unsigned short dest_height,
+	/*
+	 * whether to enable chroma-keying or global-alpha
+	 * see VA_SUBPICTURE_XXX values
+	 */
+	unsigned int flags
+)
+{
+    INIT_DRIVER_DATA
+    
+    /* TODO */
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_DeassociateSubpicture(
+	VADriverContextP ctx,
+	VASubpictureID subpicture,
+	VASurfaceID *target_surfaces,
+	int num_surfaces
+)
+{
+    INIT_DRIVER_DATA
+    
+    /* TODO */
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_CreateContext(
+		VADriverContextP ctx,
+		VAConfigID config_id,
+		int picture_width,
+		int picture_height,
+		int flag,
+		VASurfaceID *render_targets,
+		int num_render_targets,
+		VAContextID *context		/* out */
+	)
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    object_config_p obj_config;
+    int i;
+
+    obj_config = CONFIG(config_id);
+    if (NULL == obj_config)
+    {
+        vaStatus = VA_STATUS_ERROR_INVALID_CONFIG;
+        return vaStatus;
+    }
+
+    /* Validate flag */
+    /* Validate picture dimensions */
+
+    int contextID = object_heap_allocate( &driver_data->context_heap );
+    object_context_p obj_context = CONTEXT(contextID);
+    if (NULL == obj_context)
+    {
+        vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
+        return vaStatus;
+    }
+
+    obj_context->context_id  = contextID;
+    *context = contextID;
+    obj_context->current_render_target = -1;
+    obj_context->config_id = config_id;
+    obj_context->picture_width = picture_width;
+    obj_context->picture_height = picture_height;
+    obj_context->num_render_targets = num_render_targets;
+    obj_context->render_targets = (VASurfaceID *) malloc(num_render_targets * sizeof(VASurfaceID));
+    if (obj_context->render_targets == NULL)
+    {
+        vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
+        return vaStatus;
+    }
+    
+    for(i = 0; i < num_render_targets; i++)
+    {
+        if (NULL == SURFACE(render_targets[i]))
+        {
+            vaStatus = VA_STATUS_ERROR_INVALID_SURFACE;
+            break;
+        }
+        obj_context->render_targets[i] = render_targets[i];
+    }
+    obj_context->flags = flag;
+
+    /* Error recovery */
+    if (VA_STATUS_SUCCESS != vaStatus)
+    {
+        obj_context->context_id = -1;
+        obj_context->config_id = -1;
+        free(obj_context->render_targets);
+        obj_context->render_targets = NULL;
+        obj_context->num_render_targets = 0;
+        obj_context->flags = 0;
+        object_heap_free( &driver_data->context_heap, (object_base_p) obj_context);
+    }
+
+    return vaStatus;
+}
+
+
+VAStatus dummy_DestroyContext(
+		VADriverContextP ctx,
+		VAContextID context
+	)
+{
+    INIT_DRIVER_DATA
+    object_context_p obj_context = CONTEXT(context);
+    ASSERT(obj_context);
+
+    obj_context->context_id = -1;
+    obj_context->config_id = -1;
+    obj_context->picture_width = 0;
+    obj_context->picture_height = 0;
+    if (obj_context->render_targets)
+    {
+        free(obj_context->render_targets);
+    }
+    obj_context->render_targets = NULL;
+    obj_context->num_render_targets = 0;
+    obj_context->flags = 0;
+
+    obj_context->current_render_target = -1;
+
+    object_heap_free( &driver_data->context_heap, (object_base_p) obj_context);
+
+    return VA_STATUS_SUCCESS;
+}
+
+
+
+static VAStatus dummy__allocate_buffer(object_buffer_p obj_buffer, int size)
+{
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+
+    obj_buffer->buffer_data = realloc(obj_buffer->buffer_data, size);
+    if (NULL == obj_buffer->buffer_data)
+    {
+        vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
+    }
+    return vaStatus;
+}
+
+VAStatus dummy_CreateBuffer(
+		VADriverContextP ctx,
+                VAContextID context,	/* in */
+                VABufferType type,	/* in */
+                unsigned int size,		/* in */
+                unsigned int num_elements,	/* in */
+                void *data,			/* in */
+                VABufferID *buf_id		/* out */
+)
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    int bufferID;
+    object_buffer_p obj_buffer;
+
+    /* Validate type */
+    switch (type)
+    {
+        case VAPictureParameterBufferType:
+        case VAIQMatrixBufferType:
+        case VABitPlaneBufferType:
+        case VASliceGroupMapBufferType:
+        case VASliceParameterBufferType:
+        case VASliceDataBufferType:
+        case VAMacroblockParameterBufferType:
+        case VAResidualDataBufferType:
+        case VADeblockingParameterBufferType:
+        case VAImageBufferType:
+            /* Ok */
+            break;
+        default:
+            vaStatus = VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE;
+            return vaStatus;
+    }
+
+    bufferID = object_heap_allocate( &driver_data->buffer_heap );
+    obj_buffer = BUFFER(bufferID);
+    if (NULL == obj_buffer)
+    {
+        vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
+        return vaStatus;
+    }
+
+    obj_buffer->buffer_data = NULL;
+
+    vaStatus = dummy__allocate_buffer(obj_buffer, size * num_elements);
+    if (VA_STATUS_SUCCESS == vaStatus)
+    {
+        obj_buffer->max_num_elements = num_elements;
+        obj_buffer->num_elements = num_elements;
+        if (data)
+        {
+            memcpy(obj_buffer->buffer_data, data, size * num_elements);
+        }
+    }
+
+    if (VA_STATUS_SUCCESS == vaStatus)
+    {
+        *buf_id = bufferID;
+    }
+
+    return vaStatus;
+}
+
+
+VAStatus dummy_BufferSetNumElements(
+		VADriverContextP ctx,
+		VABufferID buf_id,	/* in */
+        unsigned int num_elements	/* in */
+	)
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    object_buffer_p obj_buffer = BUFFER(buf_id);
+    ASSERT(obj_buffer);
+
+    if ((num_elements < 0) || (num_elements > obj_buffer->max_num_elements))
+    {
+        vaStatus = VA_STATUS_ERROR_UNKNOWN;
+    }
+    if (VA_STATUS_SUCCESS == vaStatus)
+    {
+        obj_buffer->num_elements = num_elements;
+    }
+
+    return vaStatus;
+}
+
+VAStatus dummy_MapBuffer(
+		VADriverContextP ctx,
+		VABufferID buf_id,	/* in */
+		void **pbuf         /* out */
+	)
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_ERROR_UNKNOWN;
+    object_buffer_p obj_buffer = BUFFER(buf_id);
+    ASSERT(obj_buffer);
+    if (NULL == obj_buffer)
+    {
+        vaStatus = VA_STATUS_ERROR_INVALID_BUFFER;
+        return vaStatus;
+    }
+
+    if (NULL != obj_buffer->buffer_data)
+    {
+        *pbuf = obj_buffer->buffer_data;
+        vaStatus = VA_STATUS_SUCCESS;
+    }
+    return vaStatus;
+}
+
+VAStatus dummy_UnmapBuffer(
+		VADriverContextP ctx,
+		VABufferID buf_id	/* in */
+	)
+{
+    /* Do nothing */
+    return VA_STATUS_SUCCESS;
+}
+
+static void dummy__destroy_buffer(struct dummy_driver_data *driver_data, object_buffer_p obj_buffer)
+{
+    if (NULL != obj_buffer->buffer_data)
+    {
+        free(obj_buffer->buffer_data);
+        obj_buffer->buffer_data = NULL;
+    }
+
+    object_heap_free( &driver_data->buffer_heap, (object_base_p) obj_buffer);
+}
+
+VAStatus dummy_DestroyBuffer(
+		VADriverContextP ctx,
+		VABufferID buffer_id
+	)
+{
+    INIT_DRIVER_DATA
+    object_buffer_p obj_buffer = BUFFER(buffer_id);
+    ASSERT(obj_buffer);
+
+    dummy__destroy_buffer(driver_data, obj_buffer);
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_BeginPicture(
+		VADriverContextP ctx,
+		VAContextID context,
+		VASurfaceID render_target
+	)
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    object_context_p obj_context;
+    object_surface_p obj_surface;
+
+    obj_context = CONTEXT(context);
+    ASSERT(obj_context);
+
+    obj_surface = SURFACE(render_target);
+    ASSERT(obj_surface);
+
+    obj_context->current_render_target = obj_surface->base.id;
+
+    return vaStatus;
+}
+
+VAStatus dummy_RenderPicture(
+		VADriverContextP ctx,
+		VAContextID context,
+		VABufferID *buffers,
+		int num_buffers
+	)
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    object_context_p obj_context;
+    object_surface_p obj_surface;
+    int i;
+
+    obj_context = CONTEXT(context);
+    ASSERT(obj_context);
+
+    obj_surface = SURFACE(obj_context->current_render_target);
+    ASSERT(obj_surface);
+
+    /* verify that we got valid buffer references */
+    for(i = 0; i < num_buffers; i++)
+    {
+        object_buffer_p obj_buffer = BUFFER(buffers[i]);
+        ASSERT(obj_buffer);
+        if (NULL == obj_buffer)
+        {
+            vaStatus = VA_STATUS_ERROR_INVALID_BUFFER;
+            break;
+        }
+    }
+    
+    /* Release buffers */
+    for(i = 0; i < num_buffers; i++)
+    {
+        object_buffer_p obj_buffer = BUFFER(buffers[i]);
+        ASSERT(obj_buffer);
+        dummy__destroy_buffer(driver_data, obj_buffer);
+    }
+
+    return vaStatus;
+}
+
+VAStatus dummy_EndPicture(
+		VADriverContextP ctx,
+		VAContextID context
+	)
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    object_context_p obj_context;
+    object_surface_p obj_surface;
+
+    obj_context = CONTEXT(context);
+    ASSERT(obj_context);
+
+    obj_surface = SURFACE(obj_context->current_render_target);
+    ASSERT(obj_surface);
+
+    // For now, assume that we are done with rendering right away
+    obj_context->current_render_target = -1;
+
+    return vaStatus;
+}
+
+
+VAStatus dummy_SyncSurface(
+		VADriverContextP ctx,
+		VAContextID context,
+		VASurfaceID render_target
+	)
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    object_context_p obj_context;
+    object_surface_p obj_surface;
+
+    obj_context = CONTEXT(context);
+    ASSERT(obj_context);
+
+    obj_surface = SURFACE(render_target);
+    ASSERT(obj_surface);
+
+    /* Assume that this shouldn't be called before vaEndPicture() */
+    ASSERT( obj_context->current_render_target != obj_surface->base.id );
+
+    return vaStatus;
+}
+
+VAStatus dummy_QuerySurfaceStatus(
+		VADriverContextP ctx,
+		VASurfaceID render_target,
+		VASurfaceStatus *status	/* out */
+	)
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    object_surface_p obj_surface;
+
+    obj_surface = SURFACE(render_target);
+    ASSERT(obj_surface);
+
+    *status = VASurfaceReady;
+
+    return vaStatus;
+}
+
+VAStatus dummy_PutSurface(
+   		VADriverContextP ctx,
+		VASurfaceID surface,
+		Drawable draw, /* X Drawable */
+		short srcx,
+		short srcy,
+		unsigned short srcw,
+		unsigned short srch,
+		short destx,
+		short desty,
+		unsigned short destw,
+		unsigned short desth,
+		VARectangle *cliprects, /* client supplied clip list */
+		unsigned int number_cliprects, /* number of clip rects in the clip list */
+		unsigned int flags /* de-interlacing flags */
+	)
+{
+    /* TODO */
+    return VA_STATUS_ERROR_UNKNOWN;
+}
+
+/* 
+ * Query display attributes 
+ * The caller must provide a "attr_list" array that can hold at
+ * least vaMaxNumDisplayAttributes() entries. The actual number of attributes
+ * returned in "attr_list" is returned in "num_attributes".
+ */
+VAStatus dummy_QueryDisplayAttributes (
+		VADriverContextP ctx,
+		VADisplayAttribute *attr_list,	/* out */
+		int *num_attributes		/* out */
+	)
+{
+    /* TODO */
+    return VA_STATUS_ERROR_UNKNOWN;
+}
+
+/* 
+ * Get display attributes 
+ * This function returns the current attribute values in "attr_list".
+ * Only attributes returned with VA_DISPLAY_ATTRIB_GETTABLE set in the "flags" field
+ * from vaQueryDisplayAttributes() can have their values retrieved.  
+ */
+VAStatus dummy_GetDisplayAttributes (
+		VADriverContextP ctx,
+		VADisplayAttribute *attr_list,	/* in/out */
+		int num_attributes
+	)
+{
+    /* TODO */
+    return VA_STATUS_ERROR_UNKNOWN;
+}
+
+/* 
+ * Set display attributes 
+ * Only attributes returned with VA_DISPLAY_ATTRIB_SETTABLE set in the "flags" field
+ * from vaQueryDisplayAttributes() can be set.  If the attribute is not settable or 
+ * the value is out of range, the function returns VA_STATUS_ERROR_ATTR_NOT_SUPPORTED
+ */
+VAStatus dummy_SetDisplayAttributes (
+		VADriverContextP ctx,
+		VADisplayAttribute *attr_list,
+		int num_attributes
+	)
+{
+    /* TODO */
+    return VA_STATUS_ERROR_UNKNOWN;
+}
+
+
+VAStatus dummy_DbgCopySurfaceToBuffer(
+		VADriverContextP ctx,
+		VASurfaceID surface,
+		void **buffer, /* out */
+		unsigned int *stride /* out */
+	)
+{
+    /* TODO */
+    return VA_STATUS_ERROR_UNKNOWN;
+}
+
+VAStatus dummy_Terminate( VADriverContextP ctx )
+{
+    INIT_DRIVER_DATA
+    object_buffer_p obj_buffer;
+    object_surface_p obj_surface;
+    object_context_p obj_context;
+    object_config_p obj_config;
+    object_heap_iterator iter;
+
+    /* Clean up left over buffers */
+    obj_buffer = (object_buffer_p) object_heap_first( &driver_data->buffer_heap, &iter);
+    while (obj_buffer)
+    {
+        dummy__information_message("vaTerminate: bufferID %08x still allocated, destroying\n", obj_buffer->base.id);
+        dummy__destroy_buffer(driver_data, obj_buffer);
+        obj_buffer = (object_buffer_p) object_heap_next( &driver_data->buffer_heap, &iter);
+    }
+    object_heap_destroy( &driver_data->buffer_heap );
+
+    /* TODO cleanup */
+    object_heap_destroy( &driver_data->surface_heap );
+
+    /* TODO cleanup */
+    object_heap_destroy( &driver_data->context_heap );
+
+    /* Clean up configIDs */
+    obj_config = (object_config_p) object_heap_first( &driver_data->config_heap, &iter);
+    while (obj_config)
+    {
+        object_heap_free( &driver_data->config_heap, (object_base_p) obj_config);
+        obj_config = (object_config_p) object_heap_next( &driver_data->config_heap, &iter);
+    }
+    object_heap_destroy( &driver_data->config_heap );
+
+    free(ctx->pDriverData);
+    ctx->pDriverData = NULL;
+
+    return VA_STATUS_SUCCESS;
+}
+
+VAStatus __vaDriverInit_0_29(  VADriverContextP ctx )
+{
+    object_base_p obj;
+    int result;
+    struct dummy_driver_data *driver_data;
+    int i;
+
+    ctx->version_major = 0;
+    ctx->version_minor = 29;
+    ctx->max_profiles = DUMMY_MAX_PROFILES;
+    ctx->max_entrypoints = DUMMY_MAX_ENTRYPOINTS;
+    ctx->max_attributes = DUMMY_MAX_CONFIG_ATTRIBUTES;
+    ctx->max_image_formats = DUMMY_MAX_IMAGE_FORMATS;
+    ctx->max_subpic_formats = DUMMY_MAX_SUBPIC_FORMATS;
+    ctx->max_display_attributes = DUMMY_MAX_DISPLAY_ATTRIBUTES;
+    ctx->str_vendor = DUMMY_STR_VENDOR;
+
+    ctx->vtable.vaTerminate = dummy_Terminate;
+    ctx->vtable.vaQueryConfigEntrypoints = dummy_QueryConfigEntrypoints;
+    ctx->vtable.vaQueryConfigProfiles = dummy_QueryConfigProfiles;
+    ctx->vtable.vaQueryConfigEntrypoints = dummy_QueryConfigEntrypoints;
+    ctx->vtable.vaQueryConfigAttributes = dummy_QueryConfigAttributes;
+    ctx->vtable.vaCreateConfig = dummy_CreateConfig;
+    ctx->vtable.vaDestroyConfig = dummy_DestroyConfig;
+    ctx->vtable.vaGetConfigAttributes = dummy_GetConfigAttributes;
+    ctx->vtable.vaCreateSurfaces = dummy_CreateSurfaces;
+    ctx->vtable.vaDestroySurfaces = dummy_DestroySurfaces;
+    ctx->vtable.vaCreateContext = dummy_CreateContext;
+    ctx->vtable.vaDestroyContext = dummy_DestroyContext;
+    ctx->vtable.vaCreateBuffer = dummy_CreateBuffer;
+    ctx->vtable.vaBufferSetNumElements = dummy_BufferSetNumElements;
+    ctx->vtable.vaMapBuffer = dummy_MapBuffer;
+    ctx->vtable.vaUnmapBuffer = dummy_UnmapBuffer;
+    ctx->vtable.vaDestroyBuffer = dummy_DestroyBuffer;
+    ctx->vtable.vaBeginPicture = dummy_BeginPicture;
+    ctx->vtable.vaRenderPicture = dummy_RenderPicture;
+    ctx->vtable.vaEndPicture = dummy_EndPicture;
+    ctx->vtable.vaSyncSurface = dummy_SyncSurface;
+    ctx->vtable.vaQuerySurfaceStatus = dummy_QuerySurfaceStatus;
+    ctx->vtable.vaPutSurface = dummy_PutSurface;
+    ctx->vtable.vaQueryImageFormats = dummy_QueryImageFormats;
+    ctx->vtable.vaCreateImage = dummy_CreateImage;
+    ctx->vtable.vaDeriveImage = dummy_DeriveImage;
+    ctx->vtable.vaDestroyImage = dummy_DestroyImage;
+    ctx->vtable.vaSetImagePalette = dummy_SetImagePalette;
+    ctx->vtable.vaGetImage = dummy_GetImage;
+    ctx->vtable.vaPutImage = dummy_PutImage;
+    ctx->vtable.vaPutImage2 = dummy_PutImage2;
+    ctx->vtable.vaQuerySubpictureFormats = dummy_QuerySubpictureFormats;
+    ctx->vtable.vaCreateSubpicture = dummy_CreateSubpicture;
+    ctx->vtable.vaDestroySubpicture = dummy_DestroySubpicture;
+    ctx->vtable.vaSetSubpictureImage = dummy_SetSubpictureImage;
+    ctx->vtable.vaSetSubpictureChromakey = dummy_SetSubpictureChromakey;
+    ctx->vtable.vaSetSubpictureGlobalAlpha = dummy_SetSubpictureGlobalAlpha;
+    ctx->vtable.vaAssociateSubpicture = dummy_AssociateSubpicture;
+    ctx->vtable.vaAssociateSubpicture2 = dummy_AssociateSubpicture2;
+    ctx->vtable.vaDeassociateSubpicture = dummy_DeassociateSubpicture;
+    ctx->vtable.vaQueryDisplayAttributes = dummy_QueryDisplayAttributes;
+    ctx->vtable.vaGetDisplayAttributes = dummy_GetDisplayAttributes;
+    ctx->vtable.vaSetDisplayAttributes = dummy_SetDisplayAttributes;
+    
+    ctx->vtable.vaDbgCopySurfaceToBuffer = dummy_DbgCopySurfaceToBuffer;
+
+    driver_data = (struct dummy_driver_data *) malloc( sizeof(*driver_data) );
+    ctx->pDriverData = (void *) driver_data;
+
+    result = object_heap_init( &driver_data->config_heap, sizeof(struct object_config), CONFIG_ID_OFFSET );
+    ASSERT( result == 0 );
+
+    result = object_heap_init( &driver_data->context_heap, sizeof(struct object_context), CONTEXT_ID_OFFSET );
+    ASSERT( result == 0 );
+
+    result = object_heap_init( &driver_data->surface_heap, sizeof(struct object_surface), SURFACE_ID_OFFSET );
+    ASSERT( result == 0 );
+
+    result = object_heap_init( &driver_data->buffer_heap, sizeof(struct object_buffer), BUFFER_ID_OFFSET );
+    ASSERT( result == 0 );
+
+
+    return VA_STATUS_SUCCESS;
+}
+
diff --git a/dummy_drv_video/dummy_drv_video.h b/dummy_drv_video/dummy_drv_video.h
new file mode 100644
index 0000000..3ebd60b
--- /dev/null
+++ b/dummy_drv_video/dummy_drv_video.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2007 Intel Corporation. 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 PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _DUMMY_DRV_VIDEO_H_
+#define _DUMMY_DRV_VIDEO_H_
+
+#include "va.h"
+#include "object_heap.h"
+
+#define DUMMY_MAX_PROFILES			11
+#define DUMMY_MAX_ENTRYPOINTS			5
+#define DUMMY_MAX_CONFIG_ATTRIBUTES		10
+#define DUMMY_MAX_IMAGE_FORMATS			10
+#define DUMMY_MAX_SUBPIC_FORMATS		4
+#define DUMMY_MAX_DISPLAY_ATTRIBUTES		4
+#define DUMMY_STR_VENDOR			"Dummy Driver 1.0"
+
+struct dummy_driver_data {
+    struct object_heap	config_heap;
+    struct object_heap	context_heap;
+    struct object_heap	surface_heap;
+    struct object_heap	buffer_heap;
+};
+
+struct object_config {
+    struct object_base base;
+    VAProfile profile;
+    VAEntrypoint entrypoint;
+    VAConfigAttrib attrib_list[DUMMY_MAX_CONFIG_ATTRIBUTES];
+    int attrib_count;
+};
+
+struct object_context {
+    struct object_base base;
+    VAContextID context_id;
+    VAConfigID config_id;
+    VASurfaceID current_render_target;
+    int picture_width;
+    int picture_height;
+    int num_render_targets;
+    int flags;
+    VASurfaceID *render_targets;
+};
+
+struct object_surface {
+    struct object_base base;
+    VASurfaceID surface_id;
+};
+
+struct object_buffer {
+    struct object_base base;
+    void *buffer_data;
+    int max_num_elements;
+    int num_elements;
+};
+
+typedef struct object_config *object_config_p;
+typedef struct object_context *object_context_p;
+typedef struct object_surface *object_surface_p;
+typedef struct object_buffer *object_buffer_p;
+
+#endif /* _DUMMY_DRV_VIDEO_H_ */
diff --git a/dummy_drv_video/object_heap.c b/dummy_drv_video/object_heap.c
new file mode 100644
index 0000000..e867139
--- /dev/null
+++ b/dummy_drv_video/object_heap.c
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) 2007 Intel Corporation. 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 PRECISION INSIGHT 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 "object_heap.h"
+
+#include "assert.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define ASSERT	assert
+
+#define LAST_FREE	-1
+#define ALLOCATED	-2
+
+/*
+ * Expands the heap
+ * Return 0 on success, -1 on error
+ */
+static int object_heap_expand( object_heap_p heap )
+{
+    int i;
+    void *new_heap_index;
+    int next_free;
+    int new_heap_size = heap->heap_size + heap->heap_increment;
+    
+    new_heap_index = (void *) realloc( heap->heap_index, new_heap_size * heap->object_size );
+    if ( NULL == new_heap_index )
+    {
+        return -1; /* Out of memory */
+    }
+    heap->heap_index = new_heap_index;
+    next_free = heap->next_free;
+    for(i = new_heap_size; i-- > heap->heap_size; )
+    {
+        object_base_p obj = (object_base_p) (heap->heap_index + i * heap->object_size);
+        obj->id = i + heap->id_offset;
+        obj->next_free = next_free;
+        next_free = i;
+    }
+    heap->next_free = next_free;
+    heap->heap_size = new_heap_size;
+    return 0; /* Success */
+}
+
+/*
+ * Return 0 on success, -1 on error
+ */
+int object_heap_init( object_heap_p heap, int object_size, int id_offset)
+{
+    heap->object_size = object_size;
+    heap->id_offset = id_offset & OBJECT_HEAP_OFFSET_MASK;
+    heap->heap_size = 0;
+    heap->heap_increment = 16;
+    heap->heap_index = NULL;
+    heap->next_free = LAST_FREE;
+    return object_heap_expand(heap);
+}
+
+/*
+ * Allocates an object
+ * Returns the object ID on success, returns -1 on error
+ */
+int object_heap_allocate( object_heap_p heap )
+{
+    object_base_p obj;
+    if ( LAST_FREE == heap->next_free )
+    {
+        if( -1 == object_heap_expand( heap ) )
+        {
+            return -1; /* Out of memory */
+        }
+    }
+    ASSERT( heap->next_free >= 0 );
+    
+    obj = (object_base_p) (heap->heap_index + heap->next_free * heap->object_size);
+    heap->next_free = obj->next_free;
+    obj->next_free = ALLOCATED;
+    return obj->id;
+}
+
+/*
+ * Lookup an object by object ID
+ * Returns a pointer to the object on success, returns NULL on error
+ */
+object_base_p object_heap_lookup( object_heap_p heap, int id )
+{
+    object_base_p obj;
+    if ( (id < heap->id_offset) || (id > (heap->heap_size+heap->id_offset)) )
+    {
+        return NULL;
+    }
+    id &= OBJECT_HEAP_ID_MASK;
+    obj = (object_base_p) (heap->heap_index + id * heap->object_size);
+
+	/* Check if the object has in fact been allocated */
+	if ( obj->next_free != ALLOCATED )
+    {
+        return NULL;
+    }
+    return obj;
+}
+
+/*
+ * Iterate over all objects in the heap.
+ * Returns a pointer to the first object on the heap, returns NULL if heap is empty.
+ */
+object_base_p object_heap_first( object_heap_p heap, object_heap_iterator *iter )
+{
+    *iter = -1;
+    return object_heap_next( heap, iter );
+}
+
+/*
+ * Iterate over all objects in the heap.
+ * Returns a pointer to the next object on the heap, returns NULL if heap is empty.
+ */
+object_base_p object_heap_next( object_heap_p heap, object_heap_iterator *iter )
+{
+    object_base_p obj;
+    int i = *iter + 1;
+    while ( i < heap->heap_size)
+    {
+        obj = (object_base_p) (heap->heap_index + i * heap->object_size);
+        if (obj->next_free == ALLOCATED)
+        {
+            *iter = i;
+            return obj;
+        }
+        i++;
+    }
+    *iter = i;
+    return NULL;
+}
+
+
+
+/*
+ * Frees an object
+ */
+void object_heap_free( object_heap_p heap, object_base_p obj )
+{
+    /* Don't complain about NULL pointers */
+    if (NULL != obj)
+    {
+        /* Check if the object has in fact been allocated */
+        ASSERT( obj->next_free == ALLOCATED );
+    
+        obj->next_free = heap->next_free;
+        heap->next_free = obj->id & OBJECT_HEAP_ID_MASK;
+    }
+}
+
+/*
+ * Destroys a heap, the heap must be empty.
+ */
+void object_heap_destroy( object_heap_p heap )
+{
+    object_base_p obj;
+    int i;
+    /* Check if heap is empty */
+    for (i = 0; i < heap->heap_size; i++)
+    {
+        /* Check if object is not still allocated */
+        obj = (object_base_p) (heap->heap_index + i * heap->object_size);
+        ASSERT( obj->next_free != ALLOCATED );
+    }
+    free(heap->heap_index);
+    heap->heap_size = 0;
+    heap->heap_index = NULL;
+    heap->next_free = LAST_FREE;
+}
diff --git a/dummy_drv_video/object_heap.h b/dummy_drv_video/object_heap.h
new file mode 100644
index 0000000..154fddb
--- /dev/null
+++ b/dummy_drv_video/object_heap.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2007 Intel Corporation. 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 PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _OBJECT_HEAP_H_
+#define _OBJECT_HEAP_H_
+
+#define OBJECT_HEAP_OFFSET_MASK		0x7F000000
+#define OBJECT_HEAP_ID_MASK			0x00FFFFFF
+
+typedef struct object_base *object_base_p;
+typedef struct object_heap *object_heap_p;
+
+struct object_base {
+    int id;
+    int next_free;
+};
+
+struct object_heap {
+    int	object_size;
+    int id_offset;
+    void *heap_index;
+    int next_free;
+    int heap_size;
+    int heap_increment;
+};
+
+typedef int object_heap_iterator;
+
+/*
+ * Return 0 on success, -1 on error
+ */
+int object_heap_init( object_heap_p heap, int object_size, int id_offset);
+
+/*
+ * Allocates an object
+ * Returns the object ID on success, returns -1 on error
+ */
+int object_heap_allocate( object_heap_p heap );
+
+/*
+ * Lookup an allocated object by object ID
+ * Returns a pointer to the object on success, returns NULL on error
+ */
+object_base_p object_heap_lookup( object_heap_p heap, int id );
+
+/*
+ * Iterate over all objects in the heap.
+ * Returns a pointer to the first object on the heap, returns NULL if heap is empty.
+ */
+object_base_p object_heap_first( object_heap_p heap, object_heap_iterator *iter );
+
+/*
+ * Iterate over all objects in the heap.
+ * Returns a pointer to the next object on the heap, returns NULL if heap is empty.
+ */
+object_base_p object_heap_next( object_heap_p heap, object_heap_iterator *iter );
+
+/*
+ * Frees an object
+ */
+void object_heap_free( object_heap_p heap, object_base_p obj );
+
+/*
+ * Destroys a heap, the heap must be empty.
+ */
+void object_heap_destroy( object_heap_p heap );
+
+#endif /* _OBJECT_HEAP_H_ */