<!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 9.1.2 Release Notes / April 30th, 2013</h1>

<p>
Mesa 9.1.2 is a bug fix release which fixes bugs found since the 9.1.1 release.
</p>
<p>
Mesa 9.1 implements the OpenGL 3.1 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 3.1.  OpenGL
3.1 is <strong>only</strong> available if requested at context creation
because GL_ARB_compatibility is not supported.
</p>

<h2>MD5 checksums</h2>
<pre>
df2aab86ff4a510ce5b0d074caa0a59f  MesaLib-9.1.2.tar.bz2
415c2bc3a9eb571aafbfa474ebf5a2e0  MesaLib-9.1.2.tar.gz
b1ae5a4d9255953980bc9254f5323420  MesaLib-9.1.2.zip
</pre>

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

<h2>Bug fixes</h2>

<p>This list is likely incomplete.</p>

<ul>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=44567">Bug 44567</a> - [965gm] green artifacts when using GLSL in XBMC</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=59238">Bug 59238</a> - many new symbols in libxatracker after recent automake work</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=59445">Bug 59445</a> - [SNB/IVB/HSW Bisected]Oglc draw-buffers2(advanced.blending.none) segfault</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=59495">Bug 59495</a> - [i965 Bisected]Oglc fbblit(advanced.blitFb-3d-cube.mirror.both) fails</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=60503">Bug 60503</a> - [r300g] Unigine Heaven 3.0: all objects are black</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=60510">Bug 60510</a> - Firefox 18.0.2 Crash On Nvidia GeForce2</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=61197">Bug 61197</a> - [SNB Bisected] kwin_gles screen corruption</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=61317">Bug 61317</a> - [IVB] corrupt rendering with UBOs</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=61395">Bug 61395</a> - glEdgeFlag can't be set to false</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=61947">Bug 61947</a> - nullpointer dereference causes xorg-server segfault when nouveau DRI driver is loaded</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=62357">Bug 62357</a> - llvmpipe: Fragment Shader with &quot;return&quot; in main causes back output</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=62434">Bug 62434</a> - [bisected] 3284.073] (EE) AIGLX error: dlopen of /usr/lib/xorg/modules/dri/r600_dri.so failed (/usr/lib/libllvmradeon9.2.0.so: undefined symbol: lp_build_tgsi_intrinsic)</li>

<li><a href="http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=349437">Debian bug #349437</a> - mesa - FTBFS: error: 'IEEE_ONE' undeclared</li>

<li><a href="http://bugzilla.redhat.com/show_bug.cgi?id=918661">Redhat bug #918661</a> - crash in routine Avogadro UI manipulation</li>

</ul>

<h2>Changes</h2>
<p>The full set of changes can be viewed by using the following GIT command:</p>

<pre>
  git log mesa-9.1.1..mesa-9.1.2
</pre>

<p>Adam Jackson (2):</p>
<ul>
  <li>glx: Build with VISIBILITY_CFLAGS in automake</li>
  <li>linux: Don't emit a .note.ABI-tag section anymore (#26663)</li>
</ul>

<p>Alan Hourihane (3):</p>
<ul>
  <li>Add missing GL_TEXTURE_CUBE_MAP entry in _mesa_legal_texture_dimensions</li>
  <li>Unreference sampler object when it's currently bound to texture unit.</li>
  <li>mesa: fix glGetInteger*(GL_SAMPLER_BINDING).</li>
</ul>

<p>Alex Deucher (1):</p>
<ul>
  <li>r600g: disable hyperz by default on 9.1</li>
</ul>

<p>Andreas Boll (5):</p>
<ul>
  <li>radeon/llvm: Link against libgallium.la to fix an undefined symbol</li>
  <li>mesa: use ieee fp on s390 and m68k</li>
  <li>build: Enable x86 assembler on Hurd.</li>
  <li>osmesa: fix out-of-tree build</li>
  <li>gallium/egl: fix out-of-tree build</li>
</ul>

<p>Anuj Phogat (1):</p>
<ul>
  <li>mesa: Fix FB blitting in case of zero size src or dst rect</li>
</ul>

<p>Brian Paul (4):</p>
<ul>
  <li>mesa: flush current state when querying GL_EDGE_FLAG</li>
  <li>vbo: fix crash found with shared display lists</li>
  <li>llvmpipe: tweak CMD_BLOCK_MAX and LP_SCENE_MAX_SIZE</li>
  <li>llvmpipe: add some scene limit sanity check assertions</li>
