NLMeansCL: GPU based Non Local Means Denoising

[frustum]

My understanding is that OpenCL programs can be compiled to run either on a GPU or on the host CPU. If this is true, I'm curious, Malcom, if you have tried this, and how fast the filter runs on the host CPU vs the original TNLmeans filter. How much penalty is there (if any) for writing it as OpenCL vs C if there is no GPU to help out.

[yup]

Malcolm :thanks: for Your time.
NLMeansCL work on my 8800 GTS 512 with last Nvidia driver (260.99). Speed for SD content little faster than real time 26-27 fps.
If You find time add also Az support for Az=1 and Az=2 it may be useful for motion compensating filtering.
yup.

[Malcolm]

My understanding is that OpenCL programs can be compiled to run either on a GPU or on the host CPU. If this is true, I'm curious, Malcom, if you have tried this, and how fast the filter runs on the host CPU vs the original TNLmeans filter. How much penalty is there (if any) for writing it as OpenCL vs C if there is no GPU to help out.

I have created a version that runs on the CPU. Please see my first post for explanations as well as some performance figures.

Let me explain some aspects regarding CPU vs. GPU:
- CPUs are not generally slower than CPUs. The performance does heavily depend on the algorithm that is implemented. For NLMeans, the results are clear. But that's just one example. There are algorithms that will always be slower on a GPU than on a CPU.
- You can see from my performance measurements, that using buffers instead of images is much slower. But that's only half the truth. I have a version of NLMeansCL on my harddisk, that is faster on my Geforce when using buffers instead of images! So the execution speed does also heavily depend on how memory is used and accessed inside the filter. But on the other hand this version is actually even slower on the CPU that version 0.2 when using buffers! So though OpenCL executes on GPUs as well as CPUs, you typically have to code to the exact hardware to achieve peak performance!
- One benefit of OpenCL is that it's naturally multithreaded. So if you throw in another CPU with double the number of cores (or a new gfx card), it will typically scale well. That's not true for TNLMeans.
- My current implementation is tuned for execution on GPUs. There are some micro optimizations for individual math functions and so on. For a serious CPU version of the filter, i would go over the implementation and play around with different expressions to see if they execute faster than the existing ones. But this is - as i said -a micro optimization.

@tormento
Sorry, i can't help you out with suggestions to mimic SMDegrain.

@yup
Yeah, i will see what i can do.

[naoan]

I dunno what I did wrong, but I still get the same error message as the one in earlier version with 0.2

Have tried setting buffer and cpu to true (either and both).

[ChaosKing]

yep, i have problems with cpu and buffer too.

[Malcolm]

@naoan, ChaosKing
If anyone of you would send me the logfile....:rolleyes:

[naoan]

Oh, sorry. Here it is (with buffer=true) :

NLMeansCL Version 0.2
ScriptEnvironment present.
Number of OpenCL Compute Platforms = 1.
Trying OpenCL Compute Platform
Advanced Micro Devices, Inc..
OpenCL 1.1 ATI-Stream-v2.3 (451).
OpenCL Compute Context successfully created.
Number of OpenCL Devices in Platform = 2.
Using first OpenCL Device.
ATI RV770.
Device available.
OpenCL Command Queue successfully created.
OpenCL error code detected: BuildProgramFailure.


The log is exactly the same with buffer=false and stop at "Device available." with cpu and buffer set at true.

Thanks again. :)

[Malcolm]

Ok, i see. There are 2 problems.
The behaviour of AMDs OpenCL platform is different than i thought. So if you have an AMD gfx card, as well as the CPU as OpenCL device, then the selection of the CPU fails and it is using the GPU. I can change the selection strategy, to overcome this. (Selecting the CPU as computation device actually works if you have an Nvidia GPU). I will provide this ASAP.

The second thing is, that the compilation of the kernel fails. Since i don't own an AMD gfx card, it's nearly impossible for me to tell what the reason could be!
So far i can only tell that my implementation is correct, since it runs on Nvidia GPUs as well as the CPU.
The cause can only be that i'm using some functions that are not implemented by AMD and thus the AMD OpenCL driver refuses to compile!
Sorry for any inconvenience i have caused, by providing something which obviously doesn't run on Radeons. But i'm just trying to give you someting..

[naoan]

Hey, no worries there, in fact I'm very thankful you even try to do something about it and for making this plugin available to community for free. :o

I've been meaning to upgrade my GPU, and now my choice is clear, thanks to this plugin. ;)

[ChaosKing]

NLMeansCL(cpu=true) -> http://img141.imageshack.us/img141/4598/nlm.th.png (http://img141.imageshack.us/i/nlm.png/)
My CPU: Intel Q9550

I can't find a debug log, c:\temp is empty

===================================================
GPU Caps Viewer v1.9.5
http://www.ozone3d.net/gpu_caps_viewer/
===================================================


===================================[ System / CPU ]
- CPU Name: Intel(R) Core(TM)2 Quad CPU Q9550 @ 2.83GHz
- CPU Core Speed: 2833 MHz
- CPU Num Cores: 4
- Family: 6 - Model: 7 - Stepping: 10
- Physical Memory Size: 4095 MB
- Operating System: Windows 7 64-bit build 7600 [No Service Pack]
- DirectX Version: 10.0
- PhysX Version: 9100514


===================================[ Graphics Adapter / GPU ]
- SLI: disabled
- GPUs: 1
- Logical GPUs: 1
- OpenGL Renderer: GeForce GTX 260/PCI/SSE2
- Drivers Renderer: NVIDIA GeForce GTX 260
- DB Renderer: NVIDIA GeForce GTX 260
- Device Description: NVIDIA GeForce GTX 260
- Adapter String: GeForce GTX 260
- Vendor: NVIDIA Corporation
- Vendor ID: 0x10DE
- Device ID: 0x05E2
- Sub device ID: 0x1109
- Sub vendor ID: 0x19DA
- Drivers Version: 8.17.12.6099 (10-16-2010) - nvoglv64
- GPU Codename: GT200
- GPU Unified Shader Processors: 192
- GPU Vertex Shader Processors: 0
- GPU Pixel Shader Processors: 0
- SM / SIMD: 24
- TPC: 8
- TPD (Watts): 182
- Video Memory Size: 896 MB
- Video Memory Type: GDDR3
- Clocks level #0: Core: 300MHz - Memory: 100MHz - Shader: 600MHz
- Clocks level #1: Core: 400MHz - Memory: 300MHz - Shader: 800MHz
- Clocks level #2: Core: 576MHz - Memory: 999MHz - Shader: 1242MHz
- BIOS String: 62.0.61.0.0
- Current Display Mode: 1280x1024 @ 60 Hz - 32 bpp


