<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html lang="en">
<head>
  <meta http-equiv="content-type" content="text/html; charset=utf-8">
  <title>Mesa Release Notes</title>
  <link rel="stylesheet" type="text/css" href="../mesa.css">
</head>
<body>

<div class="header">
  <h1>The Mesa 3D Graphics Library</h1>
</div>

<iframe src="../contents.html"></iframe>
<div class="content">

<h1>Mesa 19.1.1 Release Notes / June 25, 2019</h1>

<p>
Mesa 19.1.1 is a bug fix release which fixes bugs found since the 19.1.0 release.
</p>
<p>
Mesa 19.1.1 implements the OpenGL 4.5 API, but the version reported by
glGetString(GL_VERSION) or glGetIntegerv(GL_MAJOR_VERSION) /
glGetIntegerv(GL_MINOR_VERSION) depends on the particular driver being used.
Some drivers don't support all the features required in OpenGL 4.5.  OpenGL
4.5 is <strong>only</strong> available if requested at context creation.
Compatibility contexts may report a lower version depending on each driver.
</p>

<h2>SHA256 checksums</h2>
<pre>
72114b16b4a84373b2acda060fe2bb1d45ea2598efab3ef2d44bdeda74f15581  mesa-19.1.1.tar.xz
</pre>


<h2>New features</h2>
<p>None</p>


<h2>Bug fixes</h2>

<ul>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=110709">Bug 110709</a> - g_glxglvnddispatchfuncs.c and glxglvnd.c fail to build with clang 8.0</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=110901">Bug 110901</a> - mesa-19.1.0/src/util/futex.h:82: use of out of scope variable ?</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=110902">Bug 110902</a> - mesa-19.1.0/src/broadcom/compiler/vir_opt_redundant_flags.c:104]: (style) Same expression</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=110921">Bug 110921</a> - virgl on OpenGL 3.3 host regressed to OpenGL 2.1</li>

</ul>


<h2>Changes</h2>

<p>Alejandro Piñeiro (1):</p>
<ul>
  <li>v3d: fix checking twice auf flag</li>
</ul>

<p>Bas Nieuwenhuizen (5):</p>
<ul>
  <li>radv: Skip transitions coming from external queue.</li>
  <li>radv: Decompress DCC when the image format is not allowed for buffers.</li>
  <li>radv: Fix vulkan build in meson.</li>
  <li>anv: Fix vulkan build in meson.</li>
  <li>meson: Allow building radeonsi with just the android platform.</li>
</ul>

<p>Dave Airlie (1):</p>
<ul>
  <li>nouveau: fix frees in unsupported IR error paths.</li>
</ul>

<p>Eduardo Lima Mitev (1):</p>
<ul>
  <li>freedreno/a5xx: Fix indirect draw max_indices calculation</li>
</ul>

<p>Eric Engestrom (3):</p>
<ul>
  <li>util/futex: fix dangling pointer use</li>
  <li>glx: fix glvnd pointer types</li>
  <li>util/os_file: resize buffer to what was actually needed</li>
</ul>

<p>Gert Wollny (1):</p>
<ul>
  <li>virgl: Assume sRGB write control for older guest kernels or virglrenderer hosts</li>
</ul>

<p>Haihao Xiang (1):</p>
<ul>
  <li>i965: support UYVY for external import only</li>
</ul>

<p>Jason Ekstrand (1):</p>
<ul>
  <li>anv: Set STATE_BASE_ADDRESS upper bounds on gen7</li>
</ul>

<p>Juan A. Suarez Romero (2):</p>
<ul>
  <li>docs: Add SHA256 sums for 19.1.0</li>
  <li>Update version to 19.1.1</li>
</ul>

<p>Kenneth Graunke (2):</p>
<ul>
  <li>glsl: Fix out of bounds read in shader_cache_read_program_metadata</li>
  <li>iris: Fix iris_flush_and_dirty_history to actually dirty history.</li>
</ul>

<p>Kevin Strasser (2):</p>
<ul>
  <li>gallium/winsys/kms: Fix dumb buffer bpp</li>
  <li>st/mesa: Add rgbx handling for fp formats</li>
</ul>

<p>Lionel Landwerlin (2):</p>
<ul>
  <li>anv: do not parse genxml data without INTEL_DEBUG=bat</li>
  <li>intel/dump: fix segfault when the app hasn't accessed the device</li>
</ul>

<p>Mathias Fröhlich (1):</p>
<ul>
  <li>egl: Don't add hardware device if there is no render node v2.</li>
</ul>

<p>Richard Thier (1):</p>
<ul>
  <li>r300g: restore performance after RADEON_FLAG_NO_INTERPROCESS_SHARING was added</li>
</ul>

<p>Rob Clark (1):</p>
<ul>
  <li>freedreno/a6xx: un-swap X24S8_UINT</li>
</ul>

<p>Samuel Pitoiset (4):</p>
<ul>
  <li>radv: fix occlusion queries on VegaM</li>
  <li>radv: fix VK_EXT_memory_budget if one heap isn't available</li>
  <li>radv: fix FMASK expand with SRGB formats</li>
  <li>radv: disable viewport clamping even if FS doesn't write Z</li>
</ul>


</div>
</body>
</html>
