Merge lp:~jsjgruber/nux/lp1167018.1 into lp:nux

[John S. Gruber]

Proposed fix for https://bugs.launchpad.net/ubuntu/+source/nux/+bug/1167018 formatted as distribution patches (as I can't sign the Inalogic CLA). The current blur remains (my previous proposal to fix this problem had adjusted it). This seems like a more powerful approach and shouldn't affect the result except to speed it up.

The first bzr revision contains three small patches for problems I discovered as I worked. Each is a form of indexing problem.

The second contains the bug fix, which moves as much processing as possible from the per pixel shader to the shader set-up. The actual blur algorithm remains unchanged.

------

The specifics of the moved processing is to precompute a set of vec2(offsets) and weights, the set containing one row per sample needed for the blur, with the offsets normalized to the texture length or width. These are assembled in order for purposes of improving the chance that a subsequent texture sample will find its texture memory available in its cache without rereading memory--speeding up the shader.

The shader program is adjusted to take the above input, add the offset to the current pixels coordinate in texture space, get the texture sample, and add the weighted sample to the accumulating pixel gl_FragColor. On my X1250 R400 hardware each sample needs just three shader instructions, the texture address calculation, the sample, and the weighted sample accumulation.

I have a patch I'm not proposing here to alter the LS blur algorithm to produce a more Gaussian blur, it requires an increase of about 1.5 to the sigma to produce a blur similar in strength to the current one.

[John S. Gruber (jsjgruber)]

This has been built for testing in ppa:jsjgruber/ppatwo. See https://launchpad.net/~jsjgruber/+archive/ppatwo/+packages for the build.

To test (on the affected Radeon GPU):

1. Install the associated package.
2. Use ccsm to turn on active or static blur.
3. Press the "Super" or Alt button or bring up the Logout dialog box. Any
   of these should bring up a blur of the underlying screen on which to
   interact.

[Stephen M. Webb (bregma)]

Could you please submit your 02-ubuntu-ls-blur-return.patch and 04-ubuntu-fix-ls-blur-weight-adjustment.patch as separate merge proposals to the Nux (rather than as packaging patches), since they're atomic, stand alone, and are not substatial enough to require a CLA?

[Marco Trevisan (Treviño) (3v1n0)]

John, any update?

[John S. Gruber (jsjgruber)]