===================================[ OpenGL GPU Capabilities ]
- OpenGL Version: 3.3.0
- GLSL (OpenGL Shading Language) Version: 3.30 NVIDIA via Cg compiler
- ARB Texture Units: 4
- Vertex Shader Texture Units: 32
- Pixel Shader Texture Units: 32
- Geometry Shader Texture Units: 32
- Max Texture Size: 8192x8192
- Max Anisotropic Filtering Value: X16.0
- Max Point Sprite Size: 63.4
- Max Dynamic Lights: 8
- Max Viewport Size: 8192x8192
- Max Vertex Uniform Components: 4096
- Max Fragment Uniform Components: 2048
- Max Geometry Uniform Components: 2048
- Max Varying Float: 60
- Max Vertex Bindable Uniforms: 12
- Max Fragment Bindable Uniforms: 12
- Max Geometry Bindable Uniforms: 12
- Frame Buffer Objects (FBO) Support:[yes]
- Multiple Render Targets / Max draw buffers: 8
- Pixel Buffer Objects (PBO) Support:[yes]
- S3TC Texture Compression Support:[yes]
- ATI 3Dc Texture Compression Support:[no]
- Texture Rectangle Support:[yes]
- Floating Point Textures Support:[yes]
- MSAA: 2X
- MSAA: 4X
- MSAA: 8X
- MSAA: 16X
- OpenGL Extensions: 221 extensions (GL=199 and WGL=22)
<li>GL_ARB_blend_func_extended</li>
<li>GL_ARB_color_buffer_float</li>
<li>GL_ARB_compatibility</li>
<li>GL_ARB_copy_buffer</li>
<li>GL_ARB_debug_output</li>
<li>GL_ARB_depth_buffer_float</li>
<li>GL_ARB_depth_clamp</li>
<li>GL_ARB_depth_texture</li>
<li>GL_ARB_draw_buffers</li>
<li>GL_ARB_draw_elements_base_vertex</li>
<li>GL_ARB_draw_instanced</li>
<li>GL_ARB_ES2_compatibility</li>
<li>GL_ARB_explicit_attrib_location</li>
<li>GL_ARB_fragment_coord_conventions</li>
<li>GL_ARB_fragment_program</li>
<li>GL_ARB_fragment_program_shadow</li>
<li>GL_ARB_fragment_shader</li>
<li>GL_ARB_framebuffer_object</li>
<li>GL_ARB_framebuffer_sRGB</li>
<li>GL_ARB_geometry_shader4</li>
<li>GL_ARB_get_program_binary</li>
<li>GL_ARB_half_float_pixel</li>
<li>GL_ARB_half_float_vertex</li>
<li>GL_ARB_imaging</li>
<li>GL_ARB_instanced_arrays</li>
<li>GL_ARB_map_buffer_range</li>
<li>GL_ARB_multisample</li>
<li>GL_ARB_multitexture</li>
<li>GL_ARB_occlusion_query</li>
<li>GL_ARB_occlusion_query2</li>
<li>GL_ARB_pixel_buffer_object</li>
<li>GL_ARB_point_parameters</li>
<li>GL_ARB_point_sprite</li>
<li>GL_ARB_provoking_vertex</li>
<li>GL_ARB_robustness</li>
<li>GL_ARB_sampler_objects</li>
<li>GL_ARB_seamless_cube_map</li>
<li>GL_ARB_separate_shader_objects</li>
<li>GL_ARB_shader_bit_encoding</li>
<li>GL_ARB_shader_objects</li>
<li>GL_ARB_shading_language_100</li>
<li>GL_ARB_shadow</li>
<li>GL_ARB_sync</li>
<li>GL_ARB_texture_border_clamp</li>
<li>GL_ARB_texture_buffer_object</li>
<li>GL_ARB_texture_compression</li>
<li>GL_ARB_texture_compression_rgtc</li>
<li>GL_ARB_texture_cube_map</li>
<li>GL_ARB_texture_env_add</li>
<li>GL_ARB_texture_env_combine</li>
<li>GL_ARB_texture_env_crossbar</li>
<li>GL_ARB_texture_env_dot3</li>
<li>GL_ARB_texture_float</li>
<li>GL_ARB_texture_mirrored_repeat</li>
<li>GL_ARB_texture_multisample</li>
<li>GL_ARB_texture_non_power_of_two</li>
<li>GL_ARB_texture_rectangle</li>
<li>GL_ARB_texture_rg</li>
<li>GL_ARB_texture_rgb10_a2ui</li>
<li>GL_ARB_texture_swizzle</li>
<li>GL_ARB_timer_query</li>
<li>GL_ARB_transform_feedback2</li>
<li>GL_ARB_transpose_matrix</li>
<li>GL_ARB_uniform_buffer_object</li>
<li>GL_ARB_vertex_array_bgra</li>
<li>GL_ARB_vertex_array_object</li>
<li>GL_ARB_vertex_buffer_object</li>
<li>GL_ARB_vertex_program</li>
<li>GL_ARB_vertex_shader</li>
<li>GL_ARB_vertex_type_2_10_10_10_rev</li>
<li>GL_ARB_viewport_array</li>
<li>GL_ARB_window_pos</li>
<li>GL_ATI_draw_buffers</li>
<li>GL_ATI_texture_float</li>
<li>GL_ATI_texture_mirror_once</li>
<li>GL_S3_s3tc</li>
<li>GL_EXT_texture_env_add</li>
<li>GL_EXT_abgr</li>
<li>GL_EXT_bgra</li>
<li>GL_EXT_bindable_uniform</li>
<li>GL_EXT_blend_color</li>
<li>GL_EXT_blend_equation_separate</li>
<li>GL_EXT_blend_func_separate</li>
<li>GL_EXT_blend_minmax</li>
<li>GL_EXT_blend_subtract</li>
<li>GL_EXT_compiled_vertex_array</li>
<li>GL_EXT_Cg_shader</li>
<li>GL_EXT_depth_bounds_test</li>
<li>GL_EXT_direct_state_access</li>
<li>GL_EXT_draw_buffers2</li>
<li>GL_EXT_draw_instanced</li>
<li>GL_EXT_draw_range_elements</li>
<li>GL_EXT_fog_coord</li>
<li>GL_EXT_framebuffer_blit</li>
<li>GL_EXT_framebuffer_multisample</li>
<li>GL_EXTX_framebuffer_mixed_formats</li>
<li>GL_EXT_framebuffer_object</li>
<li>GL_EXT_framebuffer_sRGB</li>
<li>GL_EXT_geometry_shader4</li>
<li>GL_EXT_gpu_program_parameters</li>
<li>GL_EXT_gpu_shader4</li>
<li>GL_EXT_multi_draw_arrays</li>
<li>GL_EXT_packed_depth_stencil</li>
<li>GL_EXT_packed_float</li>
<li>GL_EXT_packed_pixels</li>
<li>GL_EXT_pixel_buffer_object</li>
<li>GL_EXT_point_parameters</li>
<li>GL_EXT_provoking_vertex</li>
<li>GL_EXT_rescale_normal</li>
<li>GL_EXT_secondary_color</li>
<li>GL_EXT_separate_shader_objects</li>
<li>GL_EXT_separate_specular_color</li>
<li>GL_EXT_shadow_funcs</li>
<li>GL_EXT_stencil_two_side</li>
<li>GL_EXT_stencil_wrap</li>
<li>GL_EXT_texture3D</li>
<li>GL_EXT_texture_array</li>
<li>GL_EXT_texture_buffer_object</li>
<li>GL_EXT_texture_compression_latc</li>
<li>GL_EXT_texture_compression_rgtc</li>
<li>GL_EXT_texture_compression_s3tc</li>
<li>GL_EXT_texture_cube_map</li>
<li>GL_EXT_texture_edge_clamp</li>
<li>GL_EXT_texture_env_combine</li>
<li>GL_EXT_texture_env_dot3</li>
<li>GL_EXT_texture_filter_anisotropic</li>
<li>GL_EXT_texture_integer</li>
<li>GL_EXT_texture_lod</li>
<li>GL_EXT_texture_lod_bias</li>
<li>GL_EXT_texture_mirror_clamp</li>
<li>GL_EXT_texture_object</li>
<li>GL_EXT_texture_shared_exponent</li>
<li>GL_EXT_texture_sRGB</li>
<li>GL_EXT_texture_swizzle</li>
<li>GL_EXT_timer_query</li>
<li>GL_EXT_transform_feedback2</li>
<li>GL_EXT_vertex_array</li>
<li>GL_EXT_vertex_array_bgra</li>
<li>GL_IBM_rasterpos_clip</li>
<li>GL_IBM_texture_mirrored_repeat</li>
<li>GL_KTX_buffer_region</li>
<li>GL_NV_blend_square</li>
<li>GL_NV_conditional_render</li>
<li>GL_NV_copy_depth_to_color</li>
<li>GL_NV_copy_image</li>
<li>GL_NV_depth_buffer_float</li>
<li>GL_NV_depth_clamp</li>
<li>GL_NV_explicit_multisample</li>
<li>GL_NV_fence</li>
<li>GL_NV_float_buffer</li>
<li>GL_NV_fog_distance</li>
<li>GL_NV_fragment_program</li>
<li>GL_NV_fragment_program_option</li>
<li>GL_NV_fragment_program2</li>
<li>GL_NV_framebuffer_multisample_coverage</li>
<li>GL_NV_geometry_shader4</li>
<li>GL_NV_gpu_program4</li>
<li>GL_NV_half_float</li>
<li>GL_NV_light_max_exponent</li>
<li>GL_NV_multisample_coverage</li>
<li>GL_NV_multisample_filter_hint</li>
<li>GL_NV_occlusion_query</li>
<li>GL_NV_packed_depth_stencil</li>
<li>GL_NV_parameter_buffer_object</li>
<li>GL_NV_parameter_buffer_object2</li>
<li>GL_NV_pixel_data_range</li>
<li>GL_NV_point_sprite</li>
<li>GL_NV_primitive_restart</li>
<li>GL_NV_register_combiners</li>
<li>GL_NV_register_combiners2</li>
<li>GL_NV_shader_buffer_load</li>
<li>GL_NV_texgen_reflection</li>
<li>GL_NV_texture_barrier</li>
<li>GL_NV_texture_compression_vtc</li>
<li>GL_NV_texture_env_combine4</li>
<li>GL_NV_texture_expand_normal</li>
<li>GL_NV_texture_multisample</li>
<li>GL_NV_texture_rectangle</li>
<li>GL_NV_texture_shader</li>
<li>GL_NV_texture_shader2</li>
<li>GL_NV_texture_shader3</li>
<li>GL_NV_transform_feedback</li>
<li>GL_NV_transform_feedback2</li>
<li>GL_NV_vertex_array_range</li>
<li>GL_NV_vertex_array_range2</li>
<li>GL_NV_vertex_buffer_unified_memory</li>
<li>GL_NV_vertex_program</li>
<li>GL_NV_vertex_program1_1</li>
<li>GL_NV_vertex_program2</li>
<li>GL_NV_vertex_program2_option</li>
<li>GL_NV_vertex_program3</li>
<li>GL_NVX_conditional_render</li>
<li>GL_NVX_gpu_memory_info</li>
<li>GL_SGIS_generate_mipmap</li>
<li>GL_SGIS_texture_lod</li>
<li>GL_SGIX_depth_texture</li>
<li>GL_SGIX_shadow</li>
<li>GL_SUN_slice_accum</li>
<li>GL_WIN_swap_hint</li>
<li>WGL_EXT_swap_control</li>
<li>WGL_ARB_buffer_region</li>
<li>WGL_ARB_create_context</li>
<li>WGL_ARB_create_context_profile</li>
<li>WGL_ARB_create_context_robustness</li>
<li>WGL_ARB_extensions_string</li>
<li>WGL_ARB_make_current_read</li>
<li>WGL_ARB_multisample</li>
<li>WGL_ARB_pbuffer</li>
<li>WGL_ARB_pixel_format</li>
<li>WGL_ARB_pixel_format_float</li>
<li>WGL_ARB_render_texture</li>
<li>WGL_ATI_pixel_format_float</li>
<li>WGL_EXT_create_context_es2_profile</li>
<li>WGL_EXT_extensions_string</li>
<li>WGL_EXT_framebuffer_sRGB</li>
<li>WGL_EXT_pixel_format_packed_float</li>
<li>WGL_NVX_DX_interop</li>
<li>WGL_NV_float_buffer</li>
<li>WGL_NV_multisample_coverage</li>
<li>WGL_NV_render_depth_texture</li>
<li>WGL_NV_render_texture_rectangle</li>


