<!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.2.0 Release Notes / TBD</h1>

<p>
Mesa 19.2.0 is a new development release. People who are concerned
with stability and reliability should stick with a previous release or
wait for Mesa 19.2.1.
</p>
<p>
Mesa 19.2.0 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>
<p>
Mesa 19.2.0 implements the Vulkan 1.1 API, but the version reported by
the apiVersion property of the VkPhysicalDeviceProperties struct
depends on the particular driver being used.
</p>

<h2>SHA256 checksums</h2>
<pre>
TBD.
</pre>


<h2>New features</h2>

<ul>
<li>GL_ARB_post_depth_coverage on radeonsi (Navi)</li>
<li>GL_ARB_seamless_cubemap_per_texture on etnaviv (if GPU supports SEAMLESS_CUBE_MAP)</li>
<li>GL_EXT_shader_image_load_store on radeonsi (with LLVM >= 10)</li>
<li>GL_EXT_shader_samples_identical on iris and radeonsi (if using NIR)</li>
<li>GL_EXT_texture_shadow_lod on i965, iris</li>
<li>EGL_EXT_platform_device</li>
<li>VK_AMD_buffer_marker on radv</li>
<li>VK_EXT_index_type_uint8 on radv</li>
<li>VK_EXT_post_depth_coverage on radv</li>
<li>VK_EXT_queue_family_foreign on radv</li>
<li>VK_EXT_sample_locations on radv</li>
<li>VK_EXT_shader_demote_to_helper_invocation on Intel.</li>
<li>VK_KHR_depth_stencil_resolve on radv</li>
<li>VK_KHR_imageless_framebuffer on radv</li>
<li>VK_KHR_shader_atomic_int64 on radv</li>
<li>VK_KHR_uniform_buffer_standard_layout on radv</li>
</ul>

<h2>Bug fixes</h2>

<ul>

<ul>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=103674">Bug 103674</a> - u_queue.c:173:7: error: implicit declaration of function 'timespec_get' is invalid in C99</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=104395">Bug 104395</a> - [CTS] GTF-GL46.gtf32.GL3Tests.packed_pixels.packed_pixels tests fail on 32bit Mesa</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=110765">Bug 110765</a> - ANV regression: Assertion `pass-&gt;attachment_count == framebuffer-&gt;attachment_count' failed</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=110814">Bug 110814</a> - KWin compositor crashes on launch</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111069">Bug 111069</a> - Assertion fails in nir_opt_remove_phis.c during compilation of SPIR-V shader</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111213">Bug 111213</a> - VA-API nouveau SIGSEGV and asserts</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111241">Bug 111241</a> - Shadertoy shader causing hang</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111248">Bug 111248</a> - Navi10 Font rendering issue in Overwatch</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111271">Bug 111271</a> - Crash in eglMakeCurrent</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111308">Bug 111308</a> - [Regression, NIR, bisected] Black squares in Unigine Heaven via DXVK</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111401">Bug 111401</a> - Vulkan overlay layer - async compute not supported, making overlay disappear in Doom</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111405">Bug 111405</a> - Some infinite 'do{}while' loops lead mesa to an infinite compilation</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111411">Bug 111411</a> - SPIR-V shader leads to GPU hang, sometimes making machine unstable</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111414">Bug 111414</a> - [REGRESSION] [BISECTED] Segmentation fault in si_bind_blend_state after removal of the blend state NULL check</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111467">Bug 111467</a> - WOLF RPG Editor + Gallium Nine Standalone: Rendering issue when using Iris driver</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111490">Bug 111490</a> - [REGRESSION] [BISECTED] Shadow Tactics: Blades of the Shogun - problems rendering water</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111493">Bug 111493</a> - In the game The Surge (378540) - textures disappear then appear again when I change the camera angle view</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111509">Bug 111509</a> - [regression][bisected] piglit.spec.ext_image_dma_buf_import.ext_image_dma_buf_import-export fails on iris</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111522">Bug 111522</a> - [bisected] Supraland no longer start</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111529">Bug 111529</a> - EGL_PLATFORM=drm doesn't expose MESA_query_driver extension</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111552">Bug 111552</a> - Geekbench 5.0 Vulkan compute benchmark fails on Anvil</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111566">Bug 111566</a> - [REGRESSION] [BISECTED] Large CS workgroup sizes broken in combination with FP64 on Intel.</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111576">Bug 111576</a> - [bisected] Performance regression in X4:Foundations in 19.2</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111676">Bug 111676</a> - Tropico 6 apitrace throws error into logs</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=111734">Bug 111734</a> - Geometry shader with double interpolators fails in LLVM</li>

