<!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>

<h1>Mesa 7.11.1 Release Notes / November 17, 2011</h1>

<p>
Mesa 7.11.1 is a bug fix release which fixes bugs found since the 7.11 release.
</p>
<p>
Mesa 7.11 implements the OpenGL 2.1 API, but the version reported by
glGetString(GL_VERSION) depends on the particular driver being used.
Some drivers don't support all the features required in OpenGL 2.1.
</p>
<p>
See the <a href="install.html">Compiling/Installing page</a> for prerequisites
for DRI hardware acceleration.
</p>


<h2>MD5 checksums</h2>
<pre>
ac0181a4076770fb657c1169af43aa09  MesaLib-7.11.1.tar.gz
a77307102cee844ff6544ffa8fafeac1  MesaLib-7.11.1.tar.bz2
dfcb11516c1730f3981b55a65a835623  MesaLib-7.11.1.zip
2cb2b9ecb4fb7d1a6be69346ee886952  MesaGLUT-7.11.1.tar.gz
3f54e314290d4dacbab089839197080b  MesaGLUT-7.11.1.tar.bz2
5d66c7ee8c5cc2f27e1ffb037ad4172c  MesaGLUT-7.11.1.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=3165">Bug 3165</a> - texImage.IsCompressed and texImage.CompressedSize issues</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=23525">Bug 23525</a> - Software rendering on QEMU guests badly broken</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=28125">Bug 28125</a> - DRI2 prevents indirect glx</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=34628">Bug 34628</a> - [ilk] skybox errors in quake4</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=36371">Bug 36371</a> - r200: piglit readPixSanity failure</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=36669">Bug 36669</a> - EmitNoMainReturn set to 1 doesn't make the GLSL compiler lower all the RET opcodes</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=36939">Bug 36939</a> - multitexturing is messed up in quake wars (regression)</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=37907">Bug 37907</a> - [swrast] SIGSEGV swrast/s_depth.c:569</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=38163">Bug 38163</a> - Gnome Shell Display Bug</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=38625">Bug 38625</a> - ast_to_hir.cpp:1761: const glsl_type* process_array_type(YYLTYPE*, const glsl_type*, ast_node*, _mesa_glsl_parse_state*): Assertion `dummy_instructions.is_empty()' failed.</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=38729">Bug 38729</a> - [softpipe] sp_quad_depth_test.c:215:convert_quad_stencil: Assertion `0' failed.</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=38863">Bug 38863</a> - [IVB]GPU hang when running 3D games like openarena</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=39193">Bug 39193</a> - [llvmpipe and r600g] glCheckFramebufferStatusEXT segfaults in Gallium when checking status on a framebuffer bound to a texture that's bound to a pixmap</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=39651">Bug 39651</a> - [glsl] Assertion failure when implicitly converting out parameters</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=39991">Bug 39991</a> - [regression]GL_PALETTE8_RGBA8_OES format of glCompressedTexImage2D will cause err GL_INVALID_ENUM with GLES1.x</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=40022">Bug 40022</a> - [i915] out-of-bounds write src/mesa/drivers/dri/i915/i915_fragprog.c:321</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=40062">Bug 40062</a> - in etqw the strogg radar is black (regression)</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=40324">Bug 40324</a> - [SNB] gpu hang in mesa 7.11</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=40533">Bug 40533</a> - i915: piglit glean/readPixSanity: DRI2SwapBuffers: BadDrawable (invalid Pixmap or Window parameter)</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=41096">Bug 41096</a> - [sandybridge-m-gt2+] GPU lockup render.IPEHR: 0x7a000002</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=41969">Bug 41969</a> - The Mesa meta save/restore code doesn't always save the active program</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=42175">Bug 42175</a> - RV730: Display errors in glxgears &amp; WebGL</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=42268">Bug 42268</a> - [bisected] oglc pbo(negative.invalidOffsetValue) aborts on 7.11 branch</li>

<!-- <li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=">Bug </a> - </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-7.11..mesa-7.11.1
</pre>

<p>Adam Jackson (2):</p>
<ul>
  <li>drisw: Remove cargo culting that breaks GLX 1.3 ctors</li>
  <li>glx: Don't enable INTEL_swap_event unconditionally</li>
</ul>

<p>Alex Deucher (1):</p>
<ul>
  <li>r600g: fix up vs export handling</li>
</ul>

<p>Ben Widawsky (1):</p>
<ul>
  <li>intel: GetBuffer fix</li>
</ul>