===================================[ NVIDIA CUDA Capabilities ]
- CUDA Device 0
- Device name: GeForce GTX 260
- Compute Capability: 1.3
- Total Memory: 877 MB
- Shader Clock Rate: 1242 MHz
- Multiprocessors: 24
- Warp Size: 32
- Max Threads Per Block: 512
- Threads Per Block: 512 x 512 x 64
- Grid Size: 65535 x 65535 x 1
- Registers Per Block: 16384
- Texture Alignment: 256 byte
- Total Constant Memory: 64 Kb


===================================[ OpenCL Capabilities ]
- Num OpenCL platforms: 1
- Name: NVIDIA CUDA
- Version: OpenCL 1.0 CUDA 3.2.1
- Profile: FULL_PROFILE
- Vendor: NVIDIA Corporation
- Num devices: 1

- CL_DEVICE_NAME: GeForce GTX 260
- CL_DEVICE_VENDOR: NVIDIA Corporation
- CL_DRIVER_VERSION: 260.99
- CL_DEVICE_PROFILE: FULL_PROFILE
- CL_DEVICE_VERSION: OpenCL 1.0 CUDA
- CL_DEVICE_TYPE: GPU
- CL_DEVICE_VENDOR_ID: 0x10DE
- CL_DEVICE_MAX_COMPUTE_UNITS: 24
- CL_DEVICE_MAX_CLOCK_FREQUENCY: 1242MHz
- CL_NV_DEVICE_COMPUTE_CAPABILITY_MAJOR: 1
- CL_NV_DEVICE_COMPUTE_CAPABILITY_MINOR: 3
- CL_NV_DEVICE_REGISTERS_PER_BLOCK: 16384
- CL_NV_DEVICE_WARP_SIZE: 32
- CL_NV_DEVICE_GPU_OVERLAP: 1
- CL_NV_DEVICE_KERNEL_EXEC_TIMEOUT: 1
- CL_NV_DEVICE_INTEGRATED_MEMORY: 0
- CL_DEVICE_ADDRESS_BITS: 32
- CL_DEVICE_MAX_MEM_ALLOC_SIZE: 224608KB
- CL_DEVICE_GLOBAL_MEM_SIZE: 877MB
- CL_DEVICE_MAX_PARAMETER_SIZE: 4352
- CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE: 0 Bytes
- CL_DEVICE_GLOBAL_MEM_CACHE_SIZE: 0KB
- CL_DEVICE_ERROR_CORRECTION_SUPPORT: NO
- CL_DEVICE_LOCAL_MEM_TYPE: Local (scratchpad)
- CL_DEVICE_LOCAL_MEM_SIZE: 16KB
- CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE: 64KB
- CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS: 3
- CL_DEVICE_MAX_WORK_ITEM_SIZES: [512 ; 512 ; 64]
- CL_DEVICE_MAX_WORK_GROUP_SIZE: 512
- CL_EXEC_NATIVE_KERNEL: 4751356
- CL_DEVICE_IMAGE_SUPPORT: YES
- CL_DEVICE_MAX_READ_IMAGE_ARGS: 128
- CL_DEVICE_MAX_WRITE_IMAGE_ARGS: 8
- CL_DEVICE_IMAGE2D_MAX_WIDTH: 4096
- CL_DEVICE_IMAGE2D_MAX_HEIGHT: 32768
- CL_DEVICE_IMAGE3D_MAX_WIDTH: 2048
- CL_DEVICE_IMAGE3D_MAX_HEIGHT: 2048
- CL_DEVICE_IMAGE3D_MAX_DEPTH: 16
- CL_DEVICE_MAX_SAMPLERS: 16
- CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR: 1
- CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT: 1
- CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT: 1
- CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG: 1
- CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT: 1
- CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE: 1
- CL_DEVICE_EXTENSIONS: 16
- Extensions:
- cl_khr_byte_addressable_store
- cl_khr_icd
- cl_khr_gl_sharing
- cl_nv_d3d9_sharing
- cl_nv_d3d10_sharing
- cl_khr_d3d10_sharing
- cl_nv_d3d11_sharing
- cl_nv_compiler_options
- cl_nv_device_attribute_query
- cl_nv_pragma_unroll
-
- cl_khr_global_int32_base_atomics
- cl_khr_global_int32_extended_atomics
- cl_khr_local_int32_base_atomics
- cl_khr_local_int32_extended_atomics
- cl_khr_fp64


