cl-wavelet-nr: add interface to enable bayes shrink

 * wavelet-mode specify wavelet denoise mode, default is off select from
   [0:disable, 1:Hat Y, 2:Hat UV, 3:Haar Y, 4:Haar UV, 5:Haar YUV,
    6:Haar Bayes Shrink]

Signed-off-by: Wind Yuan <feng.yuan@intel.com>
diff --git a/modules/ocl/cl_3a_image_processor.cpp b/modules/ocl/cl_3a_image_processor.cpp
index 718acbb..7fd7549 100644
--- a/modules/ocl/cl_3a_image_processor.cpp
+++ b/modules/ocl/cl_3a_image_processor.cpp
@@ -55,7 +55,8 @@
     , _enable_scaler (false)
     , _enable_wireframe (false)
     , _wavelet_basis (CL_WAVELET_DISABLED)
-    , _wavelet_channel (CL_WAVELET_CHANNEL_UV)
+    , _wavelet_channel (CL_IMAGE_CHANNEL_UV)
+    , _wavelet_bayes_shrink (false)
     , _snr_mode (0)
 {
     keep_attached_buf (true);
@@ -433,7 +434,7 @@
         break;
     }
     case CL_WAVELET_HAAR: {
-        image_handler = create_cl_newwavelet_denoise_image_handler (context, _wavelet_channel);
+        image_handler = create_cl_newwavelet_denoise_image_handler (context, _wavelet_channel, _wavelet_bayes_shrink);
         _newwavelet = image_handler.dynamic_cast_ptr<CLNewWaveletDenoiseImageHandler> ();
         XCAM_FAIL_RETURN (
             WARNING,
@@ -561,10 +562,11 @@
 }
 
 bool
-CL3aImageProcessor::set_wavelet (CLWaveletBasis basis, uint32_t channel)
+CL3aImageProcessor::set_wavelet (CLWaveletBasis basis, uint32_t channel, bool bayes_shrink)
 {
     _wavelet_basis = basis;
-    _wavelet_channel = (CLWaveletChannel)channel;
+    _wavelet_channel = (CLImageChannel)channel;
+    _wavelet_bayes_shrink = bayes_shrink;
 
     STREAM_LOCK;
 
diff --git a/modules/ocl/cl_3a_image_processor.h b/modules/ocl/cl_3a_image_processor.h
index 38ec98d..5fc4ab9 100644
--- a/modules/ocl/cl_3a_image_processor.h
+++ b/modules/ocl/cl_3a_image_processor.h
@@ -92,7 +92,7 @@
     virtual bool set_scaler (bool enable);
     virtual bool set_wireframe (bool enable);
     virtual bool set_tnr (uint32_t mode, uint8_t level);
-    virtual bool set_wavelet (CLWaveletBasis basis, uint32_t channel);
+    virtual bool set_wavelet (CLWaveletBasis basis, uint32_t channel, bool bayes_shrink);
     virtual bool set_tonemapping (CLTonemappingMode wdr_mode);
 
     PipelineProfile get_profile () const {
@@ -145,6 +145,7 @@
     bool                                _enable_wireframe;
     CLWaveletBasis                      _wavelet_basis;
     uint32_t                            _wavelet_channel;
+    bool                                _wavelet_bayes_shrink;
     uint32_t                            _snr_mode; // spatial nr mode
 };
 
diff --git a/modules/ocl/cl_newwavelet_denoise_handler.cpp b/modules/ocl/cl_newwavelet_denoise_handler.cpp
index 35ec013..053007b 100644
--- a/modules/ocl/cl_newwavelet_denoise_handler.cpp
+++ b/modules/ocl/cl_newwavelet_denoise_handler.cpp
@@ -24,7 +24,6 @@
 #include "cl_newwavelet_denoise_handler.h"
 
 #define WAVELET_DECOMPOSITION_LEVELS 4
-#define WAVELET_BAYES_SHRINK 0
 
 namespace XCam {
 
@@ -193,7 +192,7 @@
     uint32_t hist_u[128] = {0};
     uint32_t hist_v[128] = {0};
 
-    if (_channel == CL_WAVELET_CHANNEL_Y) {
+    if (_channel == CL_IMAGE_CHANNEL_Y) {
         for (uint32_t i = 0; i < image_width; i++) {
             for (uint32_t j = 0; j < image_height; j++) {
                 uint8_t base = (pixel[i + j * row_pitch] <= 127) ? 127 : 128;
@@ -212,7 +211,7 @@
         noise_std_deviation = median / 0.6745;
         noise_var[0] = noise_std_deviation * noise_std_deviation;
     }
-    if (_channel == CL_WAVELET_CHANNEL_UV) {
+    if (_channel == CL_IMAGE_CHANNEL_UV) {
         for (uint32_t i = 0; i < (image_width / 2); i++) {
             for (uint32_t j = 0; j < image_height; j++) {
                 uint8_t base = (pixel[2 * i + j * row_pitch] <= 127) ? 127 : 128;
@@ -313,7 +312,7 @@
     work_size.global[1] = XCAM_ALIGN_UP (cl_height, work_size.local[1]);
 
     float weight = 4;
-    if (_channel == CL_WAVELET_CHANNEL_Y) {
+    if (_channel == CL_IMAGE_CHANNEL_Y) {
         _noise_variance[0] = buffer->noise_variance[0] * weight;
         _noise_variance[1] = buffer->noise_variance[0] * weight;
     } else {
@@ -326,7 +325,7 @@
         _handler->dump_coeff (save_image, _channel, _current_layer, CL_WAVELET_SUBBAND_HH);
     }
 #endif
-    if (_channel == CL_WAVELET_CHANNEL_Y) {
+    if (_channel == CL_IMAGE_CHANNEL_Y) {
         args[0].arg_adress = &_noise_variance[0];
         args[0].arg_size = sizeof (_noise_variance[0]);
         args[1].arg_adress = &_noise_variance[0];
@@ -383,12 +382,14 @@
         SmartPtr<CLNewWaveletDenoiseImageHandler> &handler,
         CLWaveletFilterBank fb,
         uint32_t channel,
-        uint32_t layer)
+        uint32_t layer,
+        bool bayes_shrink)
     : CLImageKernel (context, name, true)
     , _filter_bank (fb)
     , _decomposition_levels (WAVELET_DECOMPOSITION_LEVELS)
     , _channel (channel)
     , _current_layer (layer)
+    , _bayes_shrink (bayes_shrink)
     , _hard_threshold (0.1)
     , _soft_threshold (0.5)
     , _handler (handler)
@@ -447,10 +448,10 @@
     work_size.dim = XCAM_DEFAULT_IMAGE_DIM;
     work_size.local[0] = 8;
     work_size.local[1] = 4;
-    if (_channel == CL_WAVELET_CHANNEL_Y) {
+    if (_channel == CL_IMAGE_CHANNEL_Y) {
         work_size.global[0] = XCAM_ALIGN_UP ((video_info_in.width >> _current_layer) / 4 , work_size.local[0]);
         work_size.global[1] = XCAM_ALIGN_UP (video_info_in.height >> _current_layer, work_size.local[1]);
-    } else if (_channel == CL_WAVELET_CHANNEL_UV) {
+    } else if (_channel == CL_IMAGE_CHANNEL_UV) {
         work_size.global[0] = XCAM_ALIGN_UP ((video_info_in.width >> _current_layer) / 4 , work_size.local[0]);
         work_size.global[1] = XCAM_ALIGN_UP (video_info_in.height >> (_current_layer + 1), work_size.local[1]);
     }
@@ -458,18 +459,18 @@
     SmartPtr<CLWaveletDecompBuffer> buffer;
     if (_current_layer == 1) {
         if (_filter_bank == CL_WAVELET_HAAR_ANALYSIS) {
-            if (_channel == CL_WAVELET_CHANNEL_Y) {
+            if (_channel == CL_IMAGE_CHANNEL_Y) {
                 args[0].arg_adress = &_image_in->get_mem_id ();
                 args[0].arg_size = sizeof (cl_mem);
-            } else if (_channel == CL_WAVELET_CHANNEL_UV) {
+            } else if (_channel == CL_IMAGE_CHANNEL_UV) {
                 args[0].arg_adress = &_image_in_uv->get_mem_id ();
                 args[0].arg_size = sizeof (cl_mem);
             }
         } else if (_filter_bank == CL_WAVELET_HAAR_SYNTHESIS) {
-            if (_channel == CL_WAVELET_CHANNEL_Y) {
+            if (_channel == CL_IMAGE_CHANNEL_Y) {
                 args[0].arg_adress = &_image_out->get_mem_id ();
                 args[0].arg_size = sizeof (cl_mem);
-            } else if (_channel == CL_WAVELET_CHANNEL_UV) {
+            } else if (_channel == CL_IMAGE_CHANNEL_UV) {
                 args[0].arg_adress = &_image_out_uv->get_mem_id ();
                 args[0].arg_size = sizeof (cl_mem);
             }
@@ -485,30 +486,30 @@
     args[1].arg_adress = &buffer->ll->get_mem_id ();
     args[1].arg_size = sizeof (cl_mem);
 
-#if WAVELET_BAYES_SHRINK
-    if (_filter_bank == CL_WAVELET_HAAR_ANALYSIS) {
+    if (_bayes_shrink == true) {
+        if (_filter_bank == CL_WAVELET_HAAR_ANALYSIS) {
+            args[2].arg_adress = &buffer->hl[0]->get_mem_id ();
+            args[2].arg_size = sizeof (cl_mem);
+            args[3].arg_adress = &buffer->lh[0]->get_mem_id ();
+            args[3].arg_size = sizeof (cl_mem);
+            args[4].arg_adress = &buffer->hh[0]->get_mem_id ();
+            args[4].arg_size = sizeof (cl_mem);
+        } else if (_filter_bank == CL_WAVELET_HAAR_SYNTHESIS) {
+            args[2].arg_adress = &buffer->hl[2]->get_mem_id ();
+            args[2].arg_size = sizeof (cl_mem);
+            args[3].arg_adress = &buffer->lh[2]->get_mem_id ();
+            args[3].arg_size = sizeof (cl_mem);
+            args[4].arg_adress = &buffer->hh[2]->get_mem_id ();
+            args[4].arg_size = sizeof (cl_mem);
+        }
+    } else {
         args[2].arg_adress = &buffer->hl[0]->get_mem_id ();
         args[2].arg_size = sizeof (cl_mem);
         args[3].arg_adress = &buffer->lh[0]->get_mem_id ();
         args[3].arg_size = sizeof (cl_mem);
         args[4].arg_adress = &buffer->hh[0]->get_mem_id ();
         args[4].arg_size = sizeof (cl_mem);
-    } else if (_filter_bank == CL_WAVELET_HAAR_SYNTHESIS) {
-        args[2].arg_adress = &buffer->hl[2]->get_mem_id ();
-        args[2].arg_size = sizeof (cl_mem);
-        args[3].arg_adress = &buffer->lh[2]->get_mem_id ();
-        args[3].arg_size = sizeof (cl_mem);
-        args[4].arg_adress = &buffer->hh[2]->get_mem_id ();
-        args[4].arg_size = sizeof (cl_mem);
     }
-#else
-    args[2].arg_adress = &buffer->hl[0]->get_mem_id ();
-    args[2].arg_size = sizeof (cl_mem);
-    args[3].arg_adress = &buffer->lh[0]->get_mem_id ();
-    args[3].arg_size = sizeof (cl_mem);
-    args[4].arg_adress = &buffer->hh[0]->get_mem_id ();
-    args[4].arg_size = sizeof (cl_mem);
-#endif
 
     args[5].arg_adress = &_current_layer;
     args[5].arg_size = sizeof (_current_layer);
@@ -567,7 +568,7 @@
 
     _decompBufferList.clear ();
 
-    if (_channel & CL_WAVELET_CHANNEL_Y) {
+    if (_channel & CL_IMAGE_CHANNEL_Y) {
         for (int layer = 1; layer <= WAVELET_DECOMPOSITION_LEVELS; layer++) {
             decompBuffer = new CLWaveletDecompBuffer ();
             if (decompBuffer.ptr ()) {
@@ -576,7 +577,7 @@
                 decompBuffer->width = XCAM_ALIGN_UP (decompBuffer->width, 4);
                 decompBuffer->height = XCAM_ALIGN_UP (decompBuffer->height, 2);
 
-                decompBuffer->channel = CL_WAVELET_CHANNEL_Y;
+                decompBuffer->channel = CL_IMAGE_CHANNEL_Y;
                 decompBuffer->layer = layer;
                 decompBuffer->noise_variance[0] = 0;
 
@@ -628,7 +629,7 @@
         }
     }
 
-    if (_channel & CL_WAVELET_CHANNEL_UV) {
+    if (_channel & CL_IMAGE_CHANNEL_UV) {
         for (int layer = 1; layer <= WAVELET_DECOMPOSITION_LEVELS; layer++) {
             decompBuffer = new CLWaveletDecompBuffer ();
             if (decompBuffer.ptr ()) {
@@ -637,7 +638,7 @@
                 decompBuffer->width = XCAM_ALIGN_UP (decompBuffer->width, 4);
                 decompBuffer->height = XCAM_ALIGN_UP (decompBuffer->height, 2);
 
-                decompBuffer->channel = CL_WAVELET_CHANNEL_UV;
+                decompBuffer->channel = CL_IMAGE_CHANNEL_UV;
                 decompBuffer->layer = layer;
                 decompBuffer->noise_variance[1] = 0;
                 decompBuffer->noise_variance[2] = 0;
@@ -798,7 +799,8 @@
 create_kernel_haar_decomposition (SmartPtr<CLContext> &context,
                                   SmartPtr<CLNewWaveletDenoiseImageHandler> handler,
                                   uint32_t channel,
-                                  uint32_t layer)
+                                  uint32_t layer,
+                                  bool bayes_shrink)
 {
     XCamReturn ret = XCAM_RETURN_NO_ERROR;
     SmartPtr<CLWaveletTransformKernel> haar_decomp_kernel;
@@ -809,15 +811,15 @@
     snprintf (build_options, sizeof (build_options),
               " -DWAVELET_DENOISE_Y=%d "
               " -DWAVELET_DENOISE_UV=%d ",
-              (channel == CL_WAVELET_CHANNEL_Y ? 1 : 0),
-              (channel == CL_WAVELET_CHANNEL_UV ? 1 : 0));
+              (channel == CL_IMAGE_CHANNEL_Y ? 1 : 0),
+              (channel == CL_IMAGE_CHANNEL_UV ? 1 : 0));
 
     XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_wavelet_haar_decomposition)
 #include "kernel_wavelet_haar_decomposition.clx"
     XCAM_CL_KERNEL_FUNC_END;
 
     haar_decomp_kernel = new CLWaveletTransformKernel (context, "kernel_wavelet_haar_decomposition",
-            handler, CL_WAVELET_HAAR_ANALYSIS, channel, layer);
+            handler, CL_WAVELET_HAAR_ANALYSIS, channel, layer, bayes_shrink);
 
     ret = haar_decomp_kernel->load_from_source (
               kernel_wavelet_haar_decomposition_body, strlen (kernel_wavelet_haar_decomposition_body),
@@ -838,7 +840,8 @@
 create_kernel_haar_reconstruction (SmartPtr<CLContext> &context,
                                    SmartPtr<CLNewWaveletDenoiseImageHandler> handler,
                                    uint32_t channel,
-                                   uint32_t layer)
+                                   uint32_t layer,
+                                   bool bayes_shrink)
 {
     XCamReturn ret = XCAM_RETURN_NO_ERROR;
     SmartPtr<CLWaveletTransformKernel> haar_reconstruction_kernel;
@@ -850,16 +853,16 @@
               " -DWAVELET_DENOISE_Y=%d "
               " -DWAVELET_DENOISE_UV=%d "
               " -DWAVELET_BAYES_SHRINK=%d",
-              (channel == CL_WAVELET_CHANNEL_Y ? 1 : 0),
-              (channel == CL_WAVELET_CHANNEL_UV ? 1 : 0),
-              (1 == WAVELET_BAYES_SHRINK ? 1 : 0));
+              (channel == CL_IMAGE_CHANNEL_Y ? 1 : 0),
+              (channel == CL_IMAGE_CHANNEL_UV ? 1 : 0),
+              (bayes_shrink == true ? 1 : 0));
 
     XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_wavelet_haar_reconstruction)
 #include "kernel_wavelet_haar_reconstruction.clx"
     XCAM_CL_KERNEL_FUNC_END;
 
     haar_reconstruction_kernel = new CLWaveletTransformKernel (context, "kernel_wavelet_haar_reconstruction",
-            handler, CL_WAVELET_HAAR_SYNTHESIS, channel, layer);
+            handler, CL_WAVELET_HAAR_SYNTHESIS, channel, layer, bayes_shrink);
 
     ret = haar_reconstruction_kernel->load_from_source (
               kernel_wavelet_haar_reconstruction_body, strlen (kernel_wavelet_haar_reconstruction_body),
@@ -891,8 +894,8 @@
     snprintf (build_options, sizeof (build_options),
               " -DWAVELET_DENOISE_Y=%d "
               " -DWAVELET_DENOISE_UV=%d ",
-              (channel == CL_WAVELET_CHANNEL_Y ? 1 : 0),
-              (channel == CL_WAVELET_CHANNEL_UV ? 1 : 0));
+              (channel == CL_IMAGE_CHANNEL_Y ? 1 : 0),
+              (channel == CL_IMAGE_CHANNEL_UV ? 1 : 0));
 
     estimation_kernel = new CLWaveletNoiseEstimateKernel (context, "kernel_wavelet_coeff_variance", handler, channel, subband, layer);
     {
@@ -927,8 +930,8 @@
     snprintf (build_options, sizeof (build_options),
               " -DWAVELET_DENOISE_Y=%d "
               " -DWAVELET_DENOISE_UV=%d ",
-              (channel == CL_WAVELET_CHANNEL_Y ? 1 : 0),
-              (channel == CL_WAVELET_CHANNEL_UV ? 1 : 0));
+              (channel == CL_IMAGE_CHANNEL_Y ? 1 : 0),
+              (channel == CL_IMAGE_CHANNEL_UV ? 1 : 0));
 
     threshold_kernel = new CLWaveletThresholdingKernel (context,
             "kernel_wavelet_coeff_thresholding",
@@ -951,94 +954,95 @@
 }
 
 SmartPtr<CLImageHandler>
-create_cl_newwavelet_denoise_image_handler (SmartPtr<CLContext> &context, uint32_t channel)
+create_cl_newwavelet_denoise_image_handler (SmartPtr<CLContext> &context, uint32_t channel, bool bayes_shrink)
 {
     SmartPtr<CLNewWaveletDenoiseImageHandler> wavelet_handler;
     SmartPtr<CLWaveletTransformKernel> haar_decomposition_kernel;
     SmartPtr<CLWaveletTransformKernel> haar_reconstruction_kernel;
 
-    wavelet_handler = new CLNewWaveletDenoiseImageHandler ("cl_handler_newwavelet_denoise", channel);
+    wavelet_handler = new CLNewWaveletDenoiseImageHandler ("cl_newwavelet_denoise_handler", channel);
     XCAM_ASSERT (wavelet_handler.ptr ());
 
-    if (channel & CL_WAVELET_CHANNEL_Y) {
+    if (channel & CL_IMAGE_CHANNEL_Y) {
         for (int layer = 1; layer <= WAVELET_DECOMPOSITION_LEVELS; layer++) {
             SmartPtr<CLImageKernel> image_kernel =
-                create_kernel_haar_decomposition (context, wavelet_handler, CL_WAVELET_CHANNEL_Y, layer);
+                create_kernel_haar_decomposition (context, wavelet_handler, CL_IMAGE_CHANNEL_Y, layer, bayes_shrink);
             wavelet_handler->add_kernel (image_kernel);
         }
 
-#if WAVELET_BAYES_SHRINK
-        for (int layer = 1; layer <= WAVELET_DECOMPOSITION_LEVELS; layer++) {
-            SmartPtr<CLImageKernel> image_kernel;
+        if (bayes_shrink) {
+            for (int layer = 1; layer <= WAVELET_DECOMPOSITION_LEVELS; layer++) {
+                SmartPtr<CLImageKernel> image_kernel;
 
-            image_kernel = create_kernel_noise_estimation (context, wavelet_handler,
-                           CL_WAVELET_CHANNEL_Y, CL_WAVELET_SUBBAND_HH, layer);
-            wavelet_handler->add_kernel (image_kernel);
+                image_kernel = create_kernel_noise_estimation (context, wavelet_handler,
+                               CL_IMAGE_CHANNEL_Y, CL_WAVELET_SUBBAND_HH, layer);
+                wavelet_handler->add_kernel (image_kernel);
 
-            image_kernel = create_kernel_noise_estimation (context, wavelet_handler,
-                           CL_WAVELET_CHANNEL_Y, CL_WAVELET_SUBBAND_LH, layer);
-            wavelet_handler->add_kernel (image_kernel);
+                image_kernel = create_kernel_noise_estimation (context, wavelet_handler,
+                               CL_IMAGE_CHANNEL_Y, CL_WAVELET_SUBBAND_LH, layer);
+                wavelet_handler->add_kernel (image_kernel);
 
-            image_kernel = create_kernel_noise_estimation (context, wavelet_handler,
-                           CL_WAVELET_CHANNEL_Y, CL_WAVELET_SUBBAND_HL, layer);
-            wavelet_handler->add_kernel (image_kernel);
+                image_kernel = create_kernel_noise_estimation (context, wavelet_handler,
+                               CL_IMAGE_CHANNEL_Y, CL_WAVELET_SUBBAND_HL, layer);
+                wavelet_handler->add_kernel (image_kernel);
+            }
+            for (int layer = 1; layer <= WAVELET_DECOMPOSITION_LEVELS; layer++) {
+                SmartPtr<CLImageKernel> image_kernel;
+                image_kernel = create_kernel_thresholding (context, wavelet_handler, CL_IMAGE_CHANNEL_Y, layer);
+                wavelet_handler->add_kernel (image_kernel);
+            }
         }
 
-        for (int layer = 1; layer <= WAVELET_DECOMPOSITION_LEVELS; layer++) {
-            SmartPtr<CLImageKernel> image_kernel;
-            image_kernel = create_kernel_thresholding (context, wavelet_handler, CL_WAVELET_CHANNEL_Y, layer);
-            wavelet_handler->add_kernel (image_kernel);
-        }
-
-#endif
         for (int layer = WAVELET_DECOMPOSITION_LEVELS; layer >= 1; layer--) {
             SmartPtr<CLImageKernel> image_kernel =
-                create_kernel_haar_reconstruction (context, wavelet_handler, CL_WAVELET_CHANNEL_Y, layer);
+                create_kernel_haar_reconstruction (context, wavelet_handler, CL_IMAGE_CHANNEL_Y, layer, bayes_shrink);
             wavelet_handler->add_kernel (image_kernel);
         }
     }
 
-    if (channel & CL_WAVELET_CHANNEL_UV) {
+    if (channel & CL_IMAGE_CHANNEL_UV) {
         for (int layer = 1; layer <= WAVELET_DECOMPOSITION_LEVELS; layer++) {
             SmartPtr<CLImageKernel> image_kernel =
-                create_kernel_haar_decomposition (context, wavelet_handler, CL_WAVELET_CHANNEL_UV, layer);
+                create_kernel_haar_decomposition (context, wavelet_handler, CL_IMAGE_CHANNEL_UV, layer, bayes_shrink);
             wavelet_handler->add_kernel (image_kernel);
         }
-#if WAVELET_BAYES_SHRINK
-        for (int layer = 1; layer <= WAVELET_DECOMPOSITION_LEVELS; layer++) {
-            SmartPtr<CLImageKernel> image_kernel;
 
-            image_kernel = create_kernel_noise_estimation (context, wavelet_handler,
-                           CL_WAVELET_CHANNEL_UV, CL_WAVELET_SUBBAND_HH, layer);
-            wavelet_handler->add_kernel (image_kernel);
+        if (bayes_shrink) {
+            for (int layer = 1; layer <= WAVELET_DECOMPOSITION_LEVELS; layer++) {
+                SmartPtr<CLImageKernel> image_kernel;
 
-            image_kernel = create_kernel_noise_estimation (context, wavelet_handler,
-                           CL_WAVELET_CHANNEL_UV, CL_WAVELET_SUBBAND_LH, layer);
-            wavelet_handler->add_kernel (image_kernel);
+                image_kernel = create_kernel_noise_estimation (context, wavelet_handler,
+                               CL_IMAGE_CHANNEL_UV, CL_WAVELET_SUBBAND_HH, layer);
+                wavelet_handler->add_kernel (image_kernel);
 
-            image_kernel = create_kernel_noise_estimation (context, wavelet_handler,
-                           CL_WAVELET_CHANNEL_UV, CL_WAVELET_SUBBAND_HL, layer);
-            wavelet_handler->add_kernel (image_kernel);
+                image_kernel = create_kernel_noise_estimation (context, wavelet_handler,
+                               CL_IMAGE_CHANNEL_UV, CL_WAVELET_SUBBAND_LH, layer);
+                wavelet_handler->add_kernel (image_kernel);
+
+                image_kernel = create_kernel_noise_estimation (context, wavelet_handler,
+                               CL_IMAGE_CHANNEL_UV, CL_WAVELET_SUBBAND_HL, layer);
+                wavelet_handler->add_kernel (image_kernel);
+            }
+            for (int layer = 1; layer <= WAVELET_DECOMPOSITION_LEVELS; layer++) {
+                SmartPtr<CLImageKernel> image_kernel;
+                image_kernel = create_kernel_thresholding (context, wavelet_handler, CL_IMAGE_CHANNEL_UV, layer);
+                wavelet_handler->add_kernel (image_kernel);
+            }
         }
-        for (int layer = 1; layer <= WAVELET_DECOMPOSITION_LEVELS; layer++) {
-            SmartPtr<CLImageKernel> image_kernel;
-            image_kernel = create_kernel_thresholding (context, wavelet_handler, CL_WAVELET_CHANNEL_UV, layer);
-            wavelet_handler->add_kernel (image_kernel);
-        }
-#endif
+
         for (int layer = WAVELET_DECOMPOSITION_LEVELS; layer >= 1; layer--) {
             SmartPtr<CLImageKernel> image_kernel =
-                create_kernel_haar_reconstruction (context, wavelet_handler, CL_WAVELET_CHANNEL_UV, layer);
+                create_kernel_haar_reconstruction (context, wavelet_handler, CL_IMAGE_CHANNEL_UV, layer, bayes_shrink);
             wavelet_handler->add_kernel (image_kernel);
         }
     }
 
-    if ((channel & CL_WAVELET_CHANNEL_Y) &&
-            (channel & CL_WAVELET_CHANNEL_UV)) {
+    if ((channel & CL_IMAGE_CHANNEL_Y) &&
+            (channel & CL_IMAGE_CHANNEL_UV)) {
         wavelet_handler->set_clone_flags (SwappedBuffer::SwapY | SwappedBuffer::SwapUV);
-    } else if (channel & CL_WAVELET_CHANNEL_UV) {
+    } else if (channel & CL_IMAGE_CHANNEL_UV) {
         wavelet_handler->set_clone_flags (SwappedBuffer::SwapUV);
-    } else if (channel & CL_WAVELET_CHANNEL_Y) {
+    } else if (channel & CL_IMAGE_CHANNEL_Y) {
         wavelet_handler->set_clone_flags (SwappedBuffer::SwapY);
     }
 
diff --git a/modules/ocl/cl_newwavelet_denoise_handler.h b/modules/ocl/cl_newwavelet_denoise_handler.h
index 19a8e69..4778cd2 100644
--- a/modules/ocl/cl_newwavelet_denoise_handler.h
+++ b/modules/ocl/cl_newwavelet_denoise_handler.h
@@ -144,7 +144,8 @@
                                        SmartPtr<CLNewWaveletDenoiseImageHandler> &handler,
                                        CLWaveletFilterBank fb,
                                        uint32_t channel,
-                                       uint32_t layer);
+                                       uint32_t layer,
+                                       bool bayes_shrink);
 
     SmartPtr<CLWaveletDecompBuffer> get_decomp_buffer (uint32_t channel, int layer);
 
@@ -164,6 +165,7 @@
     uint32_t  _decomposition_levels;
     uint32_t  _channel;
     uint32_t  _current_layer;
+    bool      _bayes_shrink;
     float     _hard_threshold;
     float     _soft_threshold;
 
@@ -204,7 +206,7 @@
 };
 
 SmartPtr<CLImageHandler>
-create_cl_newwavelet_denoise_image_handler (SmartPtr<CLContext> &context, uint32_t channel);
+create_cl_newwavelet_denoise_image_handler (SmartPtr<CLContext> &context, uint32_t channel, bool bayes_shrink);
 
 };
 
diff --git a/modules/ocl/cl_wavelet_denoise_handler.cpp b/modules/ocl/cl_wavelet_denoise_handler.cpp
index ec69b43..7004f0c 100644
--- a/modules/ocl/cl_wavelet_denoise_handler.cpp
+++ b/modules/ocl/cl_wavelet_denoise_handler.cpp
@@ -126,7 +126,7 @@
     args[11].arg_adress = &_soft_threshold;
     args[11].arg_size = sizeof (_soft_threshold);
 
-    if (_channel & CL_WAVELET_CHANNEL_UV) {
+    if (_channel & CL_IMAGE_CHANNEL_UV) {
         work_size.global[0] = video_info_in.width / 16;
         work_size.global[1] = video_info_in.height / 2;
     } else {
@@ -208,7 +208,7 @@
         ret = wavelet_kernel->load_from_source (
                   kernel_wavelet_denoise_body, strlen (kernel_wavelet_denoise_body),
                   NULL, NULL,
-                  (channel & CL_WAVELET_CHANNEL_UV) ? "-DWAVELET_DENOISE_UV=1" : "-DWAVELET_DENOISE_UV=0");
+                  (channel & CL_IMAGE_CHANNEL_UV) ? "-DWAVELET_DENOISE_UV=1" : "-DWAVELET_DENOISE_UV=0");
         XCAM_FAIL_RETURN (
             WARNING,
             ret == XCAM_RETURN_NO_ERROR,
diff --git a/tests/test-cl-image.cpp b/tests/test-cl-image.cpp
index 69b7093..00fa4b2 100644
--- a/tests/test-cl-image.cpp
+++ b/tests/test-cl-image.cpp
@@ -561,7 +561,7 @@
         break;
     }
     case TestHandlerHatWavelet: {
-        image_handler = create_cl_wavelet_denoise_image_handler (context, CL_WAVELET_CHANNEL_UV);
+        image_handler = create_cl_wavelet_denoise_image_handler (context, CL_IMAGE_CHANNEL_UV);
         SmartPtr<CLWaveletDenoiseImageHandler> wavelet = image_handler.dynamic_cast_ptr<CLWaveletDenoiseImageHandler> ();
         XCAM_ASSERT (wavelet.ptr ());
         XCam3aResultWaveletNoiseReduction wavelet_config;
@@ -574,7 +574,7 @@
         break;
     }
     case TestHandlerHaarWavelet: {
-        image_handler = create_cl_newwavelet_denoise_image_handler (context, CL_WAVELET_CHANNEL_UV | CL_WAVELET_CHANNEL_Y);
+        image_handler = create_cl_newwavelet_denoise_image_handler (context, CL_IMAGE_CHANNEL_UV | CL_IMAGE_CHANNEL_Y, false);
         SmartPtr<CLNewWaveletDenoiseImageHandler> wavelet = image_handler.dynamic_cast_ptr<CLNewWaveletDenoiseImageHandler> ();
         XCAM_ASSERT (wavelet.ptr ());
         XCam3aResultWaveletNoiseReduction wavelet_config;
diff --git a/tests/test-device-manager.cpp b/tests/test-device-manager.cpp
index cb5e987..fefdd12 100644
--- a/tests/test-device-manager.cpp
+++ b/tests/test-device-manager.cpp
@@ -321,7 +321,7 @@
             "\t               select from [disabled, retinex, dcp], default is [disabled]\n"
             "\t --enable-retinex  enable retinex\n"
             "\t --wavelet-mode specify wavelet denoise mode, default is off\n"
-            "\t                select from [0:disable, 1:Hat Y, 2:Hat UV, 3:Haar Y, 4:Haar UV, 5:Haar YUV]\n"
+            "\t                select from [0:disable, 1:Hat Y, 2:Hat UV, 3:Haar Y, 4:Haar UV, 5:Haar YUV, 6:Haar Bayes Shrink]\n"
             "\t --enable-wireframe  enable wire frame\n"
             "\t --pipeline    pipe mode\n"
             "\t               select from [basic, advance, extreme], default is [basic]\n"
@@ -373,7 +373,8 @@
     bool wdr_type = false;
     uint32_t defog_type = 0;
     CLWaveletBasis wavelet_mode = CL_WAVELET_DISABLED;
-    uint32_t wavelet_channel = CL_WAVELET_CHANNEL_UV;
+    uint32_t wavelet_channel = CL_IMAGE_CHANNEL_UV;
+    bool wavelet_bayes_shrink = false;
     bool wireframe_type = false;
 
     int32_t brightness_level = 128;
@@ -564,19 +565,23 @@
             }
             if (atoi(optarg) == 1) {
                 wavelet_mode = CL_WAVELET_HAT;
-                wavelet_channel = CL_WAVELET_CHANNEL_Y;
+                wavelet_channel = CL_IMAGE_CHANNEL_Y;
             } else if (atoi(optarg) == 2) {
                 wavelet_mode = CL_WAVELET_HAT;
-                wavelet_channel = CL_WAVELET_CHANNEL_UV;
+                wavelet_channel = CL_IMAGE_CHANNEL_UV;
             } else if (atoi(optarg) == 3) {
                 wavelet_mode = CL_WAVELET_HAAR;
-                wavelet_channel = CL_WAVELET_CHANNEL_Y;
+                wavelet_channel = CL_IMAGE_CHANNEL_Y;
             } else if (atoi(optarg) == 4) {
                 wavelet_mode = CL_WAVELET_HAAR;
-                wavelet_channel = CL_WAVELET_CHANNEL_UV;
+                wavelet_channel = CL_IMAGE_CHANNEL_UV;
             } else if (atoi(optarg) == 5) {
                 wavelet_mode = CL_WAVELET_HAAR;
-                wavelet_channel = CL_WAVELET_CHANNEL_UV | CL_WAVELET_CHANNEL_Y;
+                wavelet_channel = CL_IMAGE_CHANNEL_UV | CL_IMAGE_CHANNEL_Y;
+            } else if (atoi(optarg) == 6) {
+                wavelet_mode = CL_WAVELET_HAAR;
+                wavelet_channel = CL_IMAGE_CHANNEL_UV | CL_IMAGE_CHANNEL_Y;
+                wavelet_bayes_shrink = true;
             } else {
                 wavelet_mode = CL_WAVELET_DISABLED;
             }
@@ -812,7 +817,7 @@
         cl_processor->set_denoise (denoise_type);
         cl_processor->set_tonemapping(wdr_mode);
         cl_processor->set_gamma (!wdr_type); // disable gamma for WDR
-        cl_processor->set_wavelet (wavelet_mode, wavelet_channel);
+        cl_processor->set_wavelet (wavelet_mode, wavelet_channel, wavelet_bayes_shrink);
         cl_processor->set_wireframe (wireframe_type);
         cl_processor->set_capture_stage (capture_stage);
 
diff --git a/wrapper/gstreamer/gstxcamsrc.cpp b/wrapper/gstreamer/gstxcamsrc.cpp
index ad1eabd..4a4df65 100644
--- a/wrapper/gstreamer/gstxcamsrc.cpp
+++ b/wrapper/gstreamer/gstxcamsrc.cpp
@@ -201,6 +201,7 @@
         {HARR_WAVELET_Y, "Haar wavelet Y", "haar Y"},
         {HARR_WAVELET_UV, "Haar wavelet UV", "haar UV"},
         {HARR_WAVELET_YUV, "Haar wavelet YUV", "haar YUV"},
+        {HARR_WAVELET_BAYES, "Haar wavelet bayes shrink", "haar Bayes"},
         {0, NULL, NULL},
     };
 
@@ -888,17 +889,19 @@
 
         if (NONE_WAVELET != xcamsrc->wavelet_mode) {
             if (HAT_WAVELET_Y == xcamsrc->wavelet_mode) {
-                cl_processor->set_wavelet (CL_WAVELET_HAT, CL_WAVELET_CHANNEL_Y);
+                cl_processor->set_wavelet (CL_WAVELET_HAT, CL_IMAGE_CHANNEL_Y, false);
             } else if (HAT_WAVELET_UV == xcamsrc->wavelet_mode) {
-                cl_processor->set_wavelet (CL_WAVELET_HAT, CL_WAVELET_CHANNEL_UV);
+                cl_processor->set_wavelet (CL_WAVELET_HAT, CL_IMAGE_CHANNEL_UV, false);
             } else if (HARR_WAVELET_Y == xcamsrc->wavelet_mode) {
-                cl_processor->set_wavelet (CL_WAVELET_HAAR, CL_WAVELET_CHANNEL_Y);
+                cl_processor->set_wavelet (CL_WAVELET_HAAR, CL_IMAGE_CHANNEL_Y, false);
             } else if (HARR_WAVELET_UV == xcamsrc->wavelet_mode) {
-                cl_processor->set_wavelet (CL_WAVELET_HAAR, CL_WAVELET_CHANNEL_UV);
+                cl_processor->set_wavelet (CL_WAVELET_HAAR, CL_IMAGE_CHANNEL_UV, false);
             } else if (HARR_WAVELET_YUV == xcamsrc->wavelet_mode) {
-                cl_processor->set_wavelet (CL_WAVELET_HAAR, CL_WAVELET_CHANNEL_UV | CL_WAVELET_CHANNEL_Y);
+                cl_processor->set_wavelet (CL_WAVELET_HAAR, CL_IMAGE_CHANNEL_UV | CL_IMAGE_CHANNEL_Y, false);
+            } else if (HARR_WAVELET_BAYES == xcamsrc->wavelet_mode) {
+                cl_processor->set_wavelet (CL_WAVELET_HAAR, CL_IMAGE_CHANNEL_UV | CL_IMAGE_CHANNEL_Y, true);
             } else {
-                cl_processor->set_wavelet (CL_WAVELET_DISABLED, CL_WAVELET_CHANNEL_UV);
+                cl_processor->set_wavelet (CL_WAVELET_DISABLED, CL_IMAGE_CHANNEL_UV, false);
             }
         }
 
@@ -1078,7 +1081,7 @@
     case GST_VIDEO_FORMAT_Y42B:
         return V4L2_PIX_FMT_YUV422P;
 
-        //RGB
+    //RGB
     case GST_VIDEO_FORMAT_RGBx:
         return V4L2_PIX_FMT_RGB32;
     case GST_VIDEO_FORMAT_BGRx:
diff --git a/wrapper/gstreamer/gstxcamsrc.h b/wrapper/gstreamer/gstxcamsrc.h
index 1aaeb44..70c17d6 100644
--- a/wrapper/gstreamer/gstxcamsrc.h
+++ b/wrapper/gstreamer/gstxcamsrc.h
@@ -66,6 +66,7 @@
     HARR_WAVELET_Y,
     HARR_WAVELET_UV,
     HARR_WAVELET_YUV,
+    HARR_WAVELET_BAYES,
 } WaveletModeType;
 
 typedef enum {
diff --git a/xcore/xcam_utils.h b/xcore/xcam_utils.h
index 25ea0f7..ee3f416 100644
--- a/xcore/xcam_utils.h
+++ b/xcore/xcam_utils.h
@@ -40,9 +40,9 @@
     CL_WAVELET_HAAR,
 };
 
-enum CLWaveletChannel {
-    CL_WAVELET_CHANNEL_Y = 1,
-    CL_WAVELET_CHANNEL_UV = 1 << 1,
+enum CLImageChannel {
+    CL_IMAGE_CHANNEL_Y = 1,
+    CL_IMAGE_CHANNEL_UV = 1 << 1,
 };
 
 inline double