Merge lp:~3v1n0/ubuntu/utopic/vdpau-video/fix-buffers into lp:ubuntu/utopic/vdpau-video

[Marco Trevisan (Treviño)]

Added patch-set from upstream to fix crash when using gstreamer-vaapi

Backported upstream commits:
 - http://cgit.freedesktop.org/vaapi/vdpau-driver/commit/?id=d26b5b3
 - http://cgit.freedesktop.org/vaapi/vdpau-driver/commit/?id=2630695
 - http://cgit.freedesktop.org/vaapi/vdpau-driver/commit/?id=e4fd3b

They fixes a crash when using gstreamer-vaapi.

[Martin Pitt (pitti)]

Uploaded, thanks!

review: Approve

[Martin Pitt (pitti)]

this FTBFSed in utopic, so you'll need a followup upload to fix that.

[Marco Trevisan (Treviño) (3v1n0)]

I think for utopic we should probably move to the upstream 0.7.4 version.

By the way, I guess the FTBFS is caused by this libva change [1], that is fixable with this vdpau-driver patch [1].

[1] http://lists.freedesktop.org/archives/libva/2013-May/001669.html
[2] http://lists.freedesktop.org/archives/libva/2013-June/001762.html

=== added directory '.pc/01_dont_clear_va_buffer_too_early.patch'
=== added directory '.pc/01_dont_clear_va_buffer_too_early.patch/src'
=== added file '.pc/01_dont_clear_va_buffer_too_early.patch/src/vdpau_buffer.c'
--- .pc/01_dont_clear_va_buffer_too_early.patch/src/vdpau_buffer.c	1970-01-01 00:00:00 +0000
+++ .pc/01_dont_clear_va_buffer_too_early.patch/src/vdpau_buffer.c	2014-05-06 21:30:45 +0000
@@ -0,0 +1,257 @@
+/*
+ *  vdpau_buffer.c - VDPAU backend for VA-API (VA buffers)
+ *
+ *  vdpau-video (C) 2009-2011 Splitted-Desktop Systems
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include "sysdeps.h"
+#include "vdpau_buffer.h"
+#include "vdpau_driver.h"
+#include "vdpau_video.h"
+#include "vdpau_dump.h"
+#include "utils.h"
+
+#define DEBUG 1
+#include "debug.h"
+
+
+// Create VA buffer object
+object_buffer_p
+create_va_buffer(
+    vdpau_driver_data_t *driver_data,
+    VAContextID         context,
+    VABufferType        buffer_type,
+    unsigned int        num_elements,
+    unsigned int        size
+)
+{
+    VABufferID buffer_id;
+    object_buffer_p obj_buffer;
+
+    buffer_id = object_heap_allocate(&driver_data->buffer_heap);
+    if (buffer_id == VA_INVALID_BUFFER)
+        return NULL;
+
+    obj_buffer = VDPAU_BUFFER(buffer_id);
+    if (!obj_buffer)
+        return NULL;
+
+    obj_buffer->va_context       = context;
+    obj_buffer->type             = buffer_type;
+    obj_buffer->max_num_elements = num_elements;
+    obj_buffer->num_elements     = num_elements;
+    obj_buffer->buffer_size      = size * num_elements;
+    obj_buffer->buffer_data      = malloc(obj_buffer->buffer_size);
+    obj_buffer->mtime            = 0;
+
+    if (!obj_buffer->buffer_data) {
+        destroy_va_buffer(driver_data, obj_buffer);
+        return NULL;
+    }
+    return obj_buffer;
+}
+
+// Destroy VA buffer object
+void
+destroy_va_buffer(
+    vdpau_driver_data_t *driver_data,
+    object_buffer_p      obj_buffer
+)
+{
+    if (!obj_buffer)
+        return;
+
+    if (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);
+}
+
+// Schedule VA buffer object for destruction
+void
+schedule_destroy_va_buffer(
+    vdpau_driver_data_p driver_data,
+    object_buffer_p     obj_buffer
+)
+{
+    object_context_p obj_context = VDPAU_CONTEXT(obj_buffer->va_context);
+    if (!obj_context)
+        return;
+
+    realloc_buffer(
+        &obj_context->dead_buffers,
+        &obj_context->dead_buffers_count_max,
+        16 + obj_context->dead_buffers_count,
+        sizeof(*obj_context->dead_buffers)
+    );
+
+    ASSERT(obj_context->dead_buffers);
+    obj_context->dead_buffers[obj_context->dead_buffers_count] = obj_buffer->base.id;
+    obj_context->dead_buffers_count++;
+}
+
+// vaCreateBuffer
+VAStatus
+vdpau_CreateBuffer(
+    VADriverContextP    ctx,
+    VAContextID         context,
+    VABufferType        type,
+    unsigned int        size,
+    unsigned int        num_elements,
+    void               *data,
+    VABufferID         *buf_id
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    if (buf_id)
+        *buf_id = VA_INVALID_BUFFER;
+
+    /* Validate type */
+    switch (type) {
+    case VAPictureParameterBufferType:
+    case VAIQMatrixBufferType:
+    case VASliceParameterBufferType:
+    case VASliceDataBufferType:
+    case VABitPlaneBufferType:
+    case VAImageBufferType:
+        /* Ok */
+        break;
+    default:
+        D(bug("ERROR: unsupported buffer type %d\n", type));
+        return VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE;
+    }
+
+    object_buffer_p obj_buffer;
+    obj_buffer = create_va_buffer(driver_data, context, type, num_elements, size);
+    if (!obj_buffer)
+        return VA_STATUS_ERROR_ALLOCATION_FAILED;
+
+    if (data)
+        memcpy(obj_buffer->buffer_data, data, obj_buffer->buffer_size);
+
+    if (buf_id)
+        *buf_id = obj_buffer->base.id;
+
+    return VA_STATUS_SUCCESS;
+}
+
+// vaDestroyBuffer
+VAStatus
+vdpau_DestroyBuffer(
+    VADriverContextP    ctx,
+    VABufferID          buffer_id
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    object_buffer_p obj_buffer = VDPAU_BUFFER(buffer_id);
+
+    if (obj_buffer)
+        destroy_va_buffer(driver_data, obj_buffer);
+
+    return VA_STATUS_SUCCESS;
+}
+
+// vaBufferSetNumElements
+VAStatus
+vdpau_BufferSetNumElements(
+    VADriverContextP    ctx,
+    VABufferID          buf_id,
+    unsigned int        num_elements
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    object_buffer_p obj_buffer = VDPAU_BUFFER(buf_id);
+    if (!obj_buffer)
+        return VA_STATUS_ERROR_INVALID_BUFFER;
+
+    if (num_elements < 0 || num_elements > obj_buffer->max_num_elements)
+        return VA_STATUS_ERROR_UNKNOWN;
+
+    obj_buffer->num_elements = num_elements;
+    return VA_STATUS_SUCCESS;
+}
+
+// vaMapBuffer
+VAStatus
+vdpau_MapBuffer(
+    VADriverContextP    ctx,
+    VABufferID          buf_id,
+    void              **pbuf
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    object_buffer_p obj_buffer = VDPAU_BUFFER(buf_id);
+    if (!obj_buffer)
+        return VA_STATUS_ERROR_INVALID_BUFFER;
+
+    if (pbuf)
+        *pbuf = obj_buffer->buffer_data;
+
+    if (obj_buffer->buffer_data == NULL)
+        return VA_STATUS_ERROR_UNKNOWN;
+
+    ++obj_buffer->mtime;
+    return VA_STATUS_SUCCESS;
+}
+
+// vaUnmapBuffer
+VAStatus
+vdpau_UnmapBuffer(
+    VADriverContextP    ctx,
+    VABufferID          buf_id
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    object_buffer_p obj_buffer = VDPAU_BUFFER(buf_id);
+    if (!obj_buffer)
+        return VA_STATUS_ERROR_INVALID_BUFFER;
+
+    ++obj_buffer->mtime;
+    return VA_STATUS_SUCCESS;
+}
+
+// vaBufferInfo
+VAStatus
+vdpau_BufferInfo(
+    VADriverContextP    ctx,
+    VAContextID         context,
+    VABufferID          buf_id,
+    VABufferType       *type,
+    unsigned int       *size,
+    unsigned int       *num_elements
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    object_buffer_p obj_buffer = VDPAU_BUFFER(buf_id);
+    if (!obj_buffer)
+        return VA_STATUS_ERROR_INVALID_BUFFER;
+
+    if (type)
+        *type = obj_buffer->type;
+    if (size)
+        *size = obj_buffer->buffer_size / obj_buffer->num_elements;
+    if (num_elements)
+        *num_elements = obj_buffer->num_elements;
+    return VA_STATUS_SUCCESS;
+}

=== added file '.pc/01_dont_clear_va_buffer_too_early.patch/src/vdpau_buffer.h'
--- .pc/01_dont_clear_va_buffer_too_early.patch/src/vdpau_buffer.h	1970-01-01 00:00:00 +0000
+++ .pc/01_dont_clear_va_buffer_too_early.patch/src/vdpau_buffer.h	2014-05-06 21:30:45 +0000
@@ -0,0 +1,115 @@
+/*
+ *  vdpau_buffer.h - VDPAU backend for VA-API (VA buffers)
+ *
+ *  vdpau-video (C) 2009-2011 Splitted-Desktop Systems
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#ifndef VDPAU_BUFFER_H
+#define VDPAU_BUFFER_H
+
+#include "vdpau_driver.h"
+
+typedef struct object_buffer object_buffer_t;
+struct object_buffer {
+    struct object_base  base;
+    VAContextID         va_context;
+    VABufferType        type;
+    void               *buffer_data;
+    unsigned int        buffer_size;
+    unsigned int        max_num_elements;
+    unsigned int        num_elements;
+    uint64_t            mtime;
+};
+
+// Create VA buffer object
+object_buffer_p
+create_va_buffer(
+    vdpau_driver_data_p driver_data,
+    VAContextID         context,
+    VABufferType        buffer_type,
+    unsigned int        num_elements,
+    unsigned int        size
+) attribute_hidden;
+
+// Destroy VA buffer object
+void
+destroy_va_buffer(
+    vdpau_driver_data_p driver_data,
+    object_buffer_p     obj_buffer
+) attribute_hidden;
+
+// Schedule VA buffer object for destruction
+void
+schedule_destroy_va_buffer(
+    vdpau_driver_data_p driver_data,
+    object_buffer_p     obj_buffer
+) attribute_hidden;
+
+// vaCreateBuffer
+VAStatus
+vdpau_CreateBuffer(
+    VADriverContextP    ctx,
+    VAContextID         context,
+    VABufferType        type,
+    unsigned int        size,
+    unsigned int        num_elements,
+    void               *data,
+    VABufferID         *buf_id
+) attribute_hidden;
+
+// vaDestroyBuffer
+VAStatus
+vdpau_DestroyBuffer(
+    VADriverContextP    ctx,
+    VABufferID          buffer_id
+) attribute_hidden;
+
+// vaBufferSetNumElements
+VAStatus
+vdpau_BufferSetNumElements(
+    VADriverContextP    ctx,
+    VABufferID          buf_id,
+    unsigned int        num_elements
+) attribute_hidden;
+
+// vaMapBuffer
+VAStatus
+vdpau_MapBuffer(
+    VADriverContextP    ctx,
+    VABufferID          buf_id,
+    void              **pbuf
+) attribute_hidden;
+
+// vaUnmapBuffer
+VAStatus
+vdpau_UnmapBuffer(
+    VADriverContextP    ctx,
+    VABufferID          buf_id
+) attribute_hidden;
+
+// vaBufferInfo
+VAStatus
+vdpau_BufferInfo(
+    VADriverContextP    ctx,
+    VAContextID         context,
+    VABufferID          buf_id,
+    VABufferType       *type,
+    unsigned int       *size,
+    unsigned int       *num_elements
+) attribute_hidden;
+
+#endif /* VDPAU_BUFFER_H */

=== added directory '.pc/02_purge_va_buffers_on_context_destroy_or_new_picture_decode_seq.patch'
=== added directory '.pc/02_purge_va_buffers_on_context_destroy_or_new_picture_decode_seq.patch/src'
=== added file '.pc/02_purge_va_buffers_on_context_destroy_or_new_picture_decode_seq.patch/src/vdpau_buffer.c'
--- .pc/02_purge_va_buffers_on_context_destroy_or_new_picture_decode_seq.patch/src/vdpau_buffer.c	1970-01-01 00:00:00 +0000
+++ .pc/02_purge_va_buffers_on_context_destroy_or_new_picture_decode_seq.patch/src/vdpau_buffer.c	2014-05-06 21:30:45 +0000
@@ -0,0 +1,259 @@
+/*
+ *  vdpau_buffer.c - VDPAU backend for VA-API (VA buffers)
+ *
+ *  vdpau-video (C) 2009-2011 Splitted-Desktop Systems
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include "sysdeps.h"
+#include "vdpau_buffer.h"
+#include "vdpau_driver.h"
+#include "vdpau_video.h"
+#include "vdpau_dump.h"
+#include "utils.h"
+
+#define DEBUG 1
+#include "debug.h"
+
+
+// Create VA buffer object
+object_buffer_p
+create_va_buffer(
+    vdpau_driver_data_t *driver_data,
+    VAContextID         context,
+    VABufferType        buffer_type,
+    unsigned int        num_elements,
+    unsigned int        size
+)
+{
+    VABufferID buffer_id;
+    object_buffer_p obj_buffer;
+
+    buffer_id = object_heap_allocate(&driver_data->buffer_heap);
+    if (buffer_id == VA_INVALID_BUFFER)
+        return NULL;
+
+    obj_buffer = VDPAU_BUFFER(buffer_id);
+    if (!obj_buffer)
+        return NULL;
+
+    obj_buffer->va_context       = context;
+    obj_buffer->type             = buffer_type;
+    obj_buffer->max_num_elements = num_elements;
+    obj_buffer->num_elements     = num_elements;
+    obj_buffer->buffer_size      = size * num_elements;
+    obj_buffer->buffer_data      = malloc(obj_buffer->buffer_size);
+    obj_buffer->mtime            = 0;
+    obj_buffer->delayed_destroy  = 0;
+
+    if (!obj_buffer->buffer_data) {
+        destroy_va_buffer(driver_data, obj_buffer);
+        return NULL;
+    }
+    return obj_buffer;
+}
+
+// Destroy VA buffer object
+void
+destroy_va_buffer(
+    vdpau_driver_data_t *driver_data,
+    object_buffer_p      obj_buffer
+)
+{
+    if (!obj_buffer)
+        return;
+
+    if (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);
+}
+
+// Schedule VA buffer object for destruction
+void
+schedule_destroy_va_buffer(
+    vdpau_driver_data_p driver_data,
+    object_buffer_p     obj_buffer
+)
+{
+    object_context_p obj_context = VDPAU_CONTEXT(obj_buffer->va_context);
+    if (!obj_context)
+        return;
+
+    realloc_buffer(
+        &obj_context->dead_buffers,
+        &obj_context->dead_buffers_count_max,
+        16 + obj_context->dead_buffers_count,
+        sizeof(*obj_context->dead_buffers)
+    );
+
+    ASSERT(obj_context->dead_buffers);
+    obj_context->dead_buffers[obj_context->dead_buffers_count] = obj_buffer->base.id;
+    obj_context->dead_buffers_count++;
+    obj_buffer->delayed_destroy = 1;
+}
+
+// vaCreateBuffer
+VAStatus
+vdpau_CreateBuffer(
+    VADriverContextP    ctx,
+    VAContextID         context,
+    VABufferType        type,
+    unsigned int        size,
+    unsigned int        num_elements,
+    void               *data,
+    VABufferID         *buf_id
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    if (buf_id)
+        *buf_id = VA_INVALID_BUFFER;
+
+    /* Validate type */
+    switch (type) {
+    case VAPictureParameterBufferType:
+    case VAIQMatrixBufferType:
+    case VASliceParameterBufferType:
+    case VASliceDataBufferType:
+    case VABitPlaneBufferType:
+    case VAImageBufferType:
+        /* Ok */
+        break;
+    default:
+        D(bug("ERROR: unsupported buffer type %d\n", type));
+        return VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE;
+    }
+
+    object_buffer_p obj_buffer;
+    obj_buffer = create_va_buffer(driver_data, context, type, num_elements, size);
+    if (!obj_buffer)
+        return VA_STATUS_ERROR_ALLOCATION_FAILED;
+
+    if (data)
+        memcpy(obj_buffer->buffer_data, data, obj_buffer->buffer_size);
+
+    if (buf_id)
+        *buf_id = obj_buffer->base.id;
+
+    return VA_STATUS_SUCCESS;
+}
+
+// vaDestroyBuffer
+VAStatus
+vdpau_DestroyBuffer(
+    VADriverContextP    ctx,
+    VABufferID          buffer_id
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    object_buffer_p obj_buffer = VDPAU_BUFFER(buffer_id);
+
+    if (obj_buffer && !obj_buffer->delayed_destroy)
+        destroy_va_buffer(driver_data, obj_buffer);
+
+    return VA_STATUS_SUCCESS;
+}
+
+// vaBufferSetNumElements
+VAStatus
+vdpau_BufferSetNumElements(
+    VADriverContextP    ctx,
+    VABufferID          buf_id,
+    unsigned int        num_elements
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    object_buffer_p obj_buffer = VDPAU_BUFFER(buf_id);
+    if (!obj_buffer)
+        return VA_STATUS_ERROR_INVALID_BUFFER;
+
+    if (num_elements < 0 || num_elements > obj_buffer->max_num_elements)
+        return VA_STATUS_ERROR_UNKNOWN;
+
+    obj_buffer->num_elements = num_elements;
+    return VA_STATUS_SUCCESS;
+}
+
+// vaMapBuffer
+VAStatus
+vdpau_MapBuffer(
+    VADriverContextP    ctx,
+    VABufferID          buf_id,
+    void              **pbuf
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    object_buffer_p obj_buffer = VDPAU_BUFFER(buf_id);
+    if (!obj_buffer)
+        return VA_STATUS_ERROR_INVALID_BUFFER;
+
+    if (pbuf)
+        *pbuf = obj_buffer->buffer_data;
+
+    if (obj_buffer->buffer_data == NULL)
+        return VA_STATUS_ERROR_UNKNOWN;
+
+    ++obj_buffer->mtime;
+    return VA_STATUS_SUCCESS;
+}
+
+// vaUnmapBuffer
+VAStatus
+vdpau_UnmapBuffer(
+    VADriverContextP    ctx,
+    VABufferID          buf_id
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    object_buffer_p obj_buffer = VDPAU_BUFFER(buf_id);
+    if (!obj_buffer)
+        return VA_STATUS_ERROR_INVALID_BUFFER;
+
+    ++obj_buffer->mtime;
+    return VA_STATUS_SUCCESS;
+}
+
+// vaBufferInfo
+VAStatus
+vdpau_BufferInfo(
+    VADriverContextP    ctx,
+    VAContextID         context,
+    VABufferID          buf_id,
+    VABufferType       *type,
+    unsigned int       *size,
+    unsigned int       *num_elements
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    object_buffer_p obj_buffer = VDPAU_BUFFER(buf_id);
+    if (!obj_buffer)
+        return VA_STATUS_ERROR_INVALID_BUFFER;
+
+    if (type)
+        *type = obj_buffer->type;
+    if (size)
+        *size = obj_buffer->buffer_size / obj_buffer->num_elements;
+    if (num_elements)
+        *num_elements = obj_buffer->num_elements;
+    return VA_STATUS_SUCCESS;
+}

=== added file '.pc/02_purge_va_buffers_on_context_destroy_or_new_picture_decode_seq.patch/src/vdpau_buffer.h'
--- .pc/02_purge_va_buffers_on_context_destroy_or_new_picture_decode_seq.patch/src/vdpau_buffer.h	1970-01-01 00:00:00 +0000
+++ .pc/02_purge_va_buffers_on_context_destroy_or_new_picture_decode_seq.patch/src/vdpau_buffer.h	2014-05-06 21:30:45 +0000
@@ -0,0 +1,116 @@
+/*
+ *  vdpau_buffer.h - VDPAU backend for VA-API (VA buffers)
+ *
+ *  vdpau-video (C) 2009-2011 Splitted-Desktop Systems
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#ifndef VDPAU_BUFFER_H
+#define VDPAU_BUFFER_H
+
+#include "vdpau_driver.h"
+
+typedef struct object_buffer object_buffer_t;
+struct object_buffer {
+    struct object_base  base;
+    VAContextID         va_context;
+    VABufferType        type;
+    void               *buffer_data;
+    unsigned int        buffer_size;
+    unsigned int        max_num_elements;
+    unsigned int        num_elements;
+    uint64_t            mtime;
+    unsigned int        delayed_destroy : 1;
+};
+
+// Create VA buffer object
+object_buffer_p
+create_va_buffer(
+    vdpau_driver_data_p driver_data,
+    VAContextID         context,
+    VABufferType        buffer_type,
+    unsigned int        num_elements,
+    unsigned int        size
+) attribute_hidden;
+
+// Destroy VA buffer object
+void
+destroy_va_buffer(
+    vdpau_driver_data_p driver_data,
+    object_buffer_p     obj_buffer
+) attribute_hidden;
+
+// Schedule VA buffer object for destruction
+void
+schedule_destroy_va_buffer(
+    vdpau_driver_data_p driver_data,
+    object_buffer_p     obj_buffer
+) attribute_hidden;
+
+// vaCreateBuffer
+VAStatus
+vdpau_CreateBuffer(
+    VADriverContextP    ctx,
+    VAContextID         context,
+    VABufferType        type,
+    unsigned int        size,
+    unsigned int        num_elements,
+    void               *data,
+    VABufferID         *buf_id
+) attribute_hidden;
+
+// vaDestroyBuffer
+VAStatus
+vdpau_DestroyBuffer(
+    VADriverContextP    ctx,
+    VABufferID          buffer_id
+) attribute_hidden;
+
+// vaBufferSetNumElements
+VAStatus
+vdpau_BufferSetNumElements(
+    VADriverContextP    ctx,
+    VABufferID          buf_id,
+    unsigned int        num_elements
+) attribute_hidden;
+
+// vaMapBuffer
+VAStatus
+vdpau_MapBuffer(
+    VADriverContextP    ctx,
+    VABufferID          buf_id,
+    void              **pbuf
+) attribute_hidden;
+
+// vaUnmapBuffer
+VAStatus
+vdpau_UnmapBuffer(
+    VADriverContextP    ctx,
+    VABufferID          buf_id
+) attribute_hidden;
+
+// vaBufferInfo
+VAStatus
+vdpau_BufferInfo(
+    VADriverContextP    ctx,
+    VAContextID         context,
+    VABufferID          buf_id,
+    VABufferType       *type,
+    unsigned int       *size,
+    unsigned int       *num_elements
+) attribute_hidden;
+
+#endif /* VDPAU_BUFFER_H */