</ul>

<p>Carl Worth (1):</p>
<ul>
  <li>i965: Avoid segfault in gen6_upload_state</li>
</ul>

<p>Chris Forbes (1):</p>
<ul>
  <li>i965/vs: Fix Gen4/5 VUE map inconsistency with gl_ClipVertex</li>
</ul>

<p>Christoph Bumiller (4):</p>
<ul>
  <li>nv50: fix 3D render target setup</li>
  <li>nv50,nvc0: disable DEPTH_RANGE_NEAR/FAR clipping during blit</li>
  <li>nv50,nvc0: fix 3d blits, restore viewport after blit</li>
  <li>nvc0: fix for 2d engine R source formats writing RRR1 and not R001</li>
</ul>

<p>Eric Anholt (5):</p>
<ul>
  <li>i965/fs: Fix register allocation for uniform pull constants in 16-wide.</li>
  <li>i965/fs: Fix broken rendering in large shaders with UBO loads.</li>
  <li>i965/fs: Also do the gen4 SEND dependency workaround against other SENDs.</li>
  <li>i965: Add definitions for gen7+ data cache messages.</li>
  <li>mesa: Disable validate_ir_tree() on release builds.</li>
</ul>

<p>Ian Romanick (5):</p>
<ul>
  <li>docs: Add 9.1.1 release md5sums</li>
  <li>mesa: Add previously picked commit to .cherry-ignore</li>
  <li>glsl: Add missing bool case in glsl_type::get_scalar_type</li>
  <li>mesa: Note that patch dbf94d1 should't actually get picked to the 9.1 branch</li>
  <li>mesa: Bump version to 9.1.2</li>
</ul>

<p>Jan de Groot (1):</p>
<ul>
  <li>dri/nouveau: fix crash in nouveau_flush</li>
</ul>

<p>José Fonseca (3):</p>
<ul>
  <li>autotools: Add missing top-level include dir.</li>
  <li>mesa,gallium,egl,mapi: One definition of C99 inline/__func__ to rule them all.</li>
  <li>include: Fix build with VS 11 (i.e, 2012).</li>
</ul>

<p>Kenneth Graunke (4):</p>
<ul>
  <li>i965: Fix INTEL_DEBUG=shader_time for Haswell.</li>
  <li>i965: Specialize SURFACE_STATE creation for shader time.</li>
  <li>i965: Make INTEL_DEBUG=shader_time use the RAW surface format.</li>
  <li>i965: Don't use texture swizzling to force alpha to 1.0 if unnecessary.</li>
</ul>

<p>Maarten Lankhorst (2):</p>
<ul>
  <li>gallium/build: Fix visibility CFLAGS in automake</li>
  <li>radeon/llvm: Do not link against libgallium when building statically.</li>
</ul>

<p>Marcin Slusarz (1):</p>
<ul>
  <li>dri/nouveau: NV17_3D class is not available for NV1a chipset</li>
</ul>

<p>Marek Olšák (3):</p>
<ul>
  <li>mesa: don't allocate a texture if width or height is 0 in CopyTexImage</li>
  <li>gallium/tgsi: fix valgrind warning</li>
  <li>mesa: handle HALF_FLOAT like FLOAT in get_tex_rgba</li>
</ul>

<p>Martin Andersson (1):</p>
<ul>
  <li>r600g: Use virtual address for PIPE_QUERY_SO* in r600_emit_query_end</li>
</ul>

<p>Matt Turner (3):</p>
<ul>
  <li>configure.ac: Don't check for X11 unconditionally.</li>
  <li>configure.ac: Remove stale comment about --x-* arguments.</li>
  <li>mesa: Implement TEXTURE_IMMUTABLE_LEVELS for ES 3.0.</li>
</ul>

<p>Michel Dänzer (1):</p>
<ul>
  <li>radeonsi: Emit pixel shader state even when only the vertex shader changed</li>
</ul>

<p>Paul Berry (1):</p>
<ul>
  <li>i965: Apply depthstencil alignment workaround when doing fast clears.</li>
</ul>

<p>Roland Scheidegger (1):</p>
<ul>
  <li>gallivm: fix return opcode handling in main function of a shader</li>
</ul>

<p>Tapani Pälli (1):</p>
<ul>
  <li>intel: Fix regression in intel_create_image_from_name stride handling</li>
</ul>

<p>Tom Stellard (1):</p>
<ul>
  <li>r300g: Fix bug in OMOD optimization</li>
</ul>

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