===================================[ Misc. ]


===================================[ Related Graphics Drivers ]
- http://www.geeks3d.com/?page_id=752
- http://downloads.guru3d.com/download.php?id=10
- http://www.tweakguides.com/NVFORCE_1.html
- http://www.nvidia.com/object/winxp-2k_archive.html
- http://www.geeks3d.com/?p=65


===================================[ Related Graphics Cards Reviews ]
- http://www.geeks3d.com/?tag=geforce-gtx-260
- http://www.google.us/search?q=NVIDIA+GeForce+GTX+260+review

[Malcolm]

I have uploaded version 0.2.1. I hope, now the selection of CPU devices will also work if and AMD Radeon is installed. See my first post for the download link

[GoodzMastaJ]

Version 0.2.1 on i7 860 and Radeon HD 4870. When I load my avs script, I see a couple dos windows flash by quickly but I get this error from Avisynth (http://stuff.damagedgoodz.net/forumposts/nlcl-buffertrue-cputrue.png) when using cpu=true and buffer=true. I seem to be getting a little bit closer to actually seeing what this filter does :)

Debug log:
NLMeansCL Version 0.2.1
ScriptEnvironment present.
Number of OpenCL Compute Platforms = 1.
Trying OpenCL Compute Platform
Advanced Micro Devices, Inc..
OpenCL 1.1 ATI-Stream-v2.3 (451).
OpenCL Compute Context successfully created.
Number of OpenCL Devices in Platform = 2.
Trying OpenCL Device
ATI RV770.
Device available.
Trying OpenCL Device
Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz.
Device available.
Device Type Cpu.
Device does not support images.
Using Device Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz.
OpenCL Command Queue successfully created.
OpenCL Program successfully built.
Prog Y Build log: .
Prog UV Build log: .

[Malcolm]

Version 0.2.1 on i7 860 and Radeon HD 4870. When I load my avs script, I see a couple dos windows flash by quickly but I get this error from Avisynth (http://stuff.damagedgoodz.net/forumposts/nlcl-buffertrue-cputrue.png) when using cpu=true and buffer=true.Hi!
the flashing of the dos windows is normal. It is caused by the AMD OpenCL driver. I will look into the remaining erro that prevents execution. I assume this is only a minor problem.

[Malcolm]

I have uploaded version 0.2.2. I really hope this is it now!

[Hiritsuki]

I want to know what "Parameter buffer", is this effect when Parameter cpu is true?
and using DDR RAM not GDDR RAM?

[tormento]

Do you have a timeframe for the temporal part? =)

[Malcolm]

I want to know what "Parameter buffer", is this effect when Parameter cpu is true?Think of it like this:
When using OpenCL image objects, the video frames are stored as textures on the gfx cards main memory. GPUs have very fast texture caches. Therefore, reading and writing from/to images is fast.
When using OpenCL buffers, the video frames are placed as 'arrays' into the main memory of the gfx card. Access is not cached. Therefore the performace is very low in comparison! (*)
When you are using a CPU as OpenCL device, this difference doesn't matter, since there are no 'texture caches' in CPUs. (memory is cached anyway)
AMD has not implemented image support in its CPU OpenCL driver yet (but it's planned!). There is no performance drawback per se as explained above. But the pity is, that you cannot execute OpenCL kernels that uses images...
AMDs RV7xxx cards don't have image support either, although they are GPUs and have texture caches for sure! It's just that the image capabilities of these GPUs is not compliant to the OpenCL spec. Therefore -> no support.

* You can get around this limitation and be faster than using images. It's just that you have to hand-tune to the exact hardware you are using and it also depends on the dimensions of the processed data. Both things are not known beforehand for avisynth filters typically (the used hardware (gfx card) and the data dimensions (video sizes)). Therefore i have implemented it only for my gfx card with hand-tuned values for 720x576 video. It's faster than using images. But it doesn't make sens to release it.

[Malcolm]

I have uploaded version 0.3. See first post.

Changes
Added mode for sum of absolute differences when computing neighborhood similarity (Parameter sse)
Performance improvements in cases where not all planes are processed (plane != 4)

[Hiritsuki]

Why do I setting avs in NLMeansCL(buffer=true) and it's seem...

http://imagewtf.com/11941.png/images/11941.png

[Hiritsuki]

and 0.3 All Default () is...

http://imagewtf.com/11942.png/images/11942.png

[Malcolm]

Why do I setting avs in NLMeansCL(buffer=true) and it's seem...

http://imagewtf.com/11941.png/images/11941.pngTry the different values for parameter smf (nan, ahp, uhp, ...). This might solve it.
Otherwise: Please send me the XML report of GPU Caps Viewer as well as the logfile of NLMeansCL.

[Archimedes]

Version 0.2.2 works fine with NLMeansCL(cpu=true, buffer=true), but with Version 0.3 an error occurred.

Here is the log file:

NLMeansCL Version 0.3
ScriptEnvironment present.
Number of OpenCL Compute Platforms = 1.
Trying OpenCL Compute Platform
Advanced Micro Devices, Inc..
OpenCL 1.1 ATI-Stream-v2.3 (451).
Number of OpenCL Devices in Platform = 1.
Trying OpenCL Device Intel(R) Core(TM)2 Duo CPU P8700 @ 2.53GHz.
Device available.
Device Type Cpu.
Device does not support images.
Using Device Intel(R) Core(TM)2 Duo CPU P8700 @ 2.53GHz.
OpenCL Compute Context successfully created.
OpenCL Command Queue successfully created.
OpenCL Program successfully built.
Prog Y Build log:
Prog UV Build log:
OpenCL error code detected: InvalidKernelName.

[Malcolm]

I have uploaded version 0.3.1.
This should solve Archimedes and Hiritsukis problems.

Working on a theoretical basis without all the platforms for testing is really a minefield! So sorry, if it takes several iterations until it runs without hiccups!

To the change of the memory allocation strategy. The different possible OpenCL memory allocation strategies are really badly documented in the OpenCL spec. There are various discussions in OpenCL forums around it. It seems no one except NVidias and AMDs core developers knows what's really going on under the hood and how they are supposed to be used...

[Hiritsuki]

ok, this is my GPU's OpenCL XML
http://www.mediafire.com/?y04xn3m1qxfby2v

[Hiritsuki]

I just found when buffer is True, I should set NLMeansCL(smf="ahp",buffer=true) to run.
btw, using buffer is slower than all default setting.
buffer=true GPU 2~8%
buffer=false GPU 23~27%

[Dogway]

@Malcolm: Just wanted to say thanks again for this great filter. I saw az implementation on the todo list so besides that, and although Im going to stick to b=0 you might want to see the aliasing issues when b>0.

http://img130.imageshack.us/img130/4021/18701094.png
http://img140.imageshack.us/img140/7246/56416655.png

[Hiritsuki]

I just test 0.31 to compare with 0.22 speed.
0.22 is fatser than 0.31
5.5fps:5.0fps

And 0.31 GPU using is lower than 1% ... this is cannot to use GPU?

[TheProfileth]

An interesting filter, can get good results without killing details if you set the h and hc below 1 , I suggest using something like nlmeanscl(plane=4,b=0,h=0.5,hc=0.6)
Edit:
I forgot to mention I was having problems where I got this error message
http://img510.imageshack.us/img510/8287/afag.png
But then I updated my graphics card driver to the new beta (I had the most recent stable version before) and now it works fine
http://www.nvidia.com/object/win7-winvista-32bit-266.35-beta-driver.html

[tormento]

I think the TODO should contain PRESET modes ;) a-la MCTD

[Dogway]

I think the TODO should contain PRESET modes ;) a-la MCTD