</ul>
</ul>

<h2>Changes</h2>

<ul>

<p>Adam Jackson (1):</p>
<ul>
  <li>docs: Update bug report URLs for the gitlab migration</li>
</ul>

<p>Alex Smith (1):</p>
<ul>
  <li>radv: Change memory type order for GPUs without dedicated VRAM</li>
</ul>

<p>Alyssa Rosenzweig (1):</p>
<ul>
  <li>pan/midgard: Fix writeout combining</li>
</ul>

<p>Andres Gomez (1):</p>
<ul>
  <li>docs: Add the maximum implemented Vulkan API version in 19.2 rel notes</li>
</ul>

<p>Andres Rodriguez (1):</p>
<ul>
  <li>radv: additional query fixes</li>
</ul>

<p>Arcady Goldmints-Orlov (1):</p>
<ul>
  <li>anv: fix descriptor limits on gen8</li>
</ul>

<p>Bas Nieuwenhuizen (6):</p>
<ul>
  <li>radv: Use correct vgpr_comp_cnt for VS if both prim_id and instance_id are needed.</li>
  <li>radv: Emit VGT_GS_ONCHIP_CNTL for tess on GFX10.</li>
  <li>radv: Disable NGG for geometry shaders.</li>
  <li>Revert "ac/nir: Lower large indirect variables to scratch"</li>
  <li>tu: Set up glsl types.</li>
  <li>radv: Add workaround for hang in The Surge 2.</li>
</ul>

<p>Caio Marcelo de Oliveira Filho (2):</p>
<ul>
  <li>nir/lower_explicit_io: Handle 1 bit loads and stores</li>
  <li>glsl/nir: Avoid overflow when setting max_uniform_location</li>
</ul>

<p>Connor Abbott (1):</p>
<ul>
  <li>radv: Call nir_propagate_invariant()</li>
</ul>

<p>Danylo Piliaiev (3):</p>
<ul>
  <li>nir/loop_unroll: Prepare loop for unrolling in wrapper_unroll</li>
  <li>nir/loop_analyze: Treat do{}while(false) loops as 0 iterations</li>
  <li>tgsi_to_nir: Translate TGSI_INTERPOLATE_COLOR as INTERP_MODE_NONE</li>
</ul>

<p>Dave Airlie (2):</p>
<ul>
  <li>virgl: fix format conversion for recent gallium changes.</li>
  <li>gallivm: fix atomic compare-and-swap</li>
</ul>

<p>Dave Stevenson (1):</p>
<ul>
  <li>broadcom/v3d: Allow importing linear BOs with arbitrary offset/stride.</li>
</ul>

<p>Dylan Baker (9):</p>
<ul>
  <li>bump version to 19.2-rc2</li>
  <li>nir: Add is_not_negative helper function</li>
  <li>Bump version for rc3</li>
  <li>meson: don't generate file into subdirs</li>
  <li>add patches to be ignored</li>
  <li>Bump version for 19.2.0-rc4</li>
  <li>cherry-ignore: Add patches</li>
  <li>rehardcode from origin/master to upstream/master</li>
  <li>bin/get-pick-list: use --oneline=pretty instead of --oneline</li>
</ul>