=== added file '.pc/02_purge_va_buffers_on_context_destroy_or_new_picture_decode_seq.patch/src/vdpau_decode.c'
--- .pc/02_purge_va_buffers_on_context_destroy_or_new_picture_decode_seq.patch/src/vdpau_decode.c	1970-01-01 00:00:00 +0000
+++ .pc/02_purge_va_buffers_on_context_destroy_or_new_picture_decode_seq.patch/src/vdpau_decode.c	2014-05-06 21:30:45 +0000
@@ -0,0 +1,1271 @@
+/*
+ *  vdpau_decode.c - VDPAU backend for VA-API (decoder)
+ *
+ *  vdpau-video (C) 2009-2011 Splitted-Desktop Systems
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include "sysdeps.h"
+#include "vdpau_decode.h"
+#include "vdpau_driver.h"
+#include "vdpau_buffer.h"
+#include "vdpau_video.h"
+#include "vdpau_dump.h"
+#include "utils.h"
+#include "put_bits.h"
+
+#define DEBUG 1
+#include "debug.h"
+
+
+// Translates VdpDecoderProfile to VdpCodec
+VdpCodec get_VdpCodec(VdpDecoderProfile profile)
+{
+    switch (profile) {
+    case VDP_DECODER_PROFILE_MPEG1:
+        return VDP_CODEC_MPEG1;
+    case VDP_DECODER_PROFILE_MPEG2_SIMPLE:
+    case VDP_DECODER_PROFILE_MPEG2_MAIN:
+        return VDP_CODEC_MPEG2;
+#if USE_VDPAU_MPEG4
+    case VDP_DECODER_PROFILE_MPEG4_PART2_SP:
+    case VDP_DECODER_PROFILE_MPEG4_PART2_ASP:
+    case VDP_DECODER_PROFILE_DIVX4_QMOBILE:
+    case VDP_DECODER_PROFILE_DIVX4_MOBILE:
+    case VDP_DECODER_PROFILE_DIVX4_HOME_THEATER:
+    case VDP_DECODER_PROFILE_DIVX4_HD_1080P:
+    case VDP_DECODER_PROFILE_DIVX5_QMOBILE:
+    case VDP_DECODER_PROFILE_DIVX5_MOBILE:
+    case VDP_DECODER_PROFILE_DIVX5_HOME_THEATER:
+    case VDP_DECODER_PROFILE_DIVX5_HD_1080P:
+        return VDP_CODEC_MPEG4;
+#endif
+    case VDP_DECODER_PROFILE_H264_BASELINE:
+    case VDP_DECODER_PROFILE_H264_MAIN:
+    case VDP_DECODER_PROFILE_H264_HIGH:
+        return VDP_CODEC_H264;
+    case VDP_DECODER_PROFILE_VC1_SIMPLE:
+    case VDP_DECODER_PROFILE_VC1_MAIN:
+    case VDP_DECODER_PROFILE_VC1_ADVANCED:
+        return VDP_CODEC_VC1;
+    }
+    return 0;
+}
+
+// Translates VAProfile to VdpDecoderProfile
+VdpDecoderProfile get_VdpDecoderProfile(VAProfile profile)
+{
+    switch (profile) {
+    case VAProfileMPEG2Simple:  return VDP_DECODER_PROFILE_MPEG2_SIMPLE;
+    case VAProfileMPEG2Main:    return VDP_DECODER_PROFILE_MPEG2_MAIN;
+#if USE_VDPAU_MPEG4
+    case VAProfileMPEG4Simple:  return VDP_DECODER_PROFILE_MPEG4_PART2_SP;
+    case VAProfileMPEG4AdvancedSimple: return VDP_DECODER_PROFILE_MPEG4_PART2_ASP;
+#endif
+    case VAProfileH264Baseline: return VDP_DECODER_PROFILE_H264_BASELINE;
+    case VAProfileH264Main:     return VDP_DECODER_PROFILE_H264_MAIN;
+    case VAProfileH264High:     return VDP_DECODER_PROFILE_H264_HIGH;
+    case VAProfileVC1Simple:    return VDP_DECODER_PROFILE_VC1_SIMPLE;
+    case VAProfileVC1Main:      return VDP_DECODER_PROFILE_VC1_MAIN;
+    case VAProfileVC1Advanced:  return VDP_DECODER_PROFILE_VC1_ADVANCED;
+    default:                    break;
+    }
+    return (VdpDecoderProfile)-1;
+}
+
+// Checks whether the VDPAU implementation supports the specified profile
+static inline VdpBool
+is_supported_profile(
+    vdpau_driver_data_t *driver_data,
+    VdpDecoderProfile    profile
+)
+{
+    VdpBool is_supported = VDP_FALSE;
+    VdpStatus vdp_status;
+    uint32_t max_level, max_references, max_width, max_height;
+
+    if (profile == (VdpDecoderProfile)-1)
+        return VDP_FALSE;
+
+    vdp_status = vdpau_decoder_query_capabilities(
+        driver_data,
+        driver_data->vdp_device,
+        profile,
+        &is_supported,
+        &max_level,
+        &max_references,
+        &max_width,
+        &max_height
+    );
+    return (VDPAU_CHECK_STATUS(vdp_status, "VdpDecoderQueryCapabilities()") &&
+            is_supported);
+}
+
+// Checks decoder for profile/entrypoint is available
+VAStatus
+check_decoder(
+    vdpau_driver_data_t *driver_data,
+    VAProfile            profile,
+    VAEntrypoint         entrypoint
+)
+{
+    if (!is_supported_profile(driver_data, get_VdpDecoderProfile(profile)))
+        return VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
+
+    /* VDPAU only supports VLD */
+    if (entrypoint != VAEntrypointVLD)
+        return VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+
+    return VA_STATUS_SUCCESS;
+}
+
+// Computes value for VdpDecoderCreate()::max_references parameter
+static int
+get_max_ref_frames(
+    VdpDecoderProfile profile,
+    unsigned int      width,
+    unsigned int      height
+)
+{
+    int max_ref_frames = 2;
+
+    switch (profile) {
+    case VDP_DECODER_PROFILE_H264_MAIN:
+    case VDP_DECODER_PROFILE_H264_HIGH:
+    {
+        /* level 4.1 limits */
+        unsigned int aligned_width  = (width + 15) & -16;
+        unsigned int aligned_height = (height + 15) & -16;
+        unsigned int surface_size   = (aligned_width * aligned_height * 3) / 2;
+        if ((max_ref_frames = (12 * 1024 * 1024) / surface_size) > 16)
+            max_ref_frames = 16;
+        break;
+    }
+    }
+    return max_ref_frames;
+}
+
+// Returns the maximum number of reference frames of a decode session
+static inline int get_num_ref_frames(object_context_p obj_context)
+{
+    if (obj_context->vdp_codec == VDP_CODEC_H264)
+        return obj_context->vdp_picture_info.h264.num_ref_frames;
+    return 2;
+}
+
+// Ensure VDPAU decoder is created for the specified number of reference frames
+static VdpStatus
+ensure_decoder_with_max_refs(
+    vdpau_driver_data_t *driver_data,
+    object_context_p     obj_context,
+    int                  max_ref_frames
+)
+{
+    VdpStatus vdp_status;
+
+    if (max_ref_frames < 0)
+        max_ref_frames =
+            get_max_ref_frames(obj_context->vdp_profile,
+                               obj_context->picture_width,
+                               obj_context->picture_height);
+
+    if (obj_context->vdp_decoder == VDP_INVALID_HANDLE ||
+        obj_context->max_ref_frames < max_ref_frames) {
+        obj_context->max_ref_frames = max_ref_frames;
+
+        if (obj_context->vdp_decoder != VDP_INVALID_HANDLE) {
+            vdpau_decoder_destroy(driver_data, obj_context->vdp_decoder);
+            obj_context->vdp_decoder = VDP_INVALID_HANDLE;
+        }
+
+        vdp_status = vdpau_decoder_create(
+            driver_data,
+            driver_data->vdp_device,
+            obj_context->vdp_profile,
+            obj_context->picture_width,
+            obj_context->picture_height,
+            max_ref_frames,
+            &obj_context->vdp_decoder
+        );
+        if (!VDPAU_CHECK_STATUS(vdp_status, "VdpDecoderCreate()"))
+            return vdp_status;
+    }
+    return VDP_STATUS_OK;
+}
+
+// Lazy allocate (generated) slice data buffer. Buffer lives until vaDestroyContext()
+static uint8_t *
+alloc_gen_slice_data(object_context_p obj_context, unsigned int size)
+{
+    uint8_t *gen_slice_data = obj_context->gen_slice_data;
+
+    if (obj_context->gen_slice_data_size + size > obj_context->gen_slice_data_size_max) {
+        obj_context->gen_slice_data_size_max += size;
+        gen_slice_data = realloc(obj_context->gen_slice_data,
+                                 obj_context->gen_slice_data_size_max);
+        if (!gen_slice_data)
+            return NULL;
+        obj_context->gen_slice_data = gen_slice_data;
+    }
+    gen_slice_data += obj_context->gen_slice_data_size;
+    obj_context->gen_slice_data_size += size;
+    return gen_slice_data;
+}
+
+// Lazy allocate VdpBitstreamBuffer. Buffer lives until vaDestroyContext()
+static VdpBitstreamBuffer *
+alloc_VdpBitstreamBuffer(object_context_p obj_context)
+{
+    VdpBitstreamBuffer *vdp_bitstream_buffers;
+
+    vdp_bitstream_buffers = realloc_buffer(
+        &obj_context->vdp_bitstream_buffers,
+        &obj_context->vdp_bitstream_buffers_count_max,
+        1 + obj_context->vdp_bitstream_buffers_count,
+        sizeof(*obj_context->vdp_bitstream_buffers)
+    );
+    if (!vdp_bitstream_buffers)
+        return NULL;
+
+    return &vdp_bitstream_buffers[obj_context->vdp_bitstream_buffers_count++];
+}
+
+// Append VASliceDataBuffer hunk into VDPAU buffer
+static int
+append_VdpBitstreamBuffer(
+    object_context_p obj_context,
+    const uint8_t   *buffer,
+    uint32_t         buffer_size
+)
+{
+    VdpBitstreamBuffer *bitstream_buffer;
+
+    bitstream_buffer = alloc_VdpBitstreamBuffer(obj_context);
+    if (!bitstream_buffer)
+        return -1;
+
+    bitstream_buffer->struct_version  = VDP_BITSTREAM_BUFFER_VERSION;
+    bitstream_buffer->bitstream       = buffer;
+    bitstream_buffer->bitstream_bytes = buffer_size;
+    return 0;
+}
+
+// Initialize VdpReferenceFrameH264 to default values
+static void init_VdpReferenceFrameH264(VdpReferenceFrameH264 *rf)
+{
+    rf->surface             = VDP_INVALID_HANDLE;
+    rf->is_long_term        = VDP_FALSE;
+    rf->top_is_reference    = VDP_FALSE;
+    rf->bottom_is_reference = VDP_FALSE;
+    rf->field_order_cnt[0]  = 0;
+    rf->field_order_cnt[1]  = 0;
+    rf->frame_idx           = 0;
+}
+
+static const uint8_t ff_identity[64] = {
+    0,   1,  2,  3,  4,  5,  6,  7,
+    8,   9, 10, 11, 12, 13, 14, 15,
+    16, 17, 18, 19, 20, 21, 22, 23,
+    24, 25, 26, 27, 28, 29, 30, 31,
+    32, 33, 34, 35, 36, 37, 38, 39,
+    40, 41, 42, 43, 44, 45, 46, 47,
+    48, 49, 50, 51, 52, 53, 54, 55,
+    56, 57, 58, 59, 60, 61, 62, 63
+};
+
+static const uint8_t ff_zigzag_direct[64] = {
+    0,   1,  8, 16,  9,  2,  3, 10,
+    17, 24, 32, 25, 18, 11,  4,  5,
+    12, 19, 26, 33, 40, 48, 41, 34,
+    27, 20, 13,  6,  7, 14, 21, 28,
+    35, 42, 49, 56, 57, 50, 43, 36,
+    29, 22, 15, 23, 30, 37, 44, 51,
+    58, 59, 52, 45, 38, 31, 39, 46,
+    53, 60, 61, 54, 47, 55, 62, 63
+};
+
+static const uint8_t ff_mpeg1_default_intra_matrix[64] = {
+     8, 16, 19, 22, 26, 27, 29, 34,
+    16, 16, 22, 24, 27, 29, 34, 37,
+    19, 22, 26, 27, 29, 34, 34, 38,
+    22, 22, 26, 27, 29, 34, 37, 40,
+    22, 26, 27, 29, 32, 35, 40, 48,
+    26, 27, 29, 32, 35, 40, 48, 58,
+    26, 27, 29, 34, 38, 46, 56, 69,
+    27, 29, 35, 38, 46, 56, 69, 83
+};
+
+static const uint8_t ff_mpeg1_default_non_intra_matrix[64] = {
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16
+};
+
+static const uint8_t ff_mpeg4_default_intra_matrix[64] = {
+     8, 17, 18, 19, 21, 23, 25, 27,
+    17, 18, 19, 21, 23, 25, 27, 28,
+    20, 21, 22, 23, 24, 26, 28, 30,
+    21, 22, 23, 24, 26, 28, 30, 32,
+    22, 23, 24, 26, 28, 30, 32, 35,
+    23, 24, 26, 28, 30, 32, 35, 38,
+    25, 26, 28, 30, 32, 35, 38, 41,
+    27, 28, 30, 32, 35, 38, 41, 45,
+};
+
+static const uint8_t ff_mpeg4_default_non_intra_matrix[64] = {
+    16, 17, 18, 19, 20, 21, 22, 23,
+    17, 18, 19, 20, 21, 22, 23, 24,
+    18, 19, 20, 21, 22, 23, 24, 25,
+    19, 20, 21, 22, 23, 24, 26, 27,
+    20, 21, 22, 23, 25, 26, 27, 28,
+    21, 22, 23, 24, 26, 27, 28, 30,
+    22, 23, 24, 26, 27, 28, 30, 31,
+    23, 24, 25, 27, 28, 30, 31, 33,
+};
+
+// Compute integer log2
+static inline int ilog2(uint32_t v)
+{
+    /* From <http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog> */
+    uint32_t r, shift;
+    r     = (v > 0xffff) << 4; v >>= r;
+    shift = (v > 0xff  ) << 3; v >>= shift; r |= shift;
+    shift = (v > 0xf   ) << 2; v >>= shift; r |= shift;
+    shift = (v > 0x3   ) << 1; v >>= shift; r |= shift;
+    return r | (v >> 1);
+}
+
+// Translate VASurfaceID
+static int
+translate_VASurfaceID(
+    vdpau_driver_data_t *driver_data,
+    VASurfaceID          va_surface,
+    VdpVideoSurface     *vdp_surface
+)
+{
+    object_surface_p obj_surface;
+
+    if (va_surface == VA_INVALID_SURFACE) {
+        *vdp_surface = VDP_INVALID_HANDLE;
+        return 1;
+    }
+
+    obj_surface = VDPAU_SURFACE(va_surface);
+    if (!obj_surface)
+        return 0;
+
+    *vdp_surface = obj_surface->vdp_surface;
+    return 1;
+}
+
+// Translate VAPictureH264
+static int
+translate_VAPictureH264(
+    vdpau_driver_data_t   *driver_data,
+    const VAPictureH264   *va_pic,
+    VdpReferenceFrameH264 *rf
+)
+{
+    // Handle invalid surfaces specifically
+    if (va_pic->picture_id == VA_INVALID_SURFACE) {
+        init_VdpReferenceFrameH264(rf);
+        return 1;
+    }
+
+    if (!translate_VASurfaceID(driver_data, va_pic->picture_id, &rf->surface))
+        return 0;
+    rf->is_long_term            = (va_pic->flags & VA_PICTURE_H264_LONG_TERM_REFERENCE) != 0;
+    if ((va_pic->flags & (VA_PICTURE_H264_TOP_FIELD|VA_PICTURE_H264_BOTTOM_FIELD)) == 0) {
+        rf->top_is_reference    = VDP_TRUE;
+        rf->bottom_is_reference = VDP_TRUE;
+    }
+    else {
+        rf->top_is_reference    = (va_pic->flags & VA_PICTURE_H264_TOP_FIELD) != 0;
+        rf->bottom_is_reference = (va_pic->flags & VA_PICTURE_H264_BOTTOM_FIELD) != 0;
+    }
+    rf->field_order_cnt[0]      = va_pic->TopFieldOrderCnt;
+    rf->field_order_cnt[1]      = va_pic->BottomFieldOrderCnt;
+    rf->frame_idx               = va_pic->frame_idx;
+    return 1;
+}
+
+// Translate no buffer
+static int
+translate_nothing(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    return 1;
+}
+
+// Translate VASliceDataBuffer
+static int
+translate_VASliceDataBuffer(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    if (obj_context->vdp_codec == VDP_CODEC_H264) {
+        /* Check we have the start code */
+        /* XXX: check for other codecs too? */
+        /* XXX: this assumes we get SliceParams before SliceData */
+        static const uint8_t start_code_prefix[3] = { 0x00, 0x00, 0x01 };
+        VASliceParameterBufferH264 * const slice_params = obj_context->last_slice_params;
+        unsigned int i;
+        for (i = 0; i < obj_context->last_slice_params_count; i++) {
+            VASliceParameterBufferH264 * const slice_param = &slice_params[i];
+            uint8_t *buf = (uint8_t *)obj_buffer->buffer_data + slice_param->slice_data_offset;
+            if (memcmp(buf, start_code_prefix, sizeof(start_code_prefix)) != 0) {
+                if (append_VdpBitstreamBuffer(obj_context,
+                                              start_code_prefix,
+                                              sizeof(start_code_prefix)) < 0)
+                    return 0;
+            }
+            if (append_VdpBitstreamBuffer(obj_context,
+                                          buf,
+                                          slice_param->slice_data_size) < 0)
+                return 0;
+        }
+        return 1;
+    }
+
+#if USE_VDPAU_MPEG4
+    if (obj_context->vdp_codec == VDP_CODEC_MPEG4 &&
+        obj_context->vdp_bitstream_buffers_count == 0) {
+        PutBitContext pb;
+        uint8_t slice_header_buffer[32];
+        uint8_t *slice_header;
+        int slice_header_size;
+        const uint8_t *slice_data = obj_buffer->buffer_data;
+        uint32_t slice_data_size = obj_buffer->buffer_size;
+        VAPictureParameterBufferMPEG4 * const pic_param = obj_context->last_pic_param;
+        VASliceParameterBufferMPEG4 * const slice_param = obj_context->last_slice_params;
+
+        int time_incr = 1 + ilog2(pic_param->vop_time_increment_resolution - 1);
+        if (time_incr < 1)
+            time_incr = 1;
+
+        static const uint16_t VOP_STARTCODE = 0x01b6;
+        enum {
+            VOP_I_TYPE = 0,
+            VOP_P_TYPE,
+            VOP_B_TYPE,
+            VOP_S_TYPE
+        };
+
+        /* XXX: this is a hack to compute the length of
+           modulo_time_base "1" sequence. We probably should be
+           reconstructing through an extra VOP field in VA-API? */
+        int nbits = (32 +                               /* VOP start code       */
+                     2 +                                /* vop_coding_type      */
+                     1 +                                /* modulo_time_base "0" */
+                     1 +                                /* marker_bit           */
+                     time_incr +                        /* vop_time_increment   */
+                     1 +                                /* marker_bit           */
+                     1 +                                /* vop_coded            */
+                     (pic_param->vop_fields.bits.vop_coding_type == VOP_P_TYPE ? 1 : 0) +
+                     3 +                                /* intra_dc_vlc_thr     */
+                     (pic_param->vol_fields.bits.interlaced ? 2 : 0) +
+                     5 +                                /* vop_quant            */
+                     (pic_param->vop_fields.bits.vop_coding_type != VOP_I_TYPE ? 3 : 0) +
+                     (pic_param->vop_fields.bits.vop_coding_type == VOP_B_TYPE ? 3 : 0));
+        if ((nbits = slice_param->macroblock_offset - (nbits % 8)) < 0)
+            nbits += 8;
+
+        /* Reconstruct the VOP header */
+        init_put_bits(&pb, slice_header_buffer, sizeof(slice_header_buffer));
+        put_bits(&pb, 16, 0);                   /* vop header */
+        put_bits(&pb, 16, VOP_STARTCODE);       /* vop header */
+        put_bits(&pb, 2, pic_param->vop_fields.bits.vop_coding_type);
+        while (nbits-- > 0)
+            put_bits(&pb, 1, 1);                /* modulo_time_base "1" */
+        put_bits(&pb, 1, 0);                    /* modulo_time_base "0" */
+        put_bits(&pb, 1, 1);                    /* marker */
+        put_bits(&pb, time_incr, 0);            /* time increment */
+        put_bits(&pb, 1, 1);                    /* marker */
+        put_bits(&pb, 1, 1);                    /* vop coded */
+        if (pic_param->vop_fields.bits.vop_coding_type == VOP_P_TYPE)
+            put_bits(&pb, 1, pic_param->vop_fields.bits.vop_rounding_type);
+        put_bits(&pb, 3, pic_param->vop_fields.bits.intra_dc_vlc_thr);
+        if (pic_param->vol_fields.bits.interlaced) {
+            put_bits(&pb, 1, pic_param->vop_fields.bits.top_field_first);
+            put_bits(&pb, 1, pic_param->vop_fields.bits.alternate_vertical_scan_flag);
+        }
+        put_bits(&pb, 5, slice_param->quant_scale);
+        if (pic_param->vop_fields.bits.vop_coding_type != VOP_I_TYPE)
+            put_bits(&pb, 3, pic_param->vop_fcode_forward);
+        if (pic_param->vop_fields.bits.vop_coding_type == VOP_B_TYPE)
+            put_bits(&pb, 3, pic_param->vop_fcode_backward);
+
+        /* Merge in bits from the first byte of the slice */
+        ASSERT((put_bits_count(&pb) % 8) == slice_param->macroblock_offset);
+        if ((put_bits_count(&pb) % 8) != slice_param->macroblock_offset)
+            return 0;
+        const int r = 8 - (put_bits_count(&pb) % 8);
+        if (r > 0)
+            put_bits(&pb, r, slice_data[0] & ((1U << r) - 1));
+        flush_put_bits(&pb);
+
+        ASSERT((put_bits_count(&pb) % 8) == 0);
+        slice_header_size = put_bits_count(&pb) / 8;
+        ASSERT(slice_header_size <= sizeof(slice_header_buffer));
+        slice_header = alloc_gen_slice_data(obj_context, slice_header_size);
+        if (!slice_header)
+            return 0;
+        memcpy(slice_header, slice_header_buffer, slice_header_size);
+        if (append_VdpBitstreamBuffer(obj_context, slice_header, slice_header_size) < 0)
+            return 0;
+        if (append_VdpBitstreamBuffer(obj_context, slice_data + 1, slice_data_size - 1) < 0)
+            return 0;
+        return 1;
+    }
+#endif
+
+    if (append_VdpBitstreamBuffer(obj_context,
+                                  obj_buffer->buffer_data,
+                                  obj_buffer->buffer_size) < 0)
+        return 0;
+    return 1;
+}
+
+// Translate VAPictureParameterBufferMPEG2
+static int
+translate_VAPictureParameterBufferMPEG2(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    VdpPictureInfoMPEG1Or2 * const pic_info = &obj_context->vdp_picture_info.mpeg2;
+    VAPictureParameterBufferMPEG2 * const pic_param = obj_buffer->buffer_data;
+
+    if (!translate_VASurfaceID(driver_data,
+                               pic_param->forward_reference_picture,
+                               &pic_info->forward_reference))
+        return 0;
+
+    if (!translate_VASurfaceID(driver_data,
+                               pic_param->backward_reference_picture,
+                               &pic_info->backward_reference))
+        return 0;
+
+    pic_info->picture_structure          = pic_param->picture_coding_extension.bits.picture_structure;
+    pic_info->picture_coding_type        = pic_param->picture_coding_type;
+    pic_info->intra_dc_precision         = pic_param->picture_coding_extension.bits.intra_dc_precision;
+    pic_info->frame_pred_frame_dct       = pic_param->picture_coding_extension.bits.frame_pred_frame_dct;
+    pic_info->concealment_motion_vectors = pic_param->picture_coding_extension.bits.concealment_motion_vectors;
+    pic_info->intra_vlc_format           = pic_param->picture_coding_extension.bits.intra_vlc_format;
+    pic_info->alternate_scan             = pic_param->picture_coding_extension.bits.alternate_scan;
+    pic_info->q_scale_type               = pic_param->picture_coding_extension.bits.q_scale_type;
+    pic_info->top_field_first            = pic_param->picture_coding_extension.bits.top_field_first;
+    pic_info->full_pel_forward_vector    = 0;
+    pic_info->full_pel_backward_vector   = 0;
+    pic_info->f_code[0][0]               = (pic_param->f_code >> 12) & 0xf;
+    pic_info->f_code[0][1]               = (pic_param->f_code >>  8) & 0xf;
+    pic_info->f_code[1][0]               = (pic_param->f_code >>  4) & 0xf;
+    pic_info->f_code[1][1]               = pic_param->f_code & 0xf;
+    return 1;
+}
+
+// Translate VAIQMatrixBufferMPEG2
+static int
+translate_VAIQMatrixBufferMPEG2(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    VdpPictureInfoMPEG1Or2 * const pic_info = &obj_context->vdp_picture_info.mpeg2;
+    VAIQMatrixBufferMPEG2 * const iq_matrix = obj_buffer->buffer_data;
+    const uint8_t *intra_matrix;
+    const uint8_t *intra_matrix_lookup;
+    const uint8_t *inter_matrix;
+    const uint8_t *inter_matrix_lookup;
+    int i;
+
+    if (iq_matrix->load_intra_quantiser_matrix) {
+        intra_matrix = iq_matrix->intra_quantiser_matrix;
+        intra_matrix_lookup = ff_zigzag_direct;
+    }
+    else {
+        intra_matrix = ff_mpeg1_default_intra_matrix;
+        intra_matrix_lookup = ff_identity;
+    }
+
+    if (iq_matrix->load_non_intra_quantiser_matrix) {
+        inter_matrix = iq_matrix->non_intra_quantiser_matrix;
+        inter_matrix_lookup = ff_zigzag_direct;
+    }
+    else {
+        inter_matrix = ff_mpeg1_default_non_intra_matrix;
+        inter_matrix_lookup = ff_identity;
+    }
+
+    for (i = 0; i < 64; i++) {
+        pic_info->intra_quantizer_matrix[intra_matrix_lookup[i]] =
+            intra_matrix[i];
+        pic_info->non_intra_quantizer_matrix[inter_matrix_lookup[i]] =
+            inter_matrix[i];
+    }
+    return 1;
+}
+
+// Translate VASliceParameterBufferMPEG2
+static int
+translate_VASliceParameterBufferMPEG2(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+    )
+{
+    VdpPictureInfoMPEG1Or2 * const pic_info = &obj_context->vdp_picture_info.mpeg2;
+
+    pic_info->slice_count               += obj_buffer->num_elements;
+    obj_context->last_slice_params       = obj_buffer->buffer_data;
+    obj_context->last_slice_params_count = obj_buffer->num_elements;
+    return 1;
+}
+
+#if USE_VDPAU_MPEG4
+// Translate VAPictureParameterBufferMPEG4
+static int
+translate_VAPictureParameterBufferMPEG4(
+    vdpau_driver_data_p driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    VdpPictureInfoMPEG4Part2 * const pic_info = &obj_context->vdp_picture_info.mpeg4;
+    VAPictureParameterBufferMPEG4 * const pic_param = obj_buffer->buffer_data;
+
+    /* XXX: we don't support short-video-header formats */
+    if (pic_param->vol_fields.bits.short_video_header)
+        return 0;
+
+    if (!translate_VASurfaceID(driver_data,
+                               pic_param->forward_reference_picture,
+                               &pic_info->forward_reference))
+        return 0;
+
+    if (!translate_VASurfaceID(driver_data,
+                               pic_param->backward_reference_picture,
+                               &pic_info->backward_reference))
+        return 0;
+
+    if (pic_param->vol_fields.bits.interlaced) {
+        vdpau_information_message("unsupported MPEG-4 video with interlaced "
+                                  "content, please report this video\n");
+        pic_info->trd[0] = 2*pic_param->TRD; /* XXX: + d(0) */
+        pic_info->trb[0] = 2*pic_param->TRB; /* XXX: + d(0) */
+        pic_info->trd[1] = 2*pic_param->TRD; /* XXX: + d(1) */
+        pic_info->trb[1] = 2*pic_param->TRB; /* XXX: + d(1) */
+    }
+    else {
+        pic_info->trd[0] = pic_param->TRD;
+        pic_info->trb[0] = pic_param->TRB;
+        pic_info->trd[1] = 0;
+        pic_info->trb[1] = 0;
+    }
+
+    pic_info->vop_time_increment_resolution     = pic_param->vop_time_increment_resolution;
+    pic_info->vop_coding_type                   = pic_param->vop_fields.bits.vop_coding_type;
+    pic_info->vop_fcode_forward                 = pic_param->vop_fcode_forward;
+    pic_info->vop_fcode_backward                = pic_param->vop_fcode_backward;
+    pic_info->resync_marker_disable             = pic_param->vol_fields.bits.resync_marker_disable;
+    pic_info->interlaced                        = pic_param->vol_fields.bits.interlaced;
+    pic_info->quant_type                        = pic_param->vol_fields.bits.quant_type;
+    pic_info->quarter_sample                    = pic_param->vol_fields.bits.quarter_sample;
+    pic_info->short_video_header                = pic_param->vol_fields.bits.short_video_header;
+    pic_info->rounding_control                  = pic_param->vop_fields.bits.vop_rounding_type;
+    pic_info->alternate_vertical_scan_flag      = pic_param->vop_fields.bits.alternate_vertical_scan_flag;
+    pic_info->top_field_first                   = pic_param->vop_fields.bits.top_field_first;
+
+    obj_context->last_pic_param                 = obj_buffer->buffer_data;
+    return 1;
+}
+
+// Translate VAIQMatrixBufferMPEG4
+static int
+translate_VAIQMatrixBufferMPEG4(
+    vdpau_driver_data_p driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    VdpPictureInfoMPEG4Part2 * const pic_info = &obj_context->vdp_picture_info.mpeg4;
+    VAIQMatrixBufferMPEG4 * const iq_matrix = obj_buffer->buffer_data;
+    const uint8_t *intra_matrix;
+    const uint8_t *intra_matrix_lookup;
+    const uint8_t *inter_matrix;
+    const uint8_t *inter_matrix_lookup;
+    int i;
+
+    if (iq_matrix->load_intra_quant_mat) {
+        intra_matrix = iq_matrix->intra_quant_mat;
+        intra_matrix_lookup = ff_zigzag_direct;
+    }
+    else {
+        intra_matrix = ff_mpeg4_default_intra_matrix;
+        intra_matrix_lookup = ff_identity;
+    }
+
+    if (iq_matrix->load_non_intra_quant_mat) {
+        inter_matrix = iq_matrix->non_intra_quant_mat;
+        inter_matrix_lookup = ff_zigzag_direct;
+    }
+    else {
+        inter_matrix = ff_mpeg4_default_non_intra_matrix;
+        inter_matrix_lookup = ff_identity;
+    }
+
+    for (i = 0; i < 64; i++) {
+        pic_info->intra_quantizer_matrix[intra_matrix_lookup[i]] =
+            intra_matrix[i];
+        pic_info->non_intra_quantizer_matrix[inter_matrix_lookup[i]] =
+            inter_matrix[i];
+    }
+    return 1;
+}
+
+// Translate VASliceParameterBufferMPEG4
+static int
+translate_VASliceParameterBufferMPEG4(
+    vdpau_driver_data_p driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+    )
+{
+    obj_context->last_slice_params       = obj_buffer->buffer_data;
+    obj_context->last_slice_params_count = obj_buffer->num_elements;
+    return 1;
+}
+#endif
+
+// Translate VAPictureParameterBufferH264
+static int
+translate_VAPictureParameterBufferH264(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    VdpPictureInfoH264 * const pic_info = &obj_context->vdp_picture_info.h264;
+    VAPictureParameterBufferH264 * const pic_param = obj_buffer->buffer_data;
+    VAPictureH264 * const CurrPic = &pic_param->CurrPic;
+    unsigned int i;
+
+    pic_info->field_order_cnt[0]                = CurrPic->TopFieldOrderCnt;
+    pic_info->field_order_cnt[1]                = CurrPic->BottomFieldOrderCnt;
+    pic_info->is_reference                      = pic_param->pic_fields.bits.reference_pic_flag;
+
+    pic_info->frame_num                         = pic_param->frame_num;
+    pic_info->field_pic_flag                    = pic_param->pic_fields.bits.field_pic_flag;
+    pic_info->bottom_field_flag                 = pic_param->pic_fields.bits.field_pic_flag && (CurrPic->flags & VA_PICTURE_H264_BOTTOM_FIELD) != 0;
+    pic_info->num_ref_frames                    = pic_param->num_ref_frames;
+    pic_info->mb_adaptive_frame_field_flag      = pic_param->seq_fields.bits.mb_adaptive_frame_field_flag && !pic_info->field_pic_flag;
+    pic_info->constrained_intra_pred_flag       = pic_param->pic_fields.bits.constrained_intra_pred_flag;
+    pic_info->weighted_pred_flag                = pic_param->pic_fields.bits.weighted_pred_flag;
+    pic_info->weighted_bipred_idc               = pic_param->pic_fields.bits.weighted_bipred_idc;
+    pic_info->frame_mbs_only_flag               = pic_param->seq_fields.bits.frame_mbs_only_flag;
+    pic_info->transform_8x8_mode_flag           = pic_param->pic_fields.bits.transform_8x8_mode_flag;
+    pic_info->chroma_qp_index_offset            = pic_param->chroma_qp_index_offset;
+    pic_info->second_chroma_qp_index_offset     = pic_param->second_chroma_qp_index_offset;
+    pic_info->pic_init_qp_minus26               = pic_param->pic_init_qp_minus26;
+    pic_info->log2_max_frame_num_minus4         = pic_param->seq_fields.bits.log2_max_frame_num_minus4;
+    pic_info->pic_order_cnt_type                = pic_param->seq_fields.bits.pic_order_cnt_type;
+    pic_info->log2_max_pic_order_cnt_lsb_minus4 = pic_param->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4;
+    pic_info->delta_pic_order_always_zero_flag  = pic_param->seq_fields.bits.delta_pic_order_always_zero_flag;
+    pic_info->direct_8x8_inference_flag         = pic_param->seq_fields.bits.direct_8x8_inference_flag;
+    pic_info->entropy_coding_mode_flag          = pic_param->pic_fields.bits.entropy_coding_mode_flag;
+    pic_info->pic_order_present_flag            = pic_param->pic_fields.bits.pic_order_present_flag;
+    pic_info->deblocking_filter_control_present_flag = pic_param->pic_fields.bits.deblocking_filter_control_present_flag;
+    pic_info->redundant_pic_cnt_present_flag    = pic_param->pic_fields.bits.redundant_pic_cnt_present_flag;
+
+    for (i = 0; i < 16; i++) {
+        if (!translate_VAPictureH264(driver_data,
+                                     &pic_param->ReferenceFrames[i],
+                                     &pic_info->referenceFrames[i]))
+                return 0;
+    }
+    return 1;
+}
+
+// Translate VAIQMatrixBufferH264
+static int
+translate_VAIQMatrixBufferH264(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    VdpPictureInfoH264 * const pic_info = &obj_context->vdp_picture_info.h264;
+    VAIQMatrixBufferH264 * const iq_matrix = obj_buffer->buffer_data;
+    int i, j;
+
+    if (sizeof(pic_info->scaling_lists_4x4) == sizeof(iq_matrix->ScalingList4x4))
+        memcpy(pic_info->scaling_lists_4x4, iq_matrix->ScalingList4x4,
+               sizeof(pic_info->scaling_lists_4x4));
+    else {
+        for (j = 0; j < 6; j++) {
+            for (i = 0; i < 16; i++)
+                pic_info->scaling_lists_4x4[j][i] = iq_matrix->ScalingList4x4[j][i];
+        }
+    }
+
+    if (sizeof(pic_info->scaling_lists_8x8) == sizeof(iq_matrix->ScalingList8x8))
+        memcpy(pic_info->scaling_lists_8x8, iq_matrix->ScalingList8x8,
+               sizeof(pic_info->scaling_lists_8x8));
+    else {
+        for (j = 0; j < 2; j++) {
+            for (i = 0; i < 64; i++)
+                pic_info->scaling_lists_8x8[j][i] = iq_matrix->ScalingList8x8[j][i];
+        }
+    }
+    return 1;
+}
+
+// Translate VASliceParameterBufferH264
+static int
+translate_VASliceParameterBufferH264(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    VdpPictureInfoH264 * const pic_info = &obj_context->vdp_picture_info.h264;
+    VASliceParameterBufferH264 * const slice_params = obj_buffer->buffer_data;
+    VASliceParameterBufferH264 * const slice_param = &slice_params[obj_buffer->num_elements - 1];
+
+    pic_info->slice_count                 += obj_buffer->num_elements;
+    pic_info->num_ref_idx_l0_active_minus1 = slice_param->num_ref_idx_l0_active_minus1;
+    pic_info->num_ref_idx_l1_active_minus1 = slice_param->num_ref_idx_l1_active_minus1;
+    obj_context->last_slice_params         = obj_buffer->buffer_data;
+    obj_context->last_slice_params_count   = obj_buffer->num_elements;
+    return 1;
+}
+
+// Translate VAPictureParameterBufferVC1
+static int
+translate_VAPictureParameterBufferVC1(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    VdpPictureInfoVC1 * const pic_info = &obj_context->vdp_picture_info.vc1;
+    VAPictureParameterBufferVC1 * const pic_param = obj_buffer->buffer_data;
+    int picture_type, major_version, minor_version;
+
+    if (!translate_VASurfaceID(driver_data,
+                               pic_param->forward_reference_picture,
+                               &pic_info->forward_reference))
+        return 0;
+
+    if (!translate_VASurfaceID(driver_data,
+                               pic_param->backward_reference_picture,
+                               &pic_info->backward_reference))
+        return 0;
+
+    switch (pic_param->picture_fields.bits.picture_type) {
+    case 0: picture_type = 0; break; /* I */
+    case 1: picture_type = 1; break; /* P */
+    case 2: picture_type = 3; break; /* B */
+    case 3: picture_type = 4; break; /* BI */
+    case 4: picture_type = 1; break; /* P "skipped" */
+    default: return 0;
+    }
+
+    pic_info->picture_type      = picture_type;
+    pic_info->frame_coding_mode = pic_param->picture_fields.bits.frame_coding_mode;
+    pic_info->postprocflag      = pic_param->post_processing != 0;
+    pic_info->pulldown          = pic_param->sequence_fields.bits.pulldown;
+    pic_info->interlace         = pic_param->sequence_fields.bits.interlace;
+    pic_info->tfcntrflag        = pic_param->sequence_fields.bits.tfcntrflag;
+    pic_info->finterpflag       = pic_param->sequence_fields.bits.finterpflag;
+    pic_info->psf               = pic_param->sequence_fields.bits.psf;
+    pic_info->dquant            = pic_param->pic_quantizer_fields.bits.dquant;
+    pic_info->panscan_flag      = pic_param->entrypoint_fields.bits.panscan_flag;
+    pic_info->refdist_flag      = pic_param->reference_fields.bits.reference_distance_flag;
+    pic_info->quantizer         = pic_param->pic_quantizer_fields.bits.quantizer;
+    pic_info->extended_mv       = pic_param->mv_fields.bits.extended_mv_flag;
+    pic_info->extended_dmv      = pic_param->mv_fields.bits.extended_dmv_flag;
+    pic_info->overlap           = pic_param->sequence_fields.bits.overlap;
+    pic_info->vstransform       = pic_param->transform_fields.bits.variable_sized_transform_flag;
+    pic_info->loopfilter        = pic_param->entrypoint_fields.bits.loopfilter;
+    pic_info->fastuvmc          = pic_param->fast_uvmc_flag;
+    pic_info->range_mapy_flag   = pic_param->range_mapping_fields.bits.luma_flag;
+    pic_info->range_mapy        = pic_param->range_mapping_fields.bits.luma;
+    pic_info->range_mapuv_flag  = pic_param->range_mapping_fields.bits.chroma_flag;
+    pic_info->range_mapuv       = pic_param->range_mapping_fields.bits.chroma;
+    pic_info->multires          = pic_param->sequence_fields.bits.multires;
+    pic_info->syncmarker        = pic_param->sequence_fields.bits.syncmarker;
+    pic_info->rangered          = pic_param->sequence_fields.bits.rangered;
+    if (!vdpau_is_nvidia(driver_data, &major_version, &minor_version) ||
+        (major_version > 180 || minor_version >= 35))
+        pic_info->rangered     |= pic_param->range_reduction_frame << 1;
+    pic_info->maxbframes        = pic_param->sequence_fields.bits.max_b_frames;
+    pic_info->deblockEnable     = pic_param->post_processing != 0; /* XXX: this is NVIDIA's vdpau.c semantics (postprocflag & 1) */
+    pic_info->pquant            = pic_param->pic_quantizer_fields.bits.pic_quantizer_scale;
+    return 1;
+}
+
+// Translate VASliceParameterBufferVC1
+static int
+translate_VASliceParameterBufferVC1(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    VdpPictureInfoVC1 * const pic_info = &obj_context->vdp_picture_info.vc1;
+
+    pic_info->slice_count               += obj_buffer->num_elements;
+    obj_context->last_slice_params       = obj_buffer->buffer_data;
+    obj_context->last_slice_params_count = obj_buffer->num_elements;
+    return 1;
+}
+
+// Translate VA buffer
+typedef int
+(*translate_buffer_func_t)(vdpau_driver_data_t *driver_data,
+                           object_context_p    obj_context,
+                           object_buffer_p     obj_buffer);
+
+typedef struct translate_buffer_info translate_buffer_info_t;
+struct translate_buffer_info {
+    VdpCodec codec;
+    VABufferType type;
+    translate_buffer_func_t func;
+};
+
+static int
+translate_buffer(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    static const translate_buffer_info_t translate_info[] = {
+#define _(CODEC, TYPE)                                  \
+        { VDP_CODEC_##CODEC, VA##TYPE##BufferType,      \
+          translate_VA##TYPE##Buffer##CODEC }
+        _(MPEG2, PictureParameter),
+        _(MPEG2, IQMatrix),
+        _(MPEG2, SliceParameter),
+#if USE_VDPAU_MPEG4
+        _(MPEG4, PictureParameter),
+        _(MPEG4, IQMatrix),
+        _(MPEG4, SliceParameter),
+#endif
+        _(H264, PictureParameter),
+        _(H264, IQMatrix),
+        _(H264, SliceParameter),
+        _(VC1, PictureParameter),
+        _(VC1, SliceParameter),
+#undef _
+        { VDP_CODEC_VC1, VABitPlaneBufferType, translate_nothing },
+        { 0, VASliceDataBufferType, translate_VASliceDataBuffer },
+        { 0, 0, NULL }
+    };
+    const translate_buffer_info_t *tbip;
+    for (tbip = translate_info; tbip->func != NULL; tbip++) {
+        if (tbip->codec && tbip->codec != obj_context->vdp_codec)
+            continue;
+        if (tbip->type != obj_buffer->type)
+            continue;
+        return tbip->func(driver_data, obj_context, obj_buffer);
+    }
+    D(bug("ERROR: no translate function found for %s%s\n",
+          string_of_VABufferType(obj_buffer->type),
+          obj_context->vdp_codec ? string_of_VdpCodec(obj_context->vdp_codec) : NULL));
+    return 0;
+}
+
+// vaQueryConfigProfiles
+VAStatus
+vdpau_QueryConfigProfiles(
+    VADriverContextP    ctx,
+    VAProfile          *profile_list,
+    int                *num_profiles
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    static const VAProfile va_profiles[] = {
+        VAProfileMPEG2Simple,
+        VAProfileMPEG2Main,
+        VAProfileMPEG4Simple,
+        VAProfileMPEG4AdvancedSimple,
+        VAProfileMPEG4Main,
+        VAProfileH264Baseline,
+        VAProfileH264Main,
+        VAProfileH264High,
+        VAProfileVC1Simple,
+        VAProfileVC1Main,
+        VAProfileVC1Advanced
+    };
+
+    int i, n = 0;
+    for (i = 0; i < ARRAY_ELEMS(va_profiles); i++) {
+        VAProfile profile = va_profiles[i];
+        VdpDecoderProfile vdp_profile = get_VdpDecoderProfile(profile);
+        if (is_supported_profile(driver_data, vdp_profile))
+            profile_list[n++] = profile;
+    }
+
+    /* If the assert fails then VDPAU_MAX_PROFILES needs to be bigger */
+    ASSERT(n <= VDPAU_MAX_PROFILES);
+    if (num_profiles)
+        *num_profiles = n;
+
+    return VA_STATUS_SUCCESS;
+}
+
+// vaQueryConfigEntrypoints
+VAStatus
+vdpau_QueryConfigEntrypoints(
+    VADriverContextP    ctx,
+    VAProfile           profile,
+    VAEntrypoint       *entrypoint_list,
+    int                *num_entrypoints
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    VdpDecoderProfile vdp_profile = get_VdpDecoderProfile(profile);
+    if (!is_supported_profile(driver_data, vdp_profile))
+        return VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
+
+    VAEntrypoint entrypoint;
+    switch (profile) {
+    case VAProfileMPEG2Simple:
+    case VAProfileMPEG2Main:
+        entrypoint = VAEntrypointVLD;
+        break;
+    case VAProfileMPEG4Simple:
+    case VAProfileMPEG4AdvancedSimple:
+    case VAProfileMPEG4Main:
+        entrypoint = VAEntrypointVLD;
+        break;
+    case VAProfileH264Baseline:
+    case VAProfileH264Main:
+    case VAProfileH264High:
+        entrypoint = VAEntrypointVLD;
+        break;
+    case VAProfileVC1Simple:
+    case VAProfileVC1Main:
+    case VAProfileVC1Advanced:
+        entrypoint = VAEntrypointVLD;
+        break;
+    default:
+        entrypoint = 0;
+        break;
+    }
+
+    if (entrypoint_list)
+        *entrypoint_list = entrypoint;
+
+    if (num_entrypoints)
+        *num_entrypoints = entrypoint != 0;
+
+    return VA_STATUS_SUCCESS;
+}
+
+// vaBeginPicture
+VAStatus
+vdpau_BeginPicture(
+    VADriverContextP    ctx,
+    VAContextID         context,
+    VASurfaceID         render_target
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    object_context_p obj_context = VDPAU_CONTEXT(context);
+    if (!obj_context)
+        return VA_STATUS_ERROR_INVALID_CONTEXT;
+
+    object_surface_p obj_surface = VDPAU_SURFACE(render_target);
+    if (!obj_surface)
+        return VA_STATUS_ERROR_INVALID_SURFACE;
+
+    obj_surface->va_surface_status           = VASurfaceRendering;
+    obj_context->last_pic_param              = NULL;
+    obj_context->last_slice_params           = NULL;
+    obj_context->last_slice_params_count     = 0;
+    obj_context->current_render_target       = obj_surface->base.id;
+    obj_context->gen_slice_data_size         = 0;
+    obj_context->vdp_bitstream_buffers_count = 0;
+
+    switch (obj_context->vdp_codec) {
+    case VDP_CODEC_MPEG1:
+    case VDP_CODEC_MPEG2:
+        obj_context->vdp_picture_info.mpeg2.slice_count = 0;
+        break;
+    case VDP_CODEC_MPEG4:
+        break;
+    case VDP_CODEC_H264:
+        obj_context->vdp_picture_info.h264.slice_count = 0;
+        break;
+    case VDP_CODEC_VC1:
+        obj_context->vdp_picture_info.vc1.slice_count = 0;
+        break;
+    default:
+        return VA_STATUS_ERROR_UNKNOWN;
+    }
+    return VA_STATUS_SUCCESS;
+}
+
+// vaRenderPicture
+VAStatus
+vdpau_RenderPicture(
+    VADriverContextP    ctx,
+    VAContextID         context,
+    VABufferID         *buffers,
+    int                 num_buffers
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+    int i;
+
+    object_context_p obj_context = VDPAU_CONTEXT(context);
+    if (!obj_context)
+        return VA_STATUS_ERROR_INVALID_CONTEXT;
+
+    object_surface_p obj_surface = VDPAU_SURFACE(obj_context->current_render_target);
+    if (!obj_surface)
+        return VA_STATUS_ERROR_INVALID_SURFACE;
+
+    /* Verify that we got valid buffer references */
+    for (i = 0; i < num_buffers; i++) {
+        object_buffer_p obj_buffer = VDPAU_BUFFER(buffers[i]);
+        if (!obj_buffer)
+            return VA_STATUS_ERROR_INVALID_BUFFER;
+    }
+
+    /* Translate buffers */
+    for (i = 0; i < num_buffers; i++) {
+        object_buffer_p obj_buffer = VDPAU_BUFFER(buffers[i]);
+        if (!translate_buffer(driver_data, obj_context, obj_buffer))
+            return VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE;
+        /* Release any buffer that is not VASliceDataBuffer */
+        /* VASliceParameterBuffer is also needed to check for start_codes */
+        switch (obj_buffer->type) {
+        case VASliceParameterBufferType:
+        case VASliceDataBufferType:
+            schedule_destroy_va_buffer(driver_data, obj_buffer);
+            break;
+        case VAPictureParameterBufferType:
+            /* Preserve VAPictureParameterBufferMPEG4 */
+            if (obj_context->vdp_codec == VDP_CODEC_MPEG4) {
+                schedule_destroy_va_buffer(driver_data, obj_buffer);
+                break;
+            }
+            /* fall-through */
+        default:
+            destroy_va_buffer(driver_data, obj_buffer);
+            break;
+        }
+    }
+
+    return VA_STATUS_SUCCESS;
+}
+
+// vaEndPicture
+VAStatus
+vdpau_EndPicture(
+    VADriverContextP    ctx,
+    VAContextID         context
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+    unsigned int i;
+
+    object_context_p obj_context = VDPAU_CONTEXT(context);
+    if (!obj_context)
+        return VA_STATUS_ERROR_INVALID_CONTEXT;
+
+    object_surface_p obj_surface = VDPAU_SURFACE(obj_context->current_render_target);
+    if (!obj_surface)
+        return VA_STATUS_ERROR_INVALID_SURFACE;
+
+    if (trace_enabled()) {
+        switch (obj_context->vdp_codec) {
+        case VDP_CODEC_MPEG1:
+        case VDP_CODEC_MPEG2:
+            dump_VdpPictureInfoMPEG1Or2(&obj_context->vdp_picture_info.mpeg2);
+            break;
+#if HAVE_VDPAU_MPEG4
+        case VDP_CODEC_MPEG4:
+            dump_VdpPictureInfoMPEG4Part2(&obj_context->vdp_picture_info.mpeg4);
+            break;
+#endif
+        case VDP_CODEC_H264:
+            dump_VdpPictureInfoH264(&obj_context->vdp_picture_info.h264);
+            break;
+        case VDP_CODEC_VC1:
+            dump_VdpPictureInfoVC1(&obj_context->vdp_picture_info.vc1);
+            break;
+        default:
+            break;
+        }
+        for (i = 0; i < obj_context->vdp_bitstream_buffers_count; i++)
+            dump_VdpBitstreamBuffer(&obj_context->vdp_bitstream_buffers[i]);
+    }
+
+    VAStatus va_status;
+    VdpStatus vdp_status;
+    vdp_status = ensure_decoder_with_max_refs(
+        driver_data,
+        obj_context,
+        get_num_ref_frames(obj_context)
+    );
+    if (vdp_status == VDP_STATUS_OK)
+        vdp_status = vdpau_decoder_render(
+            driver_data,
+            obj_context->vdp_decoder,
+            obj_surface->vdp_surface,
+            (VdpPictureInfo)&obj_context->vdp_picture_info,
+            obj_context->vdp_bitstream_buffers_count,
+            obj_context->vdp_bitstream_buffers
+        );
+    va_status = vdpau_get_VAStatus(vdp_status);
+
+    /* XXX: assume we are done with rendering right away */
+    obj_context->current_render_target = VA_INVALID_SURFACE;
+
+    /* Release pending buffers */
+    if (obj_context->dead_buffers_count > 0) {
+        ASSERT(obj_context->dead_buffers);
+        int i;
+        for (i = 0; i < obj_context->dead_buffers_count; i++) {
+            object_buffer_p obj_buffer = VDPAU_BUFFER(obj_context->dead_buffers[i]);
+            ASSERT(obj_buffer);
+            destroy_va_buffer(driver_data, obj_buffer);
+        }
+        obj_context->dead_buffers_count = 0;
+    }
+
+    return va_status;
+}

=== added file '.pc/02_purge_va_buffers_on_context_destroy_or_new_picture_decode_seq.patch/src/vdpau_video.c'
--- .pc/02_purge_va_buffers_on_context_destroy_or_new_picture_decode_seq.patch/src/vdpau_video.c	1970-01-01 00:00:00 +0000
+++ .pc/02_purge_va_buffers_on_context_destroy_or_new_picture_decode_seq.patch/src/vdpau_video.c	2014-05-06 21:30:45 +0000
@@ -0,0 +1,995 @@
+/*
+ *  vdpau_video.c - VDPAU backend for VA-API
+ *
+ *  vdpau-video (C) 2009-2011 Splitted-Desktop Systems
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include "sysdeps.h"
+#include "vdpau_video.h"
+#include "vdpau_video_x11.h"
+#include "vdpau_decode.h"
+#include "vdpau_subpic.h"
+#include "vdpau_mixer.h"
+#include "utils.h"
+
+#define DEBUG 1
+#include "debug.h"
+
+
+/* Define wait delay (in microseconds) for vaSyncSurface() implementation
+   with polling. */
+#define VDPAU_SYNC_DELAY 5000
+
+// Translates VA-API chroma format to VdpChromaType
+static VdpChromaType get_VdpChromaType(int format)
+{
+    switch (format) {
+    case VA_RT_FORMAT_YUV420: return VDP_CHROMA_TYPE_420;
+    case VA_RT_FORMAT_YUV422: return VDP_CHROMA_TYPE_422;
+    case VA_RT_FORMAT_YUV444: return VDP_CHROMA_TYPE_444;
+    }
+    return (VdpChromaType)-1;
+}
+
+
+/* ====================================================================== */
+/* === VA-API Implementation with VDPAU                               === */
+/* ====================================================================== */
+
+// Returns the maximum dimensions supported by the VDPAU implementation for that profile
+static inline VdpBool
+get_max_surface_size(
+    vdpau_driver_data_t *driver_data,
+    VdpDecoderProfile    profile,
+    uint32_t            *pmax_width,
+    uint32_t            *pmax_height
+)
+{
+    VdpBool is_supported = VDP_FALSE;
+    VdpStatus vdp_status;
+    uint32_t max_level, max_references, max_width, max_height;
+
+    if (pmax_width)
+        *pmax_width = 0;
+    if (pmax_height)
+        *pmax_height = 0;
+
+    vdp_status = vdpau_decoder_query_capabilities(
+        driver_data,
+        driver_data->vdp_device,
+        profile,
+        &is_supported,
+        &max_level,
+        &max_references,
+        &max_width,
+        &max_height
+    );
+    if (!VDPAU_CHECK_STATUS(vdp_status, "VdpDecoderQueryCapabilities()"))
+        return VDP_FALSE;
+
+    if (!is_supported)
+        return VDP_FALSE;
+
+    if (pmax_width)
+        *pmax_width = max_width;
+    if (max_height)
+        *pmax_height = max_height;
+
+    return VDP_TRUE;
+}
+
+// vaGetConfigAttributes
+VAStatus
+vdpau_GetConfigAttributes(
+    VADriverContextP    ctx,
+    VAProfile           profile,
+    VAEntrypoint        entrypoint,
+    VAConfigAttrib     *attrib_list,
+    int                 num_attribs
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    VAStatus va_status = check_decoder(driver_data, profile, entrypoint);
+    if (va_status != VA_STATUS_SUCCESS)
+        return va_status;
+
+    int i;
+    for (i = 0; i < num_attribs; i++) {
+        switch (attrib_list[i].type) {
+        case VAConfigAttribRTFormat:
+            attrib_list[i].value = VA_RT_FORMAT_YUV420;
+            break;
+        default:
+            attrib_list[i].value = VA_ATTRIB_NOT_SUPPORTED;
+            break;
+        }
+    }
+    return VA_STATUS_SUCCESS;
+}
+
+static VAStatus
+vdpau_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 < VDPAU_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;
+}
+
+// vaDestroyConfig
+VAStatus vdpau_DestroyConfig(VADriverContextP ctx, VAConfigID config_id)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    object_config_p obj_config = VDPAU_CONFIG(config_id);
+    if (!obj_config)
+        return VA_STATUS_ERROR_INVALID_CONFIG;
+
+    object_heap_free(&driver_data->config_heap, (object_base_p)obj_config);
+    return VA_STATUS_SUCCESS;
+}
+
+// vaCreateConfig
+VAStatus
+vdpau_CreateConfig(
+    VADriverContextP    ctx,
+    VAProfile           profile,
+    VAEntrypoint        entrypoint,
+    VAConfigAttrib     *attrib_list,
+    int                 num_attribs,
+    VAConfigID         *config_id
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    VAStatus va_status;
+    int configID;
+    object_config_p obj_config;
+    int i;
+
+    /* Validate profile and entrypoint */
+    va_status = check_decoder(driver_data, profile, entrypoint);
+    if (va_status != VA_STATUS_SUCCESS)
+        return va_status;
+
+    configID = object_heap_allocate(&driver_data->config_heap);
+    if ((obj_config = VDPAU_CONFIG(configID)) == NULL)
+        return VA_STATUS_ERROR_ALLOCATION_FAILED;
+
+    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++) {
+        va_status = vdpau_update_attribute(obj_config, &attrib_list[i]);
+        if (va_status != VA_STATUS_SUCCESS) {
+            vdpau_DestroyConfig(ctx, configID);
+            return va_status;
+        }
+    }
+
+    if (config_id)
+        *config_id = configID;
+
+    return va_status;
+}
+
+// vaQueryConfigAttributes
+VAStatus
+vdpau_QueryConfigAttributes(
+    VADriverContextP    ctx,
+    VAConfigID          config_id,
+    VAProfile          *profile,
+    VAEntrypoint       *entrypoint,
+    VAConfigAttrib     *attrib_list,
+    int                *num_attribs
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    VAStatus va_status = VA_STATUS_SUCCESS;
+    object_config_p obj_config;
+    int i;
+
+    obj_config = VDPAU_CONFIG(config_id);
+    if (!obj_config)
+        return VA_STATUS_ERROR_INVALID_CONFIG;
+
+    if (profile)
+        *profile = obj_config->profile;
+
+    if (entrypoint)
+        *entrypoint = obj_config->entrypoint;
+
+    if (num_attribs)
+        *num_attribs =  obj_config->attrib_count;
+
+    if (attrib_list) {
+        for (i = 0; i < obj_config->attrib_count; i++)
+            attrib_list[i] = obj_config->attrib_list[i];
+    }
+
+    return va_status;
+}
+
+// Add subpicture association to surface
+// NOTE: the subpicture owns the SubpictureAssociation object
+int surface_add_association(
+    object_surface_p            obj_surface,
+    SubpictureAssociationP      assoc
+)
+{
+    /* Check that we don't already have this association */
+    if (obj_surface->assocs) {
+        unsigned int i;
+        for (i = 0; i < obj_surface->assocs_count; i++) {
+            if (obj_surface->assocs[i] == assoc)
+                return 0;
+            if (obj_surface->assocs[i]->subpicture == assoc->subpicture) {
+                /* XXX: this should not happen, but replace it in the interim */
+                ASSERT(obj_surface->assocs[i]->surface == assoc->surface);
+                obj_surface->assocs[i] = assoc;
+                return 0;
+            }
+        }
+    }
+
+    /* Check that we have not reached the maximum subpictures capacity yet */
+    if (obj_surface->assocs_count >= VDPAU_MAX_SUBPICTURES)
+        return -1;
+
+    /* Append this subpicture association */
+    SubpictureAssociationP *assocs;
+    assocs = realloc_buffer(
+        &obj_surface->assocs,
+        &obj_surface->assocs_count_max,
+        1 + obj_surface->assocs_count,
+        sizeof(obj_surface->assocs[0])
+    );
+    if (!assocs)
+        return -1;
+
+    assocs[obj_surface->assocs_count++] = assoc;
+    return 0;
+}
+
+// Remove subpicture association from surface
+// NOTE: the subpicture owns the SubpictureAssociation object
+int surface_remove_association(
+    object_surface_p            obj_surface,
+    SubpictureAssociationP      assoc
+)
+{
+    if (!obj_surface->assocs || obj_surface->assocs_count == 0)
+        return -1;
+
+    unsigned int i;
+    const unsigned int last = obj_surface->assocs_count - 1;
+    for (i = 0; i <= last; i++) {
+        if (obj_surface->assocs[i] == assoc) {
+            /* Swap with the last subpicture */
+            obj_surface->assocs[i] = obj_surface->assocs[last];
+            obj_surface->assocs[last] = NULL;
+            obj_surface->assocs_count--;
+            return 0;
+        }
+    }
+    return -1;
+}
+
+// vaDestroySurfaces
+VAStatus
+vdpau_DestroySurfaces(
+    VADriverContextP    ctx,
+    VASurfaceID        *surface_list,
+    int                 num_surfaces
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    int i, j, n;
+    for (i = num_surfaces - 1; i >= 0; i--) {
+        object_surface_p obj_surface = VDPAU_SURFACE(surface_list[i]);
+        ASSERT(obj_surface);
+        if (!obj_surface)
+            continue;
+
+        if (obj_surface->vdp_surface != VDP_INVALID_HANDLE) {
+            vdpau_video_surface_destroy(driver_data, obj_surface->vdp_surface);
+            obj_surface->vdp_surface = VDP_INVALID_HANDLE;
+        }
+
+        for (j = 0; j < obj_surface->output_surfaces_count; j++) {
+            output_surface_unref(driver_data, obj_surface->output_surfaces[j]);
+            obj_surface->output_surfaces[j] = NULL;
+        }
+        free(obj_surface->output_surfaces);
+        obj_surface->output_surfaces_count = 0;
+        obj_surface->output_surfaces_count_max = 0;
+
+        if (obj_surface->video_mixer) {
+            video_mixer_unref(driver_data, obj_surface->video_mixer);
+            obj_surface->video_mixer = NULL;
+        }
+
+        if (obj_surface->assocs) {
+            object_subpicture_p obj_subpicture;
+            VAStatus status;
+            const unsigned int n_assocs = obj_surface->assocs_count;
+
+            for (j = 0, n = 0; j < n_assocs; j++) {
+                SubpictureAssociationP const assoc = obj_surface->assocs[0];
+                ASSERT(assoc);
+                if (!assoc)
+                    continue;
+                obj_subpicture = VDPAU_SUBPICTURE(assoc->subpicture);
+                ASSERT(obj_subpicture);
+                if (!obj_subpicture)
+                    continue;
+                status = subpicture_deassociate_1(obj_subpicture, obj_surface);
+                if (status == VA_STATUS_SUCCESS)
+                    ++n;
+            }
+            if (n != n_assocs)
+                vdpau_error_message("vaDestroySurfaces(): surface 0x%08x still "
+                                    "has %d subpictures associated to it\n",
+                                    obj_surface->base.id, n_assocs - n);
+            free(obj_surface->assocs);
+            obj_surface->assocs = NULL;
+        }
+        obj_surface->assocs_count = 0;
+        obj_surface->assocs_count_max = 0;
+
+        object_heap_free(&driver_data->surface_heap, (object_base_p)obj_surface);
+    }
+    return VA_STATUS_SUCCESS;
+}
+
+// vaCreateSurfaces
+VAStatus
+vdpau_CreateSurfaces(
+    VADriverContextP    ctx,
+    int                 width,
+    int                 height,
+    int                 format,
+    int                 num_surfaces,
+    VASurfaceID         *surfaces
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    VAStatus va_status = VA_STATUS_SUCCESS;
+    VdpVideoSurface vdp_surface = VDP_INVALID_HANDLE;
+    VdpChromaType vdp_chroma_type = get_VdpChromaType(format);
+    VdpStatus vdp_status;
+    int i;
+
+    /* We only support one format */
+    if (format != VA_RT_FORMAT_YUV420)
+        return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
+
+    for (i = 0; i < num_surfaces; i++) {
+        vdp_status = vdpau_video_surface_create(
+            driver_data,
+            driver_data->vdp_device,
+            vdp_chroma_type,
+            width, height,
+            &vdp_surface
+        );
+        if (!VDPAU_CHECK_STATUS(vdp_status, "VdpVideoSurfaceCreate()")) {
+            va_status = VA_STATUS_ERROR_ALLOCATION_FAILED;
+            break;
+        }
+
+        int va_surface = object_heap_allocate(&driver_data->surface_heap);
+        object_surface_p obj_surface = VDPAU_SURFACE(va_surface);
+        if (!obj_surface) {
+            va_status = VA_STATUS_ERROR_ALLOCATION_FAILED;
+            break;
+        }
+        obj_surface->va_context                 = VA_INVALID_ID;
+        obj_surface->va_surface_status          = VASurfaceReady;
+        obj_surface->vdp_surface                = vdp_surface;
+        obj_surface->width                      = width;
+        obj_surface->height                     = height;
+        obj_surface->assocs                     = NULL;
+        obj_surface->assocs_count               = 0;
+        obj_surface->assocs_count_max           = 0;
+        obj_surface->vdp_chroma_type            = vdp_chroma_type;
+        obj_surface->output_surfaces            = NULL;
+        obj_surface->output_surfaces_count      = 0;
+        obj_surface->output_surfaces_count_max  = 0;
+        obj_surface->video_mixer                = NULL;
+        surfaces[i]                             = va_surface;
+        vdp_surface                             = VDP_INVALID_HANDLE;
+
+        object_mixer_p obj_mixer;
+        obj_mixer = video_mixer_create_cached(driver_data, obj_surface);
+        if (!obj_mixer) {
+            va_status = VA_STATUS_ERROR_ALLOCATION_FAILED;
+            break;
+        }
+        obj_surface->video_mixer = obj_mixer;
+    }
+
+    /* Error recovery */
+    if (va_status != VA_STATUS_SUCCESS) {
+        if (vdp_surface != VDP_INVALID_HANDLE)
+            vdpau_video_surface_destroy(driver_data, vdp_surface);
+        vdpau_DestroySurfaces(ctx, surfaces, i);
+    }
+    return va_status;
+}
+
+// vaDestroyContext
+VAStatus vdpau_DestroyContext(VADriverContextP ctx, VAContextID context)
+{
+    VDPAU_DRIVER_DATA_INIT;
+    int i;
+
+    object_context_p obj_context = VDPAU_CONTEXT(context);
+    if (!obj_context)
+        return VA_STATUS_ERROR_INVALID_CONTEXT;
+
+    if (obj_context->gen_slice_data) {
+        free(obj_context->gen_slice_data);
+        obj_context->gen_slice_data = NULL;
+        obj_context->gen_slice_data_size = 0;
+        obj_context->gen_slice_data_size_max = 0;
+    }
+
+    if (obj_context->vdp_bitstream_buffers) {
+        free(obj_context->vdp_bitstream_buffers);
+        obj_context->vdp_bitstream_buffers = NULL;
+        obj_context->vdp_bitstream_buffers_count = 0;
+        obj_context->vdp_bitstream_buffers_count_max = 0;
+    }
+
+    if (obj_context->vdp_decoder != VDP_INVALID_HANDLE) {
+        vdpau_decoder_destroy(driver_data, obj_context->vdp_decoder);
+        obj_context->vdp_decoder = VDP_INVALID_HANDLE;
+    }
+
+    if (obj_context->dead_buffers) {
+        free(obj_context->dead_buffers);
+        obj_context->dead_buffers = NULL;
+    }
+
+    if (obj_context->render_targets) {
+        for (i = 0; i < obj_context->num_render_targets; i++) {
+            object_surface_p obj_surface;
+            obj_surface = VDPAU_SURFACE(obj_context->render_targets[i]);
+            if (obj_surface)
+                obj_surface->va_context = VA_INVALID_ID;
+        }
+        free(obj_context->render_targets);
+        obj_context->render_targets = NULL;
+    }
+
+    obj_context->context_id             = VA_INVALID_ID;
+    obj_context->config_id              = VA_INVALID_ID;
+    obj_context->current_render_target  = VA_INVALID_SURFACE;
+    obj_context->picture_width          = 0;
+    obj_context->picture_height         = 0;
+    obj_context->num_render_targets     = 0;
+    obj_context->flags                  = 0;
+    obj_context->dead_buffers_count     = 0;
+    obj_context->dead_buffers_count_max = 0;
+
+    object_heap_free(&driver_data->context_heap, (object_base_p)obj_context);
+    return VA_STATUS_SUCCESS;
+}
+
+// vaCreateContext
+VAStatus
+vdpau_CreateContext(
+    VADriverContextP    ctx,
+    VAConfigID          config_id,
+    int                 picture_width,
+    int                 picture_height,
+    int                 flag,
+    VASurfaceID        *render_targets,
+    int                 num_render_targets,
+    VAContextID        *context
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    if (context)
+        *context = VA_INVALID_ID;
+
+    object_config_p obj_config;
+    if ((obj_config = VDPAU_CONFIG(config_id)) == NULL)
+        return VA_STATUS_ERROR_INVALID_CONFIG;
+
+    /* XXX: validate flag */
+
+    VdpDecoderProfile vdp_profile;
+    uint32_t max_width, max_height;
+    int i;
+    vdp_profile = get_VdpDecoderProfile(obj_config->profile);
+    if (!get_max_surface_size(driver_data, vdp_profile, &max_width, &max_height))
+        return VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
+    if (picture_width > max_width || picture_height > max_height)
+        return VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED;
+
+    VAContextID context_id = object_heap_allocate(&driver_data->context_heap);
+    if (context_id == VA_INVALID_ID)
+        return VA_STATUS_ERROR_ALLOCATION_FAILED;
+
+    object_context_p obj_context = VDPAU_CONTEXT(context_id);
+    if (!obj_context)
+        return VA_STATUS_ERROR_ALLOCATION_FAILED;
+    if (context)
+        *context = context_id;
+
+    obj_context->context_id             = context_id;
+    obj_context->config_id              = config_id;
+    obj_context->current_render_target  = VA_INVALID_SURFACE;
+    obj_context->picture_width          = picture_width;
+    obj_context->picture_height         = picture_height;
+    obj_context->num_render_targets     = num_render_targets;
+    obj_context->flags                  = flag;
+    obj_context->max_ref_frames         = -1;
+    obj_context->render_targets         = (VASurfaceID *)
+        calloc(num_render_targets, sizeof(VASurfaceID));
+    obj_context->dead_buffers           = NULL;
+    obj_context->dead_buffers_count     = 0;
+    obj_context->dead_buffers_count_max = 0;
+    obj_context->vdp_codec              = get_VdpCodec(vdp_profile);
+    obj_context->vdp_profile            = vdp_profile;
+    obj_context->vdp_decoder            = VDP_INVALID_HANDLE;
+    obj_context->gen_slice_data = NULL;
+    obj_context->gen_slice_data_size = 0;
+    obj_context->gen_slice_data_size_max = 0;
+    obj_context->vdp_bitstream_buffers = NULL;
+    obj_context->vdp_bitstream_buffers_count = 0;
+    obj_context->vdp_bitstream_buffers_count_max = 0;
+
+    if (!obj_context->render_targets) {
+        vdpau_DestroyContext(ctx, context_id);
+        return VA_STATUS_ERROR_ALLOCATION_FAILED;
+    }
+
+    for (i = 0; i < num_render_targets; i++) {
+        object_surface_t *obj_surface;
+        if ((obj_surface = VDPAU_SURFACE(render_targets[i])) == NULL) {
+            vdpau_DestroyContext(ctx, context_id);
+            return VA_STATUS_ERROR_INVALID_SURFACE;
+        }
+        obj_context->render_targets[i] = render_targets[i];
+        /* XXX: assume we can only associate a surface to a single context */
+        ASSERT(obj_surface->va_context == VA_INVALID_ID);
+        obj_surface->va_context = context_id;
+    }
+    return VA_STATUS_SUCCESS;
+}
+
+// Query surface status
+VAStatus
+query_surface_status(
+    vdpau_driver_data_t *driver_data,
+    object_surface_p     obj_surface,
+    VASurfaceStatus     *status
+)
+{
+    VAStatus va_status = VA_STATUS_SUCCESS;
+
+    if (obj_surface->va_surface_status == VASurfaceDisplaying) {
+        unsigned int i, num_output_surfaces_displaying = 0;
+        for (i = 0; i < obj_surface->output_surfaces_count; i++) {
+            object_output_p obj_output = obj_surface->output_surfaces[i];
+            if (!obj_output)
+                return VA_STATUS_ERROR_INVALID_SURFACE;
+
+            VdpOutputSurface vdp_output_surface;
+            vdp_output_surface = obj_output->vdp_output_surfaces[obj_output->displayed_output_surface];
+            if (vdp_output_surface == VDP_INVALID_HANDLE)
+                continue;
+
+            VdpPresentationQueueStatus vdp_queue_status;
+            VdpTime vdp_dummy_time;
+            VdpStatus vdp_status;
+            vdp_status = vdpau_presentation_queue_query_surface_status(
+                driver_data,
+                obj_output->vdp_flip_queue,
+                vdp_output_surface,
+                &vdp_queue_status,
+                &vdp_dummy_time
+            );
+            va_status = vdpau_get_VAStatus(vdp_status);
+
+            if (vdp_queue_status != VDP_PRESENTATION_QUEUE_STATUS_VISIBLE)
+                ++num_output_surfaces_displaying;
+        }
+
+        if (num_output_surfaces_displaying == 0)
+            obj_surface->va_surface_status = VASurfaceReady;
+    }
+
+    if (status)
+        *status = obj_surface->va_surface_status;
+
+    return va_status;
+}
+
+// vaQuerySurfaceStatus
+VAStatus
+vdpau_QuerySurfaceStatus(
+    VADriverContextP    ctx,
+    VASurfaceID         render_target,
+    VASurfaceStatus    *status
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    object_surface_p obj_surface = VDPAU_SURFACE(render_target);
+    if (!obj_surface)
+        return VA_STATUS_ERROR_INVALID_SURFACE;
+
+    return query_surface_status(driver_data, obj_surface, status);
+}
+
+// Wait for the surface to complete pending operations
+VAStatus
+sync_surface(
+    vdpau_driver_data_t *driver_data,
+    object_surface_p     obj_surface
+)
+{
+    /* VDPAU only supports status interface for in-progress display */
+    /* XXX: polling is bad but there currently is no alternative */
+    for (;;) {
+        VASurfaceStatus va_surface_status;
+        VAStatus va_status;
+
+        va_status = query_surface_status(
+            driver_data,
+            obj_surface,
+            &va_surface_status
+        );
+        if (va_status != VA_STATUS_SUCCESS)
+            return va_status;
+
+        if (va_surface_status != VASurfaceDisplaying)
+            break;
+        delay_usec(VDPAU_SYNC_DELAY);
+    }
+    return VA_STATUS_SUCCESS;
+}
+
+// vaSyncSurface
+VAStatus
+vdpau_SyncSurface2(
+    VADriverContextP    ctx,
+    VASurfaceID         render_target
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    object_surface_p obj_surface = VDPAU_SURFACE(render_target);
+    if (!obj_surface)
+        return VA_STATUS_ERROR_INVALID_SURFACE;
+
+    /* Assume that this shouldn't be called before vaEndPicture() */
+    object_context_p obj_context = VDPAU_CONTEXT(obj_surface->va_context);
+    if (obj_context) {
+        ASSERT(obj_context->current_render_target != obj_surface->base.id);
+        if (obj_context->current_render_target == obj_surface->base.id)
+            return VA_STATUS_ERROR_INVALID_CONTEXT;
+    }
+
+    return sync_surface(driver_data, obj_surface);
+}
+
+VAStatus
+vdpau_SyncSurface3(
+    VADriverContextP    ctx,
+    VAContextID         context,
+    VASurfaceID         render_target
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    object_surface_p obj_surface = VDPAU_SURFACE(render_target);
+    if (!obj_surface)
+        return VA_STATUS_ERROR_INVALID_SURFACE;
+
+    /* Assume that this shouldn't be called before vaEndPicture() */
+    object_context_p obj_context = VDPAU_CONTEXT(context);
+    if (obj_context) {
+        ASSERT(obj_context->current_render_target != obj_surface->base.id);
+        if (obj_context->current_render_target == obj_surface->base.id)
+            return VA_STATUS_ERROR_INVALID_CONTEXT;
+    }
+    return sync_surface(driver_data, obj_surface);
+}
+
+// Ensure VA Display Attributes are initialized
+static int ensure_display_attributes(vdpau_driver_data_t *driver_data)
+{
+    VADisplayAttribute *attr;
+
+    if (driver_data->va_display_attrs_count > 0)
+        return 0;
+
+    memset(driver_data->va_display_attrs_mtime, 0, sizeof(driver_data->va_display_attrs_mtime));
+
+    attr = &driver_data->va_display_attrs[0];
+
+    attr->type      = VADisplayAttribDirectSurface;
+    attr->value     = 0; /* VdpVideoSurface is copied into VdpOutputSurface */
+    attr->min_value = attr->value;
+    attr->max_value = attr->value;
+    attr->flags     = VA_DISPLAY_ATTRIB_GETTABLE;
+    attr++;
+
+    attr->type      = VADisplayAttribBrightness;
+    attr->value     = 0;
+    attr->min_value = -100;
+    attr->max_value = 100;
+    attr->flags     = VA_DISPLAY_ATTRIB_GETTABLE|VA_DISPLAY_ATTRIB_SETTABLE;
+    attr++;
+
+    attr->type      = VADisplayAttribContrast;
+    attr->value     = 0;
+    attr->min_value = -100;
+    attr->max_value = 100;
+    attr->flags     = VA_DISPLAY_ATTRIB_GETTABLE|VA_DISPLAY_ATTRIB_SETTABLE;
+    attr++;
+
+    attr->type      = VADisplayAttribHue;
+    attr->value     = 0;
+    attr->min_value = -100;
+    attr->max_value = 100;
+    attr->flags     = VA_DISPLAY_ATTRIB_GETTABLE|VA_DISPLAY_ATTRIB_SETTABLE;
+    attr++;
+
+    attr->type      = VADisplayAttribSaturation;
+    attr->value     = 0;
+    attr->min_value = -100;
+    attr->max_value = 100;
+    attr->flags     = VA_DISPLAY_ATTRIB_GETTABLE|VA_DISPLAY_ATTRIB_SETTABLE;
+    attr++;
+
+    attr->type      = VADisplayAttribBackgroundColor;
+    attr->value     = 0;
+    attr->min_value = 0;
+    attr->max_value = 0xffffff;
+    attr->flags     = VA_DISPLAY_ATTRIB_GETTABLE|VA_DISPLAY_ATTRIB_SETTABLE;
+    attr++;
+
+    driver_data->va_display_attrs_count = attr - driver_data->va_display_attrs;
+    ASSERT(driver_data->va_display_attrs_count <= VDPAU_MAX_DISPLAY_ATTRIBUTES);
+    return 0;
+}
+
+// Look up for the specified VA display attribute
+static VADisplayAttribute *
+get_display_attribute(
+    vdpau_driver_data_t *driver_data,
+    VADisplayAttribType  type
+)
+{
+    if (ensure_display_attributes(driver_data) < 0)
+        return NULL;
+
+    unsigned int i;
+    for (i = 0; i < driver_data->va_display_attrs_count; i++) {
+        if (driver_data->va_display_attrs[i].type == type)
+            return &driver_data->va_display_attrs[i];
+    }
+    return NULL;
+}
+
+// vaQueryDisplayAttributes
+VAStatus
+vdpau_QueryDisplayAttributes(
+    VADriverContextP    ctx,
+    VADisplayAttribute *attr_list,
+    int                *num_attributes
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    if (ensure_display_attributes(driver_data) < 0)
+        return VA_STATUS_ERROR_OPERATION_FAILED;
+
+    if (attr_list)
+        memcpy(attr_list, driver_data->va_display_attrs,
+               driver_data->va_display_attrs_count * sizeof(attr_list[0]));
+
+    if (num_attributes)
+        *num_attributes = driver_data->va_display_attrs_count;
+
+    return VA_STATUS_SUCCESS;
+}
+
+// vaGetDisplayAttributes
+VAStatus
+vdpau_GetDisplayAttributes(
+    VADriverContextP    ctx,
+    VADisplayAttribute *attr_list,
+    int                 num_attributes
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    unsigned int i;
+    for (i = 0; i < num_attributes; i++) {
+        VADisplayAttribute * const dst_attr = &attr_list[i];
+        VADisplayAttribute *src_attr;
+
+        src_attr = get_display_attribute(driver_data, dst_attr->type);
+        if (src_attr && (src_attr->flags & VA_DISPLAY_ATTRIB_GETTABLE) != 0) {
+            dst_attr->min_value = src_attr->min_value;
+            dst_attr->max_value = src_attr->max_value;
+            dst_attr->value     = src_attr->value;
+        }
+        else
+            dst_attr->flags    &= ~VA_DISPLAY_ATTRIB_GETTABLE;
+    }
+    return VA_STATUS_SUCCESS;
+}
+
+// vaSetDisplayAttributes
+VAStatus
+vdpau_SetDisplayAttributes(
+    VADriverContextP    ctx,
+    VADisplayAttribute *attr_list,
+    int                 num_attributes
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    unsigned int i;
+    for (i = 0; i < num_attributes; i++) {
+        VADisplayAttribute * const src_attr = &attr_list[i];
+        VADisplayAttribute *dst_attr;
+
+        dst_attr = get_display_attribute(driver_data, src_attr->type);
+        if (!dst_attr)
+            return VA_STATUS_ERROR_ATTR_NOT_SUPPORTED;
+
+        if ((dst_attr->flags & VA_DISPLAY_ATTRIB_SETTABLE) != 0) {
+            dst_attr->value = src_attr->value;
+
+            static uint64_t mtime;
+            const int display_attr_index = dst_attr - driver_data->va_display_attrs;
+            ASSERT(display_attr_index < VDPAU_MAX_DISPLAY_ATTRIBUTES);
+            driver_data->va_display_attrs_mtime[display_attr_index] = ++mtime;
+        }
+    }
+    return VA_STATUS_SUCCESS;
+}
+
+// vaDbgCopySurfaceToBuffer (not a PUBLIC interface)
+VAStatus
+vdpau_DbgCopySurfaceToBuffer(
+    VADriverContextP    ctx,
+    VASurfaceID         surface,
+    void              **buffer,
+    unsigned int       *stride
+)
+{
+    /* TODO */
+    return VA_STATUS_ERROR_UNKNOWN;
+}
+
+#if VA_CHECK_VERSION(0,30,0)
+// vaCreateSurfaceFromCIFrame
+VAStatus
+vdpau_CreateSurfaceFromCIFrame(
+    VADriverContextP    ctx,
+    unsigned long       frame_id,
+    VASurfaceID        *surface
+)
+{
+    /* TODO */
+    return VA_STATUS_ERROR_UNKNOWN;
+}
+
+// vaCreateSurfaceFromV4L2Buf
+VAStatus
+vdpau_CreateSurfaceFromV4L2Buf(
+    VADriverContextP    ctx,
+    int                 v4l2_fd,
+    struct v4l2_format *v4l2_fmt,
+    struct v4l2_buffer *v4l2_buf,
+    VASurfaceID        *surface
+)
+{
+    /* TODO */
+    return VA_STATUS_ERROR_UNKNOWN;
+}
+
+// vaCopySurfaceToBuffer
+VAStatus
+vdpau_CopySurfaceToBuffer(
+    VADriverContextP    ctx,
+    VASurfaceID         surface,
+    unsigned int       *fourcc,
+    unsigned int       *luma_stride,
+    unsigned int       *chroma_u_stride,
+    unsigned int       *chroma_v_stride,
+    unsigned int       *luma_offset,
+    unsigned int       *chroma_u_offset,
+    unsigned int       *chroma_v_offset,
+    void              **buffer
+)
+{
+    /* TODO */
+    return VA_STATUS_ERROR_UNKNOWN;
+}
+#endif
+
+#if VA_CHECK_VERSION(0,31,1)
+// vaLockSurface
+VAStatus
+vdpau_LockSurface(
+    VADriverContextP    ctx,
+    VASurfaceID         surface,
+    unsigned int       *fourcc,
+    unsigned int       *luma_stride,
+    unsigned int       *chroma_u_stride,
+    unsigned int       *chroma_v_stride,
+    unsigned int       *luma_offset,
+    unsigned int       *chroma_u_offset,
+    unsigned int       *chroma_v_offset,
+    unsigned int       *buffer_name,
+    void              **buffer
+)
+{
+    if (fourcc)          *fourcc          = VA_FOURCC('N','V','1','2');
+    if (luma_stride)     *luma_stride     = 0;
+    if (chroma_u_stride) *chroma_u_stride = 0;
+    if (chroma_v_stride) *chroma_v_stride = 0;
+    if (luma_offset)     *luma_offset     = 0;
+    if (chroma_u_offset) *chroma_u_offset = 0;
+    if (chroma_v_offset) *chroma_v_offset = 0;
+    if (buffer_name)     *buffer_name     = 0;
+    if (buffer)          *buffer          = NULL;
+    return VA_STATUS_SUCCESS;
+}
+
+// vaUnlockSurface
+VAStatus
+vdpau_UnlockSurface(
+    VADriverContextP    ctx,
+    VASurfaceID         surface
+)
+{
+    return VA_STATUS_SUCCESS;
+}
+#endif

