Revert to Mesa 13.0.6 again.

Corruption has again been reported on Intel hardware running Xorg with
the modesetting driver (which uses OpenGL based acceleration instead of
SNA acceleration the intel driver defaults to).

Reported in various forms on Sandy Bridge (X220), Ivy Bridge (X230) and
Haswell (X240).  Confirmed to not occur with the intel driver but the
xserver was changed to default to the modesetting driver on >= gen4
hardware (except Ironlake).

One means of triggering this is to open a large pdf with xpdf on an
idle machine and highlight a section of the document.

There have been reports of gpu hangs on gen4 intel hardware
(T500 with GM45, X61 with 965GM) when starting Xorg as well.

16 files changed, 211 insertions, 355 deletions

diff --git a/lib/mesa/src/gallium/auxiliary/vl/vl_bicubic_filter.c b/lib/mesa/src/gallium/auxiliary/vl/vl_bicubic_filter.c
index a3dc6c8c5..0364d4326 100644
--- a/lib/mesa/src/gallium/auxiliary/vl/vl_bicubic_filter.c
+++ b/lib/mesa/src/gallium/auxiliary/vl/vl_bicubic_filter.c
@@ -35,7 +35,6 @@
 #include "util/u_memory.h"
 #include "util/u_math.h"
 #include "util/u_rect.h"
-#include "util/u_upload_mgr.h"
 
 #include "vl_types.h"
 #include "vl_vertex_buffers.h"
@@ -174,11 +173,6 @@ create_frag_shader(struct vl_bicubic_filter *filter, unsigned video_width,
 
    i_vtex = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);
    sampler = ureg_DECL_sampler(shader, 0);
-   ureg_DECL_sampler_view(shader, 0, TGSI_TEXTURE_2D,
-                          TGSI_RETURN_TYPE_FLOAT,
-                          TGSI_RETURN_TYPE_FLOAT,
-                          TGSI_RETURN_TYPE_FLOAT,
-                          TGSI_RETURN_TYPE_FLOAT);
 
    for (i = 0; i < 23; ++i)
       t_array[i] = ureg_DECL_temporary(shader);
@@ -192,8 +186,8 @@ create_frag_shader(struct vl_bicubic_filter *filter, unsigned video_width,
     * t = frac(temp)
     * vtex = floor(i_vtex)/i_size
     */
-   ureg_ADD(shader, ureg_writemask(t_array[21], TGSI_WRITEMASK_XY),
-            i_vtex, ureg_negate(half_pixel));
+   ureg_SUB(shader, ureg_writemask(t_array[21], TGSI_WRITEMASK_XY),
+            i_vtex, half_pixel);
    ureg_MUL(shader, ureg_writemask(t_array[22], TGSI_WRITEMASK_XY),
             ureg_src(t_array[21]), ureg_imm2f(shader, video_width, video_height));
    ureg_FRC(shader, ureg_writemask(t, TGSI_WRITEMASK_XY),
@@ -295,7 +289,7 @@ vl_bicubic_filter_init(struct vl_bicubic_filter *filter, struct pipe_context *pi
       goto error_sampler;
 
    filter->quad = vl_vb_upload_quads(pipe);
-   if(!filter->quad.buffer.resource)
+   if(!filter->quad.buffer)
       goto error_quad;
 
    memset(&ve, 0, sizeof(ve));
@@ -349,7 +343,7 @@ error_vs:
    pipe->delete_vertex_elements_state(pipe, filter->ves);
 
 error_ves:
-   pipe_resource_reference(&filter->quad.buffer.resource, NULL);
+   pipe_resource_reference(&filter->quad.buffer, NULL);
 
 error_quad:
    pipe->delete_sampler_state(pipe, filter->sampler);
@@ -373,7 +367,7 @@ vl_bicubic_filter_cleanup(struct vl_bicubic_filter *filter)
    filter->pipe->delete_blend_state(filter->pipe, filter->blend);
    filter->pipe->delete_rasterizer_state(filter->pipe, filter->rs_state);
    filter->pipe->delete_vertex_elements_state(filter->pipe, filter->ves);
-   pipe_resource_reference(&filter->quad.buffer.resource, NULL);
+   pipe_resource_reference(&filter->quad.buffer, NULL);
 
    filter->pipe->delete_vs_state(filter->pipe, filter->vs);
    filter->pipe->delete_fs_state(filter->pipe, filter->fs);
@@ -390,7 +384,8 @@ vl_bicubic_filter_render(struct vl_bicubic_filter *filter,
    struct pipe_framebuffer_state fb_state;
    struct pipe_scissor_state scissor;
    union pipe_color_union clear_color;
-
+   struct pipe_transfer *buf_transfer;
+   struct pipe_resource *surface_size;
    assert(filter && src && dst);
 
    if (dst_clip) {
@@ -407,6 +402,14 @@ vl_bicubic_filter_render(struct vl_bicubic_filter *filter,
 
    clear_color.f[0] = clear_color.f[1] = 0.0f;
    clear_color.f[2] = clear_color.f[3] = 0.0f;
+   surface_size = pipe_buffer_create
+   (
+      filter->pipe->screen,
+      PIPE_BIND_CONSTANT_BUFFER,
+      PIPE_USAGE_DEFAULT,
+      2*sizeof(float)
+   );
+
 
    memset(&viewport, 0, sizeof(viewport));
    if(dst_area){
@@ -420,18 +423,14 @@ vl_bicubic_filter_render(struct vl_bicubic_filter *filter,
    }
    viewport.scale[2] = 1;
 
-   struct pipe_constant_buffer cb = {};
-   float *ptr = NULL;
+   float *ptr = pipe_buffer_map(filter->pipe, surface_size,
+                               PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD_RANGE,
+                               &buf_transfer);
 
-   u_upload_alloc(filter->pipe->const_uploader, 0, 2 * sizeof(float), 256,
-                  &cb.buffer_offset, &cb.buffer, (void**)&ptr);
-   cb.buffer_size = 2 * sizeof(float);
+   ptr[0] = 0.5f/viewport.scale[0];
+   ptr[1] = 0.5f/viewport.scale[1];
 
-   if (ptr) {
-      ptr[0] = 0.5f/viewport.scale[0];
-      ptr[1] = 0.5f/viewport.scale[1];
-   }
-   u_upload_unmap(filter->pipe->const_uploader);
+   pipe_buffer_unmap(filter->pipe, buf_transfer);
 
    memset(&fb_state, 0, sizeof(fb_state));
    fb_state.width = dst->width;
@@ -442,8 +441,7 @@ vl_bicubic_filter_render(struct vl_bicubic_filter *filter,
    filter->pipe->set_scissor_states(filter->pipe, 0, 1, &scissor);
    filter->pipe->clear_render_target(filter->pipe, dst, &clear_color,
                                      0, 0, dst->width, dst->height, false);
-   filter->pipe->set_constant_buffer(filter->pipe, PIPE_SHADER_FRAGMENT,
-                                     0, &cb);
+   pipe_set_constant_buffer(filter->pipe, PIPE_SHADER_FRAGMENT, 0, surface_size);
    filter->pipe->bind_rasterizer_state(filter->pipe, filter->rs_state);
    filter->pipe->bind_blend_state(filter->pipe, filter->blend);
    filter->pipe->bind_sampler_states(filter->pipe, PIPE_SHADER_FRAGMENT,
diff --git a/lib/mesa/src/gallium/auxiliary/vl/vl_compositor.c b/lib/mesa/src/gallium/auxiliary/vl/vl_compositor.c
index a79bf1126..03a0a6453 100644
--- a/lib/mesa/src/gallium/auxiliary/vl/vl_compositor.c
+++ b/lib/mesa/src/gallium/auxiliary/vl/vl_compositor.c
@@ -137,15 +137,9 @@ create_frag_shader_weave(struct ureg_program *shader, struct ureg_dst fragment)
    i_tc[0] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTOP, TGSI_INTERPOLATE_LINEAR);
    i_tc[1] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VBOTTOM, TGSI_INTERPOLATE_LINEAR);
 
-   for (i = 0; i < 3; ++i) {
+   for (i = 0; i < 3; ++i)
       sampler[i] = ureg_DECL_sampler(shader, i);
-      ureg_DECL_sampler_view(shader, i, TGSI_TEXTURE_2D_ARRAY,
-                             TGSI_RETURN_TYPE_FLOAT,
-                             TGSI_RETURN_TYPE_FLOAT,
-                             TGSI_RETURN_TYPE_FLOAT,
-                             TGSI_RETURN_TYPE_FLOAT);
-   }
-   
+
    for (i = 0; i < 2; ++i) {
       t_tc[i] = ureg_DECL_temporary(shader);
       t_texel[i] = ureg_DECL_temporary(shader);
@@ -157,8 +151,8 @@ create_frag_shader_weave(struct ureg_program *shader, struct ureg_dst fragment)
     */
    for (i = 0; i < 2; ++i) {
       ureg_MOV(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_X), i_tc[i]);
-      ureg_ADD(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_YZ),
-               i_tc[i], ureg_imm1f(shader, -0.5f));
+      ureg_SUB(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_YZ),
+               i_tc[i], ureg_imm1f(shader, 0.5f));
       ureg_ROUND(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_YZ), ureg_src(t_tc[i]));
       ureg_MOV(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_W),
                ureg_imm1f(shader, i ? 1.0f : 0.0f));
@@ -254,15 +248,9 @@ create_frag_shader_video_buffer(struct vl_compositor *c)
       return false;
 
    tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);
-   for (i = 0; i < 3; ++i) {
+   for (i = 0; i < 3; ++i)
       sampler[i] = ureg_DECL_sampler(shader, i);
-      ureg_DECL_sampler_view(shader, i, TGSI_TEXTURE_2D_ARRAY,
-                             TGSI_RETURN_TYPE_FLOAT,
-                             TGSI_RETURN_TYPE_FLOAT,
-                             TGSI_RETURN_TYPE_FLOAT,
-                             TGSI_RETURN_TYPE_FLOAT);
-   }
-   
+
    texel = ureg_DECL_temporary(shader);
    fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
 
@@ -354,18 +342,8 @@ create_frag_shader_palette(struct vl_compositor *c, bool include_cc)
 
    tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);
    sampler = ureg_DECL_sampler(shader, 0);
-   ureg_DECL_sampler_view(shader, 0, TGSI_TEXTURE_2D,
-                          TGSI_RETURN_TYPE_FLOAT,
-                          TGSI_RETURN_TYPE_FLOAT,
-                          TGSI_RETURN_TYPE_FLOAT,
-                          TGSI_RETURN_TYPE_FLOAT);
    palette = ureg_DECL_sampler(shader, 1);
-   ureg_DECL_sampler_view(shader, 1, TGSI_TEXTURE_1D,
-                          TGSI_RETURN_TYPE_FLOAT,
-                          TGSI_RETURN_TYPE_FLOAT,
-                          TGSI_RETURN_TYPE_FLOAT,
-                          TGSI_RETURN_TYPE_FLOAT);
-   
+
    texel = ureg_DECL_temporary(shader);
    fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
 
@@ -406,11 +384,6 @@ create_frag_shader_rgba(struct vl_compositor *c)
    tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);
    color = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_COLOR, VS_O_COLOR, TGSI_INTERPOLATE_LINEAR);
    sampler = ureg_DECL_sampler(shader, 0);