I think it's easy enough, you'd mostly use only A and H parameters

[Malcolm]

I just found when buffer is True, I should set NLMeansCL(smf="ahp",buffer=true) to run.
btw, using buffer is slower than all default setting.
buffer=true GPU 2~8%
buffer=false GPU 23~27%
I just found when buffer is True, I should set NLMeansCL(smf="ahp",buffer=true) to run.
Yes, smf=ahp is now the default from version 0.3.1 on.

btw, using buffer is slower than all default setting.
Let me cite myself: When using OpenCL buffers... Access is not cached. Therefore the performace is very low in comparison!
To the 2~8% resp. 23~27% GPU utilization:
i don't know where you got your numbers from, but let's assume that they are right (i can imagine that they ARE right indeed). What does this mean? Is 27% bad? Sure 100% would be better. Are 100% realistically achievable? I don't think so.
Massively parallel computing is really about keeping your computing cores busy. Now for GPU processing (the following is a strong simplification, but it's true at the core): Let's say that you have a given algorithm where you read in 9 Pixel values (one center value and 8 surrounding values) and do a number of 40 arithmetic operations (5 for each surrounding pixel) before you can write back one resulting pixel value to your destination.
Let's also assume that reading or writing a pixel value from memory (uncached!) takes 400 cycles where doing an arithmetic calculation takes only 4 cycles.
For the calculation of one resulting destination pixel, your GPU is waiting 9x400 cycles (= 3600 cycles) while reading from / writing to the memory. In this time your GPU can do 900 arithmetic calculations (3600 / 4), but it only has to do 40 calculations. For the rest of the time it's simply waiting for the data from the memory to arrive. Therefore the utilization is at ~ 4.4%
Now what do you do to increase utilization?

Take a look at these slides from Nvidia
http://img140.imageshack.us/img140/1130/gpu1.th.jpg (http://img140.imageshack.us/i/gpu1.jpg/) http://img153.imageshack.us/img153/1764/gpu2j.th.jpg (http://img153.imageshack.us/i/gpu2j.jpg/)

Now for the 2~8% utilization. Yes i know, using uncached buffers directly for calculations on the GPU is a bad idea. I already wrotethat it would be terribly slow in comparison. But for execution on CPUs it really doesn't matter at all. Therefore buffer=true is useful only in conjunction with cpu=true.

[Hiritsuki]

ah...but I say faster is just compare with 2.2 and 3.1.

and the gpu using is from AIDA64 Extreme's show

[SilaSurfer]

~Malcolm~

Wow a cousin of TnlMeans just faster. Is this filter ready for general use?

[TheProfileth]

~Malcolm~

Wow a cousin of TnlMeans just faster. Is this filter ready for general use?

Definitely great results too when you lower the h and hc

[SilaSurfer]

I wonder if my Geforce 9500gt is fast enough?

[tormento]

Any news about temporal part?

[Joachim Buambeki]

Hi,

great port to OpenCL, thanks for that. The speed-up is incredible.

Are there any restrictions regarding the image size?
Is it possible to process a 40mpix image with a card like the GTS 450 1024mb?

What about recommended settings at such a resolution? With TNLmeans I used these settings for a 16mpix image and liked the results very much (based on the examples in the 3rd page of the TNLmeans thread):
tnlmeans(h=1.7,ax=10,ay=10,bx=0,by=0,sx=3,sy=3,a=1.3)
Are there recommendations for the settings that are based on the fact that the image has much more details than a simple full HD or even SD image?
Though processing time is not really an issue for me, I obviously don't want to unnecessarily waste processing time.

What about YV24 support in the future?

I would also appreciate a temporal mode. :)

