kc3-lang/angle/src/libANGLE/renderer/gl/WorkaroundsGL.h

• Show log

  Commit

• Hash : 218cf9ee
  Author :
  Date : 2016-05-20T13:55:24
  

  Fix unpacking overlapping unpack buffer rows on NVIDIA GL
  
  When unpack parameters are set so that rows being read overlap in
  the unpack buffer stored in GPU memory, NVIDIA GL driver may not
  upload the last pixels of the last one or more rows of a texture. The
  driver may also crash when the amount of overlap is high.
  
  This issue affects both TexImage* and TexSubImage* calls.
  
  Work around the issue by uploading textures row by row when the rows
  being read overlap in the unpack buffer. The workaround could possibly
  be optimized by uploading several of the first rows with a single call
  in some cases where the amount of overlap is low, but this is expected
  to be a rarely used corner case, so the added complexity that the
  optimization would create seems like a bad tradeoff.
  
  The issue does not seem to be triggered when the layers (images) of a
  3D texture overlap, as long as the rows inside the images don't.
  
  The workaround has been ported from Chromium.
  
  This patch adds setting dirty bits when unpack state is set in
  StateManagerGL.
  
  The included test case also reveals some issue in the D3D backend, but
  this is left to be addressed later.
  
  BUG=angleproject:1376
  TEST=angle_end2end_tests
  
  Change-Id: I7dbe73ebb70bbbc284fa92381546f4f2f832d333
  Reviewed-on: https://chromium-review.googlesource.com/346430
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  

Download

• src/libANGLE/renderer/gl/WorkaroundsGL.h

• //
  // Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  // WorkaroundsGL.h: Workarounds for GL driver bugs and other issues.
  
  #ifndef LIBANGLE_RENDERER_GL_WORKAROUNDSGL_H_
  #define LIBANGLE_RENDERER_GL_WORKAROUNDSGL_H_
  
  namespace rx
  {
  
  struct WorkaroundsGL
  {
      WorkaroundsGL()
          : avoid1BitAlphaTextureFormats(false),
            rgba4IsNotSupportedForColorRendering(false),
            doesSRGBClearsOnLinearFramebufferAttachments(false),
            doWhileGLSLCausesGPUHang(false),
            finishDoesNotCauseQueriesToBeAvailable(false),
            alwaysCallUseProgramAfterLink(false),
            unpackOverlappingRowsSeparatelyUnpackBuffer(false)
      {
      }
  
      // When writing a float to a normalized integer framebuffer, desktop OpenGL is allowed to write
      // one of the two closest normalized integer representations (although round to nearest is
      // preferred) (see section 2.3.5.2 of the GL 4.5 core specification). OpenGL ES requires that
      // round-to-nearest is used (see "Conversion from Floating-Point to Framebuffer Fixed-Point" in
      // section 2.1.2 of the OpenGL ES 2.0.25 spec).  This issue only shows up on Intel and AMD
      // drivers on framebuffer formats that have 1-bit alpha, work around this by using higher
      // precision formats instead.
      bool avoid1BitAlphaTextureFormats;
  
      // On some older Intel drivers, GL_RGBA4 is not color renderable, glCheckFramebufferStatus
      // returns GL_FRAMEBUFFER_UNSUPPORTED. Work around this by using a known color-renderable
      // format.
      bool rgba4IsNotSupportedForColorRendering;
  
      // When clearing a framebuffer on Intel or AMD drivers, when GL_FRAMEBUFFER_SRGB is enabled, the
      // driver clears to the linearized clear color despite the framebuffer not supporting SRGB
      // blending.  It only seems to do this when the framebuffer has only linear attachments, mixed
      // attachments appear to get the correct clear color.
      bool doesSRGBClearsOnLinearFramebufferAttachments;
  
      // On Mac some GLSL constructs involving do-while loops cause GPU hangs, such as the following:
      //  int i = 1;
      //  do {
      //      i --;
      //      continue;
      //  } while (i > 0)
      // Work around this by rewriting the do-while to use another GLSL construct (block + while)
      bool doWhileGLSLCausesGPUHang;
  
      // Calling glFinish doesn't cause all queries to report that the result is available on some
      // (NVIDIA) drivers.  It was found that enabling GL_DEBUG_OUTPUT_SYNCHRONOUS before the finish
      // causes it to fully finish.
      bool finishDoesNotCauseQueriesToBeAvailable;
  
      // Always call useProgram after a successful link to avoid a driver bug.
      // This workaround is meant to reproduce the use_current_program_after_successful_link
      // workaround in Chromium (http://crbug.com/110263). It has been shown that this workaround is
      // not necessary for MacOSX 10.9 and higher (http://crrev.com/39eb535b).
      bool alwaysCallUseProgramAfterLink;
  
      // In the case of unpacking from a pixel unpack buffer, unpack overlapping rows row by row.
      bool unpackOverlappingRowsSeparatelyUnpackBuffer;
  };
  }
  
  #endif  // LIBANGLE_RENDERER_GL_WORKAROUNDSGL_H_
  

Download