<p>Emil Velikov (1):</p>
<ul>
  <li>Update version to 19.2.0-rc1</li>
</ul>

<p>Eric Engestrom (14):</p>
<ul>
  <li>ttn: fix 64-bit shift on 32-bit `1`</li>
  <li>egl: fix deadlock in malloc error path</li>
  <li>util/os_file: fix double-close()</li>
  <li>anv: fix format string in error message</li>
  <li>freedreno/drm-shim: fix mem leak</li>
  <li>nir: fix memleak in error path</li>
  <li>anv: add support for driconf</li>
  <li>wsi: add minImageCount override</li>
  <li>anv: add support for vk_x11_override_min_image_count</li>
  <li>amd: move adaptive sync to performance section, as it is defined in xmlpool</li>
  <li>radv: add support for vk_x11_override_min_image_count</li>
  <li>drirc: override minImageCount=2 for gfxbench</li>
  <li>gl: drop incorrect pkg-config file for glvnd</li>
  <li>meson: re-add incorrect pkg-config files with GLVND for backward compatibility</li>
</ul>

<p>Erik Faye-Lund (2):</p>
<ul>
  <li>gallium/auxiliary/indices: consistently apply start only to input</li>
  <li>util: fix SSE-version needed for double opcodes</li>
</ul>

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

<p>Hal Gentz (2):</p>
<ul>
  <li>glx: Fix SEGV due to dereferencing a NULL ptr from XCB-GLX.</li>
  <li>gallium/osmesa: Fix the inability to set no context as current.</li>
</ul>

<p>Iago Toral Quiroga (1):</p>
<ul>
  <li>v3d: make sure we have enough space in the CL for the primitive counts packet</li>
</ul>

<p>Ian Romanick (8):</p>
<ul>
  <li>nir/algrbraic: Don't optimize open-coded bitfield reverse when lowering is enabled</li>
  <li>intel/compiler: Request bitfield_reverse lowering on pre-Gen7 hardware</li>
  <li>nir/algebraic: Mark some value range analysis-based optimizations imprecise</li>
  <li>nir/range-analysis: Adjust result range of exp2 to account for flush-to-zero</li>
  <li>nir/range-analysis: Adjust result range of multiplication to account for flush-to-zero</li>
  <li>nir/range-analysis: Fix incorrect fadd range result for (ne_zero, ne_zero)</li>
  <li>nir/range-analysis: Handle constants in nir_op_mov just like nir_op_bcsel</li>
  <li>nir/algebraic: Do not apply late DPH optimization in vertex processing stages</li>
</ul>

<p>Ilia Mirkin (1):</p>
<ul>
  <li>gallium/vl: use compute preference for all multimedia, not just blit</li>
</ul>

<p>Jason Ekstrand (9):</p>
<ul>
  <li>anv: Bump maxComputeWorkgroupSize</li>
  <li>nir: Handle complex derefs in nir_split_array_vars</li>
  <li>nir: Don't infinitely recurse in lower_ssa_defs_to_regs_block</li>
  <li>nir: Add a block_is_unreachable helper</li>
  <li>nir/repair_ssa: Repair dominance for unreachable blocks</li>
  <li>nir/repair_ssa: Insert deref casts when needed</li>
  <li>nir/dead_cf: Repair SSA if the pass makes progress</li>
  <li>intel/fs: Handle UNDEF in split_virtual_grfs</li>
  <li>nir/repair_ssa: Replace the unreachable check with the phi builder</li>
</ul>

<p>Jonathan Marek (1):</p>
<ul>
  <li>freedreno/a2xx: ir2: fix lowering of instructions after float lowering</li>
</ul>

<p>Jose Maria Casanova Crespo (1):</p>
<ul>
  <li>mesa: recover target_check before get_current_tex_objects</li>
</ul>

<p>Juan A. Suarez Romero (1):</p>
<ul>
  <li>bin/get-pick-list.sh: sha1 commits can be smaller than 8 chars</li>
</ul>