Best Regards
David

[Malcolm]

Are there any restrictions regarding the image size?Yes, your graphics card has a limitation for the dimensions of images/textures you can process. For my 9600 GT its 4096 x 32768 pixels. But you can always help yourself out by doing for example 4 crops to divide the video in 4 parts, call NLMeansCL 4 times and 'stack' the results together again. If you choose an overlap when cropping that is bigger than A+B there should be no visible difference compared to processing the video in one part.Is it possible to process a 40mpix image with a card like the GTS 450 1024mb?With the above mentioned workaround, yes. It could happen - depending of how big you choose parameters A & B and how big your video dimensions are, that the processing of one frame takes longer that 2 or 3 seconds. MS Windows will then kill & restart your graphics card driver bacause it assumes that it has crashed. You can change the timeout as well as the general behaviour of windows by changing some registry entries. Google will help you to find the proper way to do this.What about YV24 support in the future?Should be pretty easy to add.I would also appreciate a temporal mode. :)I have implemented a version with temporal support that is able to handle an arbitrary number of frames. So you can pass in parameter Az=[any number].
But this version is still buggy (some image artifacts & results slightly different from TNLMeans). So i will not release it until this has been fixed.

Besides of that: You should not expect too much from the temporal mode. In theory - when you look at the way the non-local means algorithm works - it should make no / little difference from where the color values are aquired. Either from frames before / after the current or from a bigger radius (parameter A) around the current pixel inside the current frame. That is because the algorithm works non-locally! The algorithm really works in a different way than most of the other temporal-enabled noise filters!

But i guess you guys won't be satisfied until you get your temporal mode... ;)

[TheProfileth]

personally I think you should stay away from the temporal mode since most temporal filtering is a waste of time, I would focus more on improving things and maybe adding other parts or something. great job btw
also just a dream
If you were able to make a version of tbilateral run on the gpu I would be insanely happy :3

[markanini]

I think such a plugin exists in the form of a virtualdub plugin by a russian company. FWIW

[Dogway]

Is temporal an intrinsic feature of nlmeans algorithm, or just an addon feature tritical made on his filter?

[tritical]

Is temporal an intrinsic feature of nlmeans algorithm, or just an addon feature tritical made on his filter?
I was going to write a long reply relating bilateral filtering/nl-means, but I'm too tired :). Really there is no reason to limit nl-means to the current image when processing video - aside from limiting the search area to make the algorithm faster. If you look at the papers I have on my website under tnlmeans you will see that the original nl-means creator is actually the one who proposed extending it to 3d when processing video.

