intel: Stop creating the wrapped stencil irb.
authorEric Anholt <eric@anholt.net>
Wed, 7 Dec 2011 23:02:02 +0000 (15:02 -0800)
committerEric Anholt <eric@anholt.net>
Mon, 19 Dec 2011 21:20:11 +0000 (13:20 -0800)
There were only two places it was really used at this point, which was
in the batchbuffer emit of the separate stencil packets for gen6/7.
Just write in the ->stencil_mt reference in those two places and ditch
all this flailing around with allocation and refcounts.

v2: Fix separate stencil on gen7.

Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
src/mesa/drivers/dri/i965/brw_misc_state.c
src/mesa/drivers/dri/i965/gen7_misc_state.c
src/mesa/drivers/dri/intel/intel_fbo.c
src/mesa/drivers/dri/intel/intel_fbo.h
src/mesa/drivers/dri/intel/intel_mipmap_tree.h

index 3e8cb3f5f0a6161ca75f015a1fe62da61161777b..8a6a694bcce6533e9216644af7d946e4df1066e9 100644 (file)
@@ -208,6 +208,7 @@ brw_depthbuffer_format(struct brw_context *brw)
 
    if (!drb &&
        (srb = intel_get_renderbuffer(fb, BUFFER_STENCIL)) &&
+       !srb->mt->stencil_mt &&
        srb->Base.Format == MESA_FORMAT_S8_Z24) {
       drb = srb;
    }
@@ -239,8 +240,10 @@ static void emit_depthbuffer(struct brw_context *brw)
    /* _NEW_BUFFERS */
    struct intel_renderbuffer *depth_irb = intel_get_renderbuffer(fb, BUFFER_DEPTH);
    struct intel_renderbuffer *stencil_irb = intel_get_renderbuffer(fb, BUFFER_STENCIL);
+   struct intel_mipmap_tree *stencil_mt = NULL;
    struct intel_region *hiz_region = NULL;
    unsigned int len;
+   bool separate_stencil = false;
 
    if (depth_irb &&
        depth_irb->mt &&
@@ -256,17 +259,21 @@ static void emit_depthbuffer(struct brw_context *brw)
       intel_emit_depth_stall_flushes(intel);
    }
 
-   /*
-    * If either depth or stencil buffer has packed depth/stencil format,
-    * then don't use separate stencil. Emit only a depth buffer.
+   /* Find the real separate stencil mt if present. */
+   if (stencil_irb) {
+      stencil_mt = stencil_irb->mt;
+      if (stencil_mt->stencil_mt)
+        stencil_mt = stencil_mt->stencil_mt;
+
+      if (stencil_mt->format == MESA_FORMAT_S8)
+        separate_stencil = true;
+   }
+
+   /* If there's a packed depth/stencil bound to stencil only, we need to
+    * emit the packed depth/stencil buffer packet.
     */
-   if (depth_irb && depth_irb->Base.Format == MESA_FORMAT_S8_Z24) {
-      stencil_irb = NULL;
-   } else if (!depth_irb && stencil_irb
-             && stencil_irb->Base.Format == MESA_FORMAT_S8_Z24) {
+   if (!depth_irb && stencil_irb && !separate_stencil)
       depth_irb = stencil_irb;
-      stencil_irb = NULL;
-   }
 
    if (intel->gen >= 6)
       len = 7;
@@ -275,7 +282,7 @@ static void emit_depthbuffer(struct brw_context *brw)
    else
       len = 5;
 