-   ureg_DECL_sampler_view(shader, 0, TGSI_TEXTURE_2D,
-                          TGSI_RETURN_TYPE_FLOAT,
-                          TGSI_RETURN_TYPE_FLOAT,
-                          TGSI_RETURN_TYPE_FLOAT,
-                          TGSI_RETURN_TYPE_FLOAT);
    texel = ureg_DECL_temporary(shader);
    fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
 
@@ -605,8 +578,7 @@ init_buffers(struct vl_compositor *c)
     */
    c->vertex_buf.stride = sizeof(struct vertex2f) + sizeof(struct vertex4f) * 2;
    c->vertex_buf.buffer_offset = 0;
-   c->vertex_buf.buffer.resource = NULL;
-   c->vertex_buf.is_user_buffer = false;
+   c->vertex_buf.buffer = NULL;
 
    vertex_elems[0].src_offset = 0;
    vertex_elems[0].instance_divisor = 0;
@@ -631,7 +603,7 @@ cleanup_buffers(struct vl_compositor *c)
    assert(c);
 
    c->pipe->delete_vertex_elements_state(c->pipe, c->vertex_elems_state);
-   pipe_resource_reference(&c->vertex_buf.buffer.resource, NULL);
+   pipe_resource_reference(&c->vertex_buf.buffer, NULL);
 }
 
 static inline struct u_rect
@@ -810,10 +782,10 @@ gen_vertex_data(struct vl_compositor *c, struct vl_compositor_state *s, struct u
    assert(c);
 
    /* Allocate new memory for vertices. */
-   u_upload_alloc(c->pipe->stream_uploader, 0,
+   u_upload_alloc(c->upload, 0,
                   c->vertex_buf.stride * VL_COMPOSITOR_MAX_LAYERS * 4, /* size */
                   4, /* alignment */
-                  &c->vertex_buf.buffer_offset, &c->vertex_buf.buffer.resource,
+                  &c->vertex_buf.buffer_offset, &c->vertex_buf.buffer,
                   (void**)&vb);
 
    for (i = 0; i < VL_COMPOSITOR_MAX_LAYERS; i++) {
@@ -845,7 +817,7 @@ gen_vertex_data(struct vl_compositor *c, struct vl_compositor_state *s, struct u
       }
    }
 
-   u_upload_unmap(c->pipe->stream_uploader);
+   u_upload_unmap(c->upload);
 }
 
 static void
@@ -941,12 +913,13 @@ vl_compositor_cleanup(struct vl_compositor *c)
 {
    assert(c);
 
+   u_upload_destroy(c->upload);
    cleanup_buffers(c);
    cleanup_shaders(c);
    cleanup_pipe_state(c);
 }
 
-bool
+void
 vl_compositor_set_csc_matrix(struct vl_compositor_state *s,
                              vl_csc_matrix const *matrix,
                              float luma_min, float luma_max)
@@ -959,9 +932,6 @@ vl_compositor_set_csc_matrix(struct vl_compositor_state *s,
                                PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD_RANGE,
                                &buf_transfer);
 
-   if (!ptr)
-      return false;
-
    memcpy(ptr, matrix, sizeof(vl_csc_matrix));
 
    ptr += sizeof(vl_csc_matrix)/sizeof(float);
@@ -969,8 +939,6 @@ vl_compositor_set_csc_matrix(struct vl_compositor_state *s,
    ptr[1] = luma_max;
 
    pipe_buffer_unmap(s->pipe, buf_transfer);
-
-   return true;
 }
 
 void
@@ -1224,16 +1192,25 @@ vl_compositor_init(struct vl_compositor *c, struct pipe_context *pipe)
 
    c->pipe = pipe;
 
+   c->upload = u_upload_create(pipe, 128 * 1024, PIPE_BIND_VERTEX_BUFFER,
+                               PIPE_USAGE_STREAM);
+
+   if (!c->upload)
+      return false;
+
    if (!init_pipe_state(c)) {
+      u_upload_destroy(c->upload);
       return false;
    }
 
    if (!init_shaders(c)) {
+      u_upload_destroy(c->upload);
       cleanup_pipe_state(c);
       return false;
    }
 
    if (!init_buffers(c)) {
+      u_upload_destroy(c->upload);
       cleanup_shaders(c);
       cleanup_pipe_state(c);
       return false;
@@ -1269,14 +1246,10 @@ vl_compositor_init_state(struct vl_compositor_state *s, struct pipe_context *pip
       sizeof(csc_matrix) + 2*sizeof(float)
    );
 
-   if (!s->csc_matrix)
-      return false;
-
    vl_compositor_clear_layers(s);
 
    vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_IDENTITY, NULL, true, &csc_matrix);
-   if (!vl_compositor_set_csc_matrix(s, (const vl_csc_matrix *)&csc_matrix, 1.0f, 0.0f))
-      return false;
+   vl_compositor_set_csc_matrix(s, (const vl_csc_matrix *)&csc_matrix, 1.0f, 0.0f);
 
    return true;
 }