<p>Brian Paul (15):</p>
<ul>
  <li>docs: add 7.11 md5 sums</li>
  <li>docs: news item for 7.11 release</li>
  <li>st/mesa: Convert size assertions to conditionals in st_texture_image_copy.</li>
  <li>softpipe: add missing stencil format case in convert_quad_stencil()</li>
  <li>mesa: fix texstore addressing bugs for depth/stencil formats</li>
  <li>mesa: add missing breaks for GL_TEXTURE_CUBE_MAP_SEAMLESS queries</li>
  <li>swrast: don't try to do depth testing if there's no depth buffer</li>
  <li>meta: fix/add checks for GL_EXT_framebuffer_sRGB</li>
  <li>mesa: fix PACK_COLOR_5551(), PACK_COLOR_1555() macros</li>
  <li>meta: fix broken sRGB mipmap generation</li>
  <li>mesa: add _NEW_CURRENT_ATTRIB in _mesa_program_state_flags()</li>
  <li>mesa: fix error handling for dlist image unpacking</li>
  <li>mesa: generate GL_INVALID_OPERATION in glIsEnabledIndex() between Begin/End</li>
  <li>mesa: fix incorrect error code in _mesa_FramebufferTexture1D/3DEXT()</li>
  <li>mesa: fix format/type check in unpack_image() for bitmaps</li>
</ul>

<p>Carl Simonson (1):</p>
<ul>
  <li>i830: Add missing vtable entry for i830 from the hiz work.</li>
</ul>

<p>Carl Worth (5):</p>
<ul>
  <li>glcpp: Fix two (or more) successive applications of token pasting</li>
  <li>glcpp: Test a non-function-like macro using the token paste operator</li>
  <li>glcpp: Implement token pasting for non-function-like macros</li>
  <li>glcpp: Raise error if defining any macro containing two consecutive underscores</li>
  <li>glcpp: Add a test for #elif with an undefined macro.</li>
</ul>

<p>Chad Versace (5):</p>
<ul>
  <li>glsl: Add method glsl_type::can_implicitly_convert_to()</li>
  <li>glsl: Fix implicit conversions in non-constructor function calls</li>
  <li>glsl: Remove ir_function.cpp:type_compare()</li>
  <li>glsl: Fix conversions in array constructors</li>
  <li>x86-64: Fix compile error with clang</li>
</ul>

<p>Chia-I Wu (3):</p>
<ul>
  <li>glsl: empty declarations should be valid</li>
  <li>intel: rename intel_extensions_es2.c to intel_extensions_es.c</li>
  <li>intel: fix GLESv1 support</li>
</ul>

<p>Chris Wilson (1):</p>
<ul>
  <li>i915: out-of-bounds write in calc_live_regs()</li>
</ul>

<p>Christopher James Halse Rogers (1):</p>
<ul>
  <li>glx/dri2: Paper over errors in DRI2Connect when indirect</li>
</ul>

<p>David Reveman (1):</p>
<ul>
  <li>i915g: Fix off-by-one in scissors.</li>
</ul>

<p>Eric Anholt (16):</p>
<ul>
  <li>mesa: Don't skip glGetProgramEnvParam4dvARB if there was already an error.</li>
  <li>mesa: Fix glGetUniform() type conversions.</li>
  <li>mesa: Add support for Begin/EndConditionalRender in display lists.</li>
  <li>mesa: Throw an error instead of asserting for condrender with query == 0.</li>
  <li>mesa: Throw an error when starting conditional render on an active query.</li>
  <li>mesa: Don't skip glGetProgramLocalParam4dvARB if there was already an error.</li>
  <li>glsl: Allow ir_assignment() constructor to not specify condition.</li>
  <li>glsl: Clarify error message about whole-array assignment in GLSL 1.10.</li>
  <li>glsl: When assigning to a whole array, mark the array as accessed.</li>
  <li>glsl: When assiging from a whole array, mark it as used.</li>
  <li>i965/fs: Respect ARB_color_buffer_float clamping.</li>
  <li>i965: Add missing _NEW_POLYGON flag to polygon stipple upload.</li>
  <li>i965: Fix polygon stipple offset state flagging.</li>
  <li>intel: Mark MESA_FORMAT_X8_Z24 as always supported.</li>
  <li>mesa: Don't error on glFeedbackBuffer(size = 0, buffer = NULL)</li>
  <li>glsl: Fix gl_NormalMatrix swizzle setup to match i965's invariants.</li>
</ul>

<p>Henri Verbeet (6):</p>
<ul>
  <li>mesa: Also set the remaining draw buffers to GL_NONE when updating just the first buffer in _mesa_drawbuffers().</li>
  <li>r600g: Support the PIPE_FORMAT_R16_FLOAT colorformat.</li>
  <li>mesa: Check the texture against all units in unbind_texobj_from_texunits().</li>
  <li>mesa: Allow sampling from units &gt;= MAX_TEXTURE_UNITS in shaders.</li>
  <li>mesa: Use the Elements macro for the sampler index assert in validate_samplers().</li>
  <li>mesa: Fix a couple of TexEnv unit limits.</li>