Marco, I'm waiting to hear back from Stephen who is working on the overall CLA issue for the patch set. If I get a good affirmative response through Stephen I'll reformat all of this as direct changes to Nux rather than as a set of distribution patches and request a merge of that. (I assume that's OK with you, too).

Unmerged revisions

813. By John S. Gruber on 2013-08-21

debian/patches/06-ubuntu-simplify-ls-shaders.patch :
Radically simplify (and generalize) the linear sampling gaussian
blur shader programs by calculating the coordinates normalized
by texture by width or height in the setup. Express these
as x,y vectors.
Apply them as simply as possible in the shader to save
shader instructions.
Also see that the offsets are given to the shader in
order, providing much improved locality of memory access.
This alone causes much time savings as the hardware
can have subsequent memory locations cached--which is impossible
when going from, e.g., texture coordinate (0,-9) directly to
(0, 9). Instead the order is (0, -9), (0, -8)...(0, 0), (0, 1)...
(0, 8), (0, 9).
Fixes lp: #1167018

812. By John S. Gruber on 2013-08-20

Add three patches to debian/patches to resolve problems related to LS
blurring:
02-ubuntu-ls-blur-return.patch
Return the length of the vectors so there is room in the shader
for all of them. This resolves an inconsistency between the
shader, shader setup and function return.
03-ubuntu-ls-blur-max-program.patch
Use the sigma rather than the number of samples required when
calculating the place to store one of the two linear sampling
gaussian blur shader programs in the cache.
The number of cache locations is limited to 11 and the
number of samples required can easily exceed that.
04-ubuntu-fix-ls-blur-weight-adjustment.patch
In the linear sampling gaussian blur calculation of offsets and
weights adjust the last weight as well as all others.

=== modified file 'debian/changelog'
--- debian/changelog	2013-08-16 10:34:41 +0000
+++ debian/changelog	2013-08-22 16:28:41 +0000
@@ -1,3 +1,49 @@
+nux (4.0.2+13.10.20130816.2-0ubuntu2~jgu002) saucy; urgency=low
+
+  * debian/patches/06-ubuntu-simplify-ls-shaders.patch :
+             Radically simplify (and generalize) the linear sampling gaussian
+             blur shader programs by calculating the coordinates normalized
+             by texture by width or height in the setup. Express these
+             as x,y vectors.
+
+             Apply them as simply as possible in the shader to save
+             shader instructions.
+
+             Also see that the offsets are given to the shader in
+             order, providing much improved locality of memory access.
+             This alone causes much time savings as the hardware
+             can have subsequent memory locations cached--which is impossible
+             when going from, e.g., texture coordinate (0,-9) directly to
+             (0, 9). Instead the order is (0, -9), (0, -8)...(0, 0), (0, 1)...
+             (0, 8), (0, 9).
+
+             Fixes lp: #1167018
+
+ -- John S Gruber <[e-mail]>  Tue, 20 Aug 2013 17:49:11 -0400
+
+nux (4.0.2+13.10.20130816.2-0ubuntu2~jgu001) saucy; urgency=low
+
+  * Add three patches to debian/patches to resolve problems related to LS
+             blurring:
+
+  02-ubuntu-ls-blur-return.patch 
+             Return the length of the vectors so there is room in the shader
+             for all of them. This resolves an inconsistency between the
+             shader, shader setup and function return.
+
+  03-ubuntu-ls-blur-max-program.patch
+             Use the sigma rather than the number of samples required when
+             calculating the place to store one of the two linear sampling
+             gaussian blur shader programs in the cache.
+             The number of cache locations is limited to 11 and the
+             number of samples required can easily exceed that.
+
+  04-ubuntu-fix-ls-blur-weight-adjustment.patch 
+             In the linear sampling gaussian blur calculation of offsets and
+             weights adjust the last weight as well as all others.
+
+ -- John S Gruber <[e-mail]>  Tue, 20 Aug 2013 14:40:43 -0400
+
 nux (4.0.2+13.10.20130816.2-0ubuntu1) saucy; urgency=low
 
   [ Stephen M. Webb ]
 
=== added file 'debian/patches/02-ubuntu-ls-blur-return.patch'
--- debian/patches/02-ubuntu-ls-blur-return.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/02-ubuntu-ls-blur-return.patch	2013-08-22 16:28:41 +0000
@@ -0,0 +1,17 @@
+Description: Return the length of the vectors so there is room in the shader
+             for all of them. This resolves an inconsistency between the
+             shader, shader setup and function return.
+Author: John S. Gruber <[e-mail]>
+Index: lp-1167018/NuxGraphics/GraphicsEngine.cpp
+===================================================================
+--- lp-1167018.orig/NuxGraphics/GraphicsEngine.cpp	2013-06-21 14:27:15.234611000 -0400
++++ lp-1167018/NuxGraphics/GraphicsEngine.cpp	2013-06-21 14:31:09.445907747 -0400
+@@ -1373,7 +1373,7 @@
+       weights[i] /= total;
+     }
+     
+-    return support;
++    return (int) weights.size();
+   }
+ 
+   void GraphicsEngine::GaussianWeights(float **weights, float sigma, unsigned int num_tap)
 