diff --git a/lib/mesa/src/gallium/auxiliary/vl/vl_compositor.h b/lib/mesa/src/gallium/auxiliary/vl/vl_compositor.h
index 535abb75c..ceab5e004 100644
--- a/lib/mesa/src/gallium/auxiliary/vl/vl_compositor.h
+++ b/lib/mesa/src/gallium/auxiliary/vl/vl_compositor.h
@@ -99,6 +99,7 @@ struct vl_compositor_state
 struct vl_compositor
 {
    struct pipe_context *pipe;
+   struct u_upload_mgr *upload;
 
    struct pipe_framebuffer_state fb_state;
    struct pipe_vertex_buffer vertex_buf;
@@ -141,7 +142,7 @@ vl_compositor_init_state(struct vl_compositor_state *state, struct pipe_context
 /**
  * set yuv -> rgba conversion matrix
  */
-bool
+void
 vl_compositor_set_csc_matrix(struct vl_compositor_state *settings,
                              const vl_csc_matrix *matrix,
                              float luma_min, float luma_max);
diff --git a/lib/mesa/src/gallium/auxiliary/vl/vl_csc.c b/lib/mesa/src/gallium/auxiliary/vl/vl_csc.c
index e4395d062..c8efe2867 100644
--- a/lib/mesa/src/gallium/auxiliary/vl/vl_csc.c
+++ b/lib/mesa/src/gallium/auxiliary/vl/vl_csc.c
@@ -59,10 +59,10 @@
  * [ 0, 0, 0, 1]
  *
  * brightness
- * [ 1, 0, 0, b/c]
- * [ 0, 1, 0,   0]
- * [ 0, 0, 1,   0]
- * [ 0, 0, 0,   1]
+ * [ 1, 0, 0, b]
+ * [ 0, 1, 0, 0]
+ * [ 0, 0, 1, 0]
+ * [ 0, 0, 0, 1]
  *
  * saturation
  * [ 1, 0, 0, 0]
@@ -108,6 +108,18 @@ static const vl_csc_matrix bt_601 =
 };
 
 /*
+ * Converts ITU-R BT.601 YCbCr pixels to RGB pixels where:
+ * Y is in [16,235], Cb and Cr are in [16,240]
+ * R, G, and B are in [0,255]
+ */
+static const vl_csc_matrix bt_601_full =
+{
+   { 1.164f,  0.0f,    1.596f, 0.0f, },
+   { 1.164f, -0.391f, -0.813f, 0.0f, },
+   { 1.164f,  2.018f,  0.0f,   0.0f, }
+};
+
+/*
  * Converts ITU-R BT.709 YCbCr pixels to RGB pixels where:
  * Y is in [16,235], Cb and Cr are in [16,240]
  * R, G, and B are in [16,235]
@@ -120,15 +132,29 @@ static const vl_csc_matrix bt_709 =
 };
 
 /*
- * Converts SMPTE 240M YCbCr pixels to RGB pixels where:
+ * Converts ITU-R BT.709 YCbCr pixels to RGB pixels where:
  * Y is in [16,235], Cb and Cr are in [16,240]
- * R, G, and B are in [16,235]
+ * R, G, and B are in [0,255]
  */
+static const vl_csc_matrix bt_709_full =
+{
+   { 1.164f,  0.0f,    1.793f, 0.0f, },
+   { 1.164f, -0.213f, -0.534f, 0.0f, },
+   { 1.164f,  2.115f,  0.0f,   0.0f, }
+};
+
 static const vl_csc_matrix smpte240m =
 {
-   { 1.0f,  0.0f,    1.541f, 0.0f, },
-   { 1.0f, -0.221f, -0.466f, 0.0f, },
-   { 1.0f,  1.785f,  0.0f,   0.0f, }
+   { 1.0f,  0.0f,    1.582f, 0.0f, },
+   { 1.0f, -0.228f, -0.478f, 0.0f, },
+   { 1.0f,  1.833f,  0.0f,   0.0f, }
+};
+
+static const vl_csc_matrix smpte240m_full =
+{
+   { 1.164f,  0.0f,    1.794f, 0.0f, },
+   { 1.164f, -0.258f, -0.543f, 0.0f, },
+   { 1.164f,  2.079f,  0.0f,   0.0f, }
 };
 
 static const vl_csc_matrix identity =
@@ -150,6 +176,7 @@ void vl_csc_get_matrix(enum VL_CSC_COLOR_STANDARD cs,
                        bool full_range,
                        vl_csc_matrix *matrix)
 {
+   float ybias = full_range ? -16.0f/255.0f : 0.0f;
    float cbbias = -128.0f/255.0f;
    float crbias = -128.0f/255.0f;
 
@@ -158,31 +185,20 @@ void vl_csc_get_matrix(enum VL_CSC_COLOR_STANDARD cs,
    float s = p->saturation;
    float b = p->brightness;
    float h = p->hue;
-   float x, y;
 
    const vl_csc_matrix *cstd;
 
-   if (full_range) {
-      c *= 1.164f;              /* Adjust for the y range */
-      b *= 1.164f;              /* Adjust for the y range */
-      b -= c * 16.0f  / 255.0f; /* Adjust for the y bias */
-   }
-
-   /* Parameter substitutions */
-   x = c * s * cosf(h);
-   y = c * s * sinf(h);
-
    assert(matrix);
 
    switch (cs) {
       case VL_CSC_COLOR_STANDARD_BT_601:
-         cstd = &bt_601;
+         cstd = full_range ? &bt_601_full : &bt_601;
          break;
       case VL_CSC_COLOR_STANDARD_BT_709:
-         cstd = &bt_709;
+         cstd = full_range ? &bt_709_full : &bt_709;
          break;
       case VL_CSC_COLOR_STANDARD_SMPTE_240M:
-         cstd = &smpte240m;
+         cstd = full_range ? &smpte240m_full : &smpte240m;
          break;
       case VL_CSC_COLOR_STANDARD_IDENTITY:
       default:
@@ -192,23 +208,23 @@ void vl_csc_get_matrix(enum VL_CSC_COLOR_STANDARD cs,
    }
 
    (*matrix)[0][0] = c * (*cstd)[0][0];
-   (*matrix)[0][1] = (*cstd)[0][1] * x - (*cstd)[0][2] * y;
-   (*matrix)[0][2] = (*cstd)[0][2] * x + (*cstd)[0][1] * y;
-   (*matrix)[0][3] = (*cstd)[0][3] + (*cstd)[0][0] * b +
-                     (*cstd)[0][1] * (x * cbbias + y * crbias) +
-                     (*cstd)[0][2] * (x * crbias - y * cbbias);
+   (*matrix)[0][1] = c * (*cstd)[0][1] * s * cosf(h) - c * (*cstd)[0][2] * s * sinf(h);
+   (*matrix)[0][2] = c * (*cstd)[0][2] * s * cosf(h) + c * (*cstd)[0][1] * s * sinf(h);
+   (*matrix)[0][3] = (*cstd)[0][3] + (*cstd)[0][0] * (b + c * ybias) +
+                     (*cstd)[0][1] * (c * cbbias * s * cosf(h) + c * crbias * s * sinf(h)) +
+                     (*cstd)[0][2] * (c * crbias * s * cosf(h) - c * cbbias * s * sinf(h));
 
    (*matrix)[1][0] = c * (*cstd)[1][0];
-   (*matrix)[1][1] = (*cstd)[1][1] * x - (*cstd)[1][2] * y;
-   (*matrix)[1][2] = (*cstd)[1][2] * x + (*cstd)[1][1] * y;
-   (*matrix)[1][3] = (*cstd)[1][3] + (*cstd)[1][0] * b +
-                     (*cstd)[1][1] * (x * cbbias + y * crbias) +
-                     (*cstd)[1][2] * (x * crbias - y * cbbias);
+   (*matrix)[1][1] = c * (*cstd)[1][1] * s * cosf(h) - c * (*cstd)[1][2] * s * sinf(h);
+   (*matrix)[1][2] = c * (*cstd)[1][2] * s * cosf(h) + c * (*cstd)[1][1] * s * sinf(h);
+   (*matrix)[1][3] = (*cstd)[1][3] + (*cstd)[1][0] * (b + c * ybias) +
+                     (*cstd)[1][1] * (c * cbbias * s * cosf(h) + c * crbias * s * sinf(h)) +
+                     (*cstd)[1][2] * (c * crbias * s * cosf(h) - c * cbbias * s * sinf(h));
 
    (*matrix)[2][0] = c * (*cstd)[2][0];
-   (*matrix)[2][1] = (*cstd)[2][1] * x - (*cstd)[2][2] * y;
-   (*matrix)[2][2] = (*cstd)[2][2] * x + (*cstd)[2][1] * y;
-   (*matrix)[2][3] = (*cstd)[2][3] + (*cstd)[2][0] * b +
-                     (*cstd)[2][1] * (x * cbbias + y * crbias) +
-                     (*cstd)[2][2] * (x * crbias - y * cbbias);
+   (*matrix)[2][1] = c * (*cstd)[2][1] * s * cosf(h) - c * (*cstd)[2][2] * s * sinf(h);
+   (*matrix)[2][2] = c * (*cstd)[2][2] * s * cosf(h) + c * (*cstd)[2][1] * s * sinf(h);
+   (*matrix)[2][3] = (*cstd)[2][3] + (*cstd)[2][0] * (b + c * ybias) +
+                     (*cstd)[2][1] * (c * cbbias * s * cosf(h) + c * crbias * s * sinf(h)) +
+                     (*cstd)[2][2] * (c * crbias * s * cosf(h) - c * cbbias * s * sinf(h));
 }
diff --git a/lib/mesa/src/gallium/auxiliary/vl/vl_deint_filter.c b/lib/mesa/src/gallium/auxiliary/vl/vl_deint_filter.c
index d2c48bda7..3ca3b4954 100644
--- a/lib/mesa/src/gallium/auxiliary/vl/vl_deint_filter.c
+++ b/lib/mesa/src/gallium/auxiliary/vl/vl_deint_filter.c
@@ -173,21 +173,21 @@ create_deint_frag_shader(struct vl_deint_filter *filter, unsigned field,
       // cur vs prev2
       ureg_TEX(shader, t_a, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_comp_bot), sampler_cur);
       ureg_TEX(shader, t_b, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_comp_bot), sampler_prevprev);
-      ureg_ADD(shader, ureg_writemask(t_diff, TGSI_WRITEMASK_X), ureg_src(t_a), ureg_negate(ureg_src(t_b)));
+      ureg_SUB(shader, ureg_writemask(t_diff, TGSI_WRITEMASK_X), ureg_src(t_a), ureg_src(t_b));
       // prev vs next
       ureg_TEX(shader, t_a, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_comp_top), sampler_prev);
       ureg_TEX(shader, t_b, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_comp_top), sampler_next);
