Attachment 81345 Details for Bug 64695 – Improved error handling for post-process code

[patch] Improved error handling for post-process code

0001-postprocess-handle-partial-intialization-failures.patch (text/plain), 23.47 KB, created by Brian Paul on 2013-06-24 14:33:45 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Brian Paul

Created: 2013-06-24 14:33:45 UTC

Size: 23.47 KB

patch

obsolete

>From f0f1c0225d1f1351f8d0ffa201ad21c7dc688415 Mon Sep 17 00:00:00 2001
>From: Matthew McClure <mcclurem@vmware.com>
>Date: Fri, 21 Jun 2013 13:45:55 -0700
>Subject: [PATCH] postprocess: handle partial intialization failures.
>
>This patch fixes segfaults observed when enabling the post processing
>features. When the format is not supported, or a texture cannot be
>created, the code must gracefully handle failure and report the error to
>the calling code for proper failure handling.
>
>To accomplish this the following changes were made to the filters.h
>prototypes:
>
>- bool return for pp_init_func
>- Added pp_free_func for filter specific resource destruction
>
>Fixes segfaults from backtraces:
>
>* util_destroy_blit
>  pp_free
>
>* u_transfer_inline_write_vtbl
>  pp_jimenezmlaa_init_run
>  pp_init
>
>This patch also uses tgsi_alloc_tokens to allocate temporary tokens in
>pp_tgsi_to_state, instead of allocating the array on the stack. This
>fixes the following stack corruption segfault in pp_run.c:
>
>* _int_free
>  aaline_delete_fs_state
>  pp_free
>
>Bug Number: 1021843
>Reviewed-by: Brian Paul <brianp@vmware.com>
>---
> src/gallium/auxiliary/postprocess/filters.h     |   18 +--
> src/gallium/auxiliary/postprocess/postprocess.h |   22 ++--
> src/gallium/auxiliary/postprocess/pp_celshade.c |   10 +-
> src/gallium/auxiliary/postprocess/pp_colors.c   |   21 +++-
> src/gallium/auxiliary/postprocess/pp_init.c     |  145 +++++++++++++++++------
> src/gallium/auxiliary/postprocess/pp_mlaa.c     |  121 +++++++++++++------
> src/gallium/auxiliary/postprocess/pp_run.c      |   39 +++++-
> 7 files changed, 281 insertions(+), 95 deletions(-)
>
>diff --git a/src/gallium/auxiliary/postprocess/filters.h b/src/gallium/auxiliary/postprocess/filters.h
>index 2454088..c2b2da1 100644
>--- a/src/gallium/auxiliary/postprocess/filters.h
>+++ b/src/gallium/auxiliary/postprocess/filters.h
>@@ -30,8 +30,9 @@
> 
> #include "postprocess/postprocess.h"
> 
>-typedef void (*pp_init_func) (struct pp_queue_t *, unsigned int,
>+typedef bool (*pp_init_func) (struct pp_queue_t *, unsigned int,
>                               unsigned int);
>+typedef void (*pp_free_func) (struct pp_queue_t *, unsigned int);
> 
> struct pp_filter_t
> {
>@@ -41,18 +42,19 @@ struct pp_filter_t
>    unsigned int verts;          /* How many are vertex shaders */
>    pp_init_func init;           /* Init function */
>    pp_func main;                /* Run function */
>+   pp_free_func free;           /* Free function */
> };
> 
> /*	Order matters. Put new filters in a suitable place. */
> 
> static const struct pp_filter_t pp_filters[PP_FILTERS] = {
>-/*    name			inner	shaders	verts	init			run */
>-   { "pp_noblue",		0,	2,	1,	pp_noblue_init,		pp_nocolor },
>-   { "pp_nogreen",		0,	2,	1,	pp_nogreen_init,	pp_nocolor },
>-   { "pp_nored",		0,	2,	1,	pp_nored_init,		pp_nocolor },
>-   { "pp_celshade",		0,	2,	1,	pp_celshade_init,	pp_nocolor },
>-   { "pp_jimenezmlaa",		2,	5,	2,	pp_jimenezmlaa_init,	pp_jimenezmlaa },
>-   { "pp_jimenezmlaa_color",	2,	5,	2,	pp_jimenezmlaa_init_color, pp_jimenezmlaa_color },
>+/*    name			inner	shaders	verts	init			run                       free   */
>+   { "pp_noblue",		0,	2,	1,	pp_noblue_init,		pp_nocolor,               pp_nocolor_free },
>+   { "pp_nogreen",		0,	2,	1,	pp_nogreen_init,	pp_nocolor,               pp_nocolor_free },
>+   { "pp_nored",		0,	2,	1,	pp_nored_init,		pp_nocolor,               pp_nocolor_free },
>+   { "pp_celshade",		0,	2,	1,	pp_celshade_init,	pp_nocolor,               pp_celshade_free },
>+   { "pp_jimenezmlaa",		2,	5,	2,	pp_jimenezmlaa_init,	pp_jimenezmlaa,           pp_jimenezmlaa_free },
>+   { "pp_jimenezmlaa_color",	2,	5,	2,	pp_jimenezmlaa_init_color, pp_jimenezmlaa_color,  pp_jimenezmlaa_free },
> };
> 
> #endif
>diff --git a/src/gallium/auxiliary/postprocess/postprocess.h b/src/gallium/auxiliary/postprocess/postprocess.h
>index 52ebeb9..8678996 100644
>--- a/src/gallium/auxiliary/postprocess/postprocess.h
>+++ b/src/gallium/auxiliary/postprocess/postprocess.h
>@@ -53,11 +53,13 @@ struct pp_queue_t
> 
>    struct pipe_resource *depth; /* depth of original input */
>    struct pipe_resource *stencil;       /* stencil shared by inner_tmps */
>+   struct pipe_resource *constbuf;      /* MLAA constant buffer */
>+   struct pipe_resource *areamaptex;    /* MLAA area map texture */
> 
>    struct pipe_surface *tmps[2], *inner_tmps[3], *stencils;
> 
>    void ***shaders;             /* Shaders in TGSI form */
>-   unsigned int *verts;
>+   unsigned int *filters;       /* Active filter to filters.h mapping. */
>    struct program *p;
> 
>    bool fbos_init;
>@@ -88,14 +90,20 @@ void pp_jimenezmlaa_color(struct pp_queue_t *, struct pipe_resource *,
> 
> /* The filter init functions */
> 
>-void pp_celshade_init(struct pp_queue_t *, unsigned int, unsigned int);
>+bool pp_celshade_init(struct pp_queue_t *, unsigned int, unsigned int);
> 
>-void pp_nored_init(struct pp_queue_t *, unsigned int, unsigned int);
>-void pp_nogreen_init(struct pp_queue_t *, unsigned int, unsigned int);
>-void pp_noblue_init(struct pp_queue_t *, unsigned int, unsigned int);
>+bool pp_nored_init(struct pp_queue_t *, unsigned int, unsigned int);
>+bool pp_nogreen_init(struct pp_queue_t *, unsigned int, unsigned int);
>+bool pp_noblue_init(struct pp_queue_t *, unsigned int, unsigned int);
> 
>-void pp_jimenezmlaa_init(struct pp_queue_t *, unsigned int, unsigned int);
>-void pp_jimenezmlaa_init_color(struct pp_queue_t *, unsigned int,
>+bool pp_jimenezmlaa_init(struct pp_queue_t *, unsigned int, unsigned int);
>+bool pp_jimenezmlaa_init_color(struct pp_queue_t *, unsigned int,
>                                unsigned int);
> 
>+/* The filter free functions */
>+
>+void pp_celshade_free(struct pp_queue_t *, unsigned int);
>+void pp_nocolor_free(struct pp_queue_t *, unsigned int);
>+void pp_jimenezmlaa_free(struct pp_queue_t *, unsigned int);
>+
> #endif
>diff --git a/src/gallium/auxiliary/postprocess/pp_celshade.c b/src/gallium/auxiliary/postprocess/pp_celshade.c
>index 4454764..b7b7473 100644
>--- a/src/gallium/auxiliary/postprocess/pp_celshade.c
>+++ b/src/gallium/auxiliary/postprocess/pp_celshade.c
>@@ -30,9 +30,17 @@
> #include "postprocess/pp_filters.h"
> 
> /** Init function */
>-void
>+bool
> pp_celshade_init(struct pp_queue_t *ppq, unsigned int n, unsigned int val)
> {
>    ppq->shaders[n][1] =
>       pp_tgsi_to_state(ppq->p->pipe, celshade, false, "celshade");
>+
>+   return (ppq->shaders[n][1] != NULL) ? TRUE : FALSE;
>+}
>+
>+/** Free function */
>+void
>+pp_celshade_free(struct pp_queue_t *ppq, unsigned int n)
>+{
> }
>diff --git a/src/gallium/auxiliary/postprocess/pp_colors.c b/src/gallium/auxiliary/postprocess/pp_colors.c
>index 1773e53..756d92f 100644
>--- a/src/gallium/auxiliary/postprocess/pp_colors.c
>+++ b/src/gallium/auxiliary/postprocess/pp_colors.c
>@@ -57,24 +57,37 @@ pp_nocolor(struct pp_queue_t *ppq, struct pipe_resource *in,
> 
> /* Init functions */
> 
>-void
>+bool
> pp_nored_init(struct pp_queue_t *ppq, unsigned int n, unsigned int val)
> {
>-   ppq->shaders[n][1] = pp_tgsi_to_state(ppq->p->pipe, nored, false, "nored");
>+   ppq->shaders[n][1] =
>+      pp_tgsi_to_state(ppq->p->pipe, nored, false, "nored");
>+
>+   return (ppq->shaders[n][1] != NULL) ? TRUE : FALSE;
> }
> 
> 
>-void
>+bool
> pp_nogreen_init(struct pp_queue_t *ppq, unsigned int n, unsigned int val)
> {
>    ppq->shaders[n][1] =
>       pp_tgsi_to_state(ppq->p->pipe, nogreen, false, "nogreen");
>+
>+   return (ppq->shaders[n][1] != NULL) ? TRUE : FALSE;
> }
> 
> 
>-void
>+bool
> pp_noblue_init(struct pp_queue_t *ppq, unsigned int n, unsigned int val)
> {
>    ppq->shaders[n][1] =
>       pp_tgsi_to_state(ppq->p->pipe, noblue, false, "noblue");
>+
>+   return (ppq->shaders[n][1] != NULL) ? TRUE : FALSE;
>+}
>+
>+/* Free functions */
>+void
>+pp_nocolor_free(struct pp_queue_t *ppq, unsigned int n)
>+{
> }
>diff --git a/src/gallium/auxiliary/postprocess/pp_init.c b/src/gallium/auxiliary/postprocess/pp_init.c
>index 89aa501..5f71a19 100644
>--- a/src/gallium/auxiliary/postprocess/pp_init.c
>+++ b/src/gallium/auxiliary/postprocess/pp_init.c
>@@ -42,57 +42,81 @@ struct pp_queue_t *
> pp_init(struct pipe_context *pipe, const unsigned int *enabled,
>         struct cso_context *cso)
> {
>-
>+   unsigned int num_filters = 0;
>    unsigned int curpos = 0, i, tmp_req = 0;
>    struct pp_queue_t *ppq;
>-   pp_func *tmp_q;
> 
>    pp_debug("Initializing the post-processing queue.\n");
> 
>    /* How many filters were requested? */
>    for (i = 0; i < PP_FILTERS; i++) {
>       if (enabled[i])
>-         curpos++;
>+         num_filters++;
>    }
>-   if (!curpos)
>+   if (num_filters == 0)
>       return NULL;
> 
>    ppq = CALLOC(1, sizeof(struct pp_queue_t));
>-   tmp_q = CALLOC(curpos, sizeof(pp_func));
>-   ppq->shaders = CALLOC(curpos, sizeof(void *));
>-   ppq->verts = CALLOC(curpos, sizeof(unsigned int));
> 
>-   if (!tmp_q || !ppq || !ppq->shaders || !ppq->verts)
>+   if (ppq == NULL) {
>+      pp_debug("Unable to allocate memory for ppq.\n");
>       goto error;
>+   }
>+
>+   ppq->pp_queue = CALLOC(num_filters, sizeof(pp_func));
>+   if (ppq->pp_queue == NULL) {
>+      pp_debug("Unable to allocate memory for pp_queue.\n");
>+      goto error;
>+   }
>+
>+   ppq->shaders = CALLOC(num_filters, sizeof(void *));
>+   ppq->filters = CALLOC(num_filters, sizeof(unsigned int));
>+
>+   if ((ppq->shaders == NULL) ||
>+       (ppq->filters == NULL)) {
>+      pp_debug("Unable to allocate memory for shaders and filter arrays.\n");
>+      goto error;
>+   }
> 
>    ppq->p = pp_init_prog(ppq, pipe, cso);
>-   if (!ppq->p)
>+   if (ppq->p == NULL) {
>+      pp_debug("pp_init_prog returned NULL.\n");
>       goto error;
>+   }
> 
>    /* Add the enabled filters to the queue, in order */
>    curpos = 0;
>-   ppq->pp_queue = tmp_q;
>    for (i = 0; i < PP_FILTERS; i++) {
>       if (enabled[i]) {
>          ppq->pp_queue[curpos] = pp_filters[i].main;
>          tmp_req = MAX2(tmp_req, pp_filters[i].inner_tmps);
>+         ppq->filters[curpos] = i;
> 
>          if (pp_filters[i].shaders) {
>             ppq->shaders[curpos] =
>                CALLOC(pp_filters[i].shaders + 1, sizeof(void *));
>-            ppq->verts[curpos] = pp_filters[i].verts;
>-            if (!ppq->shaders[curpos])
>+            if (!ppq->shaders[curpos]) {
>+               pp_debug("Unable to allocate memory for shader list.\n");
>                goto error;
>+            }
>          }
>-         pp_filters[i].init(ppq, curpos, enabled[i]);
>+
>+         /* Call the initialization function for the filter. */
>+         if (!pp_filters[i].init(ppq, curpos, enabled[i])) {
>+            pp_debug("Initialization for filter %u failed.\n", i);
>+            goto error;
>+         }           
> 
>          curpos++;
>       }
>    }
> 
>    ppq->p->blitctx = util_create_blit(ppq->p->pipe, cso);
>-   if (!ppq->p->blitctx)
>+
>+   if (ppq->p->blitctx == NULL) {
>+      pp_debug("Unable to create a blit context.\n");
>       goto error;
>+   }
> 
>    ppq->n_filters = curpos;
>    ppq->n_tmp = (curpos > 2 ? 2 : 1);
>@@ -104,16 +128,18 @@ pp_init(struct pipe_context *pipe, const unsigned int *enabled,
>       ppq->shaders[i][0] = ppq->p->passvs;
> 
>    pp_debug("Queue successfully allocated. %u filter(s).\n", curpos);
>-
>+   
>    return ppq;
> 
>  error:
>-   pp_debug("Error setting up pp\n");
> 
>-   if (ppq)
>-      FREE(ppq->p);
>-   FREE(ppq);
>-   FREE(tmp_q);
>+   if (ppq) {
>+      /* Assign curpos, since we only need to destroy initialized filters. */
>+      ppq->n_filters = curpos;
>+
>+      /* Call the common free function which must handle partial initialization. */
>+      pp_free(ppq);
>+   }
> 
>    return NULL;
> }
>@@ -142,33 +168,81 @@ pp_free_fbos(struct pp_queue_t *ppq)
>    ppq->fbos_init = false;
> }
> 
>-/** Free the pp queue. Called on context termination. */
>+/** 
>+ * Free the pp queue. Called on context termination and failure in
>+ * pp_init.
>+ */
> void
> pp_free(struct pp_queue_t *ppq)
> {
>-
>    unsigned int i, j;
> 
>    pp_free_fbos(ppq);
> 
>-   util_destroy_blit(ppq->p->blitctx);
>+   if (ppq && ppq->p) {
>+      /* Only destroy created contexts. */
>+      if (ppq->p->blitctx) {
>+         util_destroy_blit(ppq->p->blitctx);
>+      }
> 
>-   for (i = 0; i < ppq->n_filters; i++) {
>-      for (j = 0; j < PP_MAX_PASSES && ppq->shaders[i][j]; j++) {
>-         if (j >= ppq->verts[i]) {
>-            ppq->p->pipe->delete_fs_state(ppq->p->pipe, ppq->shaders[i][j]);
>-            ppq->shaders[i][j] = NULL;
>-         }
>-         else if (ppq->shaders[i][j] != ppq->p->passvs) {
>-            ppq->p->pipe->delete_vs_state(ppq->p->pipe, ppq->shaders[i][j]);
>-            ppq->shaders[i][j] = NULL;
>+      if (ppq->p->pipe && ppq->filters && ppq->shaders) {
>+         for (i = 0; i < ppq->n_filters; i++) {
>+            unsigned int filter = ppq->filters[i];
>+
>+            if (ppq->shaders[i] == NULL) {
>+               continue;
>+            }
>+
>+            /*
>+             * Common shader destruction code for all postprocessing
>+             * filters.
>+             */
>+            for (j = 0; j < pp_filters[filter].shaders; j++) {
>+               if (ppq->shaders[i][j] == NULL) {
>+                  /* We reached the end of initialized shaders. */
>+                  break;
>+               }
>+
>+               if (ppq->shaders[i][j] == ppq->p->passvs) {
>+                  continue;
>+               }
>+
>+               assert(ppq);
>+               assert(ppq->p);
>+               assert(ppq->p->pipe);
>+ 
>+               if (j >= pp_filters[filter].verts) {
>+                  assert(ppq->p->pipe->delete_fs_state);
>+                  ppq->p->pipe->delete_fs_state(ppq->p->pipe,
>+                                                ppq->shaders[i][j]);
>+                  ppq->shaders[i][j] = NULL;
>+               } else {
>+                  assert(ppq->p->pipe->delete_vs_state);
>+                  ppq->p->pipe->delete_vs_state(ppq->p->pipe,
>+                                                ppq->shaders[i][j]);
>+                  ppq->shaders[i][j] = NULL;
>+               }
>+            }
>+
>+            /* Finally call each filter type's free functionality. */
>+            pp_filters[filter].free(ppq, i);
>          }
>       }
>+
>+      FREE(ppq->p);
>    }
> 
>-   FREE(ppq->p);
>-   FREE(ppq->pp_queue);
>-   FREE(ppq);
>+   if (ppq) {
>+      /*
>+       * Handle partial initialization for common resource destruction
>+       * in the create path.
>+       */
>+      FREE(ppq->filters);
>+      FREE(ppq->shaders);
>+      FREE(ppq->pp_queue);
>+  
>+      FREE(ppq);
>+   }
> 
>    pp_debug("Queue taken down.\n");
> }
>@@ -256,7 +330,6 @@ pp_init_fbos(struct pp_queue_t *ppq, unsigned int w,
>    if (!ppq->stencil || !ppq->stencils)
>       goto error;
> 
>-
>    p->framebuffer.width = w;
>    p->framebuffer.height = h;
> 
>diff --git a/src/gallium/auxiliary/postprocess/pp_mlaa.c b/src/gallium/auxiliary/postprocess/pp_mlaa.c
>index 6d9fa9a..503749b 100644
>--- a/src/gallium/auxiliary/postprocess/pp_mlaa.c
>+++ b/src/gallium/auxiliary/postprocess/pp_mlaa.c
>@@ -56,16 +56,16 @@
> static float constants[] = { 1, 1, 0, 0 };
> static unsigned int dimensions[2] = { 0, 0 };
> 
>-static struct pipe_resource *constbuf, *areamaptex;
>-
> /** Upload the constants. */
> static void
>-up_consts(struct pipe_context *pipe)
>+up_consts(struct pp_queue_t *ppq)
> {
>+   struct pipe_context *pipe = ppq->p->pipe;
>    struct pipe_box box;
> 
>    u_box_2d(0, 0, sizeof(constants), 1, &box);
>-   pipe->transfer_inline_write(pipe, constbuf, 0, PIPE_TRANSFER_WRITE,
>+
>+   pipe->transfer_inline_write(pipe, ppq->constbuf, 0, PIPE_TRANSFER_WRITE,
>                                &box, constants, sizeof(constants),
>                                sizeof(constants));
> }
>@@ -81,11 +81,24 @@ pp_jimenezmlaa_run(struct pp_queue_t *ppq, struct pipe_resource *in,
>    struct pipe_depth_stencil_alpha_state mstencil;
>    struct pipe_sampler_view v_tmp, *arr[3];
> 
>-   unsigned int w = p->framebuffer.width;
>-   unsigned int h = p->framebuffer.height;
>+   unsigned int w = 0;
>+   unsigned int h = 0;
> 
>    const struct pipe_stencil_ref ref = { {1} };
>+
>+   /* Insufficient initialization checks. */
>+   assert(p);
>+   assert(ppq);
>+   assert(ppq->constbuf);
>+   assert(ppq->areamaptex);
>+   assert(ppq->inner_tmp);
>+   assert(ppq->shaders[n]);
>+
>+   w = p->framebuffer.width;
>+   h = p->framebuffer.height;
>+
>    memset(&mstencil, 0, sizeof(mstencil));
>+
>    cso_set_stencil_ref(p->cso, &ref);
> 
>    /* Init the pixel size constant */
>@@ -94,13 +107,15 @@ pp_jimenezmlaa_run(struct pp_queue_t *ppq, struct pipe_resource *in,
>       constants[0] = 1.0f / p->framebuffer.width;
>       constants[1] = 1.0f / p->framebuffer.height;
> 
>-      up_consts(p->pipe);
>+      up_consts(ppq);
>       dimensions[0] = p->framebuffer.width;
>       dimensions[1] = p->framebuffer.height;
>    }
> 
>-   cso_set_constant_buffer_resource(p->cso, PIPE_SHADER_VERTEX, 0, constbuf);
>-   cso_set_constant_buffer_resource(p->cso, PIPE_SHADER_FRAGMENT, 0, constbuf);
>+   cso_set_constant_buffer_resource(p->cso, PIPE_SHADER_VERTEX,
>+                                    0, ppq->constbuf);
>+   cso_set_constant_buffer_resource(p->cso, PIPE_SHADER_FRAGMENT,
>+                                    0, ppq->constbuf);
> 
>    mstencil.stencil[0].enabled = 1;
>    mstencil.stencil[0].valuemask = mstencil.stencil[0].writemask = ~0;
>@@ -142,7 +157,7 @@ pp_jimenezmlaa_run(struct pp_queue_t *ppq, struct pipe_resource *in,
>    mstencil.stencil[0].zpass_op = PIPE_STENCIL_OP_KEEP;
>    cso_set_depth_stencil_alpha(p->cso, &mstencil);
> 
>-   pp_filter_setup_in(p, areamaptex);
>+   pp_filter_setup_in(p, ppq->areamaptex);
>    pp_filter_setup_out(p, ppq->inner_tmp[1]);
> 
>    u_sampler_view_default_template(&v_tmp, ppq->inner_tmp[0],
>@@ -206,32 +221,34 @@ pp_jimenezmlaa_run(struct pp_queue_t *ppq, struct pipe_resource *in,
> }
> 
> /** The init function of the MLAA filter. */
>-static void
>+static bool
> pp_jimenezmlaa_init_run(struct pp_queue_t *ppq, unsigned int n,
>                         unsigned int val, bool iscolor)
> {
> 
>    struct pipe_box box;
>    struct pipe_resource res;
>-   char *tmp_text;
>-
>-   constbuf = pipe_buffer_create(ppq->p->screen, PIPE_BIND_CONSTANT_BUFFER,
>-                                 PIPE_USAGE_STATIC, sizeof(constants));
>-   if (!constbuf) {
>-      pp_debug("Failed to allocate constant buffer\n");
>-      return;
>-   }
>-
>-
>-   pp_debug("mlaa: using %u max search steps\n", val);
>+   char *tmp_text = NULL;
> 
>    tmp_text = CALLOC(sizeof(blend2fs_1) + sizeof(blend2fs_2) +
>                      IMM_SPACE, sizeof(char));
> 
>-   if (!tmp_text) {
>+   if (tmp_text == NULL) {
>       pp_debug("Failed to allocate shader space\n");
>-      return;
>+      return FALSE;
>+   }
>+
>+   ppq->constbuf = pipe_buffer_create(ppq->p->screen,
>+                                      PIPE_BIND_CONSTANT_BUFFER,
>+                                      PIPE_USAGE_STATIC,
>+                                      sizeof(constants));
>+   if (ppq->constbuf == NULL) {
>+      pp_debug("Failed to allocate constant buffer\n");
>+      goto fail;
>    }
>+
>+   pp_debug("mlaa: using %u max search steps\n", val);
>+
>    util_sprintf(tmp_text, "%s"
>                 "IMM FLT32 {    %.8f,     0.0000,     0.0000,     0.0000}\n"
>                 "%s\n", blend2fs_1, (float) val, blend2fs_2);
>@@ -249,15 +266,19 @@ pp_jimenezmlaa_init_run(struct pp_queue_t *ppq, unsigned int n,
>                                             res.target, 1, res.bind))
>       pp_debug("Areamap format not supported\n");
> 
>-   areamaptex = ppq->p->screen->resource_create(ppq->p->screen, &res);
>+   ppq->areamaptex = ppq->p->screen->resource_create(ppq->p->screen, &res);
>+   
>+   if (ppq->areamaptex == NULL) {
>+      pp_debug("Failed to allocate area map texture\n");
>+      goto fail;
>+   }
>+   
>    u_box_2d(0, 0, 165, 165, &box);
> 
>-   ppq->p->pipe->transfer_inline_write(ppq->p->pipe, areamaptex, 0,
>+   ppq->p->pipe->transfer_inline_write(ppq->p->pipe, ppq->areamaptex, 0,
>                                        PIPE_TRANSFER_WRITE, &box,
>                                        areamap, 165 * 2, sizeof(areamap));
> 
>-
>-
>    ppq->shaders[n][1] = pp_tgsi_to_state(ppq->p->pipe, offsetvs, true,
>                                          "offsetvs");
>    if (iscolor)
>@@ -272,23 +293,35 @@ pp_jimenezmlaa_init_run(struct pp_queue_t *ppq, unsigned int n,
>                                          "neigh3fs");
> 
>    FREE(tmp_text);
>+
>+   return TRUE;
>+
>+ fail:
>+   
>+   FREE(tmp_text);
>+
>+   /*
>+    * Call the common free function for destruction of partially initialized
>+    * resources.
>+    */
>+   pp_jimenezmlaa_free(ppq, n);
>+
>+   return FALSE;
> }
> 
> /** Short wrapper to init the depth version. */
>-void
>+bool
> pp_jimenezmlaa_init(struct pp_queue_t *ppq, unsigned int n, unsigned int val)
> {
>-
>-   pp_jimenezmlaa_init_run(ppq, n, val, false);
>+   return pp_jimenezmlaa_init_run(ppq, n, val, false);
> }
> 
> /** Short wrapper to init the color version. */
>-void
>+bool
> pp_jimenezmlaa_init_color(struct pp_queue_t *ppq, unsigned int n,
>                           unsigned int val)
> {
>-
>-   pp_jimenezmlaa_init_run(ppq, n, val, true);
>+   return pp_jimenezmlaa_init_run(ppq, n, val, true);
> }
> 
> /** Short wrapper to run the depth version. */
>@@ -306,3 +339,23 @@ pp_jimenezmlaa_color(struct pp_queue_t *ppq, struct pipe_resource *in,
> {
>    pp_jimenezmlaa_run(ppq, in, out, n, true);
> }
>+
>+
>+/**
>+ * Short wrapper to free the mlaa filter resources. Shaders are freed in
>+ * the common code in pp_free.
>+ */
>+void
>+pp_jimenezmlaa_free(struct pp_queue_t *ppq, unsigned int n)
>+{
>+   if (ppq->areamaptex) {
>+      ppq->p->screen->resource_destroy(ppq->p->screen, ppq->areamaptex);
>+      ppq->areamaptex = NULL;
>+   }
>+
>+   if (ppq->constbuf) {
>+      ppq->p->screen->resource_destroy(ppq->p->screen, ppq->constbuf);
>+      ppq->constbuf = NULL;
>+   }
>+}
>+
>diff --git a/src/gallium/auxiliary/postprocess/pp_run.c b/src/gallium/auxiliary/postprocess/pp_run.c
>index 54a513e..5b1d016 100644
>--- a/src/gallium/auxiliary/postprocess/pp_run.c
>+++ b/src/gallium/auxiliary/postprocess/pp_run.c
>@@ -32,6 +32,8 @@
> #include "util/u_inlines.h"
> #include "util/u_sampler.h"
> 
>+#include "tgsi/tgsi_parse.h"
>+
> /**
> *	Main run function of the PP queue. Called on swapbuffers/flush.
> *
>@@ -46,6 +48,13 @@ pp_run(struct pp_queue_t *ppq, struct pipe_resource *in,
>    unsigned int i;
>    struct cso_context *cso = ppq->p->cso;
> 
>+   if (ppq->n_filters == 0)
>+      return;
>+
>+   assert(ppq->pp_queue);
>+   assert(ppq->tmp[0]);
>+   assert(ppq->tmp[1]);
>+ 
>    if (in->width0 != ppq->p->framebuffer.width ||
>        in->height0 != ppq->p->framebuffer.height) {
>       pp_debug("Resizing the temp pp buffers\n");
>@@ -98,6 +107,9 @@ pp_run(struct pp_queue_t *ppq, struct pipe_resource *in,
>    pipe_resource_reference(&refout, out);
> 
>    switch (ppq->n_filters) {
>+   case 0:
>+      /* Failsafe, but never reached. */
>+      break;
>    case 1:                     /* No temp buf */
>       ppq->pp_queue[0] (ppq, in, out, 0);
>       break;
>@@ -192,7 +204,19 @@ pp_tgsi_to_state(struct pipe_context *pipe, const char *text, bool isvs,
>                  const char *name)
> {
>    struct pipe_shader_state state;
>-   struct tgsi_token tokens[PP_MAX_TOKENS];
>+   struct tgsi_token *tokens = NULL;
>+   void *ret_state = NULL;
>+ 
>+   /*
>+    * Allocate temporary token storage. State creation will duplicate
>+    * tokens so we must free them on exit.
>+    */ 
>+   tokens = tgsi_alloc_tokens(PP_MAX_TOKENS);
>+
>+   if (tokens == NULL) {
>+      pp_debug("Failed to allocate temporary token storage.\n");
>+      return NULL;
>+   }
> 
>    if (tgsi_text_translate(text, tokens, Elements(tokens)) == FALSE) {
>       pp_debug("Failed to translate %s\n", name);
>@@ -202,10 +226,15 @@ pp_tgsi_to_state(struct pipe_context *pipe, const char *text, bool isvs,
>    state.tokens = tokens;
>    memset(&state.stream_output, 0, sizeof(state.stream_output));
> 
>-   if (isvs)
>-      return pipe->create_vs_state(pipe, &state);
>-   else
>-      return pipe->create_fs_state(pipe, &state);
>+   if (isvs) {
>+      ret_state = pipe->create_vs_state(pipe, &state);
>+      FREE(tokens);
>+   } else {
>+      ret_state = pipe->create_fs_state(pipe, &state);
>+      FREE(tokens);
>+   }
>+
>+   return ret_state;
> }
> 
> /** Setup misc state for the filter. */
>-- 
>1.7.10.4
>

Actions: View | Splinter Review

Attachments on bug 64695: 81345

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.