=== added file 'debian/patches/03-ubuntu-ls-blur-max-program.patch'
--- debian/patches/03-ubuntu-ls-blur-max-program.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/03-ubuntu-ls-blur-max-program.patch	2013-08-22 16:28:41 +0000
@@ -0,0 +1,143 @@
+Description: Use the sigma rather than the number of samples required when
+             calculating the place to store one of the two linear sampling
+             gaussian blur shader programs in the cache.
+             The number of cache locations is limited to 11 and the
+             number of samples required can easily exceed that.
+Author:      John S. Gruber <[e-mail]>
+--- a/NuxGraphics/RenderingPipeGLSL.cpp
++++ b/NuxGraphics/RenderingPipeGLSL.cpp
+@@ -630,9 +630,9 @@
+     _vertical_hq_gauss_filter_prog[k-1]->Link();
+   }
+   
+-  void GraphicsEngine::InitSLHorizontalLSGaussFilter(int k)
++  void GraphicsEngine::InitSLHorizontalLSGaussFilter(int k, int index)
+   {
+-    if (_horizontal_ls_gauss_filter_prog[k-1].IsValid())
++    if (_horizontal_ls_gauss_filter_prog[index].IsValid())
+     {
+       // Shader program already compiled
+       return;
+@@ -674,21 +674,21 @@
+     char* shader_prog = new char[l+10];
+     sprintf(shader_prog, ps_string.c_str(), k);
+ 
+-    _horizontal_ls_gauss_filter_prog[k-1] = _graphics_display.m_DeviceFactory->CreateShaderProgram();
++    _horizontal_ls_gauss_filter_prog[index] = _graphics_display.m_DeviceFactory->CreateShaderProgram();
+     vs->SetShaderCode(vs_string.c_str());
+     ps->SetShaderCode(shader_prog);
+     delete[] shader_prog;
+ 
+-    _horizontal_ls_gauss_filter_prog[k-1]->ClearShaderObjects();
+-    _horizontal_ls_gauss_filter_prog[k-1]->AddShaderObject(vs);
+-    _horizontal_ls_gauss_filter_prog[k-1]->AddShaderObject(ps);
+-    CHECKGL(glBindAttribLocation(_horizontal_ls_gauss_filter_prog[k-1]->GetOpenGLID(), 0, "vertex"));
+-    _horizontal_ls_gauss_filter_prog[k-1]->Link();
++    _horizontal_ls_gauss_filter_prog[index]->ClearShaderObjects();
++    _horizontal_ls_gauss_filter_prog[index]->AddShaderObject(vs);
++    _horizontal_ls_gauss_filter_prog[index]->AddShaderObject(ps);
++    CHECKGL(glBindAttribLocation(_horizontal_ls_gauss_filter_prog[index]->GetOpenGLID(), 0, "vertex"));
++    _horizontal_ls_gauss_filter_prog[index]->Link();
+   }
+ 
+-  void GraphicsEngine::InitSLVerticalLSGaussFilter(int k)
++  void GraphicsEngine::InitSLVerticalLSGaussFilter(int k, int index)
+   {
+-    if (_vertical_ls_gauss_filter_prog[k-1].IsValid())
++    if (_vertical_ls_gauss_filter_prog[index].IsValid())
+     {
+       // Shader program already compiled
+       return;
+@@ -730,16 +730,16 @@
+     char* shader_prog = new char[l+10];
+     sprintf(shader_prog, ps_string.c_str(), k);
+ 
+-    _vertical_ls_gauss_filter_prog[k-1] = _graphics_display.m_DeviceFactory->CreateShaderProgram();
++    _vertical_ls_gauss_filter_prog[index] = _graphics_display.m_DeviceFactory->CreateShaderProgram();
+     vs->SetShaderCode(vs_string.c_str());
+     ps->SetShaderCode(shader_prog);
+     delete[] shader_prog;
+ 
+-    _vertical_ls_gauss_filter_prog[k-1]->ClearShaderObjects();
+-    _vertical_ls_gauss_filter_prog[k-1]->AddShaderObject(vs);
+-    _vertical_ls_gauss_filter_prog[k-1]->AddShaderObject(ps);
+-    CHECKGL(glBindAttribLocation(_vertical_ls_gauss_filter_prog[k-1]->GetOpenGLID(), 0, "vertex"));
+-    _vertical_ls_gauss_filter_prog[k-1]->Link();
++    _vertical_ls_gauss_filter_prog[index]->ClearShaderObjects();
++    _vertical_ls_gauss_filter_prog[index]->AddShaderObject(vs);
++    _vertical_ls_gauss_filter_prog[index]->AddShaderObject(ps);
++    CHECKGL(glBindAttribLocation(_vertical_ls_gauss_filter_prog[index]->GetOpenGLID(), 0, "vertex"));
++    _vertical_ls_gauss_filter_prog[index]->Link();
+   }
+ 
+   void GraphicsEngine::InitSLColorMatrixFilter()
+@@ -2097,14 +2097,15 @@
+   
+   void GraphicsEngine::QRP_GLSL_HorizontalLSGauss(int x, int y, int width, int height, ObjectPtr<IOpenGLBaseTexture> device_texture, TexCoordXForm &texxform0, const Color & /* c0 */, float sigma)
+   {
++    int index = int(sigma) - 1;
+     std::vector<float> weights(0);
+     std::vector<float> offsets(0);
+     
+     int num_samples = LinearSampleGaussianWeights(weights, offsets, sigma);
+ 
+-    if (_horizontal_ls_gauss_filter_prog[num_samples-1].IsValid() == false)
++    if (_horizontal_ls_gauss_filter_prog[index].IsValid() == false)
+     {
+-      InitSLHorizontalLSGaussFilter(num_samples);
++      InitSLHorizontalLSGaussFilter(num_samples, index);
+     }
+ 
+     m_quad_tex_stats++;
+@@ -2125,7 +2126,7 @@
+       return;
+     }
+ 
+-    shader_prog = _horizontal_ls_gauss_filter_prog[num_samples-1];
++    shader_prog = _horizontal_ls_gauss_filter_prog[index];
+ 
+     CHECKGL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0));
+     CHECKGL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0));
+@@ -2171,14 +2172,15 @@
+ 
+   void GraphicsEngine::QRP_GLSL_VerticalLSGauss(int x, int y, int width, int height, ObjectPtr<IOpenGLBaseTexture> device_texture, TexCoordXForm &texxform0, const Color & /* c0 */, float sigma)
+   {
++    int index = int(sigma) - 1;
+     std::vector<float> weights(0);
+     std::vector<float> offsets(0);
+     
+     int num_samples = LinearSampleGaussianWeights(weights, offsets, sigma);
+ 
+-    if (_vertical_ls_gauss_filter_prog[num_samples-1].IsValid() == false)
++    if (_vertical_ls_gauss_filter_prog[index].IsValid() == false)
+     {
+-      InitSLVerticalLSGaussFilter(num_samples);
++      InitSLVerticalLSGaussFilter(num_samples, index);
+     }
+ 
+     m_quad_tex_stats++;
+@@ -2199,7 +2201,7 @@
+       return;
+     }
+ 
+-    shader_prog = _vertical_ls_gauss_filter_prog[num_samples-1];
++    shader_prog = _vertical_ls_gauss_filter_prog[index];
+ 
+     CHECKGL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0));
+     CHECKGL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0));
+--- a/NuxGraphics/GraphicsEngine.h
++++ b/NuxGraphics/GraphicsEngine.h
+@@ -1028,11 +1028,11 @@
+     //! Gauss vertical filter.
+     ObjectPtr<IOpenGLShaderProgram> _vertical_hq_gauss_filter_prog[NUX_MAX_GAUSSIAN_SIGMA];
+     
+-    void InitSLHorizontalLSGaussFilter(int k);
++    void InitSLHorizontalLSGaussFilter(int k, int index);
+     //! Gauss horizontal filter.
+     ObjectPtr<IOpenGLShaderProgram> _horizontal_ls_gauss_filter_prog[NUX_MAX_GAUSSIAN_SIGMA];
+ 
+-    void InitSLVerticalLSGaussFilter(int k);
++    void InitSLVerticalLSGaussFilter(int k, int index);
+     //! Gauss vertical filter.
+     ObjectPtr<IOpenGLShaderProgram> _vertical_ls_gauss_filter_prog[NUX_MAX_GAUSSIAN_SIGMA];
+ 
 