-      ureg_ADD(shader, ureg_writemask(t_diff, TGSI_WRITEMASK_Y), ureg_src(t_a), ureg_negate(ureg_src(t_b)));
+      ureg_SUB(shader, ureg_writemask(t_diff, TGSI_WRITEMASK_Y), ureg_src(t_a), ureg_src(t_b));
    } else {
       /* interpolating bottom field -> current field is a top field */
       // cur vs prev2
       ureg_TEX(shader, t_a, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_comp_top), sampler_cur);
       ureg_TEX(shader, t_b, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_comp_top), sampler_prevprev);
-      ureg_ADD(shader, ureg_writemask(t_diff, TGSI_WRITEMASK_X), ureg_src(t_a), ureg_negate(ureg_src(t_b)));
+      ureg_SUB(shader, ureg_writemask(t_diff, TGSI_WRITEMASK_X), ureg_src(t_a), ureg_src(t_b));
       // prev vs next
       ureg_TEX(shader, t_a, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_comp_bot), sampler_prev);
       ureg_TEX(shader, t_b, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_comp_bot), sampler_next);
-      ureg_ADD(shader, ureg_writemask(t_diff, TGSI_WRITEMASK_Y), ureg_src(t_a), ureg_negate(ureg_src(t_b)));
+      ureg_SUB(shader, ureg_writemask(t_diff, TGSI_WRITEMASK_Y), ureg_src(t_a), ureg_src(t_b));
    }
 
    // absolute maximum of differences