<p>Kenneth Graunke (20):</p>
<ul>
  <li>gallium/ddebug: Wrap resource_get_param if available</li>
  <li>gallium/trace: Wrap resource_get_param if available</li>
  <li>gallium/rbug: Wrap resource_get_param if available</li>
  <li>gallium/noop: Implement resource_get_param</li>
  <li>iris: Replace devinfo-&gt;gen with GEN_GEN</li>
  <li>iris: Fix broken aux.possible/sampler_usages bitmask handling</li>
  <li>iris: Update fast clear colors on Gen9 with direct immediate writes.</li>
  <li>iris: Drop copy format hacks from copy region based transfer path.</li>
  <li>iris: Avoid unnecessary resolves on transfer maps</li>
  <li>iris: Fix large timeout handling in rel2abs()</li>
  <li>isl: Drop UnormPathInColorPipe for buffer surfaces.</li>
  <li>isl: Don't set UnormPathInColorPipe for integer surfaces.</li>
  <li>util: Add a _mesa_i64roundevenf() helper.</li>
  <li>mesa: Fix _mesa_float_to_unorm() on 32-bit systems.</li>
  <li>iris: Fix partial fast clear checks to account for miplevel.</li>
  <li>iris: Report correct number of planes for planar images</li>
  <li>iris: Fix constant buffer sizes for non-UBOs</li>
  <li>gallium: Fix util_format_get_depth_only</li>
  <li>iris: Initialize ice-&gt;state.prim_mode to an invalid value</li>
  <li>intel: Increase Gen11 compute shader scratch IDs to 64.</li>
</ul>

<p>Lepton Wu (1):</p>
<ul>
  <li>virgl: Fix pipe_resource leaks under multi-sample.</li>
</ul>

<p>Lionel Landwerlin (9):</p>
<ul>
  <li>util/timespec: use unsigned 64 bit integers for nsec values</li>
  <li>util: fix compilation on macos</li>
  <li>egl: fix platform selection</li>
  <li>vulkan/overlay: bounce image back to present layout</li>
  <li>radv: store engine name</li>
  <li>driconfig: add a new engine name/version parameter</li>
  <li>vulkan: add vk_x11_strict_image_count option</li>
  <li>util/xmlconfig: fix regexp compile failure check</li>
  <li>drirc: include unreal engine version 0 to 23</li>
</ul>

<p>Marek Olšák (23):</p>
<ul>
  <li>radeonsi/gfx10: fix the legacy pipeline by storing as_ngg in the shader cache</li>
  <li>radeonsi: move some global shader cache flags to per-binary flags</li>
  <li>radeonsi/gfx10: fix tessellation for the legacy pipeline</li>
  <li>radeonsi/gfx10: fix the PRIMITIVES_GENERATED query if using legacy streamout</li>
  <li>radeonsi/gfx10: create the GS copy shader if using legacy streamout</li>
  <li>radeonsi/gfx10: add as_ngg variant for VS as ES to select Wave32/64</li>
  <li>radeonsi/gfx10: fix InstanceID for legacy VS+GS</li>
  <li>radeonsi/gfx10: don't initialize VGT_INSTANCE_STEP_RATE_0</li>
  <li>radeonsi/gfx10: always use the legacy pipeline for streamout</li>
  <li>radeonsi/gfx10: finish up Navi14, add PCI ID</li>
  <li>radeonsi/gfx10: add AMD_DEBUG=nongg</li>
  <li>winsys/amdgpu+radeon: process AMD_DEBUG in addition to R600_DEBUG</li>
  <li>radeonsi: add PKT3_CONTEXT_REG_RMW</li>
  <li>radeonsi/gfx10: remove incorrect ngg/pos_writes_edgeflag variables</li>
  <li>radeonsi/gfx10: set PA_CL_VS_OUT_CNTL with CONTEXT_REG_RMW to fix edge flags</li>
  <li>radeonsi: consolidate determining VGPR_COMP_CNT for API VS</li>
  <li>radeonsi: unbind blend/DSA/rasterizer state correctly in delete functions</li>
  <li>radeonsi: fix scratch buffer WAVESIZE setting leading to corruption</li>
  <li>radeonsi/gfx10: don't call gfx10_destroy_query with compute-only contexts</li>
  <li>radeonsi/gfx10: fix wave occupancy computations</li>
  <li>radeonsi: add Navi12 PCI ID</li>
  <li>amd: add more PCI IDs for Navi14</li>
  <li>ac/addrlib: fix chip identification for Vega10, Arcturus, Raven2, Renoir</li>