=== added directory '.pc/03_mark_destroyed_buffers_as_deleted.patch'
=== added directory '.pc/03_mark_destroyed_buffers_as_deleted.patch/src'
=== added file '.pc/03_mark_destroyed_buffers_as_deleted.patch/src/vdpau_decode.c'
--- .pc/03_mark_destroyed_buffers_as_deleted.patch/src/vdpau_decode.c	1970-01-01 00:00:00 +0000
+++ .pc/03_mark_destroyed_buffers_as_deleted.patch/src/vdpau_decode.c	2014-05-06 21:30:45 +0000
@@ -0,0 +1,1264 @@
+/*
+ *  vdpau_decode.c - VDPAU backend for VA-API (decoder)
+ *
+ *  vdpau-video (C) 2009-2011 Splitted-Desktop Systems
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include "sysdeps.h"
+#include "vdpau_decode.h"
+#include "vdpau_driver.h"
+#include "vdpau_buffer.h"
+#include "vdpau_video.h"
+#include "vdpau_dump.h"
+#include "utils.h"
+#include "put_bits.h"
+
+#define DEBUG 1
+#include "debug.h"
+
+
+// Translates VdpDecoderProfile to VdpCodec
+VdpCodec get_VdpCodec(VdpDecoderProfile profile)
+{
+    switch (profile) {
+    case VDP_DECODER_PROFILE_MPEG1:
+        return VDP_CODEC_MPEG1;
+    case VDP_DECODER_PROFILE_MPEG2_SIMPLE:
+    case VDP_DECODER_PROFILE_MPEG2_MAIN:
+        return VDP_CODEC_MPEG2;
+#if USE_VDPAU_MPEG4
+    case VDP_DECODER_PROFILE_MPEG4_PART2_SP:
+    case VDP_DECODER_PROFILE_MPEG4_PART2_ASP:
+    case VDP_DECODER_PROFILE_DIVX4_QMOBILE:
+    case VDP_DECODER_PROFILE_DIVX4_MOBILE:
+    case VDP_DECODER_PROFILE_DIVX4_HOME_THEATER:
+    case VDP_DECODER_PROFILE_DIVX4_HD_1080P:
+    case VDP_DECODER_PROFILE_DIVX5_QMOBILE:
+    case VDP_DECODER_PROFILE_DIVX5_MOBILE:
+    case VDP_DECODER_PROFILE_DIVX5_HOME_THEATER:
+    case VDP_DECODER_PROFILE_DIVX5_HD_1080P:
+        return VDP_CODEC_MPEG4;
+#endif
+    case VDP_DECODER_PROFILE_H264_BASELINE:
+    case VDP_DECODER_PROFILE_H264_MAIN:
+    case VDP_DECODER_PROFILE_H264_HIGH:
+        return VDP_CODEC_H264;
+    case VDP_DECODER_PROFILE_VC1_SIMPLE:
+    case VDP_DECODER_PROFILE_VC1_MAIN:
+    case VDP_DECODER_PROFILE_VC1_ADVANCED:
+        return VDP_CODEC_VC1;
+    }
+    return 0;
+}
+
+// Translates VAProfile to VdpDecoderProfile
+VdpDecoderProfile get_VdpDecoderProfile(VAProfile profile)
+{
+    switch (profile) {
+    case VAProfileMPEG2Simple:  return VDP_DECODER_PROFILE_MPEG2_SIMPLE;
+    case VAProfileMPEG2Main:    return VDP_DECODER_PROFILE_MPEG2_MAIN;
+#if USE_VDPAU_MPEG4
+    case VAProfileMPEG4Simple:  return VDP_DECODER_PROFILE_MPEG4_PART2_SP;
+    case VAProfileMPEG4AdvancedSimple: return VDP_DECODER_PROFILE_MPEG4_PART2_ASP;
+#endif
+    case VAProfileH264Baseline: return VDP_DECODER_PROFILE_H264_BASELINE;
+    case VAProfileH264Main:     return VDP_DECODER_PROFILE_H264_MAIN;
+    case VAProfileH264High:     return VDP_DECODER_PROFILE_H264_HIGH;
+    case VAProfileVC1Simple:    return VDP_DECODER_PROFILE_VC1_SIMPLE;
+    case VAProfileVC1Main:      return VDP_DECODER_PROFILE_VC1_MAIN;
+    case VAProfileVC1Advanced:  return VDP_DECODER_PROFILE_VC1_ADVANCED;
+    default:                    break;
+    }
+    return (VdpDecoderProfile)-1;
+}
+
+// Checks whether the VDPAU implementation supports the specified profile
+static inline VdpBool
+is_supported_profile(
+    vdpau_driver_data_t *driver_data,
+    VdpDecoderProfile    profile
+)
+{
+    VdpBool is_supported = VDP_FALSE;
+    VdpStatus vdp_status;
+    uint32_t max_level, max_references, max_width, max_height;
+
+    if (profile == (VdpDecoderProfile)-1)
+        return VDP_FALSE;
+
+    vdp_status = vdpau_decoder_query_capabilities(
+        driver_data,
+        driver_data->vdp_device,
+        profile,
+        &is_supported,
+        &max_level,
+        &max_references,
+        &max_width,
+        &max_height
+    );
+    return (VDPAU_CHECK_STATUS(vdp_status, "VdpDecoderQueryCapabilities()") &&
+            is_supported);
+}
+
+// Checks decoder for profile/entrypoint is available
+VAStatus
+check_decoder(
+    vdpau_driver_data_t *driver_data,
+    VAProfile            profile,
+    VAEntrypoint         entrypoint
+)
+{
+    if (!is_supported_profile(driver_data, get_VdpDecoderProfile(profile)))
+        return VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
+
+    /* VDPAU only supports VLD */
+    if (entrypoint != VAEntrypointVLD)
+        return VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+
+    return VA_STATUS_SUCCESS;
+}
+
+// Computes value for VdpDecoderCreate()::max_references parameter
+static int
+get_max_ref_frames(
+    VdpDecoderProfile profile,
+    unsigned int      width,
+    unsigned int      height
+)
+{
+    int max_ref_frames = 2;
+
+    switch (profile) {
+    case VDP_DECODER_PROFILE_H264_MAIN:
+    case VDP_DECODER_PROFILE_H264_HIGH:
+    {
+        /* level 4.1 limits */
+        unsigned int aligned_width  = (width + 15) & -16;
+        unsigned int aligned_height = (height + 15) & -16;
+        unsigned int surface_size   = (aligned_width * aligned_height * 3) / 2;
+        if ((max_ref_frames = (12 * 1024 * 1024) / surface_size) > 16)
+            max_ref_frames = 16;
+        break;
+    }
+    }
+    return max_ref_frames;
+}
+
+// Returns the maximum number of reference frames of a decode session
+static inline int get_num_ref_frames(object_context_p obj_context)
+{
+    if (obj_context->vdp_codec == VDP_CODEC_H264)
+        return obj_context->vdp_picture_info.h264.num_ref_frames;
+    return 2;
+}
+
+// Ensure VDPAU decoder is created for the specified number of reference frames
+static VdpStatus
+ensure_decoder_with_max_refs(
+    vdpau_driver_data_t *driver_data,
+    object_context_p     obj_context,
+    int                  max_ref_frames
+)
+{
+    VdpStatus vdp_status;
+
+    if (max_ref_frames < 0)
+        max_ref_frames =
+            get_max_ref_frames(obj_context->vdp_profile,
+                               obj_context->picture_width,
+                               obj_context->picture_height);
+
+    if (obj_context->vdp_decoder == VDP_INVALID_HANDLE ||
+        obj_context->max_ref_frames < max_ref_frames) {
+        obj_context->max_ref_frames = max_ref_frames;
+
+        if (obj_context->vdp_decoder != VDP_INVALID_HANDLE) {
+            vdpau_decoder_destroy(driver_data, obj_context->vdp_decoder);
+            obj_context->vdp_decoder = VDP_INVALID_HANDLE;
+        }
+
+        vdp_status = vdpau_decoder_create(
+            driver_data,
+            driver_data->vdp_device,
+            obj_context->vdp_profile,
+            obj_context->picture_width,
+            obj_context->picture_height,
+            max_ref_frames,
+            &obj_context->vdp_decoder
+        );
+        if (!VDPAU_CHECK_STATUS(vdp_status, "VdpDecoderCreate()"))
+            return vdp_status;
+    }
+    return VDP_STATUS_OK;
+}
+
+// Lazy allocate (generated) slice data buffer. Buffer lives until vaDestroyContext()
+static uint8_t *
+alloc_gen_slice_data(object_context_p obj_context, unsigned int size)
+{
+    uint8_t *gen_slice_data = obj_context->gen_slice_data;
+
+    if (obj_context->gen_slice_data_size + size > obj_context->gen_slice_data_size_max) {
+        obj_context->gen_slice_data_size_max += size;
+        gen_slice_data = realloc(obj_context->gen_slice_data,
+                                 obj_context->gen_slice_data_size_max);
+        if (!gen_slice_data)
+            return NULL;
+        obj_context->gen_slice_data = gen_slice_data;
+    }
+    gen_slice_data += obj_context->gen_slice_data_size;
+    obj_context->gen_slice_data_size += size;
+    return gen_slice_data;
+}
+
+// Lazy allocate VdpBitstreamBuffer. Buffer lives until vaDestroyContext()
+static VdpBitstreamBuffer *
+alloc_VdpBitstreamBuffer(object_context_p obj_context)
+{
+    VdpBitstreamBuffer *vdp_bitstream_buffers;
+
+    vdp_bitstream_buffers = realloc_buffer(
+        &obj_context->vdp_bitstream_buffers,
+        &obj_context->vdp_bitstream_buffers_count_max,
+        1 + obj_context->vdp_bitstream_buffers_count,
+        sizeof(*obj_context->vdp_bitstream_buffers)
+    );
+    if (!vdp_bitstream_buffers)
+        return NULL;
+
+    return &vdp_bitstream_buffers[obj_context->vdp_bitstream_buffers_count++];
+}
+
+// Append VASliceDataBuffer hunk into VDPAU buffer
+static int
+append_VdpBitstreamBuffer(
+    object_context_p obj_context,
+    const uint8_t   *buffer,
+    uint32_t         buffer_size
+)
+{
+    VdpBitstreamBuffer *bitstream_buffer;
+
+    bitstream_buffer = alloc_VdpBitstreamBuffer(obj_context);
+    if (!bitstream_buffer)
+        return -1;
+
+    bitstream_buffer->struct_version  = VDP_BITSTREAM_BUFFER_VERSION;
+    bitstream_buffer->bitstream       = buffer;
+    bitstream_buffer->bitstream_bytes = buffer_size;
+    return 0;
+}
+
+// Initialize VdpReferenceFrameH264 to default values
+static void init_VdpReferenceFrameH264(VdpReferenceFrameH264 *rf)
+{
+    rf->surface             = VDP_INVALID_HANDLE;
+    rf->is_long_term        = VDP_FALSE;
+    rf->top_is_reference    = VDP_FALSE;
+    rf->bottom_is_reference = VDP_FALSE;
+    rf->field_order_cnt[0]  = 0;
+    rf->field_order_cnt[1]  = 0;
+    rf->frame_idx           = 0;
+}
+
+static const uint8_t ff_identity[64] = {
+    0,   1,  2,  3,  4,  5,  6,  7,
+    8,   9, 10, 11, 12, 13, 14, 15,
+    16, 17, 18, 19, 20, 21, 22, 23,
+    24, 25, 26, 27, 28, 29, 30, 31,
+    32, 33, 34, 35, 36, 37, 38, 39,
+    40, 41, 42, 43, 44, 45, 46, 47,
+    48, 49, 50, 51, 52, 53, 54, 55,
+    56, 57, 58, 59, 60, 61, 62, 63
+};
+
+static const uint8_t ff_zigzag_direct[64] = {
+    0,   1,  8, 16,  9,  2,  3, 10,
+    17, 24, 32, 25, 18, 11,  4,  5,
+    12, 19, 26, 33, 40, 48, 41, 34,
+    27, 20, 13,  6,  7, 14, 21, 28,
+    35, 42, 49, 56, 57, 50, 43, 36,
+    29, 22, 15, 23, 30, 37, 44, 51,
+    58, 59, 52, 45, 38, 31, 39, 46,
+    53, 60, 61, 54, 47, 55, 62, 63
+};
+
+static const uint8_t ff_mpeg1_default_intra_matrix[64] = {
+     8, 16, 19, 22, 26, 27, 29, 34,
+    16, 16, 22, 24, 27, 29, 34, 37,
+    19, 22, 26, 27, 29, 34, 34, 38,
+    22, 22, 26, 27, 29, 34, 37, 40,
+    22, 26, 27, 29, 32, 35, 40, 48,
+    26, 27, 29, 32, 35, 40, 48, 58,
+    26, 27, 29, 34, 38, 46, 56, 69,
+    27, 29, 35, 38, 46, 56, 69, 83
+};
+
+static const uint8_t ff_mpeg1_default_non_intra_matrix[64] = {
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16
+};
+
+static const uint8_t ff_mpeg4_default_intra_matrix[64] = {
+     8, 17, 18, 19, 21, 23, 25, 27,
+    17, 18, 19, 21, 23, 25, 27, 28,
+    20, 21, 22, 23, 24, 26, 28, 30,
+    21, 22, 23, 24, 26, 28, 30, 32,
+    22, 23, 24, 26, 28, 30, 32, 35,
+    23, 24, 26, 28, 30, 32, 35, 38,
+    25, 26, 28, 30, 32, 35, 38, 41,
+    27, 28, 30, 32, 35, 38, 41, 45,
+};
+
+static const uint8_t ff_mpeg4_default_non_intra_matrix[64] = {
+    16, 17, 18, 19, 20, 21, 22, 23,
+    17, 18, 19, 20, 21, 22, 23, 24,
+    18, 19, 20, 21, 22, 23, 24, 25,
+    19, 20, 21, 22, 23, 24, 26, 27,
+    20, 21, 22, 23, 25, 26, 27, 28,
+    21, 22, 23, 24, 26, 27, 28, 30,
+    22, 23, 24, 26, 27, 28, 30, 31,
+    23, 24, 25, 27, 28, 30, 31, 33,
+};
+
+// Compute integer log2
+static inline int ilog2(uint32_t v)
+{
+    /* From <http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog> */
+    uint32_t r, shift;
+    r     = (v > 0xffff) << 4; v >>= r;
+    shift = (v > 0xff  ) << 3; v >>= shift; r |= shift;
+    shift = (v > 0xf   ) << 2; v >>= shift; r |= shift;
+    shift = (v > 0x3   ) << 1; v >>= shift; r |= shift;
+    return r | (v >> 1);
+}
+
+// Translate VASurfaceID
+static int
+translate_VASurfaceID(
+    vdpau_driver_data_t *driver_data,
+    VASurfaceID          va_surface,
+    VdpVideoSurface     *vdp_surface
+)
+{
+    object_surface_p obj_surface;
+
+    if (va_surface == VA_INVALID_SURFACE) {
+        *vdp_surface = VDP_INVALID_HANDLE;
+        return 1;
+    }
+
+    obj_surface = VDPAU_SURFACE(va_surface);
+    if (!obj_surface)
+        return 0;
+
+    *vdp_surface = obj_surface->vdp_surface;
+    return 1;
+}
+
+// Translate VAPictureH264
+static int
+translate_VAPictureH264(
+    vdpau_driver_data_t   *driver_data,
+    const VAPictureH264   *va_pic,
+    VdpReferenceFrameH264 *rf
+)
+{
+    // Handle invalid surfaces specifically
+    if (va_pic->picture_id == VA_INVALID_SURFACE) {
+        init_VdpReferenceFrameH264(rf);
+        return 1;
+    }
+
+    if (!translate_VASurfaceID(driver_data, va_pic->picture_id, &rf->surface))
+        return 0;
+    rf->is_long_term            = (va_pic->flags & VA_PICTURE_H264_LONG_TERM_REFERENCE) != 0;
+    if ((va_pic->flags & (VA_PICTURE_H264_TOP_FIELD|VA_PICTURE_H264_BOTTOM_FIELD)) == 0) {
+        rf->top_is_reference    = VDP_TRUE;
+        rf->bottom_is_reference = VDP_TRUE;
+    }
+    else {
+        rf->top_is_reference    = (va_pic->flags & VA_PICTURE_H264_TOP_FIELD) != 0;
+        rf->bottom_is_reference = (va_pic->flags & VA_PICTURE_H264_BOTTOM_FIELD) != 0;
+    }
+    rf->field_order_cnt[0]      = va_pic->TopFieldOrderCnt;
+    rf->field_order_cnt[1]      = va_pic->BottomFieldOrderCnt;
+    rf->frame_idx               = va_pic->frame_idx;
+    return 1;
+}
+
+// Translate no buffer
+static int
+translate_nothing(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    return 1;
+}
+
+// Translate VASliceDataBuffer
+static int
+translate_VASliceDataBuffer(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    if (obj_context->vdp_codec == VDP_CODEC_H264) {
+        /* Check we have the start code */
+        /* XXX: check for other codecs too? */
+        /* XXX: this assumes we get SliceParams before SliceData */
+        static const uint8_t start_code_prefix[3] = { 0x00, 0x00, 0x01 };
+        VASliceParameterBufferH264 * const slice_params = obj_context->last_slice_params;
+        unsigned int i;
+        for (i = 0; i < obj_context->last_slice_params_count; i++) {
+            VASliceParameterBufferH264 * const slice_param = &slice_params[i];
+            uint8_t *buf = (uint8_t *)obj_buffer->buffer_data + slice_param->slice_data_offset;
+            if (memcmp(buf, start_code_prefix, sizeof(start_code_prefix)) != 0) {
+                if (append_VdpBitstreamBuffer(obj_context,
+                                              start_code_prefix,
+                                              sizeof(start_code_prefix)) < 0)
+                    return 0;
+            }
+            if (append_VdpBitstreamBuffer(obj_context,
+                                          buf,
+                                          slice_param->slice_data_size) < 0)
+                return 0;
+        }
+        return 1;
+    }
+
+#if USE_VDPAU_MPEG4
+    if (obj_context->vdp_codec == VDP_CODEC_MPEG4 &&
+        obj_context->vdp_bitstream_buffers_count == 0) {
+        PutBitContext pb;
+        uint8_t slice_header_buffer[32];
+        uint8_t *slice_header;
+        int slice_header_size;
+        const uint8_t *slice_data = obj_buffer->buffer_data;
+        uint32_t slice_data_size = obj_buffer->buffer_size;
+        VAPictureParameterBufferMPEG4 * const pic_param = obj_context->last_pic_param;
+        VASliceParameterBufferMPEG4 * const slice_param = obj_context->last_slice_params;
+
+        int time_incr = 1 + ilog2(pic_param->vop_time_increment_resolution - 1);
+        if (time_incr < 1)
+            time_incr = 1;
+
+        static const uint16_t VOP_STARTCODE = 0x01b6;
+        enum {
+            VOP_I_TYPE = 0,
+            VOP_P_TYPE,
+            VOP_B_TYPE,
+            VOP_S_TYPE
+        };
+
+        /* XXX: this is a hack to compute the length of
+           modulo_time_base "1" sequence. We probably should be
+           reconstructing through an extra VOP field in VA-API? */
+        int nbits = (32 +                               /* VOP start code       */
+                     2 +                                /* vop_coding_type      */
+                     1 +                                /* modulo_time_base "0" */
+                     1 +                                /* marker_bit           */
+                     time_incr +                        /* vop_time_increment   */
+                     1 +                                /* marker_bit           */
+                     1 +                                /* vop_coded            */
+                     (pic_param->vop_fields.bits.vop_coding_type == VOP_P_TYPE ? 1 : 0) +
+                     3 +                                /* intra_dc_vlc_thr     */
+                     (pic_param->vol_fields.bits.interlaced ? 2 : 0) +
+                     5 +                                /* vop_quant            */
+                     (pic_param->vop_fields.bits.vop_coding_type != VOP_I_TYPE ? 3 : 0) +
+                     (pic_param->vop_fields.bits.vop_coding_type == VOP_B_TYPE ? 3 : 0));
+        if ((nbits = slice_param->macroblock_offset - (nbits % 8)) < 0)
+            nbits += 8;
+
+        /* Reconstruct the VOP header */
+        init_put_bits(&pb, slice_header_buffer, sizeof(slice_header_buffer));
+        put_bits(&pb, 16, 0);                   /* vop header */
+        put_bits(&pb, 16, VOP_STARTCODE);       /* vop header */
+        put_bits(&pb, 2, pic_param->vop_fields.bits.vop_coding_type);
+        while (nbits-- > 0)
+            put_bits(&pb, 1, 1);                /* modulo_time_base "1" */
+        put_bits(&pb, 1, 0);                    /* modulo_time_base "0" */
+        put_bits(&pb, 1, 1);                    /* marker */
+        put_bits(&pb, time_incr, 0);            /* time increment */
+        put_bits(&pb, 1, 1);                    /* marker */
+        put_bits(&pb, 1, 1);                    /* vop coded */
+        if (pic_param->vop_fields.bits.vop_coding_type == VOP_P_TYPE)
+            put_bits(&pb, 1, pic_param->vop_fields.bits.vop_rounding_type);
+        put_bits(&pb, 3, pic_param->vop_fields.bits.intra_dc_vlc_thr);
+        if (pic_param->vol_fields.bits.interlaced) {
+            put_bits(&pb, 1, pic_param->vop_fields.bits.top_field_first);
+            put_bits(&pb, 1, pic_param->vop_fields.bits.alternate_vertical_scan_flag);
+        }
+        put_bits(&pb, 5, slice_param->quant_scale);
+        if (pic_param->vop_fields.bits.vop_coding_type != VOP_I_TYPE)
+            put_bits(&pb, 3, pic_param->vop_fcode_forward);
+        if (pic_param->vop_fields.bits.vop_coding_type == VOP_B_TYPE)
+            put_bits(&pb, 3, pic_param->vop_fcode_backward);
+
+        /* Merge in bits from the first byte of the slice */
+        ASSERT((put_bits_count(&pb) % 8) == slice_param->macroblock_offset);
+        if ((put_bits_count(&pb) % 8) != slice_param->macroblock_offset)
+            return 0;
+        const int r = 8 - (put_bits_count(&pb) % 8);
+        if (r > 0)
+            put_bits(&pb, r, slice_data[0] & ((1U << r) - 1));
+        flush_put_bits(&pb);
+
+        ASSERT((put_bits_count(&pb) % 8) == 0);
+        slice_header_size = put_bits_count(&pb) / 8;
+        ASSERT(slice_header_size <= sizeof(slice_header_buffer));
+        slice_header = alloc_gen_slice_data(obj_context, slice_header_size);
+        if (!slice_header)
+            return 0;
+        memcpy(slice_header, slice_header_buffer, slice_header_size);
+        if (append_VdpBitstreamBuffer(obj_context, slice_header, slice_header_size) < 0)
+            return 0;
+        if (append_VdpBitstreamBuffer(obj_context, slice_data + 1, slice_data_size - 1) < 0)
+            return 0;
+        return 1;
+    }
+#endif
+
+    if (append_VdpBitstreamBuffer(obj_context,
+                                  obj_buffer->buffer_data,
+                                  obj_buffer->buffer_size) < 0)
+        return 0;
+    return 1;
+}
+
+// Translate VAPictureParameterBufferMPEG2
+static int
+translate_VAPictureParameterBufferMPEG2(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    VdpPictureInfoMPEG1Or2 * const pic_info = &obj_context->vdp_picture_info.mpeg2;
+    VAPictureParameterBufferMPEG2 * const pic_param = obj_buffer->buffer_data;
+
+    if (!translate_VASurfaceID(driver_data,
+                               pic_param->forward_reference_picture,
+                               &pic_info->forward_reference))
+        return 0;
+
+    if (!translate_VASurfaceID(driver_data,
+                               pic_param->backward_reference_picture,
+                               &pic_info->backward_reference))
+        return 0;
+
+    pic_info->picture_structure          = pic_param->picture_coding_extension.bits.picture_structure;
+    pic_info->picture_coding_type        = pic_param->picture_coding_type;
+    pic_info->intra_dc_precision         = pic_param->picture_coding_extension.bits.intra_dc_precision;
+    pic_info->frame_pred_frame_dct       = pic_param->picture_coding_extension.bits.frame_pred_frame_dct;
+    pic_info->concealment_motion_vectors = pic_param->picture_coding_extension.bits.concealment_motion_vectors;
+    pic_info->intra_vlc_format           = pic_param->picture_coding_extension.bits.intra_vlc_format;
+    pic_info->alternate_scan             = pic_param->picture_coding_extension.bits.alternate_scan;
+    pic_info->q_scale_type               = pic_param->picture_coding_extension.bits.q_scale_type;
+    pic_info->top_field_first            = pic_param->picture_coding_extension.bits.top_field_first;
+    pic_info->full_pel_forward_vector    = 0;
+    pic_info->full_pel_backward_vector   = 0;
+    pic_info->f_code[0][0]               = (pic_param->f_code >> 12) & 0xf;
+    pic_info->f_code[0][1]               = (pic_param->f_code >>  8) & 0xf;
+    pic_info->f_code[1][0]               = (pic_param->f_code >>  4) & 0xf;
+    pic_info->f_code[1][1]               = pic_param->f_code & 0xf;
+    return 1;
+}
+
+// Translate VAIQMatrixBufferMPEG2
+static int
+translate_VAIQMatrixBufferMPEG2(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    VdpPictureInfoMPEG1Or2 * const pic_info = &obj_context->vdp_picture_info.mpeg2;
+    VAIQMatrixBufferMPEG2 * const iq_matrix = obj_buffer->buffer_data;
+    const uint8_t *intra_matrix;
+    const uint8_t *intra_matrix_lookup;
+    const uint8_t *inter_matrix;
+    const uint8_t *inter_matrix_lookup;
+    int i;
+
+    if (iq_matrix->load_intra_quantiser_matrix) {
+        intra_matrix = iq_matrix->intra_quantiser_matrix;
+        intra_matrix_lookup = ff_zigzag_direct;
+    }
+    else {
+        intra_matrix = ff_mpeg1_default_intra_matrix;
+        intra_matrix_lookup = ff_identity;
+    }
+
+    if (iq_matrix->load_non_intra_quantiser_matrix) {
+        inter_matrix = iq_matrix->non_intra_quantiser_matrix;
+        inter_matrix_lookup = ff_zigzag_direct;
+    }
+    else {
+        inter_matrix = ff_mpeg1_default_non_intra_matrix;
+        inter_matrix_lookup = ff_identity;
+    }
+
+    for (i = 0; i < 64; i++) {
+        pic_info->intra_quantizer_matrix[intra_matrix_lookup[i]] =
+            intra_matrix[i];
+        pic_info->non_intra_quantizer_matrix[inter_matrix_lookup[i]] =
+            inter_matrix[i];
+    }
+    return 1;
+}
+
+// Translate VASliceParameterBufferMPEG2
+static int
+translate_VASliceParameterBufferMPEG2(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+    )
+{
+    VdpPictureInfoMPEG1Or2 * const pic_info = &obj_context->vdp_picture_info.mpeg2;
+
+    pic_info->slice_count               += obj_buffer->num_elements;
+    obj_context->last_slice_params       = obj_buffer->buffer_data;
+    obj_context->last_slice_params_count = obj_buffer->num_elements;
+    return 1;
+}
+
+#if USE_VDPAU_MPEG4
+// Translate VAPictureParameterBufferMPEG4
+static int
+translate_VAPictureParameterBufferMPEG4(
+    vdpau_driver_data_p driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    VdpPictureInfoMPEG4Part2 * const pic_info = &obj_context->vdp_picture_info.mpeg4;
+    VAPictureParameterBufferMPEG4 * const pic_param = obj_buffer->buffer_data;
+
+    /* XXX: we don't support short-video-header formats */
+    if (pic_param->vol_fields.bits.short_video_header)
+        return 0;
+
+    if (!translate_VASurfaceID(driver_data,
+                               pic_param->forward_reference_picture,
+                               &pic_info->forward_reference))
+        return 0;
+
+    if (!translate_VASurfaceID(driver_data,
+                               pic_param->backward_reference_picture,
+                               &pic_info->backward_reference))
+        return 0;
+
+    if (pic_param->vol_fields.bits.interlaced) {
+        vdpau_information_message("unsupported MPEG-4 video with interlaced "
+                                  "content, please report this video\n");
+        pic_info->trd[0] = 2*pic_param->TRD; /* XXX: + d(0) */
+        pic_info->trb[0] = 2*pic_param->TRB; /* XXX: + d(0) */
+        pic_info->trd[1] = 2*pic_param->TRD; /* XXX: + d(1) */
+        pic_info->trb[1] = 2*pic_param->TRB; /* XXX: + d(1) */
+    }
+    else {
+        pic_info->trd[0] = pic_param->TRD;
+        pic_info->trb[0] = pic_param->TRB;
+        pic_info->trd[1] = 0;
+        pic_info->trb[1] = 0;
+    }
+
+    pic_info->vop_time_increment_resolution     = pic_param->vop_time_increment_resolution;
+    pic_info->vop_coding_type                   = pic_param->vop_fields.bits.vop_coding_type;
+    pic_info->vop_fcode_forward                 = pic_param->vop_fcode_forward;
+    pic_info->vop_fcode_backward                = pic_param->vop_fcode_backward;
+    pic_info->resync_marker_disable             = pic_param->vol_fields.bits.resync_marker_disable;
+    pic_info->interlaced                        = pic_param->vol_fields.bits.interlaced;
+    pic_info->quant_type                        = pic_param->vol_fields.bits.quant_type;
+    pic_info->quarter_sample                    = pic_param->vol_fields.bits.quarter_sample;
+    pic_info->short_video_header                = pic_param->vol_fields.bits.short_video_header;
+    pic_info->rounding_control                  = pic_param->vop_fields.bits.vop_rounding_type;
+    pic_info->alternate_vertical_scan_flag      = pic_param->vop_fields.bits.alternate_vertical_scan_flag;
+    pic_info->top_field_first                   = pic_param->vop_fields.bits.top_field_first;
+
+    obj_context->last_pic_param                 = obj_buffer->buffer_data;
+    return 1;
+}
+
+// Translate VAIQMatrixBufferMPEG4
+static int
+translate_VAIQMatrixBufferMPEG4(
+    vdpau_driver_data_p driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    VdpPictureInfoMPEG4Part2 * const pic_info = &obj_context->vdp_picture_info.mpeg4;
+    VAIQMatrixBufferMPEG4 * const iq_matrix = obj_buffer->buffer_data;
+    const uint8_t *intra_matrix;
+    const uint8_t *intra_matrix_lookup;
+    const uint8_t *inter_matrix;
+    const uint8_t *inter_matrix_lookup;
+    int i;
+
+    if (iq_matrix->load_intra_quant_mat) {
+        intra_matrix = iq_matrix->intra_quant_mat;
+        intra_matrix_lookup = ff_zigzag_direct;
+    }
+    else {
+        intra_matrix = ff_mpeg4_default_intra_matrix;
+        intra_matrix_lookup = ff_identity;
+    }
+
+    if (iq_matrix->load_non_intra_quant_mat) {
+        inter_matrix = iq_matrix->non_intra_quant_mat;
+        inter_matrix_lookup = ff_zigzag_direct;
+    }
+    else {
+        inter_matrix = ff_mpeg4_default_non_intra_matrix;
+        inter_matrix_lookup = ff_identity;
+    }
+
+    for (i = 0; i < 64; i++) {
+        pic_info->intra_quantizer_matrix[intra_matrix_lookup[i]] =
+            intra_matrix[i];
+        pic_info->non_intra_quantizer_matrix[inter_matrix_lookup[i]] =
+            inter_matrix[i];
+    }
+    return 1;
+}
+
+// Translate VASliceParameterBufferMPEG4
+static int
+translate_VASliceParameterBufferMPEG4(
+    vdpau_driver_data_p driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+    )
+{
+    obj_context->last_slice_params       = obj_buffer->buffer_data;
+    obj_context->last_slice_params_count = obj_buffer->num_elements;
+    return 1;
+}
+#endif
+
+// Translate VAPictureParameterBufferH264
+static int
+translate_VAPictureParameterBufferH264(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    VdpPictureInfoH264 * const pic_info = &obj_context->vdp_picture_info.h264;
+    VAPictureParameterBufferH264 * const pic_param = obj_buffer->buffer_data;
+    VAPictureH264 * const CurrPic = &pic_param->CurrPic;
+    unsigned int i;
+
+    pic_info->field_order_cnt[0]                = CurrPic->TopFieldOrderCnt;
+    pic_info->field_order_cnt[1]                = CurrPic->BottomFieldOrderCnt;
+    pic_info->is_reference                      = pic_param->pic_fields.bits.reference_pic_flag;
+
+    pic_info->frame_num                         = pic_param->frame_num;
+    pic_info->field_pic_flag                    = pic_param->pic_fields.bits.field_pic_flag;
+    pic_info->bottom_field_flag                 = pic_param->pic_fields.bits.field_pic_flag && (CurrPic->flags & VA_PICTURE_H264_BOTTOM_FIELD) != 0;
+    pic_info->num_ref_frames                    = pic_param->num_ref_frames;
+    pic_info->mb_adaptive_frame_field_flag      = pic_param->seq_fields.bits.mb_adaptive_frame_field_flag && !pic_info->field_pic_flag;
+    pic_info->constrained_intra_pred_flag       = pic_param->pic_fields.bits.constrained_intra_pred_flag;
+    pic_info->weighted_pred_flag                = pic_param->pic_fields.bits.weighted_pred_flag;
+    pic_info->weighted_bipred_idc               = pic_param->pic_fields.bits.weighted_bipred_idc;
+    pic_info->frame_mbs_only_flag               = pic_param->seq_fields.bits.frame_mbs_only_flag;
+    pic_info->transform_8x8_mode_flag           = pic_param->pic_fields.bits.transform_8x8_mode_flag;
+    pic_info->chroma_qp_index_offset            = pic_param->chroma_qp_index_offset;
+    pic_info->second_chroma_qp_index_offset     = pic_param->second_chroma_qp_index_offset;
+    pic_info->pic_init_qp_minus26               = pic_param->pic_init_qp_minus26;
+    pic_info->log2_max_frame_num_minus4         = pic_param->seq_fields.bits.log2_max_frame_num_minus4;
+    pic_info->pic_order_cnt_type                = pic_param->seq_fields.bits.pic_order_cnt_type;
+    pic_info->log2_max_pic_order_cnt_lsb_minus4 = pic_param->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4;
+    pic_info->delta_pic_order_always_zero_flag  = pic_param->seq_fields.bits.delta_pic_order_always_zero_flag;
+    pic_info->direct_8x8_inference_flag         = pic_param->seq_fields.bits.direct_8x8_inference_flag;
+    pic_info->entropy_coding_mode_flag          = pic_param->pic_fields.bits.entropy_coding_mode_flag;
+    pic_info->pic_order_present_flag            = pic_param->pic_fields.bits.pic_order_present_flag;
+    pic_info->deblocking_filter_control_present_flag = pic_param->pic_fields.bits.deblocking_filter_control_present_flag;
+    pic_info->redundant_pic_cnt_present_flag    = pic_param->pic_fields.bits.redundant_pic_cnt_present_flag;
+
+    for (i = 0; i < 16; i++) {
+        if (!translate_VAPictureH264(driver_data,
+                                     &pic_param->ReferenceFrames[i],
+                                     &pic_info->referenceFrames[i]))
+                return 0;
+    }
+    return 1;
+}
+
+// Translate VAIQMatrixBufferH264
+static int
+translate_VAIQMatrixBufferH264(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    VdpPictureInfoH264 * const pic_info = &obj_context->vdp_picture_info.h264;
+    VAIQMatrixBufferH264 * const iq_matrix = obj_buffer->buffer_data;
+    int i, j;
+
+    if (sizeof(pic_info->scaling_lists_4x4) == sizeof(iq_matrix->ScalingList4x4))
+        memcpy(pic_info->scaling_lists_4x4, iq_matrix->ScalingList4x4,
+               sizeof(pic_info->scaling_lists_4x4));
+    else {
+        for (j = 0; j < 6; j++) {
+            for (i = 0; i < 16; i++)
+                pic_info->scaling_lists_4x4[j][i] = iq_matrix->ScalingList4x4[j][i];
+        }
+    }
+
+    if (sizeof(pic_info->scaling_lists_8x8) == sizeof(iq_matrix->ScalingList8x8))
+        memcpy(pic_info->scaling_lists_8x8, iq_matrix->ScalingList8x8,
+               sizeof(pic_info->scaling_lists_8x8));
+    else {
+        for (j = 0; j < 2; j++) {
+            for (i = 0; i < 64; i++)
+                pic_info->scaling_lists_8x8[j][i] = iq_matrix->ScalingList8x8[j][i];
+        }
+    }
+    return 1;
+}
+
+// Translate VASliceParameterBufferH264
+static int
+translate_VASliceParameterBufferH264(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    VdpPictureInfoH264 * const pic_info = &obj_context->vdp_picture_info.h264;
+    VASliceParameterBufferH264 * const slice_params = obj_buffer->buffer_data;
+    VASliceParameterBufferH264 * const slice_param = &slice_params[obj_buffer->num_elements - 1];
+
+    pic_info->slice_count                 += obj_buffer->num_elements;
+    pic_info->num_ref_idx_l0_active_minus1 = slice_param->num_ref_idx_l0_active_minus1;
+    pic_info->num_ref_idx_l1_active_minus1 = slice_param->num_ref_idx_l1_active_minus1;
+    obj_context->last_slice_params         = obj_buffer->buffer_data;
+    obj_context->last_slice_params_count   = obj_buffer->num_elements;
+    return 1;
+}
+
+// Translate VAPictureParameterBufferVC1
+static int
+translate_VAPictureParameterBufferVC1(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    VdpPictureInfoVC1 * const pic_info = &obj_context->vdp_picture_info.vc1;
+    VAPictureParameterBufferVC1 * const pic_param = obj_buffer->buffer_data;
+    int picture_type, major_version, minor_version;
+
+    if (!translate_VASurfaceID(driver_data,
+                               pic_param->forward_reference_picture,
+                               &pic_info->forward_reference))
+        return 0;
+
+    if (!translate_VASurfaceID(driver_data,
+                               pic_param->backward_reference_picture,
+                               &pic_info->backward_reference))
+        return 0;
+
+    switch (pic_param->picture_fields.bits.picture_type) {
+    case 0: picture_type = 0; break; /* I */
+    case 1: picture_type = 1; break; /* P */
+    case 2: picture_type = 3; break; /* B */
+    case 3: picture_type = 4; break; /* BI */
+    case 4: picture_type = 1; break; /* P "skipped" */
+    default: return 0;
+    }
+
+    pic_info->picture_type      = picture_type;
+    pic_info->frame_coding_mode = pic_param->picture_fields.bits.frame_coding_mode;
+    pic_info->postprocflag      = pic_param->post_processing != 0;
+    pic_info->pulldown          = pic_param->sequence_fields.bits.pulldown;
+    pic_info->interlace         = pic_param->sequence_fields.bits.interlace;
+    pic_info->tfcntrflag        = pic_param->sequence_fields.bits.tfcntrflag;
+    pic_info->finterpflag       = pic_param->sequence_fields.bits.finterpflag;
+    pic_info->psf               = pic_param->sequence_fields.bits.psf;
+    pic_info->dquant            = pic_param->pic_quantizer_fields.bits.dquant;
+    pic_info->panscan_flag      = pic_param->entrypoint_fields.bits.panscan_flag;
+    pic_info->refdist_flag      = pic_param->reference_fields.bits.reference_distance_flag;
+    pic_info->quantizer         = pic_param->pic_quantizer_fields.bits.quantizer;
+    pic_info->extended_mv       = pic_param->mv_fields.bits.extended_mv_flag;
+    pic_info->extended_dmv      = pic_param->mv_fields.bits.extended_dmv_flag;
+    pic_info->overlap           = pic_param->sequence_fields.bits.overlap;
+    pic_info->vstransform       = pic_param->transform_fields.bits.variable_sized_transform_flag;
+    pic_info->loopfilter        = pic_param->entrypoint_fields.bits.loopfilter;
+    pic_info->fastuvmc          = pic_param->fast_uvmc_flag;
+    pic_info->range_mapy_flag   = pic_param->range_mapping_fields.bits.luma_flag;
+    pic_info->range_mapy        = pic_param->range_mapping_fields.bits.luma;
+    pic_info->range_mapuv_flag  = pic_param->range_mapping_fields.bits.chroma_flag;
+    pic_info->range_mapuv       = pic_param->range_mapping_fields.bits.chroma;
+    pic_info->multires          = pic_param->sequence_fields.bits.multires;
+    pic_info->syncmarker        = pic_param->sequence_fields.bits.syncmarker;
+    pic_info->rangered          = pic_param->sequence_fields.bits.rangered;
+    if (!vdpau_is_nvidia(driver_data, &major_version, &minor_version) ||
+        (major_version > 180 || minor_version >= 35))
+        pic_info->rangered     |= pic_param->range_reduction_frame << 1;
+    pic_info->maxbframes        = pic_param->sequence_fields.bits.max_b_frames;
+    pic_info->deblockEnable     = pic_param->post_processing != 0; /* XXX: this is NVIDIA's vdpau.c semantics (postprocflag & 1) */
+    pic_info->pquant            = pic_param->pic_quantizer_fields.bits.pic_quantizer_scale;
+    return 1;
+}
+
+// Translate VASliceParameterBufferVC1
+static int
+translate_VASliceParameterBufferVC1(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    VdpPictureInfoVC1 * const pic_info = &obj_context->vdp_picture_info.vc1;
+
+    pic_info->slice_count               += obj_buffer->num_elements;
+    obj_context->last_slice_params       = obj_buffer->buffer_data;
+    obj_context->last_slice_params_count = obj_buffer->num_elements;
+    return 1;
+}
+
+// Translate VA buffer
+typedef int
+(*translate_buffer_func_t)(vdpau_driver_data_t *driver_data,
+                           object_context_p    obj_context,
+                           object_buffer_p     obj_buffer);
+
+typedef struct translate_buffer_info translate_buffer_info_t;
+struct translate_buffer_info {
+    VdpCodec codec;
+    VABufferType type;
+    translate_buffer_func_t func;
+};
+
+static int
+translate_buffer(
+    vdpau_driver_data_t *driver_data,
+    object_context_p    obj_context,
+    object_buffer_p     obj_buffer
+)
+{
+    static const translate_buffer_info_t translate_info[] = {
+#define _(CODEC, TYPE)                                  \
+        { VDP_CODEC_##CODEC, VA##TYPE##BufferType,      \
+          translate_VA##TYPE##Buffer##CODEC }
+        _(MPEG2, PictureParameter),
+        _(MPEG2, IQMatrix),
+        _(MPEG2, SliceParameter),
+#if USE_VDPAU_MPEG4
+        _(MPEG4, PictureParameter),
+        _(MPEG4, IQMatrix),
+        _(MPEG4, SliceParameter),
+#endif
+        _(H264, PictureParameter),
+        _(H264, IQMatrix),
+        _(H264, SliceParameter),
+        _(VC1, PictureParameter),
+        _(VC1, SliceParameter),
+#undef _
+        { VDP_CODEC_VC1, VABitPlaneBufferType, translate_nothing },
+        { 0, VASliceDataBufferType, translate_VASliceDataBuffer },
+        { 0, 0, NULL }
+    };
+    const translate_buffer_info_t *tbip;
+    for (tbip = translate_info; tbip->func != NULL; tbip++) {
+        if (tbip->codec && tbip->codec != obj_context->vdp_codec)
+            continue;
+        if (tbip->type != obj_buffer->type)
+            continue;
+        return tbip->func(driver_data, obj_context, obj_buffer);
+    }
+    D(bug("ERROR: no translate function found for %s%s\n",
+          string_of_VABufferType(obj_buffer->type),
+          obj_context->vdp_codec ? string_of_VdpCodec(obj_context->vdp_codec) : NULL));
+    return 0;
+}
+
+// vaQueryConfigProfiles
+VAStatus
+vdpau_QueryConfigProfiles(
+    VADriverContextP    ctx,
+    VAProfile          *profile_list,
+    int                *num_profiles
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    static const VAProfile va_profiles[] = {
+        VAProfileMPEG2Simple,
+        VAProfileMPEG2Main,
+        VAProfileMPEG4Simple,
+        VAProfileMPEG4AdvancedSimple,
+        VAProfileMPEG4Main,
+        VAProfileH264Baseline,
+        VAProfileH264Main,
+        VAProfileH264High,
+        VAProfileVC1Simple,
+        VAProfileVC1Main,
+        VAProfileVC1Advanced
+    };
+
+    int i, n = 0;
+    for (i = 0; i < ARRAY_ELEMS(va_profiles); i++) {
+        VAProfile profile = va_profiles[i];
+        VdpDecoderProfile vdp_profile = get_VdpDecoderProfile(profile);
+        if (is_supported_profile(driver_data, vdp_profile))
+            profile_list[n++] = profile;
+    }
+
+    /* If the assert fails then VDPAU_MAX_PROFILES needs to be bigger */
+    ASSERT(n <= VDPAU_MAX_PROFILES);
+    if (num_profiles)
+        *num_profiles = n;
+
+    return VA_STATUS_SUCCESS;
+}
+
+// vaQueryConfigEntrypoints
+VAStatus
+vdpau_QueryConfigEntrypoints(
+    VADriverContextP    ctx,
+    VAProfile           profile,
+    VAEntrypoint       *entrypoint_list,
+    int                *num_entrypoints
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    VdpDecoderProfile vdp_profile = get_VdpDecoderProfile(profile);
+    if (!is_supported_profile(driver_data, vdp_profile))
+        return VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
+
+    VAEntrypoint entrypoint;
+    switch (profile) {
+    case VAProfileMPEG2Simple:
+    case VAProfileMPEG2Main:
+        entrypoint = VAEntrypointVLD;
+        break;
+    case VAProfileMPEG4Simple:
+    case VAProfileMPEG4AdvancedSimple:
+    case VAProfileMPEG4Main:
+        entrypoint = VAEntrypointVLD;
+        break;
+    case VAProfileH264Baseline:
+    case VAProfileH264Main:
+    case VAProfileH264High:
+        entrypoint = VAEntrypointVLD;
+        break;
+    case VAProfileVC1Simple:
+    case VAProfileVC1Main:
+    case VAProfileVC1Advanced:
+        entrypoint = VAEntrypointVLD;
+        break;
+    default:
+        entrypoint = 0;
+        break;
+    }
+
+    if (entrypoint_list)
+        *entrypoint_list = entrypoint;
+
+    if (num_entrypoints)
+        *num_entrypoints = entrypoint != 0;
+
+    return VA_STATUS_SUCCESS;
+}
+
+// vaBeginPicture
+VAStatus
+vdpau_BeginPicture(
+    VADriverContextP    ctx,
+    VAContextID         context,
+    VASurfaceID         render_target
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+
+    object_context_p obj_context = VDPAU_CONTEXT(context);
+    if (!obj_context)
+        return VA_STATUS_ERROR_INVALID_CONTEXT;
+
+    object_surface_p obj_surface = VDPAU_SURFACE(render_target);
+    if (!obj_surface)
+        return VA_STATUS_ERROR_INVALID_SURFACE;
+
+    obj_surface->va_surface_status           = VASurfaceRendering;
+    obj_context->last_pic_param              = NULL;
+    obj_context->last_slice_params           = NULL;
+    obj_context->last_slice_params_count     = 0;
+    obj_context->current_render_target       = obj_surface->base.id;
+    obj_context->gen_slice_data_size         = 0;
+    obj_context->vdp_bitstream_buffers_count = 0;
+
+    switch (obj_context->vdp_codec) {
+    case VDP_CODEC_MPEG1:
+    case VDP_CODEC_MPEG2:
+        obj_context->vdp_picture_info.mpeg2.slice_count = 0;
+        break;
+    case VDP_CODEC_MPEG4:
+        break;
+    case VDP_CODEC_H264:
+        obj_context->vdp_picture_info.h264.slice_count = 0;
+        break;
+    case VDP_CODEC_VC1:
+        obj_context->vdp_picture_info.vc1.slice_count = 0;
+        break;
+    default:
+        return VA_STATUS_ERROR_UNKNOWN;
+    }
+
+    destroy_dead_va_buffers(driver_data, obj_context);
+    return VA_STATUS_SUCCESS;
+}
+
+// vaRenderPicture
+VAStatus
+vdpau_RenderPicture(
+    VADriverContextP    ctx,
+    VAContextID         context,
+    VABufferID         *buffers,
+    int                 num_buffers
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+    int i;
+
+    object_context_p obj_context = VDPAU_CONTEXT(context);
+    if (!obj_context)
+        return VA_STATUS_ERROR_INVALID_CONTEXT;
+
+    object_surface_p obj_surface = VDPAU_SURFACE(obj_context->current_render_target);
+    if (!obj_surface)
+        return VA_STATUS_ERROR_INVALID_SURFACE;
+
+    /* Verify that we got valid buffer references */
+    for (i = 0; i < num_buffers; i++) {
+        object_buffer_p obj_buffer = VDPAU_BUFFER(buffers[i]);
+        if (!obj_buffer)
+            return VA_STATUS_ERROR_INVALID_BUFFER;
+    }
+
+    /* Translate buffers */
+    for (i = 0; i < num_buffers; i++) {
+        object_buffer_p obj_buffer = VDPAU_BUFFER(buffers[i]);
+        if (!translate_buffer(driver_data, obj_context, obj_buffer))
+            return VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE;
+        /* Release any buffer that is not VASliceDataBuffer */
+        /* VASliceParameterBuffer is also needed to check for start_codes */
+        switch (obj_buffer->type) {
+        case VASliceParameterBufferType:
+        case VASliceDataBufferType:
+            schedule_destroy_va_buffer(driver_data, obj_buffer);
+            break;
+        case VAPictureParameterBufferType:
+            /* Preserve VAPictureParameterBufferMPEG4 */
+            if (obj_context->vdp_codec == VDP_CODEC_MPEG4) {
+                schedule_destroy_va_buffer(driver_data, obj_buffer);
+                break;
+            }
+            /* fall-through */
+        default:
+            destroy_va_buffer(driver_data, obj_buffer);
+            break;
+        }
+    }
+
+    return VA_STATUS_SUCCESS;
+}
+
+// vaEndPicture
+VAStatus
+vdpau_EndPicture(
+    VADriverContextP    ctx,
+    VAContextID         context
+)
+{
+    VDPAU_DRIVER_DATA_INIT;
+    unsigned int i;
+
+    object_context_p obj_context = VDPAU_CONTEXT(context);
+    if (!obj_context)
+        return VA_STATUS_ERROR_INVALID_CONTEXT;
+
+    object_surface_p obj_surface = VDPAU_SURFACE(obj_context->current_render_target);
+    if (!obj_surface)
+        return VA_STATUS_ERROR_INVALID_SURFACE;
+
+    if (trace_enabled()) {
+        switch (obj_context->vdp_codec) {
+        case VDP_CODEC_MPEG1:
+        case VDP_CODEC_MPEG2:
+            dump_VdpPictureInfoMPEG1Or2(&obj_context->vdp_picture_info.mpeg2);
+            break;
+#if HAVE_VDPAU_MPEG4
+        case VDP_CODEC_MPEG4:
+            dump_VdpPictureInfoMPEG4Part2(&obj_context->vdp_picture_info.mpeg4);
+            break;
+#endif
+        case VDP_CODEC_H264:
+            dump_VdpPictureInfoH264(&obj_context->vdp_picture_info.h264);
+            break;
+        case VDP_CODEC_VC1:
+            dump_VdpPictureInfoVC1(&obj_context->vdp_picture_info.vc1);
+            break;
+        default:
+            break;
+        }
+        for (i = 0; i < obj_context->vdp_bitstream_buffers_count; i++)
+            dump_VdpBitstreamBuffer(&obj_context->vdp_bitstream_buffers[i]);
+    }
+
+    VAStatus va_status;
+    VdpStatus vdp_status;
+    vdp_status = ensure_decoder_with_max_refs(
+        driver_data,
+        obj_context,
+        get_num_ref_frames(obj_context)
+    );
+    if (vdp_status == VDP_STATUS_OK)
+        vdp_status = vdpau_decoder_render(
+            driver_data,
+            obj_context->vdp_decoder,
+            obj_surface->vdp_surface,
+            (VdpPictureInfo)&obj_context->vdp_picture_info,
+            obj_context->vdp_bitstream_buffers_count,
+            obj_context->vdp_bitstream_buffers
+        );
+    va_status = vdpau_get_VAStatus(vdp_status);
+
+    /* XXX: assume we are done with rendering right away */
+    obj_context->current_render_target = VA_INVALID_SURFACE;
+
+    /* Release pending buffers */
+    destroy_dead_va_buffers(driver_data, obj_context);
+
+    return va_status;
+}

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2013-04-13 09:39:54 +0000
+++ .pc/applied-patches	2014-05-06 21:30:45 +0000
@@ -1,2 +1,5 @@
 autoreconf.patch
 GL_VER_1_3.patch
+01_dont_clear_va_buffer_too_early.patch
+02_purge_va_buffers_on_context_destroy_or_new_picture_decode_seq.patch
+03_mark_destroyed_buffers_as_deleted.patch

=== modified file 'debian/changelog'
--- debian/changelog	2013-04-13 09:39:54 +0000
+++ debian/changelog	2014-05-06 21:30:45 +0000
@@ -1,3 +1,10 @@
+vdpau-video (0.7.3-2ubuntu2) UNRELEASED; urgency=medium
+
+  * Added patch-set from upstream to fix crash when using
+    gstreamer-vaapi (LP: #1222790)
+
+ -- Marco Trevisan (Treviño) <[e-mail]>  Tue, 06 May 2014 23:15:53 +0200
+
 vdpau-video (0.7.3-2ubuntu1) raring; urgency=low
 
   * Added patch from Gentoo bug #438180 (backported from upstream

=== added file 'debian/patches/01_dont_clear_va_buffer_too_early.patch'
--- debian/patches/01_dont_clear_va_buffer_too_early.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/01_dont_clear_va_buffer_too_early.patch	2014-05-06 21:30:45 +0000
@@ -0,0 +1,56 @@
+Description: Don't clear VA buffers too early.
+ vaRenderPicture() is supposed to destroy a VA buffer implicitly. However,
+ some buffers need to be kept until vaEndPicture() is reached. Besides, if
+ user calls vaDestroyBuffer() in between, we still have to keep the buffer
+ live for vaEndPicture().
+
+Origin: upstream, http://cgit.freedesktop.org/vaapi/vdpau-driver/commit/?id=d26b5b3
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1222790
+Forwarded: yes
+Applied-Upstream: 0.7.4
+Author: Gwenole Beauchesne <[e-mail]>
+
+---
+diff --git a/src/vdpau_buffer.c b/src/vdpau_buffer.c
+index f1171f3..540713f 100644
+--- a/src/vdpau_buffer.c
++++ b/src/vdpau_buffer.c
+@@ -57,6 +57,7 @@ create_va_buffer(
+     obj_buffer->buffer_size      = size * num_elements;
+     obj_buffer->buffer_data      = malloc(obj_buffer->buffer_size);
+     obj_buffer->mtime            = 0;
++    obj_buffer->delayed_destroy  = 0;
+ 
+     if (!obj_buffer->buffer_data) {
+         destroy_va_buffer(driver_data, obj_buffer);
+@@ -103,6 +104,7 @@ schedule_destroy_va_buffer(
+     ASSERT(obj_context->dead_buffers);
+     obj_context->dead_buffers[obj_context->dead_buffers_count] = obj_buffer->base.id;
+     obj_context->dead_buffers_count++;
++    obj_buffer->delayed_destroy = 1;
+ }
+ 
+ // vaCreateBuffer
+@@ -162,7 +164,7 @@ vdpau_DestroyBuffer(
+ 
+     object_buffer_p obj_buffer = VDPAU_BUFFER(buffer_id);
+ 
+-    if (obj_buffer)
++    if (obj_buffer && !obj_buffer->delayed_destroy)
+         destroy_va_buffer(driver_data, obj_buffer);
+ 
+     return VA_STATUS_SUCCESS;
+diff --git a/src/vdpau_buffer.h b/src/vdpau_buffer.h
+index 7790f54..0168df9 100644
+--- a/src/vdpau_buffer.h
++++ b/src/vdpau_buffer.h
+@@ -33,6 +33,7 @@ struct object_buffer {
+     unsigned int        max_num_elements;
+     unsigned int        num_elements;
+     uint64_t            mtime;
++    unsigned int        delayed_destroy : 1;
+ };
+ 
+ // Create VA buffer object
+--
+cgit v0.9.0.2-2-gbebe

=== added file 'debian/patches/02_purge_va_buffers_on_context_destroy_or_new_picture_decode_seq.patch'
--- debian/patches/02_purge_va_buffers_on_context_destroy_or_new_picture_decode_seq.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/02_purge_va_buffers_on_context_destroy_or_new_picture_decode_seq.patch	2014-05-06 21:30:45 +0000
@@ -0,0 +1,111 @@
+Description: Purge VA buffers on context destroy or new picture decdode sequence.
+Origin: upstream, http://cgit.freedesktop.org/vaapi/vdpau-driver/commit/?id=2630695
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1222790
+Forwarded: yes
+Applied-Upstream: 0.7.4
+Author: Gwenole Beauchesne <[e-mail]>
+
+---
+diff --git a/src/vdpau_buffer.c b/src/vdpau_buffer.c
+index 540713f..8766046 100644
+--- a/src/vdpau_buffer.c
++++ b/src/vdpau_buffer.c
+@@ -28,6 +28,27 @@
+ #define DEBUG 1
+ #include "debug.h"
+ 
++// Destroy dead VA buffers
++void
++destroy_dead_va_buffers(
++    vdpau_driver_data_t *driver_data,
++    object_context_p     obj_context
++)
++{
++    object_buffer_p obj_buffer;
++    unsigned int i;
++
++    if (obj_context->dead_buffers_count < 1)
++        return;
++
++    ASSERT(obj_context->dead_buffers);
++    for (i = 0; i < obj_context->dead_buffers_count; i++) {
++        obj_buffer = VDPAU_BUFFER(obj_context->dead_buffers[i]);
++        ASSERT(obj_buffer);
++        destroy_va_buffer(driver_data, obj_buffer);
++    }
++    obj_context->dead_buffers_count = 0;
++}
+ 
+ // Create VA buffer object
+ object_buffer_p
+diff --git a/src/vdpau_buffer.h b/src/vdpau_buffer.h
+index 0168df9..42672aa 100644
+--- a/src/vdpau_buffer.h
++++ b/src/vdpau_buffer.h
+@@ -36,6 +36,13 @@ struct object_buffer {
+     unsigned int        delayed_destroy : 1;
+ };
+ 
++// Destroy dead VA buffers
++void
++destroy_dead_va_buffers(
++    vdpau_driver_data_t *driver_data,
++    object_context_p     obj_context
++) attribute_hidden;
++
+ // Create VA buffer object
+ object_buffer_p
+ create_va_buffer(
+diff --git a/src/vdpau_decode.c b/src/vdpau_decode.c
+index 08dfbf0..dee3993 100644
+--- a/src/vdpau_decode.c
++++ b/src/vdpau_decode.c
+@@ -1134,6 +1134,8 @@ vdpau_BeginPicture(
+     default:
+         return VA_STATUS_ERROR_UNKNOWN;
+     }
++
++    destroy_dead_va_buffers(driver_data, obj_context);
+     return VA_STATUS_SUCCESS;
+ }
+ 
+@@ -1256,16 +1258,7 @@ vdpau_EndPicture(
+     obj_context->current_render_target = VA_INVALID_SURFACE;
+ 
+     /* Release pending buffers */
+-    if (obj_context->dead_buffers_count > 0) {
+-        ASSERT(obj_context->dead_buffers);
+-        int i;
+-        for (i = 0; i < obj_context->dead_buffers_count; i++) {
+-            object_buffer_p obj_buffer = VDPAU_BUFFER(obj_context->dead_buffers[i]);
+-            ASSERT(obj_buffer);
+-            destroy_va_buffer(driver_data, obj_buffer);
+-        }
+-        obj_context->dead_buffers_count = 0;
+-    }
++    destroy_dead_va_buffers(driver_data, obj_context);
+ 
+     return va_status;
+ }
+diff --git a/src/vdpau_video.c b/src/vdpau_video.c
+index 3821879..05d1f5e 100644
+--- a/src/vdpau_video.c
++++ b/src/vdpau_video.c
+@@ -24,6 +24,7 @@
+ #include "vdpau_decode.h"
+ #include "vdpau_subpic.h"
+ #include "vdpau_mixer.h"
++#include "vdpau_buffer.h"
+ #include "utils.h"
+ 
+ #define DEBUG 1
+@@ -481,6 +482,7 @@ VAStatus vdpau_DestroyContext(VADriverContextP ctx, VAContextID context)
+         obj_context->vdp_decoder = VDP_INVALID_HANDLE;
+     }
+ 
++    destroy_dead_va_buffers(driver_data, obj_context);
+     if (obj_context->dead_buffers) {
+         free(obj_context->dead_buffers);
+         obj_context->dead_buffers = NULL;
+--
+cgit v0.9.0.2-2-gbebe

=== added file 'debian/patches/03_mark_destroyed_buffers_as_deleted.patch'
--- debian/patches/03_mark_destroyed_buffers_as_deleted.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/03_mark_destroyed_buffers_as_deleted.patch	2014-05-06 21:30:45 +0000
@@ -0,0 +1,28 @@
+Description: decode: mark destroyed buffers as deleted
+ In multi-threaded scenarios destroying a buffer via destroy_va_buffer()
+ will allow other threads to claim the freed buffer object. If the
+ calling code does not know whether the buffer object was freed it may
+ attempt to vaDestroyBuffer, essentially destroying a buffer object which
+ is in use by another thread.
+
+Origin: upstream, http://cgit.freedesktop.org/vaapi/vdpau-driver/commit/?id=e4fd3b
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1222790
+Forwarded: yes
+Applied-Upstream: 0.7.4
+Author: Philip Lorenz <[e-mail]>
+
+---
+diff --git a/src/vdpau_decode.c b/src/vdpau_decode.c
+index b9f1419..22d9cd9 100644
+--- a/src/vdpau_decode.c
++++ b/src/vdpau_decode.c
+@@ -1229,6 +1229,7 @@ vdpau_RenderPicture(
+             destroy_va_buffer(driver_data, obj_buffer);
+             break;
+         }
++        buffers[i] = VA_INVALID_BUFFER;
+     }
+ 
+     return VA_STATUS_SUCCESS;
+--
+cgit v0.9.0.2-2-gbebe

=== modified file 'debian/patches/series'
--- debian/patches/series	2013-04-13 09:39:54 +0000
+++ debian/patches/series	2014-05-06 21:30:45 +0000
@@ -1,2 +1,5 @@
 autoreconf.patch
 GL_VER_1_3.patch
+01_dont_clear_va_buffer_too_early.patch
+02_purge_va_buffers_on_context_destroy_or_new_picture_decode_seq.patch
+03_mark_destroyed_buffers_as_deleted.patch

=== modified file 'src/vdpau_buffer.c'
--- src/vdpau_buffer.c	2011-09-22 11:35:45 +0000
+++ src/vdpau_buffer.c	2014-05-06 21:30:45 +0000
@@ -28,6 +28,27 @@
 #define DEBUG 1
 #include "debug.h"
 
+// Destroy dead VA buffers
+void
+destroy_dead_va_buffers(
+    vdpau_driver_data_t *driver_data,
+    object_context_p     obj_context
+)
+{
+    object_buffer_p obj_buffer;
+    unsigned int i;
+
+    if (obj_context->dead_buffers_count < 1)
+        return;
+
+    ASSERT(obj_context->dead_buffers);
+    for (i = 0; i < obj_context->dead_buffers_count; i++) {
+        obj_buffer = VDPAU_BUFFER(obj_context->dead_buffers[i]);
+        ASSERT(obj_buffer);
+        destroy_va_buffer(driver_data, obj_buffer);
+    }
+    obj_context->dead_buffers_count = 0;
+}
 
 // Create VA buffer object
 object_buffer_p
@@ -57,6 +78,7 @@
     obj_buffer->buffer_size      = size * num_elements;
     obj_buffer->buffer_data      = malloc(obj_buffer->buffer_size);
     obj_buffer->mtime            = 0;
+    obj_buffer->delayed_destroy  = 0;
 
     if (!obj_buffer->buffer_data) {
         destroy_va_buffer(driver_data, obj_buffer);
@@ -103,6 +125,7 @@
     ASSERT(obj_context->dead_buffers);
     obj_context->dead_buffers[obj_context->dead_buffers_count] = obj_buffer->base.id;
     obj_context->dead_buffers_count++;
+    obj_buffer->delayed_destroy = 1;
 }
 
 // vaCreateBuffer
@@ -162,7 +185,7 @@
 
     object_buffer_p obj_buffer = VDPAU_BUFFER(buffer_id);
 
-    if (obj_buffer)
+    if (obj_buffer && !obj_buffer->delayed_destroy)
         destroy_va_buffer(driver_data, obj_buffer);
 
     return VA_STATUS_SUCCESS;

=== modified file 'src/vdpau_buffer.h'
--- src/vdpau_buffer.h	2011-09-22 11:35:45 +0000
+++ src/vdpau_buffer.h	2014-05-06 21:30:45 +0000
@@ -33,8 +33,16 @@
     unsigned int        max_num_elements;
     unsigned int        num_elements;
     uint64_t            mtime;
+    unsigned int        delayed_destroy : 1;
 };
 
+// Destroy dead VA buffers
+void
+destroy_dead_va_buffers(
+    vdpau_driver_data_t *driver_data,
+    object_context_p     obj_context
+) attribute_hidden;
+
 // Create VA buffer object
 object_buffer_p
 create_va_buffer(

=== modified file 'src/vdpau_decode.c'
--- src/vdpau_decode.c	2011-09-22 11:35:45 +0000
+++ src/vdpau_decode.c	2014-05-06 21:30:45 +0000
@@ -1134,6 +1134,8 @@
     default:
         return VA_STATUS_ERROR_UNKNOWN;
     }
+
+    destroy_dead_va_buffers(driver_data, obj_context);
     return VA_STATUS_SUCCESS;
 }
 
@@ -1187,6 +1189,7 @@
             destroy_va_buffer(driver_data, obj_buffer);
             break;
         }
+        buffers[i] = VA_INVALID_BUFFER;
     }
 
     return VA_STATUS_SUCCESS;
