I'm trying to compute a weighted mean algorithm in the GPU. I want to pass several images to the shader, via sampler2d uniforms, in a FIFO queue style, having  a new one each frame by grabbing it from a camera. This is a simplified version using a PImage to illustrate whats happening:

2.   PGraphics pg;
3.   PShader kSmooth;
4.   int texIndex = 0;
5.   boolean ready = true;
6.   PImage img;
7. 
   
8. public void setup()
9. {
10.             size(640 , 480, P2D);
11.             img = createImage(640,480,ARGB);
12.             pg = createGraphics(640,480,P2D);
13.             kSmooth = loadShader("weightedmean.glsl");
14.             kSmooth.set("width", 640);
15.             kSmooth.set("height", 480);
16. }
17. 
    
18. public void draw()
19. {
20.              background(0);
21.              kSmooth.set("tex"+texIndex, img.get());
22.              kSmooth.set("index", texIndex);
23.              pg.beginDraw();
24.              pg.shader(kSmooth);
25.              pg.rect(0,0,pg.width,pg.height);
26.              pg.endDraw();
27.              texIndex = (texIndex+1) % 5;
28.              image(pg,0,0,pg.width,pg.height);
29.              frame.setTitle("Frame "+frameCount);
30.   }

And a simplified version of the fragment shader, where the weights are fixed instead of depeanding on the index uniform:

2. #define PROCESSING_COLOR_SHADER
3. 
   
4. uniform sampler2D tex0;
5. uniform sampler2D tex1;
6. uniform sampler2D tex2;
7. uniform sampler2D tex3;
8. uniform sampler2D tex4;
9. uniform int width;
10. uniform int height; 
11. uniform int index;
12. 
    
13. void main()
14. {
15. vec2 surfacePos = vec2( (gl_FragCoord.x / width) , ( (height - gl_FragCoord.y) / height)  );
17. float val1 = (texture2D(tex0, surfacePos)).x;
18. float val2 = (texture2D(tex1, surfacePos)).x * 2.0;
19. float val3 = (texture2D(tex2, surfacePos)).x * 3.0;
20. float val4 = (texture2D(tex3, surfacePos)).x * 4.0;
21. float val5 = (texture2D(tex4, surfacePos)).x * 5.0;
22. float result = (val1 + val2 + val3 + val4 + val5) / 15.0; // 15 is the sum of all weights
23. gl_FragColor = vec4(result, 0.0, 0.0, 1.0);
24. }

In my old windows xp machine    the memory used by the process keeps increasing until reaching the max memory available set in processing's preferences, then the program freezes for a few seconds, the memory is released and the process begins again, increasing the memory usage  once again.

In my new windows 8 machine I get an OutOfMemoryError after 200 or so frames.

Is there a method to free the memory of previous textures no longer used?

Thanks.

Note: I asked first how should I do it in this post which was moved to the general discussion forum, I thought I should post a simplified code here to illustrate the problem I found while tryng a solution. Hope that's not rude.