</ul>

<p>Mauro Rossi (2):</p>
<ul>
  <li>android: mesa: revert "Enable asm unconditionally"</li>
  <li>android: anv: libmesa_vulkan_common: add libmesa_util static dependency</li>
</ul>

<p>Paulo Zanoni (2):</p>
<ul>
  <li>intel/fs: grab fail_msg from v32 instead of v16 when v32-&gt;run_cs fails</li>
  <li>intel/fs: fix SHADER_OPCODE_CLUSTER_BROADCAST for SIMD32</li>
</ul>

<p>Pierre-Eric Pelloux-Prayer (1):</p>
<ul>
  <li>glsl: replace 'x + (-x)' with constant 0</li>
</ul>

<p>Rafael Antognolli (1):</p>
<ul>
  <li>anv: Only re-emit non-dynamic state that has changed.</li>
</ul>

<p>Rhys Perry (1):</p>
<ul>
  <li>radv: always emit a position export in gs copy shaders</li>
</ul>

<p>Samuel Iglesias Gonsálvez (1):</p>
<ul>
  <li>intel/nir: do not apply the fsin and fcos trig workarounds for consts</li>
</ul>

<p>Samuel Pitoiset (11):</p>
<ul>
  <li>radv: allow to enable VK_AMD_shader_ballot only on GFX8+</li>
  <li>radv: add a new debug option called RADV_DEBUG=noshaderballot</li>
  <li>radv: force enable VK_AMD_shader_ballot for Wolfenstein Youngblood</li>
  <li>ac: fix exclusive scans on GFX8-GFX9</li>
  <li>radv/gfx10: don't initialize VGT_INSTANCE_STEP_RATE_0</li>
  <li>radv/gfx10: do not use NGG with NAVI14</li>
  <li>radv: fix getting the index type size for uint8_t</li>
  <li>nir: do not assume that the result of fexp2(a) is always an integral</li>
  <li>radv: fix allocating number of user sgprs if streamout is used</li>
  <li>radv: fix loading 64-bit GS inputs</li>
  <li>radv/gfx10: fix VK_KHR_pipeline_executable_properties with NGG GS</li>
</ul>

<p>Sergii Romantsov (2):</p>
<ul>
  <li>intel/dri: finish proper glthread</li>
  <li>nir/large_constants: more careful data copying</li>
</ul>

<p>Tapani Pälli (5):</p>
<ul>
  <li>util: fix os_create_anonymous_file on android</li>
  <li>iris/android: fix build and link with libmesa_intel_perf</li>
  <li>egl: reset blob cache set/get functions on terminate</li>
  <li>iris: close screen fd on iris_destroy_screen</li>
  <li>egl: check for NULL value like eglGetSyncAttribKHR does</li>
</ul>

<p>Thong Thai (1):</p>
<ul>
  <li>Revert "radeonsi: don't emit PKT3_CONTEXT_CONTROL on amdgpu"</li>
</ul>

<p>Timur Kristóf (1):</p>
<ul>
  <li>st/nine: Properly initialize GLSL types for NIR shaders.</li>
</ul>

<p>Vinson Lee (2):</p>
<ul>
  <li>swr: Fix build with llvm-9.0 again.</li>
  <li>travis: Fail build if any command in if statement fails.</li>
</ul>

</ul>

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