@@ -308,7 +308,7 @@ vl_deint_filter_init(struct vl_deint_filter *filter, struct pipe_context *pipe,
       goto error_sampler;
 
    filter->quad = vl_vb_upload_quads(pipe);
-   if(!filter->quad.buffer.resource)
+   if(!filter->quad.buffer)
       goto error_quad;
 
    memset(&ve, 0, sizeof(ve));
@@ -361,7 +361,7 @@ error_vs:
    pipe->delete_vertex_elements_state(pipe, filter->ves);
 
 error_ves:
-   pipe_resource_reference(&filter->quad.buffer.resource, NULL);
+   pipe_resource_reference(&filter->quad.buffer, NULL);
 
 error_quad:
    pipe->delete_sampler_state(pipe, filter->sampler);
@@ -396,7 +396,7 @@ vl_deint_filter_cleanup(struct vl_deint_filter *filter)
    filter->pipe->delete_blend_state(filter->pipe, filter->blend[2]);
    filter->pipe->delete_rasterizer_state(filter->pipe, filter->rs_state);
    filter->pipe->delete_vertex_elements_state(filter->pipe, filter->ves);
-   pipe_resource_reference(&filter->quad.buffer.resource, NULL);
+   pipe_resource_reference(&filter->quad.buffer, NULL);
 
    filter->pipe->delete_vs_state(filter->pipe, filter->vs);
    filter->pipe->delete_fs_state(filter->pipe, filter->fs_copy_top);
diff --git a/lib/mesa/src/gallium/auxiliary/vl/vl_matrix_filter.c b/lib/mesa/src/gallium/auxiliary/vl/vl_matrix_filter.c
index 1dacc7c60..e331cb758 100644
--- a/lib/mesa/src/gallium/auxiliary/vl/vl_matrix_filter.c
+++ b/lib/mesa/src/gallium/auxiliary/vl/vl_matrix_filter.c
@@ -81,50 +81,69 @@ create_frag_shader(struct vl_matrix_filter *filter, unsigned num_offsets,
    struct ureg_program *shader;
    struct ureg_src i_vtex;
    struct ureg_src sampler;
-   struct ureg_dst tmp;
+   struct ureg_dst *t_array = MALLOC(sizeof(struct ureg_dst) * num_offsets);
    struct ureg_dst t_sum;
    struct ureg_dst o_fragment;
+   bool first;
    unsigned i;
 
    shader = ureg_create(PIPE_SHADER_FRAGMENT);
    if (!shader) {
+      FREE(t_array);
       return NULL;
    }
 
    i_vtex = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);
    sampler = ureg_DECL_sampler(shader, 0);
-   ureg_DECL_sampler_view(shader, 0, TGSI_TEXTURE_2D,
-                          TGSI_RETURN_TYPE_FLOAT,
-                          TGSI_RETURN_TYPE_FLOAT,
-                          TGSI_RETURN_TYPE_FLOAT,
-                          TGSI_RETURN_TYPE_FLOAT);
-
-   tmp = ureg_DECL_temporary(shader);
-   t_sum = ureg_DECL_temporary(shader);
+
+   for (i = 0; i < num_offsets; ++i)
+      if (matrix_values[i] != 0.0f)
+         t_array[i] = ureg_DECL_temporary(shader);
+
    o_fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
 
-   ureg_MOV(shader, t_sum, ureg_imm1f(shader, 0.0f));
-   for (i = 0; i < num_offsets; ++i) {
-      if (matrix_values[i] == 0.0f)
-         continue;
+   /*
+    * t_array[0..*] = vtex + offset[0..*]
+    * t_array[0..*] = tex(t_array[0..*], sampler)
+    * o_fragment = sum(t_array[0..*] * matrix_values[0..*])
+    */
 
-      if (!is_vec_zero(offsets[i])) {
-         ureg_ADD(shader, ureg_writemask(tmp, TGSI_WRITEMASK_XY),
+   for (i = 0; i < num_offsets; ++i) {
+      if (matrix_values[i] != 0.0f && !is_vec_zero(offsets[i])) {
+         ureg_ADD(shader, ureg_writemask(t_array[i], TGSI_WRITEMASK_XY),
                   i_vtex, ureg_imm2f(shader, offsets[i].x, offsets[i].y));
-         ureg_MOV(shader, ureg_writemask(tmp, TGSI_WRITEMASK_ZW),
+         ureg_MOV(shader, ureg_writemask(t_array[i], TGSI_WRITEMASK_ZW),
                   ureg_imm1f(shader, 0.0f));
-         ureg_TEX(shader, tmp, TGSI_TEXTURE_2D, ureg_src(tmp), sampler);
-      } else {
-         ureg_TEX(shader, tmp, TGSI_TEXTURE_2D, i_vtex, sampler);
       }
-      ureg_MAD(shader, t_sum, ureg_src(tmp), ureg_imm1f(shader, matrix_values[i]),
-               ureg_src(t_sum));
    }
 
-   ureg_MOV(shader, o_fragment, ureg_src(t_sum));
+   for (i = 0; i < num_offsets; ++i) {
+      if (matrix_values[i] != 0.0f) {
+         struct ureg_src src = is_vec_zero(offsets[i]) ? i_vtex : ureg_src(t_array[i]);
+         ureg_TEX(shader, t_array[i], TGSI_TEXTURE_2D, src, sampler);
+      }
+   }
+
+   for (i = 0, first = true; i < num_offsets; ++i) {
+      if (matrix_values[i] != 0.0f) {
+         if (first) {
+            t_sum = t_array[i];
+            ureg_MUL(shader, t_sum, ureg_src(t_array[i]),
+                     ureg_imm1f(shader, matrix_values[i]));
+            first = false;
+         } else
+            ureg_MAD(shader, t_sum, ureg_src(t_array[i]),
+                     ureg_imm1f(shader, matrix_values[i]), ureg_src(t_sum));
+      }
+   }
+   if (first)
+      ureg_MOV(shader, o_fragment, ureg_imm1f(shader, 0.0f));
+   else
+      ureg_MOV(shader, o_fragment, ureg_src(t_sum));
 
    ureg_END(shader);
 
+   FREE(t_array);
    return ureg_create_shader_and_destroy(shader, filter->pipe);
 }
 
@@ -184,7 +203,7 @@ vl_matrix_filter_init(struct vl_matrix_filter *filter, struct pipe_context *pipe
       goto error_sampler;
 
    filter->quad = vl_vb_upload_quads(pipe);
-   if(!filter->quad.buffer.resource)
+   if(!filter->quad.buffer)
       goto error_quad;
 
    memset(&ve, 0, sizeof(ve));
@@ -233,7 +252,7 @@ error_offsets:
    pipe->delete_vertex_elements_state(pipe, filter->ves);
 
 error_ves:
-   pipe_resource_reference(&filter->quad.buffer.resource, NULL);
+   pipe_resource_reference(&filter->quad.buffer, NULL);
 
 error_quad:
    pipe->delete_sampler_state(pipe, filter->sampler);
@@ -257,7 +276,7 @@ vl_matrix_filter_cleanup(struct vl_matrix_filter *filter)
    filter->pipe->delete_blend_state(filter->pipe, filter->blend);
    filter->pipe->delete_rasterizer_state(filter->pipe, filter->rs_state);
    filter->pipe->delete_vertex_elements_state(filter->pipe, filter->ves);
-   pipe_resource_reference(&filter->quad.buffer.resource, NULL);
+   pipe_resource_reference(&filter->quad.buffer, NULL);
 
    filter->pipe->delete_vs_state(filter->pipe, filter->vs);
    filter->pipe->delete_fs_state(filter->pipe, filter->fs);
diff --git a/lib/mesa/src/gallium/auxiliary/vl/vl_median_filter.c b/lib/mesa/src/gallium/auxiliary/vl/vl_median_filter.c
index 273afaf2f..f7477b757 100644
--- a/lib/mesa/src/gallium/auxiliary/vl/vl_median_filter.c
+++ b/lib/mesa/src/gallium/auxiliary/vl/vl_median_filter.c
@@ -107,11 +107,6 @@ create_frag_shader(struct vl_median_filter *filter,
 
    i_vtex = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);
    sampler = ureg_DECL_sampler(shader, 0);
-   ureg_DECL_sampler_view(shader, 0, TGSI_TEXTURE_2D,
-                          TGSI_RETURN_TYPE_FLOAT,
-                          TGSI_RETURN_TYPE_FLOAT,
-                          TGSI_RETURN_TYPE_FLOAT,
-                          TGSI_RETURN_TYPE_FLOAT);
 
    for (i = 0; i < num_offsets; ++i)
       t_array[i] = ureg_DECL_temporary(shader);
@@ -295,7 +290,7 @@ vl_median_filter_init(struct vl_median_filter *filter, struct pipe_context *pipe
       goto error_sampler;
 
    filter->quad = vl_vb_upload_quads(pipe);
-   if(!filter->quad.buffer.resource)
+   if(!filter->quad.buffer)
       goto error_quad;
 
    memset(&ve, 0, sizeof(ve));
@@ -337,7 +332,7 @@ error_offsets:
    pipe->delete_vertex_elements_state(pipe, filter->ves);
 
 error_ves:
-   pipe_resource_reference(&filter->quad.buffer.resource, NULL);
+   pipe_resource_reference(&filter->quad.buffer, NULL);
 
 error_quad:
    pipe->delete_sampler_state(pipe, filter->sampler);
@@ -361,7 +356,7 @@ vl_median_filter_cleanup(struct vl_median_filter *filter)
    filter->pipe->delete_blend_state(filter->pipe, filter->blend);
    filter->pipe->delete_rasterizer_state(filter->pipe, filter->rs_state);
    filter->pipe->delete_vertex_elements_state(filter->pipe, filter->ves);
-   pipe_resource_reference(&filter->quad.buffer.resource, NULL);
+   pipe_resource_reference(&filter->quad.buffer, NULL);
 
    filter->pipe->delete_vs_state(filter->pipe, filter->vs);
    filter->pipe->delete_fs_state(filter->pipe, filter->fs);
diff --git a/lib/mesa/src/gallium/auxiliary/vl/vl_mpeg12_decoder.c b/lib/mesa/src/gallium/auxiliary/vl/vl_mpeg12_decoder.c
index b70098372..db62b44f5 100644
--- a/lib/mesa/src/gallium/auxiliary/vl/vl_mpeg12_decoder.c
+++ b/lib/mesa/src/gallium/auxiliary/vl/vl_mpeg12_decoder.c
@@ -189,7 +189,7 @@ init_zscan_buffer(struct vl_mpeg12_decoder *dec, struct vl_mpeg12_buffer *buffer
 
    memset(&sv_tmpl, 0, sizeof(sv_tmpl));
    u_sampler_view_default_template(&sv_tmpl, res, res->format);
-   sv_tmpl.swizzle_r = sv_tmpl.swizzle_g = sv_tmpl.swizzle_b = sv_tmpl.swizzle_a = PIPE_SWIZZLE_RED;
+   sv_tmpl.swizzle_r = sv_tmpl.swizzle_g = sv_tmpl.swizzle_b = sv_tmpl.swizzle_a = PIPE_SWIZZLE_X;
    buffer->zscan_source = dec->context->create_sampler_view(dec->context, res, &sv_tmpl);
    pipe_resource_reference(&res, NULL);
    if (!buffer->zscan_source)
@@ -542,7 +542,7 @@ vl_mpeg12_get_decode_buffer(struct vl_mpeg12_decoder *dec, struct pipe_video_buf
       return buffer;
 
    buffer = CALLOC_STRUCT(vl_mpeg12_buffer);
-   if (buffer == NULL)
+   if (!buffer)
       return NULL;
 
    if (!vl_vb_init(&buffer->vertex_stream, dec->context,
@@ -792,7 +792,7 @@ vl_mpeg12_end_frame(struct pipe_video_codec *decoder,
       for (j = 0; j < VL_MAX_REF_FRAMES; ++j) {
          if (!ref_frames[j] || !ref_frames[j][i]) continue;
 
-         vb[2] = vl_vb_get_mv(&buf->vertex_stream, j);;
+         vb[2] = vl_vb_get_mv(&buf->vertex_stream, j);
          dec->context->set_vertex_buffers(dec->context, 0, 3, vb);
 
          vl_mc_render_ref(i ? &dec->mc_c : &dec->mc_y, &buf->mc[i], ref_frames[j][i]);
@@ -1120,7 +1120,7 @@ vl_create_mpeg12_decoder(struct pipe_context *context,
 
    dec->base = *templat;
    dec->base.context = context;
-   dec->context = context->screen->context_create(context->screen, NULL);
+   dec->context = context->screen->context_create(context->screen, NULL, 0);
 
    dec->base.destroy = vl_mpeg12_destroy;
    dec->base.begin_frame = vl_mpeg12_begin_frame;
diff --git a/lib/mesa/src/gallium/auxiliary/vl/vl_vertex_buffers.c b/lib/mesa/src/gallium/auxiliary/vl/vl_vertex_buffers.c
index 45a9badce..13d3f8c30 100644
--- a/lib/mesa/src/gallium/auxiliary/vl/vl_vertex_buffers.c
+++ b/lib/mesa/src/gallium/auxiliary/vl/vl_vertex_buffers.c
@@ -49,23 +49,23 @@ vl_vb_upload_quads(struct pipe_context *pipe)
    /* create buffer */
    quad.stride = sizeof(struct vertex2f);
    quad.buffer_offset = 0;
-   quad.buffer.resource = pipe_buffer_create
+   quad.buffer = pipe_buffer_create
    (
       pipe->screen,
       PIPE_BIND_VERTEX_BUFFER,
       PIPE_USAGE_DEFAULT,
       sizeof(struct vertex2f) * 4
    );
-   quad.is_user_buffer = false;
+   quad.user_buffer = NULL;
 
-   if(!quad.buffer.resource)
+   if(!quad.buffer)
       return quad;
 
    /* and fill it */
    v = pipe_buffer_map
    (
       pipe,
-      quad.buffer.resource,
+      quad.buffer,
       PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD_RANGE,
       &buf_transfer
    );
@@ -94,23 +94,23 @@ vl_vb_upload_pos(struct pipe_context *pipe, unsigned width, unsigned height)
    /* create buffer */
    pos.stride = sizeof(struct vertex2s);
    pos.buffer_offset = 0;
-   pos.buffer.resource = pipe_buffer_create
+   pos.buffer = pipe_buffer_create
    (
       pipe->screen,
       PIPE_BIND_VERTEX_BUFFER,
       PIPE_USAGE_DEFAULT,
       sizeof(struct vertex2s) * width * height
    );
-   pos.is_user_buffer = false;
+   pos.user_buffer = NULL;
 
-   if(!pos.buffer.resource)
+   if(!pos.buffer)
       return pos;
 
    /* and fill it */
    v = pipe_buffer_map
    (
       pipe,
-      pos.buffer.resource,
+      pos.buffer,
       PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD_RANGE,
       &buf_transfer
    );
@@ -241,6 +241,7 @@ vl_vb_init(struct vl_vertex_buffer *buffer, struct pipe_context *pipe,
          goto error_mv;
    }
 
+   vl_vb_map(buffer, pipe);
    return true;
 
 error_mv:
@@ -268,8 +269,8 @@ vl_vb_get_ycbcr(struct vl_vertex_buffer *buffer, int component)
 
    buf.stride = sizeof(struct vl_ycbcr_block);
    buf.buffer_offset = 0;
-   buf.buffer.resource = buffer->ycbcr[component].resource;
-   buf.is_user_buffer = false;
+   buf.buffer = buffer->ycbcr[component].resource;
+   buf.user_buffer = NULL;
 
    return buf;
 }
@@ -283,8 +284,8 @@ vl_vb_get_mv(struct vl_vertex_buffer *buffer, int motionvector)
 
    buf.stride = sizeof(struct vl_motionvector);
    buf.buffer_offset = 0;
-   buf.buffer.resource = buffer->mv[motionvector].resource;
-   buf.is_user_buffer = false;
+   buf.buffer = buffer->mv[motionvector].resource;
+   buf.user_buffer = NULL;
 
    return buf;
 }
diff --git a/lib/mesa/src/gallium/auxiliary/vl/vl_video_buffer.c b/lib/mesa/src/gallium/auxiliary/vl/vl_video_buffer.c
index 3b97ac81a..fdc9598f8 100644
--- a/lib/mesa/src/gallium/auxiliary/vl/vl_video_buffer.c
+++ b/lib/mesa/src/gallium/auxiliary/vl/vl_video_buffer.c
@@ -86,12 +86,6 @@ const enum pipe_format const_resource_formats_UYVY[3] = {
    PIPE_FORMAT_NONE
 };
 
-const enum pipe_format const_resource_formats_P016[3] = {
-   PIPE_FORMAT_R16_UNORM,
-   PIPE_FORMAT_R16G16_UNORM,
-   PIPE_FORMAT_NONE
-};
-
 const unsigned const_resource_plane_order_YUV[3] = {
    0,
    1,
@@ -132,9 +126,6 @@ vl_video_buffer_formats(struct pipe_screen *screen, enum pipe_format format)
    case PIPE_FORMAT_UYVY:
       return const_resource_formats_UYVY;
 
-   case PIPE_FORMAT_P016:
-      return const_resource_formats_P016;
-
    default:
       return NULL;
    }
@@ -152,7 +143,6 @@ vl_video_buffer_plane_order(enum pipe_format format)
    case PIPE_FORMAT_B8G8R8A8_UNORM:
    case PIPE_FORMAT_YUYV:
    case PIPE_FORMAT_UYVY:
-   case PIPE_FORMAT_P016:
       return const_resource_plane_order_YUV;
 
    default:
@@ -248,8 +238,6 @@ vl_video_buffer_template(struct pipe_resource *templ,
                          unsigned depth, unsigned array_size,
                          unsigned usage, unsigned plane)
 {
-   unsigned height = tmpl->height;
-
    memset(templ, 0, sizeof(*templ));
    if (depth > 1)
       templ->target = PIPE_TEXTURE_3D;
@@ -259,14 +247,14 @@ vl_video_buffer_template(struct pipe_resource *templ,
       templ->target = PIPE_TEXTURE_2D;
    templ->format = resource_format;
    templ->width0 = tmpl->width;
+   templ->height0 = tmpl->height;
    templ->depth0 = depth;
    templ->array_size = array_size;
    templ->bind = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET | tmpl->bind;
    templ->usage = usage;
 
-   vl_video_buffer_adjust_size(&templ->width0, &height, plane,
+   vl_video_buffer_adjust_size(&templ->width0, &templ->height0, plane,
                                tmpl->chroma_format, false);
-   templ->height0 = height;
 }
 
 static void
diff --git a/lib/mesa/src/gallium/auxiliary/vl/vl_winsys.h b/lib/mesa/src/gallium/auxiliary/vl/vl_winsys.h
index 77277cefe..26db9f263 100644
--- a/lib/mesa/src/gallium/auxiliary/vl/vl_winsys.h
+++ b/lib/mesa/src/gallium/auxiliary/vl/vl_winsys.h
@@ -32,9 +32,7 @@
 #ifndef vl_winsys_h
 #define vl_winsys_h
 
-#ifdef HAVE_X11_PLATFORM
 #include <X11/Xlib.h>
-#endif
 #include "pipe/p_defines.h"
 #include "pipe/p_format.h"
 
@@ -61,37 +59,19 @@ struct vl_screen
    void *
    (*get_private)(struct vl_screen *vscreen);
 
-   void
-   (*set_back_texture_from_output)(struct vl_screen *vscreen,
-                                   struct pipe_resource *buffer,
-                                   uint32_t width, uint32_t height);
-
    struct pipe_screen *pscreen;
    struct pipe_loader_device *dev;
 };
 
-#ifdef HAVE_X11_PLATFORM
 struct vl_screen *
 vl_dri2_screen_create(Display *display, int screen);
-#else
-static inline struct vl_screen *
-vl_dri2_screen_create(void *display, int screen) { return NULL; };
-#endif
 
-#if defined(HAVE_X11_PLATFORM) && defined(HAVE_DRI3)
 struct vl_screen *
-vl_dri3_screen_create(Display *display, int screen);
-#else
-static inline struct vl_screen *
-vl_dri3_screen_create(void *display, int screen) { return NULL; };
-#endif
+vl_drm_screen_create(int fd);
 
-#ifdef HAVE_DRM_PLATFORM
+#if defined(HAVE_DRI3)
 struct vl_screen *
-vl_drm_screen_create(int fd);
-#else
-static inline struct vl_screen *
-vl_drm_screen_create(int fd) { return NULL; };
+vl_dri3_screen_create(Display *display, int screen);
 #endif
 
 #endif
diff --git a/lib/mesa/src/gallium/auxiliary/vl/vl_winsys_dri.c b/lib/mesa/src/gallium/auxiliary/vl/vl_winsys_dri.c
index 043483b7f..9ecc216b9 100644
--- a/lib/mesa/src/gallium/auxiliary/vl/vl_winsys_dri.c
+++ b/lib/mesa/src/gallium/auxiliary/vl/vl_winsys_dri.c
@@ -46,7 +46,7 @@
 #include "state_tracker/drm_driver.h"
 
 #include "util/u_memory.h"
-#include "util/crc32.h"
+#include "util/u_hash.h"
 #include "util/u_hash_table.h"
 #include "util/u_inlines.h"
 
@@ -326,7 +326,6 @@ vl_dri2_screen_create(Display *display, int screen)
    xcb_dri2_authenticate_cookie_t authenticate_cookie;
    xcb_dri2_authenticate_reply_t *authenticate = NULL;
    xcb_screen_iterator_t s;
-   xcb_screen_t *xcb_screen;
    xcb_generic_error_t *error = NULL;
    char *device_name;
    int fd, device_name_length;
@@ -358,11 +357,9 @@ vl_dri2_screen_create(Display *display, int screen)
       goto free_query;
 
    s = xcb_setup_roots_iterator(xcb_get_setup(scrn->conn));
-   xcb_screen = get_xcb_screen(s, screen);
-   if (!xcb_screen)
-      goto free_query;
 
    driverType = XCB_DRI2_DRIVER_TYPE_DRI;
+#ifdef DRI2DriverPrimeShift
    {
       char *prime = getenv("DRI_PRIME");
       if (prime) {
@@ -374,9 +371,10 @@ vl_dri2_screen_create(Display *display, int screen)
                ((primeid & DRI2DriverPrimeMask) << DRI2DriverPrimeShift);
       }
    }
+#endif
 
    connect_cookie = xcb_dri2_connect_unchecked(scrn->conn,
-                                               xcb_screen->root,
+                                               get_xcb_screen(s, screen)->root,
                                                driverType);
    connect = xcb_dri2_connect_reply(scrn->conn, connect_cookie, NULL);
    if (connect == NULL ||
@@ -398,7 +396,7 @@ vl_dri2_screen_create(Display *display, int screen)
       goto close_fd;
 
    authenticate_cookie = xcb_dri2_authenticate_unchecked(scrn->conn,
-                                                         xcb_screen->root,
+                                                         get_xcb_screen(s, screen)->root,
                                                          magic);
    authenticate = xcb_dri2_authenticate_reply(scrn->conn, authenticate_cookie, NULL);
 
@@ -406,7 +404,7 @@ vl_dri2_screen_create(Display *display, int screen)
       goto free_authenticate;
 
    if (pipe_loader_drm_probe_fd(&scrn->base.dev, fd))
-      scrn->base.pscreen = pipe_loader_create_screen(scrn->base.dev, 0);
+      scrn->base.pscreen = pipe_loader_create_screen(scrn->base.dev);
 
    if (!scrn->base.pscreen)
       goto release_pipe;
diff --git a/lib/mesa/src/gallium/auxiliary/vl/vl_winsys_dri3.c b/lib/mesa/src/gallium/auxiliary/vl/vl_winsys_dri3.c
index 68bac44d9..29299289f 100644
--- a/lib/mesa/src/gallium/auxiliary/vl/vl_winsys_dri3.c
+++ b/lib/mesa/src/gallium/auxiliary/vl/vl_winsys_dri3.c
@@ -31,7 +31,6 @@
 #include <X11/xshmfence.h>
 #include <xcb/dri3.h>
 #include <xcb/present.h>
-#include <xcb/xfixes.h>
 
 #include "loader.h"
 
@@ -72,12 +71,9 @@ struct vl_dri3_screen
    xcb_special_event_t *special_event;
 
    struct pipe_context *pipe;
-   struct pipe_resource *output_texture;
-   uint32_t clip_width, clip_height;
 
    struct vl_dri3_buffer *back_buffers[BACK_BUFFER_NUM];
    int cur_back;
-   int next_back;
 
    struct u_rect dirty_areas[BACK_BUFFER_NUM];
 
@@ -89,7 +85,7 @@ struct vl_dri3_screen
    int64_t last_ust, ns_frame, last_msc, next_msc;
 
    bool flushed;
-   bool is_different_gpu;
+   int is_different_gpu;
 };
 
 static void
@@ -109,8 +105,7 @@ dri3_free_back_buffer(struct vl_dri3_screen *scrn,
    xcb_free_pixmap(scrn->conn, buffer->pixmap);
    xcb_sync_destroy_fence(scrn->conn, buffer->sync_fence);
    xshmfence_unmap_shm(buffer->shm_fence);
-   if (!scrn->output_texture)
-      pipe_resource_reference(&buffer->texture, NULL);
+   pipe_resource_reference(&buffer->texture, NULL);
    if (buffer->linear_texture)
        pipe_resource_reference(&buffer->linear_texture, NULL);
    FREE(buffer);
@@ -241,31 +236,29 @@ dri3_alloc_back_buffer(struct vl_dri3_screen *scrn)
    templ.format = PIPE_FORMAT_B8G8R8X8_UNORM;
    templ.target = PIPE_TEXTURE_2D;
    templ.last_level = 0;
-   templ.width0 = (scrn->output_texture) ?
-                  scrn->output_texture->width0 : scrn->width;
-   templ.height0 = (scrn->output_texture) ?
-                   scrn->output_texture->height0 : scrn->height;
+   templ.width0 = scrn->width;
+   templ.height0 = scrn->height;
    templ.depth0 = 1;
    templ.array_size = 1;
 
    if (scrn->is_different_gpu) {
-      buffer->texture = (scrn->output_texture) ? scrn->output_texture :
-                        scrn->base.pscreen->resource_create(scrn->base.pscreen, &templ);
+      buffer->texture = scrn->base.pscreen->resource_create(scrn->base.pscreen,
+                                                            &templ);
       if (!buffer->texture)
          goto unmap_shm;
 
       templ.bind |= PIPE_BIND_SCANOUT | PIPE_BIND_SHARED |
                     PIPE_BIND_LINEAR;
-      buffer->linear_texture =
-          scrn->base.pscreen->resource_create(scrn->base.pscreen, &templ);
+      buffer->linear_texture = scrn->base.pscreen->resource_create(scrn->base.pscreen,
+                                                                  &templ);
       pixmap_buffer_texture = buffer->linear_texture;
 
       if (!buffer->linear_texture)
          goto no_linear_texture;
    } else {
       templ.bind |= PIPE_BIND_SCANOUT | PIPE_BIND_SHARED;
-      buffer->texture = (scrn->output_texture) ? scrn->output_texture :
-                        scrn->base.pscreen->resource_create(scrn->base.pscreen, &templ);
+      buffer->texture = scrn->base.pscreen->resource_create(scrn->base.pscreen,
+                                                            &templ);
       if (!buffer->texture)
          goto unmap_shm;
       pixmap_buffer_texture = buffer->texture;
@@ -278,14 +271,11 @@ dri3_alloc_back_buffer(struct vl_dri3_screen *scrn)
                                            usage);
    buffer_fd = whandle.handle;
    buffer->pitch = whandle.stride;
-   buffer->width = templ.width0;
-   buffer->height = templ.height0;
-
    xcb_dri3_pixmap_from_buffer(scrn->conn,
                                (pixmap = xcb_generate_id(scrn->conn)),
                                scrn->drawable,
                                0,
-                               buffer->width, buffer->height, buffer->pitch,
+                               scrn->width, scrn->height, buffer->pitch,
                                scrn->depth, 32,
                                buffer_fd);
    xcb_dri3_fence_from_fd(scrn->conn,
@@ -297,6 +287,8 @@ dri3_alloc_back_buffer(struct vl_dri3_screen *scrn)
    buffer->pixmap = pixmap;
    buffer->sync_fence = sync_fence;
    buffer->shm_fence = shm_fence;
+   buffer->width = scrn->width;
+   buffer->height = scrn->height;
 
    xshmfence_trigger(buffer->shm_fence);
 
@@ -318,8 +310,6 @@ dri3_get_back_buffer(struct vl_dri3_screen *scrn)
 {
    struct vl_dri3_buffer *buffer;
    struct pipe_resource *texture = NULL;
-   bool allocate_new_buffer = false;
-   int b, id;
 
    assert(scrn);
 
@@ -328,46 +318,8 @@ dri3_get_back_buffer(struct vl_dri3_screen *scrn)
       return NULL;
    buffer = scrn->back_buffers[scrn->cur_back];
 
-   if (scrn->output_texture) {
-      if (!buffer || buffer->width < scrn->width ||
-          buffer->height < scrn->height)
-         allocate_new_buffer = true;
-      else if (scrn->is_different_gpu)
-         /* In case of different gpu we can reuse the linear
-          * texture so we only need to set the external
-          * texture for copying
-          */
-         buffer->texture = scrn->output_texture;
-      else {
-         /* In case of a single gpu we search if the texture is
-          * already present as buffer if not we get the
-          * handle and pixmap for the texture that is set
-          */
-         for (b = 0; b < BACK_BUFFER_NUM; b++) {
-            id = (b + scrn->cur_back) % BACK_BUFFER_NUM;
-            buffer = scrn->back_buffers[id];
-            if (buffer && !buffer->busy &&
-                buffer->texture == scrn->output_texture) {
-               scrn->cur_back = id;
-               break;
-            }
-         }
-
-         if (b == BACK_BUFFER_NUM) {
-            allocate_new_buffer = true;
-            scrn->cur_back = scrn->next_back;
-            scrn->next_back = (scrn->next_back + 1) % BACK_BUFFER_NUM;
-            buffer = scrn->back_buffers[scrn->cur_back];
-         }
-      }
-
-   } else {
-      if (!buffer || buffer->width != scrn->width ||
-          buffer->height != scrn->height)
-         allocate_new_buffer = true;
-   }
-
-   if (allocate_new_buffer) {
+   if (!buffer || buffer->width != scrn->width ||
+       buffer->height != scrn->height) {
       struct vl_dri3_buffer *new_buffer;
 
       new_buffer = dri3_alloc_back_buffer(scrn);
@@ -377,8 +329,7 @@ dri3_get_back_buffer(struct vl_dri3_screen *scrn)
       if (buffer)
          dri3_free_back_buffer(scrn, buffer);
 
-      if (!scrn->output_texture)
-         vl_compositor_reset_dirty_area(&scrn->dirty_areas[scrn->cur_back]);
+      vl_compositor_reset_dirty_area(&scrn->dirty_areas[scrn->cur_back]);
       buffer = new_buffer;
       scrn->back_buffers[scrn->cur_back] = buffer;
    }
@@ -549,8 +500,6 @@ vl_dri3_flush_frontbuffer(struct pipe_screen *screen,
    uint32_t options = XCB_PRESENT_OPTION_NONE;
    struct vl_dri3_buffer *back;
    struct pipe_box src_box;
-   xcb_xfixes_region_t region;
-   xcb_rectangle_t rectangle;
 
    back = scrn->back_buffers[scrn->cur_back];
    if (!back)
@@ -562,16 +511,8 @@ vl_dri3_flush_frontbuffer(struct pipe_screen *screen,
             return;
    }
 
-   rectangle.x = 0;
-   rectangle.y = 0;
-   rectangle.width = (scrn->output_texture) ? scrn->clip_width : scrn->width;
-   rectangle.height = (scrn->output_texture) ? scrn->clip_height : scrn->height;
-
-   region = xcb_generate_id(scrn->conn);
-   xcb_xfixes_create_region(scrn->conn, region, 2, &rectangle);
-
    if (scrn->is_different_gpu) {
-      u_box_origin_2d(back->width, back->height, &src_box);
+      u_box_origin_2d(scrn->width, scrn->height, &src_box);
       scrn->pipe->resource_copy_region(scrn->pipe,
                                        back->linear_texture,
                                        0, 0, 0, 0,
@@ -587,7 +528,7 @@ vl_dri3_flush_frontbuffer(struct pipe_screen *screen,
                       scrn->drawable,
                       back->pixmap,
                       (uint32_t)(++scrn->send_sbc),
-                      0, region, 0, 0,
+                      0, 0, 0, 0,
                       None, None,
                       back->sync_fence,
                       options,
@@ -686,20 +627,6 @@ vl_dri3_screen_get_private(struct vl_screen *vscreen)
 }
 
 static void
-vl_dri3_screen_set_back_texture_from_output(struct vl_screen *vscreen,
-                                            struct pipe_resource *buffer,
-                                            uint32_t width, uint32_t height)
-{
-   struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
-
-   assert(scrn);
-
-   scrn->output_texture = buffer;
-   scrn->clip_width = (width) ? width : scrn->width;
-   scrn->clip_height = (height) ? height : scrn->height;
-}
-
-static void
 vl_dri3_screen_destroy(struct vl_screen *vscreen)
 {
    struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
@@ -748,9 +675,6 @@ vl_dri3_screen_create(Display *display, int screen)
    xcb_dri3_open_reply_t *open_reply;
    xcb_get_geometry_cookie_t geom_cookie;
    xcb_get_geometry_reply_t *geom_reply;
-   xcb_xfixes_query_version_cookie_t xfixes_cookie;
-   xcb_xfixes_query_version_reply_t *xfixes_reply;
-   xcb_generic_error_t *error;
    int fd;
 
    assert(display);
@@ -765,26 +689,12 @@ vl_dri3_screen_create(Display *display, int screen)
 
    xcb_prefetch_extension_data(scrn->conn , &xcb_dri3_id);
    xcb_prefetch_extension_data(scrn->conn, &xcb_present_id);
-   xcb_prefetch_extension_data (scrn->conn, &xcb_xfixes_id);
    extension = xcb_get_extension_data(scrn->conn, &xcb_dri3_id);
    if (!(extension && extension->present))
       goto free_screen;
    extension = xcb_get_extension_data(scrn->conn, &xcb_present_id);
    if (!(extension && extension->present))
       goto free_screen;
-   extension = xcb_get_extension_data(scrn->conn, &xcb_xfixes_id);
-   if (!(extension && extension->present))
-      goto free_screen;
-
-   xfixes_cookie = xcb_xfixes_query_version(scrn->conn, XCB_XFIXES_MAJOR_VERSION,
-                                            XCB_XFIXES_MINOR_VERSION);
-   xfixes_reply = xcb_xfixes_query_version_reply(scrn->conn, xfixes_cookie, &error);
-   if (!xfixes_reply || error || xfixes_reply->major_version < 2) {
-      free(error);
-      free(xfixes_reply);
-      goto free_screen;
-   }
-   free(xfixes_reply);
 
    open_cookie = xcb_dri3_open(scrn->conn, RootWindow(display, screen), None);
    open_reply = xcb_dri3_open_reply(scrn->conn, open_cookie, NULL);
@@ -817,13 +727,13 @@ vl_dri3_screen_create(Display *display, int screen)
    free(geom_reply);
 
    if (pipe_loader_drm_probe_fd(&scrn->base.dev, fd))
-      scrn->base.pscreen = pipe_loader_create_screen(scrn->base.dev, 0);
+      scrn->base.pscreen = pipe_loader_create_screen(scrn->base.dev);
 
    if (!scrn->base.pscreen)
       goto release_pipe;
 
    scrn->pipe = scrn->base.pscreen->context_create(scrn->base.pscreen,
-                                                   NULL, 0);
+                                                   &scrn->base, 0);
    if (!scrn->pipe)
        goto no_context;
 
@@ -834,9 +744,7 @@ vl_dri3_screen_create(Display *display, int screen)
    scrn->base.set_next_timestamp = vl_dri3_screen_set_next_timestamp;
    scrn->base.get_private = vl_dri3_screen_get_private;
    scrn->base.pscreen->flush_frontbuffer = vl_dri3_flush_frontbuffer;
-   scrn->base.set_back_texture_from_output = vl_dri3_screen_set_back_texture_from_output;
 
-   scrn->next_back = 1;
    return &scrn->base;
 
 no_context:
diff --git a/lib/mesa/src/gallium/auxiliary/vl/vl_winsys_drm.c b/lib/mesa/src/gallium/auxiliary/vl/vl_winsys_drm.c
index 6d9d94758..df8809c50 100644
--- a/lib/mesa/src/gallium/auxiliary/vl/vl_winsys_drm.c
+++ b/lib/mesa/src/gallium/auxiliary/vl/vl_winsys_drm.c
@@ -26,6 +26,7 @@
  **************************************************************************/
 
 #include <assert.h>
+#include <fcntl.h>
 
 #include "pipe/p_screen.h"
 #include "pipe-loader/pipe_loader.h"
@@ -41,20 +42,20 @@ struct vl_screen *
 vl_drm_screen_create(int fd)
 {
    struct vl_screen *vscreen;
-   int new_fd = -1;
+   int new_fd;
 
    vscreen = CALLOC_STRUCT(vl_screen);
    if (!vscreen)
       return NULL;
 
-   if (fd < 0 || (new_fd = dup(fd)) < 0)
-      goto error;
+   if (fd < 0 || (new_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3)) < 0)
+      goto free_screen;
 
    if (pipe_loader_drm_probe_fd(&vscreen->dev, new_fd))
       vscreen->pscreen = pipe_loader_create_screen(vscreen->dev);
 
    if (!vscreen->pscreen)
-      goto error;
+      goto release_pipe;
 
    vscreen->destroy = vl_drm_screen_destroy;
    vscreen->texture_from_drawable = NULL;
@@ -64,12 +65,13 @@ vl_drm_screen_create(int fd)
    vscreen->get_private = NULL;
    return vscreen;
 
-error:
+release_pipe:
    if (vscreen->dev)
       pipe_loader_release(&vscreen->dev, 1);
    else
       close(new_fd);
 
+free_screen:
    FREE(vscreen);
    return NULL;
 }
diff --git a/lib/mesa/src/gallium/auxiliary/vl/vl_zscan.c b/lib/mesa/src/gallium/auxiliary/vl/vl_zscan.c
index 75013c42b..24d64525b 100644
--- a/lib/mesa/src/gallium/auxiliary/vl/vl_zscan.c
+++ b/lib/mesa/src/gallium/auxiliary/vl/vl_zscan.c
@@ -95,27 +95,6 @@ const int vl_zscan_alternate[] =
    38,46,54,62,39,47,55,63
 };
 
-const int vl_zscan_h265_up_right_diagonal_16[] =
-{
-   /* Up-right diagonal scan order for 4x4 blocks - see H.265 section 6.5.3. */
-    0,  4,  1,  8,  5,  2, 12,  9,
-    6,  3, 13, 10,  7, 14, 11, 15,
-};
-
-const int vl_zscan_h265_up_right_diagonal[] =
-{
-   /* Up-right diagonal scan order for 8x8 blocks - see H.265 section 6.5.3. */
-    0,  8,  1, 16,  9,  2, 24, 17,
-   10,  3, 32, 25, 18, 11,  4, 40,
-   33, 26, 19, 12,  5, 48, 41, 34,
-   27, 20, 13,  6, 56, 49, 42, 35,
-   28, 21, 14,  7, 57, 50, 43, 36,
-   29, 22, 15, 58, 51, 44, 37, 30,
-   23, 59, 52, 45, 38, 31, 60, 53,
-   46, 39, 61, 54, 47, 62, 55, 63,
-};
-
-
 static void *
 create_vert_shader(struct vl_zscan *zscan)
 {
diff --git a/lib/mesa/src/gallium/auxiliary/vl/vl_zscan.h b/lib/mesa/src/gallium/auxiliary/vl/vl_zscan.h
index 292152e87..268cf0a6e 100644
--- a/lib/mesa/src/gallium/auxiliary/vl/vl_zscan.h
+++ b/lib/mesa/src/gallium/auxiliary/vl/vl_zscan.h
@@ -68,8 +68,6 @@ extern const int vl_zscan_normal_16[];
 extern const int vl_zscan_linear[];
 extern const int vl_zscan_normal[];
 extern const int vl_zscan_alternate[];
-extern const int vl_zscan_h265_up_right_diagonal_16[];
-extern const int vl_zscan_h265_up_right_diagonal[];
 
 struct pipe_sampler_view *
 vl_zscan_layout(struct pipe_context *pipe, const int layout[64], unsigned blocks_per_line);