-   if (!depth_irb && !stencil_irb) {
+   if (!depth_irb && !separate_stencil) {
       BEGIN_BATCH(len);
       OUT_BATCH(_3DSTATE_DEPTH_BUFFER << 16 | (len - 2));
       OUT_BATCH((BRW_DEPTHFORMAT_D32_FLOAT << 18) |
@@ -292,7 +299,7 @@ static void emit_depthbuffer(struct brw_context *brw)
 
       ADVANCE_BATCH();
 
-   } else if (!depth_irb && stencil_irb) {
+   } else if (!depth_irb && separate_stencil) {
       /*
        * There exists a separate stencil buffer but no depth buffer.
        *
@@ -317,10 +324,9 @@ static void emit_depthbuffer(struct brw_context *brw)
        * Section 7.5.5.1.1 3DSTATE_DEPTH_BUFFER, Bit 1.27 Tiled Surface:
        *     [DevGT+]: This field must be set to TRUE.
        */
-      struct intel_region *region = stencil_irb->mt->region;
+      struct intel_region *region = stencil_mt->region;
 
       assert(intel->has_separate_stencil);
-      assert(stencil_irb->Base.Format == MESA_FORMAT_S8);
 
       BEGIN_BATCH(len);
       OUT_BATCH(_3DSTATE_DEPTH_BUFFER << 16 | (len - 2));
@@ -346,7 +352,7 @@ static void emit_depthbuffer(struct brw_context *brw)
       uint32_t tile_x, tile_y, offset;
 
       /* If using separate stencil, hiz must be enabled. */
-      assert(!stencil_irb || hiz_region);
+      assert(!separate_stencil || hiz_region);
 
       offset = intel_renderbuffer_tile_offsets(depth_irb, &tile_x, &tile_y);
 
@@ -381,7 +387,7 @@ static void emit_depthbuffer(struct brw_context *brw)
       ADVANCE_BATCH();
    }
 
-   if (hiz_region || stencil_irb) {
+   if (hiz_region || separate_stencil) {
       /*
        * In the 3DSTATE_DEPTH_BUFFER batch emitted above, the 'separate
        * stencil enable' and 'hiz enable' bits were set. Therefore we must
@@ -408,8 +414,8 @@ static void emit_depthbuffer(struct brw_context *brw)
       }
 
       /* Emit stencil buffer. */
-      if (stencil_irb) {
-        struct intel_region *region = stencil_irb->mt->region;
+      if (separate_stencil) {
+        struct intel_region *region = stencil_mt->region;
         BEGIN_BATCH(3);
         OUT_BATCH((_3DSTATE_STENCIL_BUFFER << 16) | (3 - 2));
         OUT_BATCH(region->pitch * region->cpp - 1);
index c50cd30ec1324847f86370f91995696427e91ca7..3946cb3d1d55e0632f00b1da579c24d4ec0d2cfb 100644 (file)
@@ -38,20 +38,32 @@ static void emit_depthbuffer(struct brw_context *brw)
    /* _NEW_BUFFERS */
    struct intel_renderbuffer *drb = intel_get_renderbuffer(fb, BUFFER_DEPTH);
    struct intel_renderbuffer *srb = intel_get_renderbuffer(fb, BUFFER_STENCIL);
+   struct intel_mipmap_tree *depth_mt = NULL, *stencil_mt = NULL;
 
-   intel_emit_depth_stall_flushes(intel);
+   if (drb)
+      depth_mt = drb->mt;
+
+   if (srb) {
+      stencil_mt = srb->mt;
+      if (stencil_mt->stencil_mt)
+        stencil_mt = stencil_mt->stencil_mt;
+
+      assert(stencil_mt->format == MESA_FORMAT_S8);
+   }
 
    /* Gen7 doesn't support packed depth/stencil */
-   assert(srb == NULL || srb != drb);
+   assert(stencil_mt == NULL || depth_mt != stencil_mt);
+
+   intel_emit_depth_stall_flushes(intel);
 
-   if (drb == NULL) {
+   if (depth_mt == NULL) {
       uint32_t dw1 = BRW_DEPTHFORMAT_D32_FLOAT << 18;
       uint32_t dw3 = 0;
 
-      if (srb == NULL) {
+      if (stencil_mt == NULL) {
         dw1 |= (BRW_SURFACE_NULL << 29);
       } else {
-        struct intel_region *region = srb->mt->region;
+        struct intel_region *region = stencil_mt->region;
 
         /* _NEW_STENCIL: enable stencil buffer writes */
         dw1 |= ((ctx->Stencil.WriteMask != 0) << 27);
@@ -71,7 +83,7 @@ static void emit_depthbuffer(struct brw_context *brw)
       OUT_BATCH(0);
       ADVANCE_BATCH();
    } else {
-      struct intel_region *region = drb->mt->region;
+      struct intel_region *region = depth_mt->region;
       uint32_t tile_x, tile_y, offset;
 
       offset = intel_renderbuffer_tile_offsets(drb, &tile_x, &tile_y);
@@ -84,7 +96,7 @@ static void emit_depthbuffer(struct brw_context *brw)
       OUT_BATCH(((region->pitch * region->cpp) - 1) |
                (brw_depthbuffer_format(brw) << 18) |
                (0 << 22) /* no HiZ buffer */ |
-               ((srb != NULL && ctx->Stencil.WriteMask != 0) << 27) |
+               ((stencil_mt != NULL && ctx->Stencil.WriteMask != 0) << 27) |
                ((ctx->Depth.Mask != 0) << 28) |
                (BRW_SURFACE_2D << 29));
       OUT_RELOC(region->bo,
@@ -104,7 +116,7 @@ static void emit_depthbuffer(struct brw_context *brw)
    OUT_BATCH(0);
    ADVANCE_BATCH();
 
-   if (srb == NULL) {
+   if (stencil_mt == NULL) {
       BEGIN_BATCH(3);
       OUT_BATCH(GEN7_3DSTATE_STENCIL_BUFFER << 16 | (3 - 2));
       OUT_BATCH(0);
@@ -113,8 +125,8 @@ static void emit_depthbuffer(struct brw_context *brw)
    } else {
       BEGIN_BATCH(3);
       OUT_BATCH(GEN7_3DSTATE_STENCIL_BUFFER << 16 | (3 - 2));
-      OUT_BATCH(srb->mt->region->pitch * srb->mt->region->cpp - 1);
-      OUT_RELOC(srb->mt->region->bo,
+      OUT_BATCH(stencil_mt->region->pitch * stencil_mt->region->cpp - 1);
+      OUT_RELOC(stencil_mt->region->bo,
                I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER,
                0);
       ADVANCE_BATCH();
index 671de81c8dc4038fc77b3ac7c38f3eb531a94e55..6f518ee23b92ef656930e01be6c2c59c6573d7f8 100644 (file)
@@ -81,9 +81,12 @@ struct intel_region*
 intel_get_rb_region(struct gl_framebuffer *fb, GLuint attIndex)
 {
    struct intel_renderbuffer *irb = intel_get_renderbuffer(fb, attIndex);
-   if (irb && irb->mt)
-      return irb->mt->region;
-   else
+   if (irb && irb->mt) {
+      if (attIndex == BUFFER_STENCIL && irb->mt->stencil_mt)
+        return irb->mt->stencil_mt->region;
+      else
+        return irb->mt->region;
+   } else
       return NULL;
 }
 
@@ -111,7 +114,6 @@ intel_delete_renderbuffer(struct gl_renderbuffer *rb)
    intel_miptree_release(&irb->mt);
 
    _mesa_reference_renderbuffer(&irb->wrapped_depth, NULL);
-   _mesa_reference_renderbuffer(&irb->wrapped_stencil, NULL);
 
    free(irb);
 }
@@ -260,24 +262,19 @@ intel_alloc_renderbuffer_storage(struct gl_context * ctx, struct gl_renderbuffer
 
    if (irb->mt->stencil_mt) {
       bool ok;
-      struct intel_renderbuffer *depth_irb, *stencil_irb;
+      struct intel_renderbuffer *depth_irb;
 
       /* The RB got allocated as separate stencil.  Hook up our wrapped
-       * renderbuffers so that consumers of intel_get_renderbuffer() end up
-       * with pointers to the separate pieces.
+       * renderbuffer so that consumers of intel_get_renderbuffer(BUFFER_DEPTH)
+       * end up with pointers to the separate depth.
        */
       if (!irb->wrapped_depth) {
         _mesa_reference_renderbuffer(&irb->wrapped_depth,
                                      intel_new_renderbuffer(ctx, ~0));
       }
-      if (!irb->wrapped_stencil) {
-        _mesa_reference_renderbuffer(&irb->wrapped_stencil,
-                                     intel_new_renderbuffer(ctx, ~0));
-      }
 
       depth_irb = intel_renderbuffer(irb->wrapped_depth);
-      stencil_irb = intel_renderbuffer(irb->wrapped_stencil);
-      if (!depth_irb || !stencil_irb) {
+      if (!depth_irb) {
         intel_miptree_release(&irb->mt);
         return false;
       }
@@ -288,13 +285,6 @@ intel_alloc_renderbuffer_storage(struct gl_context * ctx, struct gl_renderbuffer
                                             MESA_FORMAT_X8_Z24,
                                             GL_DEPTH_COMPONENT24);
       assert(ok);
-
-      ok = intel_renderbuffer_update_wrapper(intel, stencil_irb,
-                                            irb->mt->stencil_mt,
-                                            0, 0, /* level, layer */
-                                            MESA_FORMAT_S8,
-                                            GL_STENCIL_INDEX);
-      assert(ok);
    }
 
    return true;
@@ -541,32 +531,25 @@ intel_renderbuffer_update_wrapper(struct intel_context *intel,
    irb->mt_level = level;
    irb->mt_layer = layer;
 
+   intel_miptree_reference(&irb->mt, mt);
    if (mt->stencil_mt && _mesa_is_depthstencil_format(rb->InternalFormat)) {
-      assert((irb->wrapped_depth == NULL) == (irb->wrapped_stencil == NULL));
-
       struct intel_renderbuffer *depth_irb;
-      struct intel_renderbuffer *stencil_irb;
 
       if (!irb->wrapped_depth) {
         depth_irb = intel_renderbuffer_wrap_miptree(intel,
                                                     mt, level, layer,
                                                     MESA_FORMAT_X8_Z24,
                                                     GL_DEPTH_COMPONENT24);
-        stencil_irb = intel_renderbuffer_wrap_miptree(intel,
-                                                      mt->stencil_mt,
-                                                      level, layer,
-                                                      MESA_FORMAT_S8,
-                                                      GL_STENCIL_INDEX8);
         _mesa_reference_renderbuffer(&irb->wrapped_depth, &depth_irb->Base);
-        _mesa_reference_renderbuffer(&irb->wrapped_stencil, &stencil_irb->Base);
 
-        if (!irb->wrapped_depth || !irb->wrapped_stencil)
+        if (!irb->wrapped_depth) {
+           intel_miptree_release(&irb->mt);
            return false;
+        }
       } else {
         bool ok = true;
 
         depth_irb = intel_renderbuffer(irb->wrapped_depth);
-        stencil_irb = intel_renderbuffer(irb->wrapped_stencil);
 
         ok &= intel_renderbuffer_update_wrapper(intel,
                                                 depth_irb,
@@ -574,20 +557,12 @@ intel_renderbuffer_update_wrapper(struct intel_context *intel,
                                                 level, layer,
                                                 MESA_FORMAT_X8_Z24,
                                                 GL_DEPTH_COMPONENT24);
-        ok &= intel_renderbuffer_update_wrapper(intel,
-                                                stencil_irb,
-                                                mt->stencil_mt,
-                                                level, layer,
-                                                MESA_FORMAT_S8,
-                                                GL_STENCIL_INDEX8);
-        if (!ok)
+        if (!ok) {
+           intel_miptree_release(&irb->mt);
            return false;
+        }
       }
-
-      intel_miptree_reference(&depth_irb->mt->stencil_mt, stencil_irb->mt);
-      intel_miptree_reference(&irb->mt, depth_irb->mt);
    } else {
-      intel_miptree_reference(&irb->mt, mt);
       intel_renderbuffer_set_draw_offset(irb);
 
       if (mt->hiz_mt == NULL &&
@@ -857,8 +832,11 @@ intel_validate_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb)
 
    if (depthRb)
       depth_mt = depthRb->mt;
-   if (stencilRb)
+   if (stencilRb) {
       stencil_mt = stencilRb->mt;
+      if (stencil_mt->stencil_mt)
+        stencil_mt = stencil_mt->stencil_mt;
+   }
 
    if (depth_mt && stencil_mt) {
       if (depth_mt == stencil_mt) {
index 174e1c293797ad3ed7188e398826521564f2f84c..b8dbb34135440794fb06c4610ece624a3653afe8 100644 (file)
@@ -72,7 +72,6 @@ struct intel_renderbuffer
     * are the real renderbuffers.
     */
    struct gl_renderbuffer *wrapped_depth;
-   struct gl_renderbuffer *wrapped_stencil;
    /** \} */
 
    GLuint draw_x, draw_y; /**< Offset of drawing within the region */
@@ -134,11 +133,6 @@ intel_get_renderbuffer(struct gl_framebuffer *fb, gl_buffer_index attIndex)
         irb = intel_renderbuffer(irb->wrapped_depth);
       }
       break;
-   case BUFFER_STENCIL:
-      if (irb->wrapped_stencil) {
-        irb = intel_renderbuffer(irb->wrapped_stencil);
-      }
-      break;
    default:
       break;
    }
index c24fa8e49b6540b792919b03757c451177d0a073..fef1dcf8ce6cd95eb5b295dd23091909e3f1af55 100644 (file)
@@ -149,8 +149,7 @@ struct intel_mipmap_tree
     * two miptrees for storing the data.  If the depthstencil texture or rb is
     * MESA_FORMAT_Z32_FLOAT_X24S8, then mt->format will be
     * MESA_FORMAT_Z32_FLOAT, otherwise for MESA_FORMAT_S8_Z24 objects it will be
-    * MESA_FORMAT_S8_Z24 (textures) or MESA_FORMAT_X8_Z24 (renderbuffers).
-    * mt->stencil_mt->format will always be MESA_FORMAT_S8.
+    * MESA_FORMAT_S8_Z24.
     */
    gl_format format;