modules/ocl/cl_wavelet_denoise_handler.cpp

/*
 * cl_wavelet_denoise_handler.cpp - CL wavelet denoise handler
 *
 *  Copyright (c) 2015 Intel Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Author: Wei Zong <wei.zong@intel.com>
 */
#include "cl_utils.h"
#include "x3a_stats_pool.h"
#include "cl_context.h"
#include "cl_device.h"
#include "cl_wavelet_denoise_handler.h"

#define WAVELET_DECOMPOSITION_LEVELS 4

namespace XCam {

static const XCamKernelInfo kernel_wavelet_denoise_info = {
    "kernel_wavelet_denoise",
#include "kernel_wavelet_denoise.clx"
    , 0,
};

CLWaveletDenoiseImageKernel::CLWaveletDenoiseImageKernel (
    const SmartPtr<CLContext> &context,
    const char *name,
    SmartPtr<CLWaveletDenoiseImageHandler> &handler,
    uint32_t channel,
    uint32_t layer)
    : CLImageKernel (context, name)
    , _channel (channel)
    , _current_layer (layer)
    , _handler (handler)
{
}

XCamReturn
CLWaveletDenoiseImageKernel::prepare_arguments (
    CLArgList &args, CLWorkSize &work_size)
{
    SmartPtr<CLContext> context = get_context ();
    SmartPtr<VideoBuffer> input = _handler->get_input_buf ();
    SmartPtr<VideoBuffer> output = _handler->get_output_buf ();

    const VideoBufferInfo &video_info_in = input->get_video_info ();
    const VideoBufferInfo &video_info_out = output->get_video_info ();

    SmartPtr<CLMemory> input_image = convert_to_clbuffer (context, input);
    SmartPtr<CLMemory> reconstruct_image = convert_to_clbuffer (context, output);

    SmartPtr<CLMemory> details_image = _handler->get_details_image ();
    SmartPtr<CLMemory> approx_image = _handler->get_approx_image ();

    uint32_t decomposition_levels = WAVELET_DECOMPOSITION_LEVELS;
    float soft_threshold = _handler->get_denoise_config ().threshold[0];
    float hard_threshold = _handler->get_denoise_config ().threshold[1];

    uint32_t input_y_offset = video_info_in.offsets[0] / 4;
    uint32_t output_y_offset = video_info_out.offsets[0] / 4;

    uint32_t input_uv_offset = video_info_in.aligned_height;
    uint32_t output_uv_offset = video_info_out.aligned_height;

    XCAM_FAIL_RETURN (
        WARNING,
        input_image->is_valid () && reconstruct_image->is_valid (),
        XCAM_RETURN_ERROR_MEM,
        "cl image kernel(%s) in/out memory not available", XCAM_STR(get_kernel_name ()));

    //set args;
    work_size.dim = XCAM_DEFAULT_IMAGE_DIM;
    work_size.local[0] = 8;
    work_size.local[1] = 4;

    if (_current_layer % 2) {
        args.push_back (new CLMemArgument (input_image));
        args.push_back (new CLMemArgument (approx_image));
    } else {
        args.push_back (new CLMemArgument (approx_image));
        args.push_back (new CLMemArgument (input_image));
    }
    args.push_back (new CLMemArgument (details_image));
    args.push_back (new CLMemArgument (reconstruct_image));
    args.push_back (new CLArgumentT<uint32_t> (input_y_offset));
    args.push_back (new CLArgumentT<uint32_t> (output_y_offset));
    args.push_back (new CLArgumentT<uint32_t> (input_uv_offset));
    args.push_back (new CLArgumentT<uint32_t> (output_uv_offset));
    args.push_back (new CLArgumentT<uint32_t> (_current_layer));
    args.push_back (new CLArgumentT<uint32_t> (decomposition_levels));
    args.push_back (new CLArgumentT<float> (hard_threshold));
    args.push_back (new CLArgumentT<float> (soft_threshold));

    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 {
        work_size.global[0] = video_info_in.width / 16;
        work_size.global[1] = video_info_in.height;
    }

    return XCAM_RETURN_NO_ERROR;
}

CLWaveletDenoiseImageHandler::CLWaveletDenoiseImageHandler (
    const SmartPtr<CLContext> &context, const char *name)
    : CLImageHandler (context, name)
{
    _config.decomposition_levels = 5;
    _config.threshold[0] = 0.5;
    _config.threshold[1] = 5.0;
}

XCamReturn
CLWaveletDenoiseImageHandler::prepare_output_buf (SmartPtr<VideoBuffer> &input, SmartPtr<VideoBuffer> &output)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    CLImageHandler::prepare_output_buf(input, output);

    if (!_approx_image.ptr ()) {
        const VideoBufferInfo & video_info = input->get_video_info ();
        uint32_t buffer_size = video_info.width * video_info.aligned_height;

        _approx_image = new CLBuffer (get_context (), buffer_size,
                                      CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR, NULL);
    }

    if (!_details_image.ptr ()) {
        const VideoBufferInfo & video_info = input->get_video_info ();
        uint32_t buffer_size = sizeof(float) * video_info.width * video_info.height;

        _details_image = new CLBuffer (get_context (), buffer_size,
                                       CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR, NULL);
    }
    return ret;
}

bool
CLWaveletDenoiseImageHandler::set_denoise_config (const XCam3aResultWaveletNoiseReduction& config)

{
    _config = config;

    return true;
}

SmartPtr<CLImageHandler>
create_cl_wavelet_denoise_image_handler (const SmartPtr<CLContext> &context, uint32_t channel)
{
    SmartPtr<CLWaveletDenoiseImageHandler> wavelet_handler;
    SmartPtr<CLWaveletDenoiseImageKernel> wavelet_kernel;

    wavelet_handler = new CLWaveletDenoiseImageHandler (context, "cl_handler_wavelet_denoise");
    XCAM_ASSERT (wavelet_handler.ptr ());

    for (int layer = 1; layer <= WAVELET_DECOMPOSITION_LEVELS; layer++) {
        wavelet_kernel = new CLWaveletDenoiseImageKernel (
            context, "kernel_wavelet_denoise", wavelet_handler, channel, layer);
        const char *build_options =
            (channel & CL_IMAGE_CHANNEL_UV) ? "-DWAVELET_DENOISE_UV=1" : "-DWAVELET_DENOISE_UV=0";

        XCAM_ASSERT (wavelet_kernel.ptr ());
        XCAM_FAIL_RETURN (
            ERROR, wavelet_kernel->build_kernel (kernel_wavelet_denoise_info, build_options) == XCAM_RETURN_NO_ERROR, NULL,
            "build wavelet denoise kernel(%s) failed", kernel_wavelet_denoise_info.kernel_name);
        XCAM_ASSERT (wavelet_kernel->is_valid ());

        wavelet_handler->add_kernel (wavelet_kernel);
    }
    return wavelet_handler;
}

};