=== added file 'debian/patches/04-ubuntu-fix-ls-blur-weight-adjustment.patch'
--- debian/patches/04-ubuntu-fix-ls-blur-weight-adjustment.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/04-ubuntu-fix-ls-blur-weight-adjustment.patch	2013-08-22 16:28:41 +0000
@@ -0,0 +1,14 @@
+Description: In the linear sampling gaussian blur calculation of offsets and
+             weights adjust the last weight as well as all others.
+Author:      John S. Gruber <[e-mail]>
+--- a/NuxGraphics/GraphicsEngine.cpp
++++ b/NuxGraphics/GraphicsEngine.cpp
+@@ -1368,7 +1368,7 @@
+     }
+     
+     //Normalise our weights.
+-    for (int i = 0; i < support; i++)
++    for (int i = 0; i <= support; i++)
+     {
+       weights[i] /= total;
+     }
 
=== added file 'debian/patches/06-ubuntu-simplify-ls-shaders.patch'
--- debian/patches/06-ubuntu-simplify-ls-shaders.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/06-ubuntu-simplify-ls-shaders.patch	2013-08-22 16:28:41 +0000
@@ -0,0 +1,175 @@
+Description: Radically simplify (and generalize) the linear sampling gaussian
+             blur shader programs by calculating the coordinates normalized
+             by texture by width or height in the setup. Express these
+             as x,y vectors.
+
+             Apply them as simply as possible in the shader to save
+             shader instructions.
+
+             Also see that the offsets are given to the shader in
+             order, providing much improved locality of memory access.
+             This alone causes much time savings as the hardware
+             can have subsequent memory locations cached--which is impossible
+             when going from, e.g., texture coordinate (0,-9) directly to
+             (0, 9). Instead the order is (0, -9), (0, -8)...(0, 0), (0, 1)...
+             (0, 8), (0, 9).
+
+             Fixes lp: #1167018
+
+Bug: https://bugs.launchpad.net/ubuntu/+source/nux/+bug/1167018
+Author:      John S. Gruber<[e-mail]>
+--- a/NuxGraphics/RenderingPipeGLSL.cpp
++++ b/NuxGraphics/RenderingPipeGLSL.cpp
+@@ -655,19 +655,15 @@
+     std::string ps_string = NUX_FRAGMENT_SHADER_HEADER
+     "varying vec4 v_tex_coord;                                                                                  \n\
+      uniform sampler2D tex_object;                                                                              \n\
+-     uniform vec2 tex_size;                                                                                     \n\
+      #define NUM_SAMPLES %d                                                                                     \n\
+-     uniform float weights[NUM_SAMPLES];                                                                        \n\
+-     uniform float offsets[NUM_SAMPLES];                                                                        \n\
++     uniform vec3 blur_input[2*NUM_SAMPLES-1];                                                                        \n\
+      void main()                                                                                                \n\
+      {                                                                                                          \n\
+-      vec3 acc = texture2D(tex_object, v_tex_coord.st).rgb*weights[0];\n\
+-      for (int i = 1; i < NUM_SAMPLES; i++)                                                                     \n\
++      gl_FragColor.rgba = vec4(0.0, 0.0, 0.0, 1.0); \n\
++      for (int i = 0; i < 2*NUM_SAMPLES-1; i++)                                                                     \n\
+       {                                                                                                         \n\
+-        acc += texture2D(tex_object, (v_tex_coord.st+(vec2(offsets[i], 0.0)/tex_size))).rgb*weights[i]; \n\
+-        acc += texture2D(tex_object, (v_tex_coord.st-(vec2(offsets[i], 0.0)/tex_size))).rgb*weights[i]; \n\
++        gl_FragColor.rgb += texture2D(tex_object, (v_tex_coord.st+blur_input[i].st)).rgb*blur_input[i].p; \n\
+       }                                                                                                         \n\
+-      gl_FragColor = vec4(acc, 1.0);                                                                    \n\
+      }";
+ 
+     int l = ps_string.length();
+@@ -711,19 +707,15 @@
+     std::string ps_string = NUX_FRAGMENT_SHADER_HEADER
+     "varying vec4 v_tex_coord;                                                                                  \n\
+      uniform sampler2D tex_object;                                                                              \n\
+-     uniform vec2 tex_size;                                                                                     \n\
+      #define NUM_SAMPLES %d                                                                                     \n\
+-     uniform float weights[NUM_SAMPLES];                                                                        \n\
+-     uniform float offsets[NUM_SAMPLES];                                                                        \n\
++     uniform vec3 blur_input[2*NUM_SAMPLES-1];                                                                        \n\
+      void main()                                                                                                \n\
+      {                                                                                                          \n\
+-      vec3 acc = texture2D(tex_object, v_tex_coord.st).rgb*weights[0]; \n\
+-      for (int i = 1; i < NUM_SAMPLES; i++)                                                                     \n\
++      gl_FragColor.rgba = vec4(0.0, 0.0, 0.0, 1.0); \n\
++      for (int i = 0; i < 2*NUM_SAMPLES-1; i++)                                                                     \n\
+       {                                                                                                         \n\
+-        acc += texture2D(tex_object, (v_tex_coord.st+(vec2(0.0, offsets[i])/tex_size))).rgb*weights[i]; \n\
+-        acc += texture2D(tex_object, (v_tex_coord.st-(vec2(0.0, offsets[i])/tex_size))).rgb*weights[i]; \n\
++        gl_FragColor.rgb += texture2D(tex_object, (v_tex_coord.st+blur_input[i].st)).rgb*blur_input[i].p; \n\
+       }                                                                                                         \n\
+-      gl_FragColor = vec4(acc, 1.0);                                                                    \n\
+      }";
+ 
+     int l = ps_string.length();
+@@ -2100,8 +2092,19 @@
+     int index = int(sigma) - 1;
+     std::vector<float> weights(0);
+     std::vector<float> offsets(0);
+-    
+     int num_samples = LinearSampleGaussianWeights(weights, offsets, sigma);
++    float *blur_input = new float [3*(2*num_samples - 1)];
++    int base = num_samples - 1;
++    for (int i=0; i < num_samples; i++)
++      {
++        offsets[i] /= width;
++        blur_input[(base-i)*3+0]  = -offsets[i];
++        blur_input[(base-i)*3+1]  = 0;
++        blur_input[(base-i)*3+2]  = weights[i];
++        blur_input[(base+i)*3+0]  = offsets[i];
++        blur_input[(base+i)*3+1]  = 0;
++        blur_input[(base+i)*3+2]  = weights[i];
++      }
+ 
+     if (_horizontal_ls_gauss_filter_prog[index].IsValid() == false)
+     {
+@@ -2133,19 +2138,13 @@
+     shader_prog->Begin();
+ 
+     int tex_object_location     = shader_prog->GetUniformLocationARB("tex_object");
+-    int weights_location        = shader_prog->GetUniformLocationARB("weights");
+-    int offsets_location        = shader_prog->GetUniformLocationARB("offsets");
+-    int tex_size_location       = shader_prog->GetUniformLocationARB("tex_size");
++    int blur_input_location     = shader_prog->GetUniformLocationARB("blur_input");
+     int vertex_location         = shader_prog->GetAttributeLocation("vertex");
+     int tex_coord_location      = shader_prog->GetAttributeLocation("tex_coord");
+ 
+     SetTexture(GL_TEXTURE0, device_texture);
+     CHECKGL(glUniform1iARB(tex_object_location, 0));
+-
+-    CHECKGL(glUniform1fv(weights_location, weights.size(), &weights[0]));
+-    CHECKGL(glUniform1fv(offsets_location, offsets.size(), &offsets[0]));
+-
+-    CHECKGL(glUniform2fARB(tex_size_location, width, height));
++    CHECKGL(glUniform3fv(blur_input_location, 2*num_samples - 1, &blur_input[0]));
+ 
+     int     VPMatrixLocation = shader_prog->GetUniformLocationARB("view_projection_matrix");
+     Matrix4 MVPMatrix = GetOpenGLModelViewProjectionMatrix();
+@@ -2168,6 +2167,8 @@
+       CHECKGL(glDisableVertexAttribArrayARB(tex_coord_location));
+ 
+     shader_prog->End();
++    delete [] blur_input;
++    blur_input = NULL;
+   }
+ 
+   void GraphicsEngine::QRP_GLSL_VerticalLSGauss(int x, int y, int width, int height, ObjectPtr<IOpenGLBaseTexture> device_texture, TexCoordXForm &texxform0, const Color & /* c0 */, float sigma)
+@@ -2175,8 +2176,19 @@
+     int index = int(sigma) - 1;
+     std::vector<float> weights(0);
+     std::vector<float> offsets(0);
+-    
+     int num_samples = LinearSampleGaussianWeights(weights, offsets, sigma);
++    float *blur_input = new float [3*(2*num_samples - 1)];
++    int base = num_samples - 1;
++    for (int i=0; i < num_samples; i++)
++      {
++        offsets[i] /= height;
++        blur_input[(base-i)*3+0]  = 0;
++        blur_input[(base-i)*3+1]  = -offsets[i];
++        blur_input[(base-i)*3+2]  = weights[i];
++        blur_input[(base+i)*3+0]  = 0;
++        blur_input[(base+i)*3+1]  = offsets[i];
++        blur_input[(base+i)*3+2]  = weights[i];
++      }
+ 
+     if (_vertical_ls_gauss_filter_prog[index].IsValid() == false)
+     {
+@@ -2208,20 +2222,14 @@
+     shader_prog->Begin();
+ 
+     int tex_object_location     = shader_prog->GetUniformLocationARB("tex_object");
+-    int weights_location        = shader_prog->GetUniformLocationARB("weights");
+-    int offsets_location        = shader_prog->GetUniformLocationARB("offsets");
+-    int tex_size_location       = shader_prog->GetUniformLocationARB("tex_size");
++    int blur_input_location     = shader_prog->GetUniformLocationARB("blur_input");
+     int vertex_location         = shader_prog->GetAttributeLocation("vertex");
+     int tex_coord_location      = shader_prog->GetAttributeLocation("tex_coord");
+ 
+     SetTexture(GL_TEXTURE0, device_texture);
+ 
+     CHECKGL(glUniform1iARB(tex_object_location, 0));
+-
+-    CHECKGL(glUniform1fv(weights_location, weights.size(), &weights[0]));
+-    CHECKGL(glUniform1fv(offsets_location, offsets.size(), &offsets[0]));
+-
+-    CHECKGL(glUniform2fARB(tex_size_location, width, height));
++    CHECKGL(glUniform3fv(blur_input_location, 2*num_samples - 1, &blur_input[0]));
+ 
+     int     VPMatrixLocation = shader_prog->GetUniformLocationARB("view_projection_matrix");
+     Matrix4 MVPMatrix = GetOpenGLModelViewProjectionMatrix();
+@@ -2244,6 +2252,8 @@
+       CHECKGL(glDisableVertexAttribArrayARB(tex_coord_location));
+ 
+     shader_prog->End();
++    delete [] blur_input;
++    blur_input = NULL;
+   }
+ 
+   void GraphicsEngine::QRP_GLSL_ColorMatrix(int x, int y, int width, int height, ObjectPtr<IOpenGLBaseTexture> device_texture, TexCoordXForm &texxform0,
 
=== modified file 'debian/patches/series'
--- debian/patches/series	2012-08-01 16:09:01 +0000
+++ debian/patches/series	2013-08-22 16:28:41 +0000
@@ -1,1 +1,5 @@
 01_blacklist_llvmpipe.patch
+02-ubuntu-ls-blur-return.patch
+03-ubuntu-ls-blur-max-program.patch
+04-ubuntu-fix-ls-blur-weight-adjustment.patch
+06-ubuntu-simplify-ls-shaders.patch