/*
|
* cl_pyramid_blender.cpp - CL multi-band blender
|
*
|
* Copyright (c) 2016 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: Wind Yuan <feng.yuan@intel.com>
|
*/
|
|
#include "cl_pyramid_blender.h"
|
#include <algorithm>
|
#include "xcam_obj_debug.h"
|
#include "cl_device.h"
|
#include "cl_utils.h"
|
|
#if CL_PYRAMID_ENABLE_DUMP
|
#define BLENDER_PROFILING_START(name) XCAM_STATIC_PROFILING_START(name)
|
#define BLENDER_PROFILING_END(name, times_of_print) XCAM_STATIC_PROFILING_END(name, times_of_print)
|
#else
|
#define BLENDER_PROFILING_START(name)
|
#define BLENDER_PROFILING_END(name, times_of_print)
|
#endif
|
|
//#define SAMPLER_POSITION_OFFSET -0.25f
|
#define SAMPLER_POSITION_OFFSET 0.0f
|
|
#define SEAM_POS_TYPE int16_t
|
#define SEAM_SUM_TYPE float
|
#define SEAM_MASK_TYPE uint8_t
|
|
namespace XCam {
|
|
enum {
|
KernelPyramidTransform = 0,
|
KernelPyramidReconstruct,
|
KernelPyramidBlender,
|
KernelPyramidScale,
|
KernelPyramidCopy,
|
KernelPyramidLap,
|
KernelImageDiff,
|
KernelSeamDP,
|
KernelSeamMaskScale,
|
KernelSeamMaskScaleSLM,
|
KernelSeamBlender
|
};
|
|
static const XCamKernelInfo kernels_info [] = {
|
{
|
"kernel_gauss_scale_transform",
|
#include "kernel_gauss_lap_pyramid.clx"
|
, 0,
|
},
|
{
|
"kernel_gauss_lap_reconstruct",
|
#include "kernel_gauss_lap_pyramid.clx"
|
, 0,
|
},
|
{
|
"kernel_pyramid_blend",
|
#include "kernel_gauss_lap_pyramid.clx"
|
, 0,
|
},
|
{
|
"kernel_pyramid_scale",
|
#include "kernel_gauss_lap_pyramid.clx"
|
, 0,
|
},
|
{
|
"kernel_pyramid_copy",
|
#include "kernel_gauss_lap_pyramid.clx"
|
, 0,
|
},
|
{
|
"kernel_lap_transform",
|
#include "kernel_gauss_lap_pyramid.clx"
|
, 0,
|
},
|
{
|
"kernel_image_diff",
|
#include "kernel_gauss_lap_pyramid.clx"
|
, 0,
|
},
|
{
|
"kernel_seam_dp",
|
#include "kernel_gauss_lap_pyramid.clx"
|
, 0,
|
},
|
{
|
"kernel_mask_gauss_scale",
|
#include "kernel_gauss_lap_pyramid.clx"
|
, 0,
|
},
|
{
|
"kernel_mask_gauss_scale_slm",
|
#include "kernel_gauss_lap_pyramid.clx"
|
, 0,
|
},
|
{
|
"kernel_seam_mask_blend",
|
#include "kernel_gauss_lap_pyramid.clx"
|
, 0,
|
}
|
};
|
|
static uint32_t
|
clamp(int32_t i, int32_t min, int32_t max)
|
{
|
if (i < min)
|
return min;
|
if (i > max - 1)
|
return max - 1;
|
return i;
|
}
|
|
static float*
|
get_gauss_coeffs (int radius, float sigma)
|
{
|
static int g_radius = 0;
|
static float g_sigma = 0;
|
static float g_table[512] = {0.0f};
|
|
int i;
|
int scale = radius * 2 + 1;
|
float dis = 0.0f, sum = 0.0f;
|
|
if (g_radius == radius && g_sigma == sigma)
|
return g_table;
|
|
XCAM_ASSERT (scale < 512);
|
|
for (i = 0; i < scale; i++) {
|
dis = ((float)i - radius) * ((float)i - radius);
|
g_table[i] = exp(-dis / (2.0f * sigma * sigma));
|
sum += g_table[i];
|
}
|
|
for(i = 0; i < scale; i++)
|
g_table[i] = g_table[i] / sum;
|
|
g_radius = radius;
|
g_sigma = sigma;
|
|
return g_table;
|
}
|
|
static bool
|
gauss_blur_buffer (SmartPtr<CLBuffer> &buf, int buf_len, int g_radius, float g_sigma)
|
{
|
float *buf_ptr = NULL;
|
float *coeff = NULL;
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
float *tmp_ptr = NULL;
|
|
coeff = get_gauss_coeffs (g_radius, g_sigma);
|
XCAM_ASSERT (coeff);
|
|
ret = buf->enqueue_map((void*&)buf_ptr, 0, buf_len * sizeof (float));
|
XCAM_FAIL_RETURN (ERROR, ret == XCAM_RETURN_NO_ERROR, false, "gauss_blur_buffer failed on enqueue_map");
|
|
tmp_ptr = (float *)xcam_malloc (buf_len * sizeof (float));
|
XCAM_ASSERT (tmp_ptr);
|
for (int i = 0; i < buf_len; ++i) {
|
tmp_ptr[i] = 0.0f;
|
for (int j = -g_radius; j <= (int)g_radius; ++j) {
|
tmp_ptr[i] += buf_ptr[clamp(i + j, 0, buf_len)] * coeff[g_radius + j];
|
}
|
}
|
|
for (int i = 0; i < buf_len; ++i) {
|
buf_ptr[i] = tmp_ptr[i];
|
}
|
xcam_free (tmp_ptr);
|
buf->enqueue_unmap((void*)buf_ptr);
|
return true;
|
}
|
|
PyramidLayer::PyramidLayer ()
|
: blend_width (0)
|
, blend_height (0)
|
{
|
for (int plane = 0; plane < CLBlenderPlaneMax; ++plane) {
|
for (int i = 0; i < XCAM_BLENDER_IMAGE_NUM; ++i) {
|
gauss_offset_x[plane][i] = 0;
|
lap_offset_x[plane][i] = 0;
|
}
|
mask_width [plane] = 0;
|
}
|
}
|
|
CLPyramidBlender::CLPyramidBlender (
|
const SmartPtr<CLContext> &context, const char *name,
|
int layers, bool need_uv, bool need_seam, CLBlenderScaleMode scale_mode)
|
: CLBlender (context, name, need_uv, scale_mode)
|
, _layers (0)
|
, _need_seam (need_seam)
|
, _seam_pos_stride (0)
|
, _seam_width (0)
|
, _seam_height (0)
|
, _seam_pos_offset_x (0)
|
, _seam_pos_valid_width (0)
|
, _seam_mask_done (false)
|
{
|
if (layers <= 1)
|
_layers = 1;
|
else if (layers > XCAM_CL_PYRAMID_MAX_LEVEL)
|
_layers = XCAM_CL_PYRAMID_MAX_LEVEL;
|
else
|
_layers = (uint32_t)layers;
|
}
|
|
CLPyramidBlender::~CLPyramidBlender ()
|
{
|
}
|
|
SmartPtr<CLImage>
|
CLPyramidBlender::get_gauss_image (uint32_t layer, uint32_t buf_index, bool is_uv)
|
{
|
XCAM_ASSERT (layer < _layers);
|
XCAM_ASSERT (buf_index < XCAM_BLENDER_IMAGE_NUM);
|
uint32_t plane = (is_uv ? 1 : 0);
|
return _pyramid_layers[layer].gauss_image[plane][buf_index];
|
}
|
|
SmartPtr<CLImage>
|
CLPyramidBlender::get_lap_image (uint32_t layer, uint32_t buf_index, bool is_uv)
|
{
|
XCAM_ASSERT (layer < _layers);
|
XCAM_ASSERT (buf_index < XCAM_BLENDER_IMAGE_NUM);
|
uint32_t plane = (is_uv ? 1 : 0);
|
|
return _pyramid_layers[layer].lap_image[plane][buf_index];
|
}
|
|
SmartPtr<CLImage>
|
CLPyramidBlender::get_blend_image (uint32_t layer, bool is_uv)
|
{
|
XCAM_ASSERT (layer < _layers);
|
uint32_t plane = (is_uv ? 1 : 0);
|
|
return _pyramid_layers[layer].blend_image[plane][BlendImageIndex];
|
}
|
|
SmartPtr<CLImage>
|
CLPyramidBlender::get_reconstruct_image (uint32_t layer, bool is_uv)
|
{
|
XCAM_ASSERT (layer < _layers);
|
uint32_t plane = (is_uv ? 1 : 0);
|
return _pyramid_layers[layer].blend_image[plane][ReconstructImageIndex];
|
}
|
|
SmartPtr<CLImage>
|
CLPyramidBlender::get_scale_image (bool is_uv)
|
{
|
uint32_t plane = (is_uv ? 1 : 0);
|
return _pyramid_layers[0].scale_image[plane];
|
}
|
|
SmartPtr<CLBuffer>
|
CLPyramidBlender::get_blend_mask (uint32_t layer, bool is_uv)
|
{
|
XCAM_ASSERT (layer < _layers);
|
uint32_t plane = (is_uv ? 1 : 0);
|
return _pyramid_layers[layer].blend_mask[plane];
|
}
|
|
SmartPtr<CLImage>
|
CLPyramidBlender::get_seam_mask (uint32_t layer)
|
{
|
XCAM_ASSERT (layer < _layers);
|
return _pyramid_layers[layer].seam_mask[CLSeamMaskCoeff];
|
}
|
|
const PyramidLayer &
|
CLPyramidBlender::get_pyramid_layer (uint32_t layer) const
|
{
|
return _pyramid_layers[layer];
|
}
|
|
const SmartPtr<CLImage> &
|
CLPyramidBlender::get_image_diff () const
|
{
|
return _image_diff;
|
}
|
|
void
|
CLPyramidBlender::get_seam_info (uint32_t &width, uint32_t &height, uint32_t &stride) const
|
{
|
width = _seam_width;
|
height = _seam_height;
|
stride = _seam_pos_stride;
|
}
|
|
void
|
CLPyramidBlender::get_seam_pos_info (uint32_t &offset_x, uint32_t &valid_width) const
|
{
|
offset_x = _seam_pos_offset_x;
|
valid_width = _seam_pos_valid_width;
|
}
|
|
void
|
PyramidLayer::bind_buf_to_layer0 (
|
SmartPtr<CLContext> context,
|
SmartPtr<VideoBuffer> &input0, SmartPtr<VideoBuffer> &input1, SmartPtr<VideoBuffer> &output,
|
const Rect &merge0_rect, const Rect &merge1_rect, bool need_uv, CLBlenderScaleMode scale_mode)
|
{
|
const VideoBufferInfo &in0_info = input0->get_video_info ();
|
const VideoBufferInfo &in1_info = input1->get_video_info ();
|
const VideoBufferInfo &out_info = output->get_video_info ();
|
int max_plane = (need_uv ? 2 : 1);
|
uint32_t divider_vert[2] = {1, 2};
|
|
XCAM_ASSERT (in0_info.height == in1_info.height);
|
XCAM_ASSERT (merge0_rect.width == merge1_rect.width);
|
|
this->blend_width = XCAM_ALIGN_UP (merge0_rect.width, XCAM_CL_BLENDER_ALIGNMENT_X);
|
this->blend_height = merge0_rect.height;
|
|
CLImageDesc cl_desc;
|
cl_desc.format.image_channel_data_type = CL_UNSIGNED_INT16;
|
cl_desc.format.image_channel_order = CL_RGBA;
|
|
for (int i_plane = 0; i_plane < max_plane; ++i_plane) {
|
cl_desc.width = in0_info.width / 8;
|
cl_desc.height = in0_info.height / divider_vert[i_plane];
|
cl_desc.row_pitch = in0_info.strides[i_plane];
|
this->gauss_image[i_plane][0] = convert_to_climage (context, input0, cl_desc, in0_info.offsets[i_plane]);
|
this->gauss_offset_x[i_plane][0] = merge0_rect.pos_x; // input0 offset
|
|
cl_desc.width = in1_info.width / 8;
|
cl_desc.height = in1_info.height / divider_vert[i_plane];
|
cl_desc.row_pitch = in1_info.strides[i_plane];
|
this->gauss_image[i_plane][1] = convert_to_climage (context, input1, cl_desc, in1_info.offsets[i_plane]);
|
this->gauss_offset_x[i_plane][1] = merge1_rect.pos_x; // input1 offset
|
|
cl_desc.width = out_info.width / 8;
|
cl_desc.height = out_info.height / divider_vert[i_plane];
|
cl_desc.row_pitch = out_info.strides[i_plane];
|
|
if (scale_mode == CLBlenderScaleLocal) {
|
this->scale_image[i_plane] = convert_to_climage (context, output, cl_desc, out_info.offsets[i_plane]);
|
|
cl_desc.width = XCAM_ALIGN_UP (this->blend_width, XCAM_CL_BLENDER_ALIGNMENT_X) / 8;
|
cl_desc.height = XCAM_ALIGN_UP (this->blend_height, divider_vert[i_plane]) / divider_vert[i_plane];
|
uint32_t row_pitch = CLImage::calculate_pixel_bytes (cl_desc.format) *
|
XCAM_ALIGN_UP (cl_desc.width, XCAM_CL_IMAGE_ALIGNMENT_X);
|
uint32_t size = row_pitch * cl_desc.height;
|
SmartPtr<CLBuffer> cl_buf = new CLBuffer (context, size);
|
XCAM_ASSERT (cl_buf.ptr () && cl_buf->is_valid ());
|
cl_desc.row_pitch = row_pitch;
|
this->blend_image[i_plane][ReconstructImageIndex] = new CLImage2D (context, cl_desc, 0, cl_buf);
|
} else {
|
this->blend_image[i_plane][ReconstructImageIndex] =
|
convert_to_climage (context, output, cl_desc, out_info.offsets[i_plane]);
|
}
|
XCAM_ASSERT (this->blend_image[i_plane][ReconstructImageIndex].ptr ());
|
}
|
|
}
|
|
void
|
PyramidLayer::init_layer0 (SmartPtr<CLContext> context, bool last_layer, bool need_uv, int mask_radius, float mask_sigma)
|
{
|
XCAM_ASSERT (this->blend_width && this->blend_height);
|
|
//init mask
|
this->mask_width[0] = this->blend_width;
|
uint32_t mask_size = this->mask_width[0] * sizeof (float);
|
this->blend_mask[0] = new CLBuffer(context, mask_size);
|
float *blend_ptr = NULL;
|
XCamReturn ret = this->blend_mask[0]->enqueue_map((void*&)blend_ptr, 0, mask_size);
|
if (!xcam_ret_is_ok (ret)) {
|
XCAM_LOG_ERROR ("PyramidLayer init layer0 failed in blend_mask mem_map");
|
return;
|
}
|
|
for (uint32_t i_ptr = 0; i_ptr < this->mask_width[0]; ++i_ptr) {
|
if (i_ptr <= this->mask_width[0] / 2)
|
blend_ptr[i_ptr] = 1.0f;
|
else
|
blend_ptr[i_ptr] = 0.0f;
|
}
|
this->blend_mask[0]->enqueue_unmap ((void*)blend_ptr);
|
gauss_blur_buffer (this->blend_mask[0], this->mask_width[0], mask_radius, mask_sigma);
|
|
if (need_uv)
|
copy_mask_from_y_to_uv (context);
|
|
if (last_layer)
|
return;
|
|
int max_plane = (need_uv ? 2 : 1);
|
uint32_t divider_vert[2] = {1, 2};
|
CLImageDesc cl_desc;
|
cl_desc.format.image_channel_data_type = CL_UNSIGNED_INT16;
|
cl_desc.format.image_channel_order = CL_RGBA;
|
for (int i_plane = 0; i_plane < max_plane; ++i_plane) {
|
cl_desc.width = this->blend_width / 8;
|
cl_desc.height = XCAM_ALIGN_UP (this->blend_height, divider_vert[i_plane]) / divider_vert[i_plane];
|
|
this->blend_image[i_plane][BlendImageIndex] = new CLImage2D (context, cl_desc);
|
this->lap_image[i_plane][0] = new CLImage2D (context, cl_desc);
|
this->lap_image[i_plane][1] = new CLImage2D (context, cl_desc);
|
this->lap_offset_x[i_plane][0] = this->lap_offset_x[i_plane][1] = 0;
|
|
#if CL_PYRAMID_ENABLE_DUMP
|
this->dump_gauss_resize[i_plane] = new CLImage2D (context, cl_desc);
|
this->dump_original[i_plane][0] = new CLImage2D (context, cl_desc);
|
this->dump_original[i_plane][1] = new CLImage2D (context, cl_desc);
|
this->dump_final[i_plane] = new CLImage2D (context, cl_desc);
|
#endif
|
}
|
}
|
|
void
|
PyramidLayer::build_cl_images (SmartPtr<CLContext> context, bool last_layer, bool need_uv)
|
{
|
uint32_t size = 0, row_pitch = 0;
|
CLImageDesc cl_desc_set;
|
SmartPtr<CLBuffer> cl_buf;
|
uint32_t divider_vert[2] = {1, 2};
|
uint32_t max_plane = (need_uv ? 2 : 1);
|
|
cl_desc_set.format.image_channel_data_type = CL_UNSIGNED_INT16;
|
cl_desc_set.format.image_channel_order = CL_RGBA;
|
|
for (uint32_t plane = 0; plane < max_plane; ++plane) {
|
for (int i_image = 0; i_image < XCAM_BLENDER_IMAGE_NUM; ++i_image) {
|
cl_desc_set.row_pitch = 0;
|
cl_desc_set.width = XCAM_ALIGN_UP (this->blend_width, XCAM_CL_BLENDER_ALIGNMENT_X) / 8;
|
cl_desc_set.height = XCAM_ALIGN_UP (this->blend_height, divider_vert[plane]) / divider_vert[plane];
|
|
//gauss y image created by cl buffer
|
row_pitch = CLImage::calculate_pixel_bytes (cl_desc_set.format) *
|
XCAM_ALIGN_UP (cl_desc_set.width, XCAM_CL_IMAGE_ALIGNMENT_X);
|
size = row_pitch * cl_desc_set.height;
|
cl_buf = new CLBuffer (context, size);
|
XCAM_ASSERT (cl_buf.ptr () && cl_buf->is_valid ());
|
cl_desc_set.row_pitch = row_pitch;
|
this->gauss_image[plane][i_image] = new CLImage2D (context, cl_desc_set, 0, cl_buf);
|
XCAM_ASSERT (this->gauss_image[plane][i_image].ptr ());
|
this->gauss_offset_x[plane][i_image] = 0; // offset to 0, need recalculate if for deep multi-band blender
|
}
|
|
cl_desc_set.width = XCAM_ALIGN_UP (this->blend_width, XCAM_CL_BLENDER_ALIGNMENT_X) / 8;
|
cl_desc_set.height = XCAM_ALIGN_UP (this->blend_height, divider_vert[plane]) / divider_vert[plane];
|
row_pitch = CLImage::calculate_pixel_bytes (cl_desc_set.format) *
|
XCAM_ALIGN_UP (cl_desc_set.width, XCAM_CL_IMAGE_ALIGNMENT_X);
|
size = row_pitch * cl_desc_set.height;
|
cl_buf = new CLBuffer (context, size);
|
XCAM_ASSERT (cl_buf.ptr () && cl_buf->is_valid ());
|
cl_desc_set.row_pitch = row_pitch;
|
this->blend_image[plane][ReconstructImageIndex] = new CLImage2D (context, cl_desc_set, 0, cl_buf);
|
XCAM_ASSERT (this->blend_image[plane][ReconstructImageIndex].ptr ());
|
#if CL_PYRAMID_ENABLE_DUMP
|
this->dump_gauss_resize[plane] = new CLImage2D (context, cl_desc_set);
|
this->dump_original[plane][0] = new CLImage2D (context, cl_desc_set);
|
this->dump_original[plane][1] = new CLImage2D (context, cl_desc_set);
|
this->dump_final[plane] = new CLImage2D (context, cl_desc_set);
|
#endif
|
if (!last_layer) {
|
cl_desc_set.row_pitch = 0;
|
this->blend_image[plane][BlendImageIndex] = new CLImage2D (context, cl_desc_set);
|
XCAM_ASSERT (this->blend_image[plane][BlendImageIndex].ptr ());
|
for (int i_image = 0; i_image < XCAM_BLENDER_IMAGE_NUM; ++i_image) {
|
this->lap_image[plane][i_image] = new CLImage2D (context, cl_desc_set);
|
XCAM_ASSERT (this->lap_image[plane][i_image].ptr ());
|
this->lap_offset_x[plane][i_image] = 0; // offset to 0, need calculate from next layer if for deep multi-band blender
|
}
|
}
|
}
|
}
|
|
bool
|
PyramidLayer::copy_mask_from_y_to_uv (SmartPtr<CLContext> &context)
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
XCAM_ASSERT (this->mask_width[0]);
|
XCAM_ASSERT (this->blend_mask[0].ptr ());
|
|
this->mask_width[1] = (this->mask_width[0] + 1) / 2;
|
this->blend_mask[1] = new CLBuffer (context, this->mask_width[1] * sizeof(float));
|
XCAM_ASSERT (this->blend_mask[1].ptr ());
|
|
float *from_ptr = NULL;
|
float *to_ptr = NULL;
|
ret = this->blend_mask[1]->enqueue_map ((void*&)to_ptr, 0, this->mask_width[1] * sizeof(float));
|
XCAM_FAIL_RETURN (ERROR, xcam_ret_is_ok (ret), false, "PyramidLayer copy mask failed in blend_mask[1] mem_map");
|
ret = this->blend_mask[0]->enqueue_map((void*&)from_ptr, 0, this->mask_width[0] * sizeof(float));
|
XCAM_FAIL_RETURN (ERROR, xcam_ret_is_ok (ret), false, "PyramidLayer copy mask failed in blend_mask[0] mem_map");
|
|
for (int i = 0; i < (int)this->mask_width[1]; ++i) {
|
if (i * 2 + 1 >= (int)this->mask_width[0]) { // todo i* 2 + 1
|
XCAM_ASSERT (i * 2 < (int)this->mask_width[0]);
|
to_ptr[i] = from_ptr[i * 2] / 2.0f;
|
} else {
|
to_ptr[i] = (from_ptr[i * 2] + from_ptr[i * 2 + 1]) / 2.0f;
|
}
|
}
|
this->blend_mask[1]->enqueue_unmap ((void*)to_ptr);
|
this->blend_mask[0]->enqueue_unmap ((void*)from_ptr);
|
|
return true;
|
}
|
|
void
|
CLPyramidBlender::last_layer_buffer_redirect ()
|
{
|
PyramidLayer &layer = _pyramid_layers[_layers - 1];
|
uint32_t max_plane = (need_uv () ? 2 : 1);
|
|
for (uint32_t plane = 0; plane < max_plane; ++plane) {
|
layer.blend_image[plane][BlendImageIndex] = layer.blend_image[plane][ReconstructImageIndex];
|
|
for (uint32_t i_image = 0; i_image < XCAM_BLENDER_IMAGE_NUM; ++i_image) {
|
layer.lap_image[plane][i_image] = layer.gauss_image[plane][i_image];
|
}
|
}
|
}
|
|
void
|
CLPyramidBlender::dump_layer_mask (uint32_t layer, bool is_uv)
|
{
|
const PyramidLayer &pyr_layer = get_pyramid_layer (layer);
|
int plane = (is_uv ? 1 : 0);
|
|
float *mask_ptr = NULL;
|
XCamReturn ret = pyr_layer.blend_mask[plane]->enqueue_map ((void*&)mask_ptr, 0, pyr_layer.mask_width[plane] * sizeof(float));
|
if (!xcam_ret_is_ok (ret)) {
|
XCAM_LOG_ERROR ("CLPyramidBlender dump mask failed in blend_mask(layer:%d) mem_map", layer);
|
return;
|
}
|
|
printf ("layer(%d)(-%s) mask, width:%d\n", layer, (is_uv ? "UV" : "Y"), pyr_layer.mask_width[plane]);
|
for (uint32_t i = 0; i < pyr_layer.mask_width[plane]; ++i) {
|
printf ("%.03f\t", mask_ptr[i]);
|
}
|
printf ("\n");
|
|
pyr_layer.blend_mask[plane]->enqueue_unmap ((void*)mask_ptr);
|
}
|
|
static bool
|
gauss_fill_mask (
|
SmartPtr<CLContext> context, PyramidLayer &prev, PyramidLayer &to, bool need_uv,
|
int mask_radius, float mask_sigma)
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
uint32_t mask_size = to.blend_width * sizeof (float);
|
uint32_t prev_size = prev.mask_width[0] * sizeof (float);
|
float *pre_ptr = NULL;
|
int i;
|
|
//gauss to[0]
|
to.mask_width[0] = to.blend_width;
|
to.blend_mask[0] = new CLBuffer (context, mask_size);
|
XCAM_ASSERT (to.blend_mask[0].ptr ());
|
float *mask0_ptr = NULL;
|
ret = to.blend_mask[0]->enqueue_map((void*&)mask0_ptr, 0, mask_size);
|
XCAM_FAIL_RETURN (ERROR, xcam_ret_is_ok (ret), false, "gauss_fill_mask failed in destination image mem_map");
|
|
ret = prev.blend_mask[0]->enqueue_map((void*&)pre_ptr, 0, prev_size);
|
XCAM_FAIL_RETURN (ERROR, xcam_ret_is_ok (ret), false, "gauss_fill_mask failed in source image mem_map");
|
|
for (i = 0; i < (int)to.blend_width; ++i) {
|
if (i * 2 + 1 >= (int)prev.mask_width[0]) { // todo i* 2 + 1
|
XCAM_ASSERT (i * 2 < (int)prev.mask_width[0]);
|
mask0_ptr[i] = pre_ptr[i * 2] / 2.0f;
|
} else {
|
mask0_ptr[i] = (pre_ptr[i * 2] + pre_ptr[i * 2 + 1]) / 2.0f;
|
}
|
}
|
prev.blend_mask[0]->enqueue_unmap ((void*)pre_ptr);
|
to.blend_mask[0]->enqueue_unmap ((void*)mask0_ptr);
|
|
gauss_blur_buffer (to.blend_mask[0], to.mask_width[0], mask_radius, mask_sigma);
|
|
if (need_uv)
|
to.copy_mask_from_y_to_uv (context);
|
|
return true;
|
}
|
|
XCamReturn
|
CLPyramidBlender::allocate_cl_buffers (
|
SmartPtr<CLContext> context,
|
SmartPtr<VideoBuffer> &input0, SmartPtr<VideoBuffer> &input1,
|
SmartPtr<VideoBuffer> &output)
|
{
|
uint32_t index = 0;
|
const Rect & window = get_merge_window ();
|
bool need_reallocate = true;
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
|
BLENDER_PROFILING_START (allocate_cl_buffers);
|
|
need_reallocate =
|
(window.width != (int32_t)_pyramid_layers[0].blend_width ||
|
(window.height != 0 && window.height != (int32_t)_pyramid_layers[0].blend_height));
|
_pyramid_layers[0].bind_buf_to_layer0 (
|
context, input0, input1, output,
|
get_input_merge_area (0), get_input_merge_area (1),
|
need_uv (), get_scale_mode ());
|
|
if (need_reallocate) {
|
int g_radius = (((float)(window.width - 1) / 2) / (1 << _layers)) * 1.2f;
|
float g_sigma = (float)g_radius;
|
|
_pyramid_layers[0].init_layer0 (context, (0 == _layers - 1), need_uv(), g_radius, g_sigma);
|
|
for (index = 1; index < _layers; ++index) {
|
_pyramid_layers[index].blend_width = (_pyramid_layers[index - 1].blend_width + 1) / 2;
|
_pyramid_layers[index].blend_height = (_pyramid_layers[index - 1].blend_height + 1) / 2;
|
|
_pyramid_layers[index].build_cl_images (context, (index == _layers - 1), need_uv ());
|
if (!_need_seam) {
|
gauss_fill_mask (context, _pyramid_layers[index - 1], _pyramid_layers[index], need_uv (), g_radius, g_sigma);
|
}
|
}
|
|
if (_need_seam) {
|
ret = init_seam_buffers (context);
|
XCAM_FAIL_RETURN (ERROR, ret == XCAM_RETURN_NO_ERROR, ret, "CLPyramidBlender init seam buffer failed");
|
}
|
}
|
|
//last layer buffer redirect
|
last_layer_buffer_redirect ();
|
_seam_mask_done = false;
|
|
BLENDER_PROFILING_END (allocate_cl_buffers, 50);
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
CLPyramidBlender::init_seam_buffers (SmartPtr<CLContext> context)
|
{
|
const PyramidLayer &layer0 = get_pyramid_layer (0);
|
CLImageDesc cl_desc;
|
|
_seam_width = layer0.blend_width;
|
_seam_height = layer0.blend_height;
|
_seam_pos_stride = XCAM_ALIGN_UP (_seam_width, 64); // need a buffer large enough to avoid judgement in kernel
|
_seam_pos_offset_x = XCAM_ALIGN_UP (_seam_width / 4, XCAM_CL_BLENDER_ALIGNMENT_X);
|
if (_seam_pos_offset_x >= _seam_width)
|
_seam_pos_offset_x = 0;
|
_seam_pos_valid_width = XCAM_ALIGN_DOWN (_seam_width / 2, XCAM_CL_BLENDER_ALIGNMENT_X);
|
if (_seam_pos_valid_width <= 0)
|
_seam_pos_valid_width = XCAM_CL_BLENDER_ALIGNMENT_X;
|
XCAM_ASSERT (_seam_pos_offset_x + _seam_pos_valid_width <= _seam_width);
|
|
XCAM_ASSERT (layer0.blend_width > 0 && layer0.blend_height > 0);
|
cl_desc.format.image_channel_data_type = CL_UNSIGNED_INT16;
|
cl_desc.format.image_channel_order = CL_RGBA;
|
cl_desc.width = _seam_width / 8;
|
cl_desc.height = _seam_height;
|
cl_desc.row_pitch = CLImage::calculate_pixel_bytes (cl_desc.format) *
|
XCAM_ALIGN_UP (cl_desc.width, XCAM_CL_IMAGE_ALIGNMENT_X);
|
|
uint32_t image_diff_size = cl_desc.row_pitch * _seam_height;
|
SmartPtr<CLBuffer> cl_diff_buf = new CLBuffer (context, image_diff_size);
|
XCAM_FAIL_RETURN (
|
ERROR,
|
cl_diff_buf.ptr () && cl_diff_buf->is_valid (),
|
XCAM_RETURN_ERROR_CL,
|
"CLPyramidBlender init seam buffer failed to create image_difference buffers");
|
|
_image_diff = new CLImage2D (context, cl_desc, 0, cl_diff_buf);
|
XCAM_FAIL_RETURN (
|
ERROR,
|
_image_diff.ptr () && _image_diff->is_valid (),
|
XCAM_RETURN_ERROR_CL,
|
"CLPyramidBlender init seam buffer failed to bind image_difference data");
|
|
uint32_t pos_buf_size = sizeof (SEAM_POS_TYPE) * _seam_pos_stride * _seam_height;
|
uint32_t sum_buf_size = sizeof (SEAM_SUM_TYPE) * _seam_pos_stride * 2; // 2 lines
|
_seam_pos_buf = new CLBuffer (context, pos_buf_size, CL_MEM_READ_WRITE);
|
_seam_sum_buf = new CLBuffer (context, sum_buf_size, CL_MEM_READ_WRITE);
|
XCAM_FAIL_RETURN (
|
ERROR,
|
_seam_pos_buf.ptr () && _seam_pos_buf->is_valid () &&
|
_seam_sum_buf.ptr () && _seam_sum_buf->is_valid (),
|
XCAM_RETURN_ERROR_CL,
|
"CLPyramidBlender init seam buffer failed to create seam buffers");
|
|
uint32_t mask_width = XCAM_ALIGN_UP(_seam_width, XCAM_CL_BLENDER_ALIGNMENT_X);
|
uint32_t mask_height = XCAM_ALIGN_UP(_seam_height, 2);
|
for (uint32_t i = 0; i < _layers; ++i) {
|
cl_desc.format.image_channel_data_type = CL_UNSIGNED_INT16;
|
cl_desc.format.image_channel_order = CL_RGBA;
|
cl_desc.width = mask_width / 8;
|
cl_desc.height = mask_height;
|
cl_desc.row_pitch = CLImage::calculate_pixel_bytes (cl_desc.format) *
|
XCAM_ALIGN_UP (cl_desc.width, XCAM_CL_IMAGE_ALIGNMENT_X);
|
|
uint32_t mask_size = cl_desc.row_pitch * mask_height;
|
SmartPtr<CLBuffer> cl_buf0 = new CLBuffer (context, mask_size);
|
SmartPtr<CLBuffer> cl_buf1 = new CLBuffer (context, mask_size);
|
XCAM_ASSERT (cl_buf0.ptr () && cl_buf0->is_valid () && cl_buf1.ptr () && cl_buf1->is_valid ());
|
|
_pyramid_layers[i].seam_mask[CLSeamMaskTmp] = new CLImage2D (context, cl_desc, 0, cl_buf0);
|
_pyramid_layers[i].seam_mask[CLSeamMaskCoeff] = new CLImage2D (context, cl_desc, 0, cl_buf1);
|
XCAM_FAIL_RETURN (
|
ERROR,
|
_pyramid_layers[i].seam_mask[CLSeamMaskTmp].ptr () && _pyramid_layers[i].seam_mask[CLSeamMaskTmp]->is_valid () &&
|
_pyramid_layers[i].seam_mask[CLSeamMaskCoeff].ptr () && _pyramid_layers[i].seam_mask[CLSeamMaskCoeff]->is_valid (),
|
XCAM_RETURN_ERROR_CL,
|
"CLPyramidBlender init seam buffer failed to create seam_mask buffer");
|
|
mask_width = XCAM_ALIGN_UP(mask_width / 2, XCAM_CL_BLENDER_ALIGNMENT_X);
|
mask_height = XCAM_ALIGN_UP(mask_height / 2, 2);
|
}
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
static void
|
assign_mask_line (SEAM_MASK_TYPE *mask_ptr, int line, int stride, int delimiter)
|
{
|
#define MASK_1 0xFFFF
|
#define MASK_0 0x00
|
|
SEAM_MASK_TYPE *line_ptr = mask_ptr + line * stride;
|
int mask_1_len = delimiter + 1;
|
|
memset (line_ptr, MASK_1, sizeof (SEAM_MASK_TYPE) * mask_1_len);
|
memset (line_ptr + mask_1_len, MASK_0, sizeof (SEAM_MASK_TYPE) * (stride - mask_1_len));
|
}
|
|
XCamReturn
|
CLPyramidBlender::fill_seam_mask ()
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
XCAM_ASSERT (_seam_pos_buf.ptr () && _seam_sum_buf.ptr ());
|
uint32_t pos_buf_size = sizeof (SEAM_POS_TYPE) * _seam_pos_stride * _seam_height;
|
uint32_t sum_buf_size = sizeof (SEAM_SUM_TYPE) * _seam_pos_stride * 2;
|
SEAM_SUM_TYPE *sum_ptr;
|
SEAM_POS_TYPE *pos_ptr;
|
SEAM_MASK_TYPE *mask_ptr;
|
|
if (_seam_mask_done)
|
return XCAM_RETURN_NO_ERROR;
|
|
ret = _seam_sum_buf->enqueue_map ((void *&)sum_ptr, 0, sum_buf_size, CL_MAP_READ);
|
XCAM_FAIL_RETURN (ERROR, ret == XCAM_RETURN_NO_ERROR, ret, "CLPyramidBlender map seam_sum_buf failed");
|
|
float min_sum = 9999999999.0f, tmp_sum;
|
int pos = 0, min_pos0, min_pos1;
|
int i = 0;
|
SEAM_SUM_TYPE *sum_ptr0 = sum_ptr, *sum_ptr1 = sum_ptr + _seam_pos_stride;
|
for (i = (int)_seam_pos_offset_x; i < (int)(_seam_pos_offset_x + _seam_pos_valid_width); ++i) {
|
tmp_sum = sum_ptr0[i] + sum_ptr1[i];
|
if (tmp_sum >= min_sum)
|
continue;
|
pos = (int)i;
|
min_sum = tmp_sum;
|
}
|
_seam_sum_buf->enqueue_unmap ((void*)sum_ptr);
|
min_pos0 = min_pos1 = pos;
|
|
BLENDER_PROFILING_START (fill_seam_mask);
|
|
// reset layer0 seam_mask
|
SmartPtr<CLImage> seam_mask = _pyramid_layers[0].seam_mask[CLSeamMaskTmp];
|
const CLImageDesc &mask_desc = seam_mask->get_image_desc ();
|
size_t mask_origin[3] = {0, 0, 0};
|
size_t mask_region[3] = {mask_desc.width, mask_desc.height, 1};
|
size_t mask_row_pitch;
|
size_t mask_slice_pitch;
|
ret = seam_mask->enqueue_map ((void *&)mask_ptr, mask_origin, mask_region,
|
&mask_row_pitch, &mask_slice_pitch, CL_MAP_READ);
|
XCAM_FAIL_RETURN (ERROR, ret == XCAM_RETURN_NO_ERROR, ret, "CLPyramidBlender map seam_mask failed");
|
uint32_t mask_stride = mask_row_pitch / sizeof (SEAM_MASK_TYPE);
|
ret = _seam_pos_buf->enqueue_map ((void *&)pos_ptr, 0, pos_buf_size, CL_MAP_READ);
|
XCAM_FAIL_RETURN (ERROR, ret == XCAM_RETURN_NO_ERROR, ret, "CLPyramidBlender map seam_pos_buf failed");
|
//printf ("***********min sum:%.3f, pos:%d, sum0:%.3f, sum1:%.3f\n", min_sum, pos, sum_ptr0[pos], sum_ptr1[pos]);
|
for (i = _seam_height / 2 - 1; i >= 0; --i) {
|
assign_mask_line (mask_ptr, i, mask_stride, min_pos0);
|
min_pos0 = pos_ptr [i * _seam_pos_stride + min_pos0];
|
}
|
|
for (i = _seam_height / 2; i < (int)_seam_height; ++i) {
|
assign_mask_line (mask_ptr, i, mask_stride, min_pos1);
|
min_pos1 = pos_ptr [i * _seam_pos_stride + min_pos1];
|
}
|
for (; i < (int)mask_desc.height; ++i) {
|
assign_mask_line (mask_ptr, i, mask_stride, min_pos1);
|
}
|
|
seam_mask->enqueue_unmap ((void*)mask_ptr);
|
_seam_pos_buf->enqueue_unmap ((void*)pos_ptr);
|
|
_seam_mask_done = true;
|
|
BLENDER_PROFILING_END (fill_seam_mask, 50);
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
CLPyramidBlender::execute_done (SmartPtr<VideoBuffer> &output)
|
{
|
int max_plane = (need_uv () ? 2 : 1);
|
XCAM_UNUSED (output);
|
|
#if CL_PYRAMID_ENABLE_DUMP
|
dump_buffers ();
|
#endif
|
|
for (int i_plane = 0; i_plane < max_plane; ++i_plane) {
|
_pyramid_layers[0].gauss_image[i_plane][0].release ();
|
_pyramid_layers[0].gauss_image[i_plane][1].release ();
|
_pyramid_layers[0].blend_image[i_plane][ReconstructImageIndex].release ();
|
|
if (_layers <= 1) {
|
_pyramid_layers[_layers - 1].blend_image[i_plane][BlendImageIndex].release ();
|
_pyramid_layers[_layers - 1].lap_image[i_plane][0].release ();
|
_pyramid_layers[_layers - 1].lap_image[i_plane][1].release ();
|
}
|
}
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
CLPyramidBlendKernel::CLPyramidBlendKernel (
|
const SmartPtr<CLContext> &context, SmartPtr<CLPyramidBlender> &blender,
|
uint32_t layer, bool is_uv, bool need_seam)
|
: CLImageKernel (context)
|
, _blender (blender)
|
, _layer (layer)
|
, _is_uv (is_uv)
|
, _need_seam (need_seam)
|
{
|
}
|
|
XCamReturn
|
CLPyramidBlendKernel::prepare_arguments (CLArgList &args, CLWorkSize &work_size)
|
{
|
SmartPtr<CLContext> context = get_context ();
|
|
SmartPtr<CLImage> image_in0 = get_input_0 ();
|
SmartPtr<CLImage> image_in1 = get_input_1 ();
|
SmartPtr<CLImage> image_out = get_output ();
|
SmartPtr<CLMemory> buf_mask;
|
if (_need_seam)
|
buf_mask = get_seam_mask ();
|
else
|
buf_mask = get_blend_mask ();
|
|
XCAM_ASSERT (image_in0.ptr () && image_in1.ptr () && image_out.ptr ());
|
const CLImageDesc &cl_desc_out = image_out->get_image_desc ();
|
|
args.push_back (new CLMemArgument (image_in0));
|
args.push_back (new CLMemArgument (image_in1));
|
args.push_back (new CLMemArgument (buf_mask));
|
args.push_back (new CLMemArgument (image_out));
|
|
work_size.dim = XCAM_DEFAULT_IMAGE_DIM;
|
work_size.local[0] = 8;
|
work_size.local[1] = 8;
|
work_size.global[0] = XCAM_ALIGN_UP (cl_desc_out.width, work_size.local[0]);
|
work_size.global[1] = XCAM_ALIGN_UP (cl_desc_out.height, work_size.local[1]);
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
CLPyramidTransformKernel::CLPyramidTransformKernel (
|
const SmartPtr<CLContext> &context,
|
SmartPtr<CLPyramidBlender> &blender,
|
uint32_t layer,
|
uint32_t buf_index,
|
bool is_uv)
|
: CLImageKernel (context)
|
, _blender (blender)
|
, _layer (layer)
|
, _buf_index (buf_index)
|
, _is_uv (is_uv)
|
{
|
XCAM_ASSERT (layer <= XCAM_CL_PYRAMID_MAX_LEVEL);
|
XCAM_ASSERT (buf_index <= XCAM_BLENDER_IMAGE_NUM);
|
}
|
|
static bool
|
change_image_format (
|
SmartPtr<CLContext> context, SmartPtr<CLImage> input,
|
SmartPtr<CLImage> &output, const CLImageDesc &new_desc)
|
{
|
SmartPtr<CLImage2D> previous = input.dynamic_cast_ptr<CLImage2D> ();
|
if (!previous.ptr () || !previous->get_bind_buf ().ptr ())
|
return false;
|
|
SmartPtr<CLBuffer> bind_buf = previous->get_bind_buf ();
|
output = new CLImage2D (context, new_desc, 0, bind_buf);
|
if (!output.ptr ())
|
return false;
|
return true;
|
}
|
|
int32_t
|
CLPyramidTransformKernel::get_input_gauss_offset_x ()
|
{
|
const PyramidLayer &layer = _blender->get_pyramid_layer (_layer);
|
uint32_t plane_index = (_is_uv ? 1 : 0);
|
return layer.gauss_offset_x[plane_index][_buf_index];
|
}
|
|
XCamReturn
|
CLPyramidTransformKernel::prepare_arguments (CLArgList &args, CLWorkSize &work_size)
|
{
|
SmartPtr<CLContext> context = get_context ();
|
|
SmartPtr<CLImage> image_in_gauss = get_input_gauss();
|
SmartPtr<CLImage> image_out_gauss = get_output_gauss();
|
//SmartPtr<CLImage> image_out_lap = get_output_lap ();
|
const CLImageDesc &cl_desc_out_gauss_pre = image_out_gauss->get_image_desc ();
|
|
CLImageDesc cl_desc_out_gauss;
|
cl_desc_out_gauss.format.image_channel_data_type = CL_UNSIGNED_INT8;
|
cl_desc_out_gauss.format.image_channel_order = CL_RGBA;
|
cl_desc_out_gauss.width = cl_desc_out_gauss_pre.width * 2;
|
cl_desc_out_gauss.height = cl_desc_out_gauss_pre.height;
|
cl_desc_out_gauss.row_pitch = cl_desc_out_gauss_pre.row_pitch;
|
SmartPtr<CLImage> format_image_out;
|
change_image_format (context, image_out_gauss, format_image_out, cl_desc_out_gauss);
|
XCAM_FAIL_RETURN (
|
ERROR,
|
format_image_out.ptr () && format_image_out->is_valid (),
|
XCAM_RETURN_ERROR_CL,
|
"CLPyramidTransformKernel change output gauss image format failed");
|
|
int gauss_offset_x = get_input_gauss_offset_x () / 8;
|
XCAM_ASSERT (gauss_offset_x * 8 == get_input_gauss_offset_x ());
|
|
args.push_back (new CLMemArgument (image_in_gauss));
|
args.push_back (new CLArgumentT<int> (gauss_offset_x));
|
args.push_back (new CLMemArgument (format_image_out));
|
|
#if CL_PYRAMID_ENABLE_DUMP
|
int plane = _is_uv ? 1 : 0;
|
SmartPtr<CLImage> dump_original = _blender->get_pyramid_layer (_layer).dump_original[plane][_buf_index];
|
|
args.push_back (new CLMemArgument (dump_original));
|
|
printf ("L%dI%d: gauss_offset_x:%d \n", _layer, _buf_index, gauss_offset_x);
|
#endif
|
|
const int workitem_lines = 2;
|
int gloabal_y = XCAM_ALIGN_UP (cl_desc_out_gauss.height, workitem_lines) / workitem_lines;
|
work_size.dim = XCAM_DEFAULT_IMAGE_DIM;
|
work_size.local[0] = 16;
|
work_size.local[1] = 4;
|
work_size.global[0] = XCAM_ALIGN_UP (cl_desc_out_gauss.width, work_size.local[0]);
|
work_size.global[1] = XCAM_ALIGN_UP (gloabal_y, work_size.local[1]);
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
CLSeamDiffKernel::CLSeamDiffKernel (
|
const SmartPtr<CLContext> &context, SmartPtr<CLPyramidBlender> &blender)
|
: CLImageKernel (context)
|
, _blender (blender)
|
{
|
}
|
|
XCamReturn
|
CLSeamDiffKernel::prepare_arguments (CLArgList &args, CLWorkSize &work_size)
|
{
|
const PyramidLayer &layer0 = _blender->get_pyramid_layer (0);
|
SmartPtr<CLImage> image0 = layer0.gauss_image[CLBlenderPlaneY][0];
|
SmartPtr<CLImage> image1 = layer0.gauss_image[CLBlenderPlaneY][1];
|
SmartPtr<CLImage> out_diff = _blender->get_image_diff ();
|
CLImageDesc out_diff_desc = out_diff->get_image_desc ();
|
|
int image_offset_x[XCAM_BLENDER_IMAGE_NUM];
|
|
for (uint32_t i = 0; i < XCAM_BLENDER_IMAGE_NUM; ++i) {
|
image_offset_x[i] = layer0.gauss_offset_x[CLBlenderPlaneY][i] / 8;
|
}
|
|
args.push_back (new CLMemArgument (image0));
|
args.push_back (new CLArgumentT<int> (image_offset_x[0]));
|
args.push_back (new CLMemArgument (image1));
|
args.push_back (new CLArgumentT<int> (image_offset_x[1]));
|
args.push_back (new CLMemArgument (out_diff));
|
|
work_size.dim = XCAM_DEFAULT_IMAGE_DIM;
|
work_size.local[0] = 8;
|
work_size.local[1] = 4;
|
work_size.global[0] = XCAM_ALIGN_UP (out_diff_desc.width, work_size.local[0]);
|
work_size.global[1] = XCAM_ALIGN_UP (out_diff_desc.height, work_size.local[1]);
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
CLSeamDPKernel::CLSeamDPKernel (
|
const SmartPtr<CLContext> &context, SmartPtr<CLPyramidBlender> &blender)
|
: CLImageKernel (context)
|
, _blender (blender)
|
{
|
}
|
|
XCamReturn
|
CLSeamDPKernel::prepare_arguments (CLArgList &args, CLWorkSize &work_size)
|
{
|
#define ELEMENT_PIXEL 1
|
|
uint32_t width, height, stride;
|
uint32_t pos_offset_x, pos_valid_width;
|
_blender->get_seam_info (width, height, stride);
|
_blender->get_seam_pos_info (pos_offset_x, pos_valid_width);
|
int seam_height = (int)height;
|
int seam_stride = (int)stride / ELEMENT_PIXEL;
|
int seam_offset_x = (int)pos_offset_x / ELEMENT_PIXEL; // ushort8
|
int seam_valid_with = (int)pos_valid_width / ELEMENT_PIXEL;
|
int max_pos = (int)(pos_offset_x + pos_valid_width - 1);
|
|
SmartPtr<CLImage> image = _blender->get_image_diff ();
|
SmartPtr<CLBuffer> pos_buf = _blender->get_seam_pos_buf ();
|
SmartPtr<CLBuffer> sum_buf = _blender->get_seam_sum_buf ();
|
XCAM_ASSERT (image.ptr () && pos_buf.ptr () && sum_buf.ptr ());
|
|
CLImageDesc cl_orig = image->get_image_desc ();
|
CLImageDesc cl_desc_convert;
|
cl_desc_convert.format.image_channel_data_type = CL_UNSIGNED_INT8;
|
cl_desc_convert.format.image_channel_order = CL_R;
|
cl_desc_convert.width = cl_orig.width * (8 / ELEMENT_PIXEL);
|
cl_desc_convert.height = cl_orig.height;
|
cl_desc_convert.row_pitch = cl_orig.row_pitch;
|
|
SmartPtr<CLImage> convert_image;
|
change_image_format (get_context (), image, convert_image, cl_desc_convert);
|
XCAM_ASSERT (convert_image.ptr () && convert_image->is_valid ());
|
|
args.push_back (new CLMemArgument (convert_image));
|
args.push_back (new CLMemArgument (pos_buf));
|
args.push_back (new CLMemArgument (sum_buf));
|
args.push_back (new CLArgumentT<int> (seam_offset_x));
|
args.push_back (new CLArgumentT<int> (seam_valid_with));
|
args.push_back (new CLArgumentT<int> (max_pos));
|
args.push_back (new CLArgumentT<int> (seam_height));
|
args.push_back (new CLArgumentT<int> (seam_stride));
|
|
work_size.dim = 1;
|
work_size.local[0] = XCAM_ALIGN_UP(seam_valid_with, 16);
|
work_size.global[0] = work_size.local[0] * 2;
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
CLPyramidSeamMaskKernel::CLPyramidSeamMaskKernel (
|
const SmartPtr<CLContext> &context, SmartPtr<CLPyramidBlender> &blender,
|
uint32_t layer, bool scale, bool need_slm)
|
: CLImageKernel (context)
|
, _blender (blender)
|
, _layer (layer)
|
, _need_scale (scale)
|
, _need_slm (need_slm)
|
{
|
XCAM_ASSERT (layer < blender->get_layers ());
|
}
|
|
XCamReturn
|
CLPyramidSeamMaskKernel::prepare_arguments (CLArgList &args, CLWorkSize &work_size)
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
ret = _blender->fill_seam_mask ();
|
XCAM_FAIL_RETURN (ERROR, ret == XCAM_RETURN_NO_ERROR, ret, "CLPyramidSeamMaskKernel fill seam mask failed");
|
|
SmartPtr<CLContext> context = get_context ();
|
const PyramidLayer &cur_layer = _blender->get_pyramid_layer (_layer);
|
SmartPtr<CLImage> input_image = cur_layer.seam_mask[CLSeamMaskTmp];
|
SmartPtr<CLImage> out_gauss = cur_layer.seam_mask[CLSeamMaskCoeff];
|
CLImageDesc out_gauss_desc = out_gauss->get_image_desc ();
|
|
XCAM_ASSERT (input_image.ptr () && out_gauss.ptr ());
|
XCAM_ASSERT (input_image->is_valid () && out_gauss->is_valid ());
|
|
args.push_back (new CLMemArgument (input_image));
|
args.push_back (new CLMemArgument (out_gauss));
|
|
|
|
if (_need_slm) {
|
int image_width = out_gauss_desc.width;
|
args.push_back (new CLArgumentT<int> (image_width));
|
}
|
|
if (_need_scale) {
|
const PyramidLayer &next_layer = _blender->get_pyramid_layer (_layer + 1);
|
SmartPtr<CLImage> out_orig = next_layer.seam_mask[CLSeamMaskTmp];
|
CLImageDesc input_desc, output_desc;
|
input_desc = out_orig->get_image_desc ();
|
output_desc.format.image_channel_data_type = CL_UNSIGNED_INT8;
|
output_desc.format.image_channel_order = CL_RGBA;
|
output_desc.width = input_desc.width * 2;
|
output_desc.height = input_desc.height;
|
output_desc.row_pitch = input_desc.row_pitch;
|
|
SmartPtr<CLImage> output_scale_image;
|
change_image_format (context, out_orig, output_scale_image, output_desc);
|
args.push_back (new CLMemArgument (output_scale_image));
|
}
|
|
uint32_t workitem_height = XCAM_ALIGN_UP (out_gauss_desc.height, 2) / 2;
|
|
work_size.dim = XCAM_DEFAULT_IMAGE_DIM;
|
|
if (_need_slm) {
|
work_size.local[0] = XCAM_ALIGN_UP (out_gauss_desc.width, 16);
|
work_size.local[1] = 1;
|
work_size.global[0] = work_size.local[0];
|
work_size.global[1] = workitem_height;
|
} else {
|
work_size.local[0] = 8;
|
work_size.local[1] = 4;
|
work_size.global[0] = XCAM_ALIGN_UP (out_gauss_desc.width, work_size.local[0]);
|
work_size.global[1] = XCAM_ALIGN_UP (workitem_height, work_size.local[1]);
|
}
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
CLPyramidLapKernel::CLPyramidLapKernel (
|
const SmartPtr<CLContext> &context,
|
SmartPtr<CLPyramidBlender> &blender,
|
uint32_t layer,
|
uint32_t buf_index,
|
bool is_uv)
|
: CLImageKernel (context)
|
, _blender (blender)
|
, _layer (layer)
|
, _buf_index (buf_index)
|
, _is_uv (is_uv)
|
{
|
XCAM_ASSERT (layer <= XCAM_CL_PYRAMID_MAX_LEVEL);
|
XCAM_ASSERT (buf_index <= XCAM_BLENDER_IMAGE_NUM);
|
}
|
|
int32_t
|
CLPyramidLapKernel::get_cur_gauss_offset_x ()
|
{
|
const PyramidLayer &layer = _blender->get_pyramid_layer (_layer);
|
uint32_t plane_index = (_is_uv ? 1 : 0);
|
return layer.gauss_offset_x[plane_index][_buf_index];
|
}
|
|
int32_t
|
CLPyramidLapKernel::get_output_lap_offset_x ()
|
{
|
const PyramidLayer &layer = _blender->get_pyramid_layer (_layer);
|
uint32_t plane_index = (_is_uv ? 1 : 0);
|
return layer.lap_offset_x[plane_index][_buf_index];
|
}
|
|
XCamReturn
|
CLPyramidLapKernel::prepare_arguments (CLArgList &args, CLWorkSize &work_size)
|
{
|
SmartPtr<CLContext> context = get_context ();
|
|
SmartPtr<CLImage> cur_gauss_image = get_current_gauss();
|
SmartPtr<CLImage> next_gauss_image_tmp = get_next_gauss();
|
SmartPtr<CLImage> image_out_lap = get_output_lap ();
|
const CLImageDesc &cl_desc_next_gauss_tmp = next_gauss_image_tmp->get_image_desc ();
|
const CLImageDesc &cl_desc_out_lap = image_out_lap->get_image_desc ();
|
float next_gauss_pixel_width = 0.0f, next_gauss_pixel_height = 0.0f;
|
|
CLImageDesc cl_desc_next_gauss;
|
if (!_is_uv) {
|
cl_desc_next_gauss.format.image_channel_data_type = CL_UNORM_INT8;
|
cl_desc_next_gauss.format.image_channel_order = CL_R;
|
cl_desc_next_gauss.width = cl_desc_next_gauss_tmp.width * 8;
|
} else {
|
cl_desc_next_gauss.format.image_channel_data_type = CL_UNORM_INT8;
|
cl_desc_next_gauss.format.image_channel_order = CL_RG;
|
cl_desc_next_gauss.width = cl_desc_next_gauss_tmp.width * 4;
|
}
|
cl_desc_next_gauss.height = cl_desc_next_gauss_tmp.height;
|
cl_desc_next_gauss.row_pitch = cl_desc_next_gauss_tmp.row_pitch;
|
SmartPtr<CLImage> next_gauss;
|
change_image_format (context, next_gauss_image_tmp, next_gauss, cl_desc_next_gauss);
|
XCAM_FAIL_RETURN (
|
ERROR,
|
next_gauss.ptr () && next_gauss->is_valid (),
|
XCAM_RETURN_ERROR_CL,
|
"CLPyramidTransformKernel change output gauss image format failed");
|
|
next_gauss_pixel_width = cl_desc_next_gauss.width;
|
next_gauss_pixel_height = cl_desc_next_gauss.height;
|
|
// out format(current layer): CL_UNSIGNED_INT16 + CL_RGBA
|
float out_width = CLImage::calculate_pixel_bytes (cl_desc_next_gauss.format) * cl_desc_next_gauss.width * 2.0f / 8.0f;
|
float out_height = next_gauss_pixel_height * 2.0f;
|
float sampler_offset_x = SAMPLER_POSITION_OFFSET / next_gauss_pixel_width;
|
float sampler_offset_y = SAMPLER_POSITION_OFFSET / next_gauss_pixel_height;
|
|
int cur_gauss_offset_x = get_cur_gauss_offset_x () / 8;
|
XCAM_ASSERT (cur_gauss_offset_x * 8 == get_cur_gauss_offset_x ());
|
int lap_offset_x = get_output_lap_offset_x () / 8;
|
XCAM_ASSERT (lap_offset_x * 8 == get_output_lap_offset_x ());
|
|
args.push_back (new CLMemArgument (cur_gauss_image));
|
args.push_back (new CLArgumentT<int> (cur_gauss_offset_x));
|
args.push_back (new CLMemArgument (next_gauss));
|
args.push_back (new CLArgumentT<float> (sampler_offset_x));
|
args.push_back (new CLArgumentT<float> (sampler_offset_y));
|
args.push_back (new CLMemArgument (image_out_lap));
|
args.push_back (new CLArgumentT<int> (lap_offset_x));
|
args.push_back (new CLArgumentT<float> (out_width));
|
args.push_back (new CLArgumentT<float> (out_height));
|
|
work_size.dim = XCAM_DEFAULT_IMAGE_DIM;
|
work_size.local[0] = 8;
|
work_size.local[1] = 4;
|
work_size.global[0] = XCAM_ALIGN_UP (cl_desc_out_lap.width, work_size.local[0]);
|
work_size.global[1] = XCAM_ALIGN_UP (cl_desc_out_lap.height, work_size.local[1]);
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
CLPyramidReconstructKernel::CLPyramidReconstructKernel (
|
const SmartPtr<CLContext> &context, SmartPtr<CLPyramidBlender> &blender,
|
uint32_t layer, bool is_uv)
|
: CLImageKernel (context)
|
, _blender (blender)
|
, _layer (layer)
|
, _is_uv (is_uv)
|
{
|
XCAM_ASSERT (layer <= XCAM_CL_PYRAMID_MAX_LEVEL);
|
}
|
|
int
|
CLPyramidReconstructKernel::get_output_reconstrcut_offset_x ()
|
{
|
if (_layer > 0)
|
return 0;
|
const Rect & window = _blender->get_merge_window ();
|
XCAM_ASSERT (window.pos_x % XCAM_CL_BLENDER_ALIGNMENT_X == 0);
|
return window.pos_x;
|
}
|
|
XCamReturn
|
CLPyramidReconstructKernel::prepare_arguments (CLArgList &args, CLWorkSize &work_size)
|
{
|
SmartPtr<CLContext> context = get_context ();
|
|
SmartPtr<CLImage> image_in_reconst = get_input_reconstruct();
|
SmartPtr<CLImage> image_in_lap = get_input_lap ();
|
SmartPtr<CLImage> image_out_reconst = get_output_reconstruct();
|
const CLImageDesc &cl_desc_in_reconst_pre = image_in_reconst->get_image_desc ();
|
// out_desc should be same as image_in_lap
|
const CLImageDesc &cl_desc_out_reconst = image_in_lap->get_image_desc (); // don't change
|
float input_gauss_width = 0.0f, input_gauss_height = 0.0f;
|
|
CLImageDesc cl_desc_in_reconst;
|
cl_desc_in_reconst.format.image_channel_data_type = CL_UNORM_INT8;
|
if (_is_uv) {
|
cl_desc_in_reconst.format.image_channel_order = CL_RG;
|
cl_desc_in_reconst.width = cl_desc_in_reconst_pre.width * 4;
|
} else {
|
cl_desc_in_reconst.format.image_channel_order = CL_R;
|
cl_desc_in_reconst.width = cl_desc_in_reconst_pre.width * 8;
|
}
|
cl_desc_in_reconst.height = cl_desc_in_reconst_pre.height;
|
cl_desc_in_reconst.row_pitch = cl_desc_in_reconst_pre.row_pitch;
|
SmartPtr<CLImage> input_reconstruct;
|
change_image_format (context, image_in_reconst, input_reconstruct, cl_desc_in_reconst);
|
XCAM_FAIL_RETURN (
|
ERROR,
|
input_reconstruct.ptr () && input_reconstruct->is_valid (),
|
XCAM_RETURN_ERROR_CL,
|
"CLPyramidTransformKernel change output gauss image format failed");
|
|
input_gauss_width = cl_desc_in_reconst.width;
|
input_gauss_height = cl_desc_in_reconst.height;
|
|
float out_reconstruct_width = CLImage::calculate_pixel_bytes (cl_desc_in_reconst.format) * cl_desc_in_reconst.width * 2.0f / 8.0f;
|
float out_reconstruct_height = input_gauss_height * 2.0f;
|
float in_sampler_offset_x = SAMPLER_POSITION_OFFSET / input_gauss_width;
|
float in_sampler_offset_y = SAMPLER_POSITION_OFFSET / input_gauss_height;
|
int out_reconstruct_offset_x = 0;
|
|
if (_blender->get_scale_mode () == CLBlenderScaleLocal) {
|
out_reconstruct_offset_x = 0;
|
} else {
|
out_reconstruct_offset_x = get_output_reconstrcut_offset_x () / 8;
|
XCAM_ASSERT (out_reconstruct_offset_x * 8 == get_output_reconstrcut_offset_x ());
|
}
|
|
args.push_back (new CLMemArgument (input_reconstruct));
|
args.push_back (new CLArgumentT<float> (in_sampler_offset_x));
|
args.push_back (new CLArgumentT<float> (in_sampler_offset_y));
|
args.push_back (new CLMemArgument (image_in_lap));
|
args.push_back (new CLMemArgument (image_out_reconst));
|
args.push_back (new CLArgumentT<int> (out_reconstruct_offset_x));
|
args.push_back (new CLArgumentT<float> (out_reconstruct_width));
|
args.push_back (new CLArgumentT<float> (out_reconstruct_height));
|
|
#if CL_PYRAMID_ENABLE_DUMP
|
int i_plane = (_is_uv ? 1 : 0);
|
const PyramidLayer &cur_layer = _blender->get_pyramid_layer (_layer);
|
SmartPtr<CLImage> dump_gauss_resize = cur_layer.dump_gauss_resize[i_plane];
|
SmartPtr<CLImage> dump_final = cur_layer.dump_final[i_plane];
|
|
args.push_back (new CLMemArgument (dump_gauss_resize));
|
args.push_back (new CLMemArgument (dump_final));
|
|
printf ("Rec%d: reconstruct_offset_x:%d, out_width:%.2f, out_height:%.2f, in_sampler_offset_x:%.2f, in_sampler_offset_y:%.2f\n",
|
_layer, out_reconstruct_offset_x, out_reconstruct_width, out_reconstruct_height,
|
in_sampler_offset_x, in_sampler_offset_y);
|
#endif
|
|
work_size.dim = XCAM_DEFAULT_IMAGE_DIM;
|
work_size.local[0] = 4;
|
work_size.local[1] = 8;
|
work_size.global[0] = XCAM_ALIGN_UP (cl_desc_out_reconst.width, work_size.local[0]);
|
work_size.global[1] = XCAM_ALIGN_UP (cl_desc_out_reconst.height, work_size.local[1]);
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
|
void
|
CLPyramidBlender::dump_buffers ()
|
{
|
static int frame_count = 0;
|
SmartPtr<CLImage> image;
|
++frame_count;
|
|
// dump difference between original image and final image
|
#if 0
|
#define CM_NUM 3
|
SmartPtr<CLImage> images[CM_NUM];
|
const Rect & window = get_merge_window ();
|
int offsets[3] = {window.pos_x, window.pos_x, 0};
|
//right edge
|
//int offsets[3] = {0 + window.width - 8, window.pos_x + window.width - 8, window.width - 8};
|
size_t row_pitch[CM_NUM];
|
size_t slice_pitch[CM_NUM];
|
uint8_t *ptr[CM_NUM] = {NULL, NULL, NULL};
|
uint32_t i = 0;
|
|
#if 1
|
// Y
|
// left edge
|
images[0] = this->get_pyramid_layer (0).gauss_image[0][0];
|
// right edge
|
//images[0] = this->get_pyramid_layer (0).gauss_image[0][1];
|
images[1] = this->get_pyramid_layer (0).blend_image[0][ReconstructImageIndex];
|
images[2] = this->get_pyramid_layer (0).dump_final[0];
|
#else
|
// UV
|
// left edge
|
images[0] = this->get_pyramid_layer (0).gauss_image[1][0];
|
// right edge
|
//images[0] = this->get_pyramid_layer (0).gauss_image[1][1];
|
images[1] = this->get_pyramid_layer (0).blend_image[1][ReconstructImageIndex];
|
images[2] = this->get_pyramid_layer (0).dump_final[1];
|
#endif
|
|
for (i = 0; i < CM_NUM; ++i) {
|
const CLImageDesc &desc = images[i]->get_image_desc ();
|
size_t origin[3] = {0, 0, 0};
|
size_t region[3] = {desc.width, desc.height, 1};
|
XCamReturn ret = images[i]->enqueue_map ((void *&)ptr[i], origin, region, &row_pitch[i], &slice_pitch[i], CL_MAP_READ);
|
XCAM_ASSERT (ret == XCAM_RETURN_NO_ERROR);
|
}
|
// offset UV, workaround of beignet
|
//offsets[0] += row_pitch[0] * 1088;
|
//offsets[1] += row_pitch[1] * 1088;
|
|
printf ("layer 0(UV) comparison, original / final-image / reconstruct offset:%d, width:%d\n", window.pos_x, window.width);
|
for (int ih = 250; ih < 280; ++ih) {
|
uint8_t *lines[CM_NUM];
|
for (i = 0; i < 2 /*CM_NUM*/; ++i) {
|
uint8_t *l = (uint8_t *)ptr[i] + offsets[i] + row_pitch[i] * ih + 0;
|
lines[i] = l;
|
printf ("%02x%02x%02x%02x%02x%02x%02x%02x ", l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7]);
|
}
|
//printf differrence between original and final image
|
printf ("delta(orig - final):");
|
for (i = 0; i < 10; ++i) {
|
printf ("%02x", (uint32_t)(lines[0][i] - lines[1][i]) & 0xFF);
|
}
|
printf ("\n");
|
}
|
|
for (i = 0; i < CM_NUM; ++i) {
|
images[i]->enqueue_unmap (ptr[i]);
|
}
|
#endif
|
|
#define DUMP_IMAGE(prefix, image, layer) \
|
desc = (image)->get_image_desc (); \
|
snprintf (filename, sizeof(filename), prefix "_L%d-%dx%d", \
|
layer, (image)->get_pixel_bytes () * desc.width, desc.height); \
|
dump_image (image, filename)
|
|
// dump image data to file
|
CLImageDesc desc;
|
char filename[1024];
|
|
image = this->get_image_diff ();
|
if (image.ptr ()) {
|
DUMP_IMAGE ("dump_image_diff", image, 0);
|
}
|
|
for (uint32_t i_layer = 0; i_layer < get_layers (); ++i_layer) {
|
//dump seam mask
|
image = this->get_pyramid_layer(i_layer).seam_mask[CLSeamMaskTmp];
|
if (image.ptr ()) {
|
DUMP_IMAGE ("dump_seam_tmp", image, i_layer);
|
}
|
|
image = this->get_pyramid_layer(i_layer).seam_mask[CLSeamMaskCoeff];
|
if (image.ptr ()) {
|
DUMP_IMAGE ("dump_seam_coeff", image, i_layer);
|
}
|
|
image = this->get_blend_image (i_layer, false); // layer 1
|
DUMP_IMAGE ("dump_blend", image, i_layer);
|
|
if (i_layer > 0) { //layer : [1, _layers -1]
|
image = this->get_gauss_image (i_layer, 0, false);
|
DUMP_IMAGE ("dump_gaussI0", image, i_layer);
|
image = this->get_gauss_image (i_layer, 1, false);
|
DUMP_IMAGE ("dump_gaussI1", image, i_layer);
|
}
|
|
if (i_layer < get_layers () - 1) {
|
image = this->get_lap_image (i_layer, 0, false); // layer : [0, _layers -2]
|
DUMP_IMAGE ("dump_lap_I0", image, i_layer);
|
}
|
}
|
|
#if CL_PYRAMID_ENABLE_DUMP
|
image = this->get_pyramid_layer (0).dump_gauss_resize[0];
|
DUMP_IMAGE ("dump_gauss_resize", image, 0);
|
|
image = this->get_pyramid_layer (0).dump_original[0][0];
|
DUMP_IMAGE ("dump_orginalI0", image, 0);
|
image = this->get_pyramid_layer (0).dump_original[0][1];
|
DUMP_IMAGE ("dump_orginalI1", image, 0);
|
|
image = this->get_pyramid_layer (0).dump_final[CLBlenderPlaneY];
|
DUMP_IMAGE ("dump_final", image, 0);
|
#endif
|
|
#if 0
|
this->dump_layer_mask (0, false);
|
this->dump_layer_mask (1, false);
|
|
//this->dump_layer_mask (0, true);
|
//this->dump_layer_mask (1, true);
|
#endif
|
|
}
|
|
CLBlenderLocalScaleKernel::CLBlenderLocalScaleKernel (
|
const SmartPtr<CLContext> &context, SmartPtr<CLPyramidBlender> &blender, bool is_uv)
|
: CLBlenderScaleKernel (context, is_uv)
|
, _blender (blender)
|
{
|
}
|
|
SmartPtr<CLImage>
|
CLBlenderLocalScaleKernel::get_input_image ()
|
{
|
SmartPtr<CLContext> context = get_context ();
|
|
SmartPtr<CLImage> rec_image = _blender->get_reconstruct_image (0, _is_uv);
|
const CLImageDesc &rec_desc = rec_image->get_image_desc ();
|
|
CLImageDesc new_desc;
|
new_desc.format.image_channel_data_type = CL_UNORM_INT8;
|
if (_is_uv) {
|
new_desc.format.image_channel_order = CL_RG;
|
new_desc.width = rec_desc.width * 4;
|
} else {
|
new_desc.format.image_channel_order = CL_R;
|
new_desc.width = rec_desc.width * 8;
|
}
|
new_desc.height = rec_desc.height;
|
new_desc.row_pitch = rec_desc.row_pitch;
|
SmartPtr<CLImage> new_image;
|
change_image_format (context, rec_image, new_image, new_desc);
|
XCAM_FAIL_RETURN (
|
ERROR,
|
new_image.ptr () && new_image->is_valid (),
|
NULL,
|
"CLBlenderLocalScaleKernel change image format failed");
|
|
_image_in = new_image;
|
return new_image;
|
}
|
|
SmartPtr<CLImage>
|
CLBlenderLocalScaleKernel::get_output_image ()
|
{
|
return _blender->get_scale_image (_is_uv);
|
}
|
|
bool
|
CLBlenderLocalScaleKernel::get_output_info (
|
uint32_t &out_width, uint32_t &out_height, int &out_offset_x)
|
{
|
XCAM_ASSERT (_image_in.ptr ());
|
|
const Rect &window = _blender->get_merge_window ();
|
const CLImageDesc &desc_in = _image_in->get_image_desc ();
|
|
out_width = window.width / 8;
|
out_height = desc_in.height;
|
out_offset_x = window.pos_x / 8;
|
|
XCAM_FAIL_RETURN (ERROR, out_width != 0, false, "get output info failed");
|
return true;
|
}
|
|
CLPyramidCopyKernel::CLPyramidCopyKernel (
|
const SmartPtr<CLContext> &context, SmartPtr<CLPyramidBlender> &blender,
|
uint32_t buf_index, bool is_uv)
|
: CLImageKernel (context)
|
, _blender (blender)
|
, _is_uv (is_uv)
|
, _buf_index (buf_index)
|
{
|
}
|
|
XCamReturn
|
CLPyramidCopyKernel::prepare_arguments (CLArgList &args, CLWorkSize &work_size)
|
{
|
SmartPtr<CLContext> context = get_context ();
|
|
SmartPtr<CLImage> from = get_input ();
|
SmartPtr<CLImage> to = get_output ();
|
|
const CLImageDesc &to_desc = to->get_image_desc ();
|
const Rect &window = _blender->get_merge_window ();
|
const Rect &input_area = _blender->get_input_valid_area (_buf_index);
|
const Rect &merge_area = _blender->get_input_merge_area (_buf_index);
|
int in_offset_x = 0;
|
int out_offset_x = 0;
|
int max_g_x = 0, max_g_y = 0;
|
|
if (_buf_index == 0) {
|
in_offset_x = input_area.pos_x / 8;
|
max_g_x = (merge_area.pos_x - input_area.pos_x) / 8;
|
out_offset_x = window.pos_x / 8 - max_g_x;
|
} else {
|
in_offset_x = (merge_area.pos_x + merge_area.width) / 8;
|
out_offset_x = (window.pos_x + window.width) / 8;
|
max_g_x = (input_area.pos_x + input_area.width) / 8 - in_offset_x;
|
}
|
max_g_y = to_desc.height;
|
XCAM_ASSERT (max_g_x > 0 && max_g_x <= (int)to_desc.width);
|
|
#if CL_PYRAMID_ENABLE_DUMP
|
printf ("copy(%d), in_offset_x:%d, out_offset_x:%d, max_x:%d\n", _buf_index, in_offset_x, out_offset_x, max_g_x);
|
#endif
|
|
args.push_back (new CLMemArgument (from));
|
args.push_back (new CLArgumentT<int> (in_offset_x));
|
args.push_back (new CLMemArgument (to));
|
args.push_back (new CLArgumentT<int> (out_offset_x));
|
args.push_back (new CLArgumentT<int> (max_g_x));
|
args.push_back (new CLArgumentT<int> (max_g_y));
|
|
work_size.dim = XCAM_DEFAULT_IMAGE_DIM;
|
work_size.local[0] = 16;
|
work_size.local[1] = 4;
|
work_size.global[0] = XCAM_ALIGN_UP (max_g_x, work_size.local[0]);
|
work_size.global[1] = XCAM_ALIGN_UP (max_g_y, work_size.local[1]);
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
static SmartPtr<CLImageKernel>
|
create_pyramid_transform_kernel (
|
const SmartPtr<CLContext> &context, SmartPtr<CLPyramidBlender> &blender,
|
uint32_t layer, uint32_t buf_index, bool is_uv)
|
{
|
char transform_option[1024];
|
snprintf (
|
transform_option, sizeof(transform_option),
|
"-DPYRAMID_UV=%d -DCL_PYRAMID_ENABLE_DUMP=%d", (is_uv ? 1 : 0), CL_PYRAMID_ENABLE_DUMP);
|
|
SmartPtr<CLImageKernel> kernel;
|
kernel = new CLPyramidTransformKernel (context, blender, layer, buf_index, is_uv);
|
XCAM_ASSERT (kernel.ptr ());
|
XCAM_FAIL_RETURN (
|
ERROR,
|
kernel->build_kernel (kernels_info[KernelPyramidTransform], transform_option) == XCAM_RETURN_NO_ERROR,
|
NULL,
|
"load pyramid blender kernel(%s) failed", (is_uv ? "UV" : "Y"));
|
return kernel;
|
}
|
|
static SmartPtr<CLImageKernel>
|
create_pyramid_lap_kernel (
|
const SmartPtr<CLContext> &context, SmartPtr<CLPyramidBlender> &blender,
|
uint32_t layer, uint32_t buf_index, bool is_uv)
|
{
|
char transform_option[1024];
|
snprintf (
|
transform_option, sizeof(transform_option),
|
"-DPYRAMID_UV=%d -DCL_PYRAMID_ENABLE_DUMP=%d", (is_uv ? 1 : 0), CL_PYRAMID_ENABLE_DUMP);
|
|
SmartPtr<CLImageKernel> kernel;
|
kernel = new CLPyramidLapKernel (context, blender, layer, buf_index, is_uv);
|
XCAM_ASSERT (kernel.ptr ());
|
XCAM_FAIL_RETURN (
|
ERROR,
|
kernel->build_kernel (kernels_info[KernelPyramidLap], transform_option) == XCAM_RETURN_NO_ERROR,
|
NULL,
|
"load pyramid blender kernel(%s) failed", (is_uv ? "UV" : "Y"));
|
return kernel;
|
}
|
|
static SmartPtr<CLImageKernel>
|
create_pyramid_reconstruct_kernel (
|
const SmartPtr<CLContext> &context,
|
SmartPtr<CLPyramidBlender> &blender,
|
uint32_t layer,
|
bool is_uv)
|
{
|
char transform_option[1024];
|
snprintf (
|
transform_option, sizeof(transform_option),
|
"-DPYRAMID_UV=%d -DCL_PYRAMID_ENABLE_DUMP=%d", (is_uv ? 1 : 0), CL_PYRAMID_ENABLE_DUMP);
|
|
SmartPtr<CLImageKernel> kernel;
|
kernel = new CLPyramidReconstructKernel (context, blender, layer, is_uv);
|
XCAM_ASSERT (kernel.ptr ());
|
XCAM_FAIL_RETURN (
|
ERROR,
|
kernel->build_kernel (kernels_info[KernelPyramidReconstruct], transform_option) == XCAM_RETURN_NO_ERROR,
|
NULL,
|
"load pyramid blender kernel(%s) failed", (is_uv ? "UV" : "Y"));
|
return kernel;
|
}
|
|
static SmartPtr<CLImageKernel>
|
create_pyramid_blend_kernel (
|
const SmartPtr<CLContext> &context,
|
SmartPtr<CLPyramidBlender> &blender,
|
uint32_t layer,
|
bool is_uv,
|
bool need_seam)
|
{
|
char transform_option[1024];
|
snprintf (
|
transform_option, sizeof(transform_option),
|
"-DPYRAMID_UV=%d -DCL_PYRAMID_ENABLE_DUMP=%d", (is_uv ? 1 : 0), CL_PYRAMID_ENABLE_DUMP);
|
|
SmartPtr<CLImageKernel> kernel;
|
kernel = new CLPyramidBlendKernel (context, blender, layer, is_uv, need_seam);
|
uint32_t index = KernelPyramidBlender;
|
if (need_seam)
|
index = KernelSeamBlender;
|
|
XCAM_ASSERT (kernel.ptr ());
|
XCAM_FAIL_RETURN (
|
ERROR,
|
kernel->build_kernel (kernels_info[index], transform_option) == XCAM_RETURN_NO_ERROR,
|
NULL,
|
"load pyramid blender kernel(%s) failed", (is_uv ? "UV" : "Y"));
|
return kernel;
|
}
|
|
static SmartPtr<CLImageKernel>
|
create_pyramid_blender_local_scale_kernel (
|
const SmartPtr<CLContext> &context,
|
SmartPtr<CLPyramidBlender> &blender,
|
bool is_uv)
|
{
|
char transform_option[1024];
|
snprintf (transform_option, sizeof(transform_option), "-DPYRAMID_UV=%d", is_uv ? 1 : 0);
|
|
SmartPtr<CLImageKernel> kernel;
|
kernel = new CLBlenderLocalScaleKernel (context, blender, is_uv);
|
XCAM_ASSERT (kernel.ptr ());
|
XCAM_FAIL_RETURN (
|
ERROR,
|
kernel->build_kernel (kernels_info[KernelPyramidScale], transform_option) == XCAM_RETURN_NO_ERROR,
|
NULL,
|
"load pyramid blender local scaling kernel(%s) failed", is_uv ? "UV" : "Y");
|
return kernel;
|
}
|
|
static SmartPtr<CLImageKernel>
|
create_pyramid_copy_kernel (
|
const SmartPtr<CLContext> &context,
|
SmartPtr<CLPyramidBlender> &blender,
|
uint32_t buf_index,
|
bool is_uv)
|
{
|
char transform_option[1024];
|
snprintf (transform_option, sizeof(transform_option), "-DPYRAMID_UV=%d", (is_uv ? 1 : 0));
|
|
SmartPtr<CLImageKernel> kernel;
|
kernel = new CLPyramidCopyKernel (context, blender, buf_index, is_uv);
|
XCAM_ASSERT (kernel.ptr ());
|
XCAM_FAIL_RETURN (
|
ERROR,
|
kernel->build_kernel (kernels_info[KernelPyramidCopy], transform_option) == XCAM_RETURN_NO_ERROR,
|
NULL,
|
"load pyramid blender kernel(%s) failed", (is_uv ? "UV" : "Y"));
|
return kernel;
|
}
|
|
static SmartPtr<CLImageKernel>
|
create_seam_diff_kernel (
|
const SmartPtr<CLContext> &context, SmartPtr<CLPyramidBlender> &blender)
|
{
|
SmartPtr<CLImageKernel> kernel;
|
kernel = new CLSeamDiffKernel (context, blender);
|
XCAM_ASSERT (kernel.ptr ());
|
XCAM_FAIL_RETURN (
|
ERROR,
|
kernel->build_kernel (kernels_info[KernelImageDiff], NULL) == XCAM_RETURN_NO_ERROR,
|
NULL,
|
"load seam diff kernel failed");
|
return kernel;
|
}
|
|
static SmartPtr<CLImageKernel>
|
create_seam_DP_kernel (
|
const SmartPtr<CLContext> &context, SmartPtr<CLPyramidBlender> &blender)
|
{
|
SmartPtr<CLImageKernel> kernel;
|
kernel = new CLSeamDPKernel (context, blender);
|
XCAM_ASSERT (kernel.ptr ());
|
XCAM_FAIL_RETURN (
|
ERROR,
|
kernel->build_kernel (kernels_info[KernelSeamDP], NULL) == XCAM_RETURN_NO_ERROR,
|
NULL,
|
"load seam DP kernel failed");
|
return kernel;
|
}
|
|
static SmartPtr<CLImageKernel>
|
create_seam_mask_scale_kernel (
|
const SmartPtr<CLContext> &context,
|
SmartPtr<CLPyramidBlender> &blender,
|
uint32_t layer,
|
bool need_scale,
|
bool need_slm)
|
{
|
char build_option[1024];
|
snprintf (build_option, sizeof(build_option), "-DENABLE_MASK_GAUSS_SCALE=%d", (need_scale ? 1 : 0));
|
int kernel_idx = (need_slm ? KernelSeamMaskScaleSLM : KernelSeamMaskScale);
|
|
SmartPtr<CLImageKernel> kernel;
|
kernel = new CLPyramidSeamMaskKernel (context, blender, layer, need_scale, need_slm);
|
XCAM_ASSERT (kernel.ptr ());
|
XCAM_FAIL_RETURN (
|
ERROR,
|
kernel->build_kernel (kernels_info[kernel_idx], build_option) == XCAM_RETURN_NO_ERROR,
|
NULL,
|
"load seam mask scale kernel failed");
|
return kernel;
|
}
|
|
SmartPtr<CLImageHandler>
|
create_pyramid_blender (
|
const SmartPtr<CLContext> &context, int layer, bool need_uv,
|
bool need_seam, CLBlenderScaleMode scale_mode)
|
{
|
SmartPtr<CLPyramidBlender> blender;
|
SmartPtr<CLImageKernel> kernel;
|
int i = 0;
|
uint32_t buf_index = 0;
|
int max_plane = (need_uv ? 2 : 1);
|
bool uv_status[2] = {false, true};
|
|
XCAM_FAIL_RETURN (
|
ERROR,
|
layer > 0 && layer <= XCAM_CL_PYRAMID_MAX_LEVEL,
|
NULL,
|
"create_pyramid_blender failed with wrong layer:%d, please set it between %d and %d",
|
layer, 1, XCAM_CL_PYRAMID_MAX_LEVEL);
|
|
blender = new CLPyramidBlender (context, "cl_pyramid_blender", layer, need_uv, need_seam, scale_mode);
|
XCAM_ASSERT (blender.ptr ());
|
|
if (need_seam) {
|
kernel = create_seam_diff_kernel (context, blender);
|
XCAM_FAIL_RETURN (ERROR, kernel.ptr (), NULL, "create seam diff kernel failed");
|
blender->add_kernel (kernel);
|
|
kernel = create_seam_DP_kernel (context, blender);
|
XCAM_FAIL_RETURN (ERROR, kernel.ptr (), NULL, "create seam DP kernel failed");
|
blender->add_kernel (kernel);
|
|
for (i = 0; i < layer; ++i) {
|
bool need_scale = (i < layer - 1);
|
bool need_slm = (i == 0);
|
kernel = create_seam_mask_scale_kernel (context, blender, (uint32_t)i, need_scale, need_slm);
|
XCAM_FAIL_RETURN (ERROR, kernel.ptr (), NULL, "create seam mask scale kernel failed");
|
blender->add_kernel (kernel);
|
}
|
}
|
|
for (int plane = 0; plane < max_plane; ++plane) {
|
for (buf_index = 0; buf_index < XCAM_BLENDER_IMAGE_NUM; ++buf_index) {
|
for (i = 0; i < layer - 1; ++i) {
|
kernel = create_pyramid_transform_kernel (context, blender, (uint32_t)i, buf_index, uv_status[plane]);
|
XCAM_FAIL_RETURN (ERROR, kernel.ptr (), NULL, "create pyramid transform kernel failed");
|
blender->add_kernel (kernel);
|
|
kernel = create_pyramid_lap_kernel (context, blender, (uint32_t)i, buf_index, uv_status[plane]);
|
XCAM_FAIL_RETURN (ERROR, kernel.ptr (), NULL, "create pyramid lap transform kernel failed");
|
blender->add_kernel (kernel);
|
}
|
}
|
|
for (i = 0; i < layer; ++i) {
|
kernel = create_pyramid_blend_kernel (context, blender, (uint32_t)i, uv_status[plane], need_seam);
|
XCAM_FAIL_RETURN (ERROR, kernel.ptr (), NULL, "create pyramid blend kernel failed");
|
blender->add_kernel (kernel);
|
}
|
|
for (i = layer - 2; i >= 0 && i < layer; --i) {
|
kernel = create_pyramid_reconstruct_kernel (context, blender, (uint32_t)i, uv_status[plane]);
|
XCAM_FAIL_RETURN (ERROR, kernel.ptr (), NULL, "create pyramid reconstruct kernel failed");
|
blender->add_kernel (kernel);
|
}
|
|
if (scale_mode == CLBlenderScaleLocal) {
|
kernel = create_pyramid_blender_local_scale_kernel (context, blender, uv_status[plane]);
|
XCAM_FAIL_RETURN (ERROR, kernel.ptr (), NULL, "create pyramid blender local scaling kernel failed");
|
blender->add_kernel (kernel);
|
}
|
|
for (buf_index = 0; buf_index < XCAM_BLENDER_IMAGE_NUM; ++buf_index) {
|
kernel = create_pyramid_copy_kernel (context, blender, buf_index, uv_status[plane]);
|
XCAM_FAIL_RETURN (ERROR, kernel.ptr (), NULL, "create pyramid copy kernel failed");
|
blender->add_kernel (kernel);
|
}
|
}
|
|
return blender;
|
}
|
|
}
|