</ul>

<p>Ian Romanick (17):</p>
<ul>
  <li>mesa: Add utility function to get base format from a GL compressed format</li>
  <li>mesa: Return the correct internal fmt when a generic compressed fmt was used</li>
  <li>mesa: Make _mesa_get_compressed_formats match the texture compression specs</li>
  <li>linker: Make linker_error set LinkStatus to false</li>
  <li>linker: Make linker_{error,warning} generally available</li>
  <li>mesa: Ensure that gl_shader_program::InfoLog is never NULL</li>
  <li>ir_to_mesa: Use Add linker_error instead of fail_link</li>
  <li>ir_to_mesa: Emit warnings instead of errors for IR that can't be lowered</li>
  <li>i915: Fail without crashing if a Mesa IR program uses too many registers</li>
  <li>i915: Only emit program errors when INTEL_DEBUG=wm or INTEL_DEBUG=fallbacks</li>
  <li>mesa: Add GL_OES_compressed_paletted_texture formats to _mesa_is_compressed_format</li>
  <li>mesa: Add GL_OES_compressed_paletted_texture formats to _mesa_base_tex_format</li>
  <li>mesa: Refactor expected texture size check in cpal_get_info</li>
  <li>mesa: Add _mesa_cpal_compressed_format_type</li>
  <li>mesa: Refactor compressed texture error checks to work with paletted textures</li>
  <li>mesa: Remove redundant compressed paletted texture error checks</li>
  <li>mesa: Advertise GL_OES_compressed_paletted_texture in OpenGL ES1.x</li>
</ul>

<p>Jeremy Huddleston (3):</p>
<ul>
  <li>apple: Silence some debug spew</li>
  <li>apple: Use the correct (OpenGL.framework) glViewport and glScissor during init</li>
  <li>apple: Implement applegl_unbind_context</li>
</ul>

<p>José Fonseca (1):</p>
<ul>
  <li>docs: Update llvmpipe docs.</li>
</ul>

<p>Kenneth Graunke (12):</p>
<ul>
  <li>glsl: Avoid massive ralloc_strndup overhead in S-Expression parsing.</li>
  <li>mesa: In validate_program(), initialize errMsg for safety.</li>
  <li>i965/gen5+: Fix incorrect miptree layout for non-power-of-two cubemaps.</li>
  <li>i965: Use proper texture alignment units for cubemaps on Gen5+.</li>
  <li>i965: Fix incorrect maximum PS thread count shift on Ivybridge.</li>
  <li>i965: Emit depth stalls and flushes before changing depth state on Gen6+.</li>
  <li>i965/fs: Allow SIMD16 with control flow on Ivybridge.</li>
  <li>i965: Allow SIMD16 color writes on Ivybridge.</li>
  <li>i965: Fix inconsistent indentation in brw_eu_emit.c.</li>
  <li>intel: Depth format fixes</li>
  <li>i965: Apply post-sync non-zero workaround to homebrew workaround.</li>
  <li>mesa/get: Move MAX_LIGHTS from GL/ES2 to GL/ES1.</li>
</ul>

<p>Kristian Høgsberg (1):</p>
<ul>
  <li>glx: Don't flush twice if we fallback to dri2CopySubBuffer</li>
</ul>

<p>Marc Pignat (1):</p>
<ul>
  <li>drisw: Fix 24bpp software rendering, take 2</li>
</ul>

<p>Marcin Baczyński (2):</p>
<ul>
  <li>configure: fix gcc version check</li>
  <li>configure: allow C{,XX}FLAGS override</li>
</ul>

<p>Marcin Slusarz (3):</p>
<ul>
  <li>nouveau: fix nouveau_fence leak</li>
  <li>nouveau: fix crash during fence emission</li>
  <li>nouveau: fix fence hang</li>
</ul>

<p>Marek Olšák (19):</p>
<ul>
  <li>vbo: do not call _mesa_max_buffer_index in debug builds</li>
  <li>winsys/radeon: fix space checking</li>
  <li>r300/compiler: fix a warning that a variable may be uninitialized</li>
  <li>r300/compiler: remove an unused-but-set variable and simplify the code</li>
  <li>u_vbuf_mgr: cleanup original vs real vertex buffer arrays</li>
  <li>u_vbuf_mgr: don't take per-instance attribs into acc. when computing max index</li>
  <li>u_vbuf_mgr: fix max_index computation for large src_offset</li>
  <li>u_vbuf_mgr: s/u_vbuf_mgr_/u_vbuf_</li>
  <li>u_vbuf_mgr: remove unused flag U_VBUF_UPLOAD_FLUSHED</li>
  <li>u_vbuf_mgr: rework user buffer uploads</li>
  <li>u_vbuf_mgr: fix uploading with a non-zero index bias</li>
  <li>configure.ac: fix xlib-based softpipe build</li>
  <li>r600g: add index_bias to index buffer bounds</li>
  <li>r300g: fix rendering with a non-zero index bias in draw_elements_immediate</li>
  <li>Revert "r300g: fix rendering with a non-zero index bias in draw_elements_immediate"</li>
  <li>pb_bufmgr_cache: flush cache when create_buffer fails and try again</li>
  <li>r300g: don't return NULL in resource_from_handle if the resource is too small</li>
  <li>r600g: set correct tiling flags in depth info</li>
  <li>r300g: don't call u_trim_pipe_prim in r300_swtcl_draw_vbo</li>