The extension itself makes perfect sense... in nl-means all you are doing is searching for pixels that are similar to the current pixel, where similarity is defined by the gaussian-weighted sum of squared differences between the neighborhoods of the pixels in question. It is this definition of similarity that makes nl-means unique (and also slow) - as opposed to say bilateral filtering that looks only at individual pixel differences, and therefore has to add in distance weighting to overcome the weaknesses of a much laxer definition of similarity. The more high similarity pixels you find the better the result. I think it is easy to see how expanding the search to surrounding frames can be of great benefit, especially in static scenes - or motion scenes if you perform motion compensation, for detailed parts of the image which you do not expect to be duplicated within a single frame. In fact, if you expand the spatial search area to the entire frame - while adding the temporal search, then there is no need to perform motion compensation, but it would be unusably slow. For flat/low detail areas or often repeated structures, expanding the search to surrounding frames is probably useless. It would of course depend on the exact properties of the noise.

[Malcolm]

The extension itself makes perfect sense...Hi tritical,
you are right in what you say about the algorithm.
When i wrote about the limited use of the temporal mode, i only mentioned some of the theoretical aspects. I also had something from the practical side in mind too but actually missed to mention that. So i wasn't very precise. One thing is the additional computation time. My implementation is less efficient in the temporal mode than in purely spatial mode. So you have to balance what you gain when using temporal mode instead of a bigger radius for A/S.
Also, as i said, the NLMeans algorithm is different from most other temporal noise algorithms since i doesn't do a temporal averaging in a way that one is used from the 'other' filters. That means clips with flickering and 'nervous' pixels will be less calmed than you might expect.
In that sense i think i am right when i say that one should not expect 'too much' from the temporal mode. You could also say: The spatial mode already does a great job and there will be no fundamental difference in the result of the temporal mode.

[bus_labi]

Version .2 and 0.31 on PhenomII X6 1055 with Radeon HD 5770

Updated latest Catalyst drivers, OpenCL. All GPU Caps Demos run successfully
OpenCL 1.1 ATI-Stream-v2.3 (451) Driver CAL 1.4.900

Debug file contains only one line "NLMeansCL Version 0.3.1"

Experimented with cpu, buffer and smf - all with same error (achp throw a different error)

:confused:

GPU Caps XML
===================================================
GPU Caps Viewer v1.9.6
http://www.ozone3d.net/gpu_caps_viewer/
===================================================


===================================[ System / CPU ]
- CPU Name: AMD Phenom(tm) II X6 1055T Processor
- CPU Core Speed: 2812 MHz
- CPU Num Cores: 6
- Family: 15 - Model: 10 - Stepping: 0
- Physical Memory Size: 4094 MB
- Operating System: Windows 7 64-bit build 7600 [No Service Pack]
- DirectX Version: 10.0
- PhysX Version: drivers not installed


===================================[ Graphics Adapter / GPU ]
- CrossFire: disabled
- GPUs: 1
- Physical adapters: 1
- OpenGL Renderer: ATI Radeon HD 5700 Series
- Drivers Renderer: ATI Radeon HD 5700 Series
- DB Renderer: ATI Radeon HD 5770
- Device Description: ATI Radeon HD 5700 Series
- Adapter String: ATI Radeon HD 5700 Series
- Vendor: ATI Technologies Inc.
- Vendor ID: 0x1002
- Device ID: 0x68B8
- Sub device ID: 0xE147
- Sub vendor ID: 0x1002
- Perf Level 0 - GPU: 157 MHz
- Perf Level 0 - Memory: 300 MHz
- Perf Level 1 - GPU: 600 MHz
- Perf Level 1 - Memory: 1200 MHz
- Perf Level 2 - GPU: 850 MHz
- Perf Level 2 - Memory: 1200 MHz
- Drivers Version: 8.812.0.0 - Catalyst 10.12 (1-4-2011) - atig6pxx.dll
- ATI Catalyst Version String: 10.12
- ATI Catalyst Release Version String: 8.812-110104a-111988C-ATI
- GPU Codename: Juniper
- GPU Unified Shader Processors: 800
- GPU Vertex Shader Processors: 0
- GPU Pixel Shader Processors: 0
- TPD (Watts): 108
- Video Memory Size: 1024 MB
- Video Memory Type: unknown
- Clocks: Level 157 - GPU: 300MHz - Memory: 1630692MHz
- Clocks: Level 600 - GPU: 1200MHz - Memory: 1630692MHz
- Clocks: Level 850 - GPU: 1200MHz - Memory: 1630692MHz
- BIOS String: 113-E14701-X05
- Current Display Mode: 1920x1200 @ 60 Hz - 32 bpp


===================================[ OpenCL Capabilities ]
- Num OpenCL platforms: 1
- Name: ATI Stream
- Version: OpenCL 1.1 ATI-Stream-v2.3 (451)
- Profile: FULL_PROFILE
- Vendor: Advanced Micro Devices, Inc.
- Num devices: 2

