/*
|
* cl_3d_denoise_handler.cpp - CL 3D noise reduction 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 "cl_3d_denoise_handler.h"
|
|
namespace XCam {
|
|
#define CL_3D_DENOISE_MAX_REFERENCE_FRAME_COUNT 3
|
#define CL_3D_DENOISE_REFERENCE_FRAME_COUNT 3
|
#define CL_3D_DENOISE_WG_WIDTH 4
|
#define CL_3D_DENOISE_WG_HEIGHT 16
|
|
#define CL_3D_DENOISE_ENABLE_SUBGROUP 1
|
#define CL_3D_DENOISE_IIR_FILTERING 1
|
|
#if CL_3D_DENOISE_ENABLE_SUBGROUP
|
#define KERNEL_3D_DENOISE_NAME "kernel_3d_denoise"
|
#else
|
#define KERNEL_3D_DENOISE_NAME "kernel_3d_denoise_slm"
|
#endif
|
|
enum {
|
Kernel3DDenoise,
|
Kernel3DDenoiseSLM,
|
};
|
|
const XCamKernelInfo kernel_3d_denoise_info[] = {
|
{
|
"kernel_3d_denoise",
|
#include "kernel_3d_denoise.clx"
|
, 0,
|
},
|
|
{
|
"kernel_3d_denoise_slm",
|
#include "kernel_3d_denoise_slm.clx"
|
, 0,
|
},
|
};
|
|
CL3DDenoiseImageKernel::CL3DDenoiseImageKernel (
|
const SmartPtr<CLContext> &context,
|
const char *name,
|
uint32_t channel,
|
SmartPtr<CL3DDenoiseImageHandler> &handler)
|
: CLImageKernel (context, name)
|
, _channel (channel)
|
, _ref_count (CL_3D_DENOISE_REFERENCE_FRAME_COUNT)
|
, _handler (handler)
|
{
|
}
|
|
XCamReturn
|
CL3DDenoiseImageKernel::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 ();
|
|
uint32_t info_index = 0;
|
if (_channel == CL_IMAGE_CHANNEL_Y) {
|
info_index = 0;
|
} else if (_channel == CL_IMAGE_CHANNEL_UV) {
|
info_index = 1;
|
}
|
|
CLImageDesc cl_desc_in, cl_desc_out;
|
cl_desc_in.format.image_channel_order = CL_RGBA;
|
#if CL_3D_DENOISE_ENABLE_SUBGROUP
|
cl_desc_in.format.image_channel_data_type = CL_UNSIGNED_INT16;
|
cl_desc_in.width = XCAM_ALIGN_UP (video_info_in.width, 8) / 8;
|
#else
|
cl_desc_in.format.image_channel_data_type = CL_UNORM_INT8;
|
cl_desc_in.width = XCAM_ALIGN_UP (video_info_in.width, 4) / 4;
|
#endif
|
cl_desc_in.height = video_info_in.height >> info_index;
|
cl_desc_in.row_pitch = video_info_in.strides[info_index];
|
|
cl_desc_out.format.image_channel_order = CL_RGBA;
|
#if CL_3D_DENOISE_ENABLE_SUBGROUP
|
cl_desc_out.format.image_channel_data_type = CL_UNSIGNED_INT16;
|
cl_desc_out.width = XCAM_ALIGN_UP (video_info_out.width, 8) / 8;
|
#else
|
cl_desc_out.format.image_channel_data_type = CL_UNORM_INT8;
|
cl_desc_out.width = XCAM_ALIGN_UP (video_info_out.width, 4) / 4;
|
#endif
|
cl_desc_out.height = video_info_out.height >> info_index;
|
cl_desc_out.row_pitch = video_info_out.strides[info_index];
|
|
_ref_count = _handler->get_ref_framecount ();
|
float gain = 5.0f / (_handler->get_denoise_config ().gain + 0.0001f);
|
float threshold = 2.0f * _handler->get_denoise_config ().threshold[info_index];
|
|
SmartPtr<CLImage> image_in = convert_to_climage (context, input, cl_desc_in, video_info_in.offsets[info_index]);
|
SmartPtr<CLImage> image_out = convert_to_climage (context, output, cl_desc_out, video_info_out.offsets[info_index]);
|
XCAM_ASSERT (image_in->is_valid () && image_out->is_valid ());
|
XCAM_FAIL_RETURN (
|
WARNING,
|
image_in->is_valid () && image_out->is_valid (),
|
XCAM_RETURN_ERROR_MEM,
|
"cl image kernel(%s) in/out memory not available", get_kernel_name ());
|
|
if (_image_in_list.size () < _ref_count) {
|
while (_image_in_list.size () < _ref_count) {
|
_image_in_list.push_back (image_in);
|
}
|
} else {
|
_image_in_list.pop_back ();
|
_image_in_list.push_front (image_in);
|
}
|
|
if (!_image_out_prev.ptr ()) {
|
_image_out_prev = image_in;
|
}
|
|
//set args;
|
args.push_back (new CLArgumentT<float> (gain));
|
args.push_back (new CLArgumentT<float> (threshold));
|
args.push_back (new CLMemArgument (_image_out_prev));
|
args.push_back (new CLMemArgument (image_out));
|
|
uint8_t image_list_count = _image_in_list.size ();
|
for (std::list<SmartPtr<CLImage>>::iterator it = _image_in_list.begin (); it != _image_in_list.end (); it++) {
|
args.push_back (new CLMemArgument (*it));
|
}
|
|
//backup enough buffers for kernel
|
for (; image_list_count < CL_3D_DENOISE_MAX_REFERENCE_FRAME_COUNT; ++image_list_count) {
|
args.push_back (new CLMemArgument (image_in));
|
}
|
|
//set worksize
|
work_size.dim = XCAM_DEFAULT_IMAGE_DIM;
|
#if CL_3D_DENOISE_ENABLE_SUBGROUP
|
work_size.local[0] = CL_3D_DENOISE_WG_WIDTH;
|
work_size.local[1] = CL_3D_DENOISE_WG_HEIGHT;
|
work_size.global[0] = XCAM_ALIGN_UP (cl_desc_in.width, work_size.local[0]);
|
work_size.global[1] = (cl_desc_in.height + work_size.local[1] - 1) / work_size.local[1] * work_size.local[1];
|
#else
|
work_size.local[0] = 8;
|
work_size.local[1] = 1;
|
work_size.global[0] = XCAM_ALIGN_UP (cl_desc_in.width, work_size.local[0]);
|
work_size.global[1] = XCAM_ALIGN_UP(cl_desc_in.height / 8, 8 * work_size.local[1]);
|
#endif
|
|
_image_out_prev = image_out;
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
CL3DDenoiseImageHandler::CL3DDenoiseImageHandler (const SmartPtr<CLContext> &context, const char *name)
|
: CLImageHandler (context, name)
|
, _ref_count (CL_3D_DENOISE_REFERENCE_FRAME_COUNT - 2)
|
{
|
_config.gain = 1.0f;
|
_config.threshold[0] = 0.05f;
|
_config.threshold[1] = 0.05f;
|
}
|
|
bool
|
CL3DDenoiseImageHandler::set_ref_framecount (const uint8_t count)
|
{
|
_ref_count = count;
|
|
return true;
|
}
|
|
bool
|
CL3DDenoiseImageHandler::set_denoise_config (const XCam3aResultTemporalNoiseReduction& config)
|
{
|
_config = config;
|
|
return true;
|
}
|
|
XCamReturn
|
CL3DDenoiseImageHandler::prepare_parameters (SmartPtr<VideoBuffer> &input, SmartPtr<VideoBuffer> &output)
|
{
|
_input_buf = input;
|
_output_buf = output;
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
static SmartPtr<CLImageKernel>
|
create_3d_denoise_kernel (
|
const SmartPtr<CLContext> &context, SmartPtr<CL3DDenoiseImageHandler> handler,
|
uint32_t channel, uint8_t ref_count)
|
{
|
char build_options[1024];
|
xcam_mem_clear (build_options);
|
|
snprintf (build_options, sizeof (build_options),
|
" -DREFERENCE_FRAME_COUNT=%d"
|
" -DWORKGROUP_WIDTH=%d"
|
" -DWORKGROUP_HEIGHT=%d"
|
" -DENABLE_IIR_FILERING=%d",
|
ref_count,
|
CL_3D_DENOISE_WG_WIDTH,
|
CL_3D_DENOISE_WG_HEIGHT,
|
CL_3D_DENOISE_IIR_FILTERING);
|
|
#if CL_3D_DENOISE_ENABLE_SUBGROUP
|
int kernel_index = Kernel3DDenoise;
|
#else
|
int kernel_index = Kernel3DDenoiseSLM;
|
#endif
|
|
SmartPtr<CLImageKernel> kernel =
|
new CL3DDenoiseImageKernel (context, KERNEL_3D_DENOISE_NAME, channel, handler);
|
XCAM_ASSERT (kernel.ptr ());
|
XCAM_FAIL_RETURN (
|
ERROR, kernel->build_kernel (kernel_3d_denoise_info[kernel_index], build_options) == XCAM_RETURN_NO_ERROR,
|
NULL, "build 3d denoise kernel failed");
|
return kernel;
|
}
|
|
SmartPtr<CLImageHandler>
|
create_cl_3d_denoise_image_handler (
|
const SmartPtr<CLContext> &context, uint32_t channel, uint8_t ref_count)
|
{
|
SmartPtr<CL3DDenoiseImageHandler> denoise_handler;
|
SmartPtr<CLImageKernel> denoise_kernel;
|
|
denoise_handler = new CL3DDenoiseImageHandler (context, "cl_3d_denoise_handler");
|
XCAM_ASSERT (denoise_handler.ptr ());
|
denoise_handler->set_ref_framecount (ref_count);
|
|
if (channel & CL_IMAGE_CHANNEL_Y) {
|
denoise_kernel = create_3d_denoise_kernel (context, denoise_handler, CL_IMAGE_CHANNEL_Y, ref_count);
|
XCAM_FAIL_RETURN (
|
ERROR, denoise_kernel.ptr (), NULL, "3D denoise handler create Y channel kernel failed.");
|
|
denoise_handler->add_kernel (denoise_kernel);
|
}
|
|
if (channel & CL_IMAGE_CHANNEL_UV) {
|
denoise_kernel = create_3d_denoise_kernel (context, denoise_handler, CL_IMAGE_CHANNEL_UV, ref_count);
|
XCAM_FAIL_RETURN (
|
ERROR, denoise_kernel.ptr (), NULL, "3D denoise handler create UV channel kernel failed.");
|
|
denoise_handler->add_kernel (denoise_kernel);
|
}
|
|
return denoise_handler;
|
}
|
};
|