@@ -1256,16 +1259,7 @@
     obj_context->current_render_target = VA_INVALID_SURFACE;
 
     /* Release pending buffers */
-    if (obj_context->dead_buffers_count > 0) {
-        ASSERT(obj_context->dead_buffers);
-        int i;
-        for (i = 0; i < obj_context->dead_buffers_count; i++) {
-            object_buffer_p obj_buffer = VDPAU_BUFFER(obj_context->dead_buffers[i]);
-            ASSERT(obj_buffer);
-            destroy_va_buffer(driver_data, obj_buffer);
-        }
-        obj_context->dead_buffers_count = 0;
-    }
+    destroy_dead_va_buffers(driver_data, obj_context);
 
     return va_status;
 }

=== modified file 'src/vdpau_video.c'
--- src/vdpau_video.c	2011-09-22 11:35:45 +0000
+++ src/vdpau_video.c	2014-05-06 21:30:45 +0000
@@ -24,6 +24,7 @@
 #include "vdpau_decode.h"
 #include "vdpau_subpic.h"
 #include "vdpau_mixer.h"
+#include "vdpau_buffer.h"
 #include "utils.h"
 
 #define DEBUG 1
@@ -481,6 +482,7 @@
         obj_context->vdp_decoder = VDP_INVALID_HANDLE;
     }
 
+    destroy_dead_va_buffers(driver_data, obj_context);
     if (obj_context->dead_buffers) {
         free(obj_context->dead_buffers);
         obj_context->dead_buffers = NULL;