- CL_DEVICE_NAME: Juniper
- CL_DEVICE_VENDOR: Advanced Micro Devices, Inc.
- CL_DRIVER_VERSION: CAL 1.4.900
- CL_DEVICE_PROFILE: FULL_PROFILE
- CL_DEVICE_VERSION: OpenCL 1.1 ATI-Stream-v2.3 (451)
- CL_DEVICE_TYPE: GPU
- CL_DEVICE_VENDOR_ID: 0x1002
- CL_DEVICE_MAX_COMPUTE_UNITS: 10
- CL_DEVICE_MAX_CLOCK_FREQUENCY: 850MHz
- CL_DEVICE_ADDRESS_BITS: 32
- CL_DEVICE_MAX_MEM_ALLOC_SIZE: 131072KB
- CL_DEVICE_GLOBAL_MEM_SIZE: 512MB
- CL_DEVICE_MAX_PARAMETER_SIZE: 1024
- CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE: 0 Bytes
- CL_DEVICE_GLOBAL_MEM_CACHE_SIZE: 0KB
- CL_DEVICE_ERROR_CORRECTION_SUPPORT: NO
- CL_DEVICE_LOCAL_MEM_TYPE: Local (scratchpad)
- CL_DEVICE_LOCAL_MEM_SIZE: 32KB
- CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE: 64KB
- CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS: 3
- CL_DEVICE_MAX_WORK_ITEM_SIZES: [256 ; 256 ; 256]
- CL_DEVICE_MAX_WORK_GROUP_SIZE: 256
- CL_EXEC_NATIVE_KERNEL: 4755436
- CL_DEVICE_IMAGE_SUPPORT: YES
- CL_DEVICE_MAX_READ_IMAGE_ARGS: 128
- CL_DEVICE_MAX_WRITE_IMAGE_ARGS: 8
- CL_DEVICE_IMAGE2D_MAX_WIDTH: 8192
- CL_DEVICE_IMAGE2D_MAX_HEIGHT: 8192
- CL_DEVICE_IMAGE3D_MAX_WIDTH: 2048
- CL_DEVICE_IMAGE3D_MAX_HEIGHT: 2048
- CL_DEVICE_IMAGE3D_MAX_DEPTH: 16
- CL_DEVICE_MAX_SAMPLERS: 16
- CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR: 16
- CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT: 8
- CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT: 4
- CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG: 2
- CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT: 4
- CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE: 0
- CL_DEVICE_EXTENSIONS: 12
- Extensions:
- cl_khr_global_int32_base_atomics
- cl_khr_global_int32_extended_atomics
- cl_khr_local_int32_base_atomics
- cl_khr_local_int32_extended_atomics
- cl_khr_3d_image_writes
- cl_khr_byte_addressable_store
- cl_khr_gl_sharing
- cl_amd_device_attribute_query
- cl_amd_printf
- cl_amd_media_ops
- cl_amd_popcnt
- cl_khr_d3d10_sharing

- CL_DEVICE_NAME: AMD Phenom(tm) II X6 1055T Processor
- CL_DEVICE_VENDOR: AuthenticAMD
- CL_DRIVER_VERSION: 2.0
- CL_DEVICE_PROFILE: FULL_PROFILE
- CL_DEVICE_VERSION: OpenCL 1.1 ATI-Stream-v2.3 (451)
- CL_DEVICE_TYPE: CPU
- CL_DEVICE_VENDOR_ID: 0x1002
- CL_DEVICE_MAX_COMPUTE_UNITS: 6
- CL_DEVICE_MAX_CLOCK_FREQUENCY: 2812MHz
- CL_DEVICE_ADDRESS_BITS: 32
- CL_DEVICE_MAX_MEM_ALLOC_SIZE: 524288KB
- CL_DEVICE_GLOBAL_MEM_SIZE: 1024MB
- CL_DEVICE_MAX_PARAMETER_SIZE: 4096
- CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE: 64 Bytes
- CL_DEVICE_GLOBAL_MEM_CACHE_SIZE: 64KB
- CL_DEVICE_ERROR_CORRECTION_SUPPORT: NO
- CL_DEVICE_LOCAL_MEM_TYPE: Global
- CL_DEVICE_LOCAL_MEM_SIZE: 32KB
- CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE: 64KB
- CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS: 3
- CL_DEVICE_MAX_WORK_ITEM_SIZES: [1024 ; 1024 ; 1024]
- CL_DEVICE_MAX_WORK_GROUP_SIZE: 1024
- CL_EXEC_NATIVE_KERNEL: 4755440
- CL_DEVICE_IMAGE_SUPPORT: NO
- CL_DEVICE_MAX_READ_IMAGE_ARGS: 0
- CL_DEVICE_MAX_WRITE_IMAGE_ARGS: 0
- CL_DEVICE_IMAGE2D_MAX_WIDTH: 0
- CL_DEVICE_IMAGE2D_MAX_HEIGHT: 0
- CL_DEVICE_IMAGE3D_MAX_WIDTH: 0
- CL_DEVICE_IMAGE3D_MAX_HEIGHT: 0
- CL_DEVICE_IMAGE3D_MAX_DEPTH: 0
- CL_DEVICE_MAX_SAMPLERS: 0
- CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR: 16
- CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT: 8
- CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT: 4
- CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG: 2
- CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT: 4
- CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE: 0
- CL_DEVICE_EXTENSIONS: 13
- Extensions:
- cl_amd_fp64
- cl_khr_global_int32_base_atomics
- cl_khr_global_int32_extended_atomics
- cl_khr_local_int32_base_atomics
- cl_khr_local_int32_extended_atomics
- cl_khr_byte_addressable_store
- cl_khr_gl_sharing
- cl_ext_device_fission
- cl_amd_device_attribute_query
- cl_amd_media_ops
- cl_amd_popcnt
- cl_amd_printf
- cl_khr_d3d10_sharing

[Malcolm]

It seems none of the moderstors wants to approve your attached image...

[bus_labi]

:) approved :)

[kypec]

:) approved :)
Yeah, but you should crop only the important part of the image next time before posting. Otherwise it looks awfully and screws whole forum layout.:mad:

[bus_labi]

Yeah, but you should crop only the important part of the image next time before posting. Otherwise it looks awfully and screws whole forum layout.:mad:

Yeah, my fault. Did not realise i had posted whole screen.
Fixed now.

[markanini]

Ok, let me explain: Under 'normal' circumstances, windows recovers your graphics card driver because it crashed. However, windows also does this, if your driver doesn't respond within 2 seconds. (You can change the time, as well as the general behaviour of windows by editing the registry).
That means: If you have a very complex OpenCL kernel, that computes for more than 2 seconds on one video frame, then windows will kill and restart your driver!
Since you have a GTX 570 i would assume that it's fast enough. So this shouldn't happen unless you use parameters like A=8, S=6 or so. But since i haven't tested the filter on that GPU i can only guess!

Can you tell me more about the registry hack? Is it a viable solution for use of extreme settings (A=20, S=6 on large stills)or is a hardware upgrade ultimately necessary? I'm using a Geforce 9800GT.

[markanini]

Found my answer here:
http://www.blog-gpgpu.com/index.php?post/2010/07/22/Windows-Vista-7-%3A-How-to-disable-the-Timeout-Detection-and-Recovery-of-GPUs-through-WDDM

Finally I can use insane A and S parameters :D