</ul>

<p>Michel Dänzer (4):</p>
<ul>
  <li>st/mesa: Finalize texture on render-to-texture.</li>
  <li>glx/dri2: Don't call X server for SwapBuffers when there's no back buffer.</li>
  <li>gallium/util: Add macros for converting from little endian to CPU byte order.</li>
  <li>r300g: Fix queries on big endian hosts.</li>
</ul>

<p>Neil Roberts (1):</p>
<ul>
  <li>meta: Fix saving the active program</li>
</ul>

<p>Paul Berry (18):</p>
<ul>
  <li>glsl: Lower unconditional return statements.</li>
  <li>glsl: Refactor logic for determining whether to lower return statements.</li>
  <li>glsl: lower unconditional returns and continues in loops.</li>
  <li>glsl: Use foreach_list in lower_jumps.cpp</li>
  <li>glsl: In lower_jumps.cpp, lower both branches of a conditional.</li>
  <li>glsl: Lower break instructions when necessary at the end of a loop.</li>
  <li>glsl: improve the accuracy of the radians() builtin function</li>
  <li>glsl: improve the accuracy of the atan(x,y) builtin function.</li>
  <li>Revert "glsl: Skip processing the first function's body in do_dead_functions()."</li>
  <li>glsl: Emit function signatures at toplevel, even for built-ins.</li>
  <li>glsl: Constant-fold built-in functions before outputting IR</li>
  <li>glsl: Check array size is const before asserting that no IR was generated.</li>
  <li>glsl: Perform implicit type conversions on function call out parameters.</li>
  <li>glsl: Fix type error when lowering integer divisions</li>
  <li>glsl: Rework oversize array check for gl_TexCoord.</li>
  <li>glsl: Remove field array_lvalue from ir_variable.</li>
  <li>glsl hierarchical visitor: Do not overwrite base_ir for parameter lists.</li>
  <li>glsl: improve the accuracy of the asin() builtin function.</li>
</ul>

<p>Tobias Droste (1):</p>
<ul>
  <li>r300/compiler: simplify code in peephole_add_presub_add</li>
</ul>

<p>Tom Fogal (1):</p>
<ul>
  <li>Only use gcc visibility support with gcc4+.</li>
</ul>

<p>Tom Stellard (1):</p>
<ul>
  <li>r300/compiler: Fix regalloc for values with multiple writers</li>
</ul>

<p>Vadim Girlin (5):</p>
<ul>
  <li>st/mesa: flush bitmap cache on query and conditional render boundaries</li>
  <li>r600g: use backend mask for occlusion queries</li>
  <li>r600g: take into account force_add_cf in pops</li>
  <li>r600g: fix check_and_set_bank_swizzle</li>
  <li>r600g: fix replace_gpr_with_pv_ps</li>
</ul>

<p>Yuanhan Liu (17):</p>
<ul>
  <li>i965: fix the constant interp bitmask for flat mode</li>
  <li>mesa: fix error handling for glEvalMesh1/2D</li>
  <li>mesa: fix error handling for some glGet* functions</li>
  <li>mesa: fix error handling for glTexEnv</li>
  <li>mesa: fix error handling for glIsEnabled</li>
  <li>mesa: fix error handling for glPixelZoom</li>
  <li>mesa: fix error handling for glSelectBuffer</li>
  <li>mesa: fix error handling for glMapBufferRange</li>
  <li>mesa: fix error handling for glMaterial*</li>
  <li>intel: fix the wrong code to detect null texture.</li>
  <li>mesa: add a function to do the image data copy stuff for save_CompressedTex(Sub)Image</li>
  <li>i965: setup address rounding enable bits</li>
  <li>mesa: generate error if pbo offset is not aligned with the size of specified type</li>
  <li>mesa: fix inverted pbo test error at _mesa_GetnCompressedTexImageARB</li>
  <li>mesa: handle the pbo case for save_Bitmap</li>
  <li>mesa: handle PBO access error in display list mode</li>
  <li>intel: don't call unmap pbo if pbo is not mapped</li>
</ul>

</body>
</html>
