/*
* soft_blender_tasks_priv.cpp - soft blender tasks private class implementation
*
* Copyright (c) 2017 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 "soft_blender_tasks_priv.h"
namespace XCam {
namespace XCamSoftTasks {
const float GaussScaleGray::coeffs[GAUSS_DOWN_SCALE_SIZE] = {0.152f, 0.222f, 0.252f, 0.222f, 0.152f};
void
GaussScaleGray::gauss_luma_2x2 (
UcharImage *in_luma, UcharImage *out_luma,
uint32_t x, uint32_t y)
{
/*
* o o o o o o o
* o o o o o o o
* o o Y(UV) o Y o o
* o o o o o o o
* o o Y o Y o o
* o o o o o o o
* o o o o o o o
*/
uint32_t in_x = x * 4, in_y = y * 4;
float line[7];
float sum0[7] = {0.0f};
float sum1[7] = {0.0f};
in_luma->read_array<float, 7> (in_x - 2, in_y - 2, line);
multiply_coeff_y (sum0, line, coeffs[0]);
in_luma->read_array<float, 7> (in_x - 2, in_y - 1, line);
multiply_coeff_y (sum0, line, coeffs[1]);
in_luma->read_array<float, 7> (in_x - 2, in_y, line);
multiply_coeff_y (sum0, line, coeffs[2]);
multiply_coeff_y (sum1, line, coeffs[0]);
in_luma->read_array<float, 7> (in_x - 2, in_y + 1, line);
multiply_coeff_y (sum0, line, coeffs[3]);
multiply_coeff_y (sum1, line, coeffs[1]);
in_luma->read_array<float, 7> (in_x - 2, in_y + 2, line);
multiply_coeff_y (sum0, line, coeffs[4]);
multiply_coeff_y (sum1, line, coeffs[2]);
in_luma->read_array<float, 7> (in_x - 2, in_y + 3, line);
multiply_coeff_y (sum1, line, coeffs[3]);
in_luma->read_array<float, 7> (in_x - 2, in_y + 4, line);
multiply_coeff_y (sum1, line, coeffs[4]);
float value[2];
Uchar out[2];
value[0] = gauss_sum (&sum0[0]);
value[1] = gauss_sum (&sum0[2]);
out[0] = convert_to_uchar (value[0]);
out[1] = convert_to_uchar (value[1]);
out_luma->write_array_no_check<2> (x * 2, y * 2, out);
value[0] = gauss_sum (&sum1[0]);
value[1] = gauss_sum (&sum1[2]);
out[0] = convert_to_uchar(value[0]);
out[1] = convert_to_uchar(value[1]);
out_luma->write_array_no_check<2> (x * 2, y * 2 + 1, out);
}
XCamReturn
GaussScaleGray::work_range (const SmartPtr<Worker::Arguments> &base, const WorkRange &range)
{
SmartPtr<GaussScaleGray::Args> args = base.dynamic_cast_ptr<GaussScaleGray::Args> ();
XCAM_ASSERT (args.ptr ());
UcharImage *in_luma = args->in_luma.ptr (), *out_luma = args->out_luma.ptr ();
XCAM_ASSERT (in_luma && out_luma);
for (uint32_t y = range.pos[1]; y < range.pos[1] + range.pos_len[1]; ++y)
for (uint32_t x = range.pos[0]; x < range.pos[0] + range.pos_len[0]; ++x)
{
gauss_luma_2x2 (in_luma, out_luma, x, y);
}
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
GaussDownScale::work_range (const SmartPtr<Worker::Arguments> &base, const WorkRange &range)
{
SmartPtr<GaussDownScale::Args> args = base.dynamic_cast_ptr<GaussDownScale::Args> ();
XCAM_ASSERT (args.ptr ());
UcharImage *in_luma = args->in_luma.ptr (), *out_luma = args->out_luma.ptr ();
Uchar2Image *in_uv = args->in_uv.ptr (), *out_uv = args->out_uv.ptr ();
XCAM_ASSERT (in_luma && in_uv);
XCAM_ASSERT (out_luma && out_uv);
for (uint32_t y = range.pos[1]; y < range.pos[1] + range.pos_len[1]; ++y)
for (uint32_t x = range.pos[0]; x < range.pos[0] + range.pos_len[0]; ++x)
{
gauss_luma_2x2 (in_luma, out_luma, x, y);
// calculate UV
int32_t in_x = x * 2, in_y = y * 2;
Float2 uv_line[5];
Float2 uv_sum [5];
in_uv->read_array<Float2, 5> (in_x - 2, in_y - 2, uv_line);
multiply_coeff_uv (uv_sum, uv_line, coeffs[0]);
in_uv->read_array<Float2, 5> (in_x - 2, in_y - 1, uv_line);
multiply_coeff_uv (uv_sum, uv_line, coeffs[1]);
in_uv->read_array<Float2, 5> (in_x - 2, in_y , uv_line);
multiply_coeff_uv (uv_sum, uv_line, coeffs[2]);
in_uv->read_array<Float2, 5> (in_x - 2, in_y + 1, uv_line);
multiply_coeff_uv (uv_sum, uv_line, coeffs[3]);
in_uv->read_array<Float2, 5> (in_x - 2, in_y + 2, uv_line);
multiply_coeff_uv (uv_sum, uv_line, coeffs[4]);
Float2 uv_value;
uv_value = gauss_sum (&uv_sum[0]);
Uchar2 uv_out(convert_to_uchar(uv_value.x), convert_to_uchar(uv_value.y));
out_uv->write_data_no_check (x, y, uv_out);
}
//printf ("done\n");
XCAM_LOG_DEBUG ("GaussDownScale work on range:[x:%d, width:%d, y:%d, height:%d]",
range.pos[0], range.pos_len[0], range.pos[1], range.pos_len[1]);
return XCAM_RETURN_NO_ERROR;
}
static inline void
blend_luma_8 (const float *luma0, const float *luma1, const float *mask, float *out)
{
//out[0] = luma0[0] * mask + luma1[0] * ( 1.0f - mask[0]);
#define BLEND_LUMA_8(idx) out[idx] = (luma0[idx] - luma1[idx]) * mask[idx] + luma1[idx]
BLEND_LUMA_8 (0);
BLEND_LUMA_8 (1);
BLEND_LUMA_8 (2);
BLEND_LUMA_8 (3);
BLEND_LUMA_8 (4);
BLEND_LUMA_8 (5);
BLEND_LUMA_8 (6);
BLEND_LUMA_8 (7);
}
static inline void
normalize_8 (float *value, const float max)
{
value[0] /= max;
value[1] /= max;
value[2] /= max;
value[3] /= max;
value[4] /= max;
value[5] /= max;
value[6] /= max;
value[7] /= max;
}
static inline void
read_and_blend_pixel_luma_8 (
const UcharImage *in0, const UcharImage *in1,
const UcharImage *mask,
const uint32_t in_x, const uint32_t in_y,
float *out_luma,
float *out_mask)
{
float luma0_line[8], luma1_line[8];
mask->read_array_no_check<float, 8> (in_x, in_y, out_mask);
in0->read_array_no_check<float, 8> (in_x, in_y, luma0_line);
in1->read_array_no_check<float, 8> (in_x, in_y, luma1_line);
normalize_8 (out_mask, 255.0f);
blend_luma_8 (luma0_line, luma1_line, out_mask, out_luma);
}
static inline void
read_and_blend_uv_4 (
const Uchar2Image *in_a, const Uchar2Image *in_b,
const float *mask,
const uint32_t in_x, const uint32_t in_y,
Float2 *out_uv)
{
Float2 line_a[4], line_b[4];
in_a->read_array_no_check<Float2, 4> (in_x, in_y, line_a);
in_b->read_array_no_check<Float2, 4> (in_x, in_y, line_b);
//out_uv[0] = line_a[0] * mask + line_b[0] * ( 1.0f - mask[0]);
#define BLEND_UV_4(i) out_uv[i] = (line_a[i] - line_b[i]) * mask[i] + line_b[i]
BLEND_UV_4 (0);
BLEND_UV_4 (1);
BLEND_UV_4 (2);
BLEND_UV_4 (3);
}
XCamReturn
BlendTask::work_range (const SmartPtr<Arguments> &base, const WorkRange &range)
{
SmartPtr<BlendTask::Args> args = base.dynamic_cast_ptr<BlendTask::Args> ();
XCAM_ASSERT (args.ptr ());
UcharImage *in0_luma = args->in_luma[0].ptr (), *in1_luma = args->in_luma[1].ptr (), *out_luma = args->out_luma.ptr ();
Uchar2Image *in0_uv = args->in_uv[0].ptr (), *in1_uv = args->in_uv[1].ptr (), *out_uv = args->out_uv.ptr ();
UcharImage *mask = args->mask.ptr ();
XCAM_ASSERT (in0_luma && in0_uv && in1_luma && in1_uv);
XCAM_ASSERT (out_luma && out_uv);
XCAM_ASSERT (mask);
for (uint32_t y = range.pos[1]; y < range.pos[1] + range.pos_len[1]; ++y)
for (uint32_t x = range.pos[0]; x < range.pos[0] + range.pos_len[0]; ++x)
{
// 8x2 -pixels each time for luma
uint32_t in_x = x * 8;
uint32_t in_y = y * 2;
float luma_blend[8], luma_mask[8];
Uchar luma_uc[8];
// process luma (in_x, in_y)
read_and_blend_pixel_luma_8 (in0_luma, in1_luma, mask, in_x, in_y, luma_blend, luma_mask);
convert_to_uchar_N<float, 8> (luma_blend, luma_uc);
out_luma->write_array_no_check<8> (in_x, in_y, luma_uc);
// process luma (in_x, in_y + 1)
read_and_blend_pixel_luma_8 (in0_luma, in1_luma, mask, in_x, in_y + 1, luma_blend, luma_mask);
convert_to_uchar_N<float, 8> (luma_blend, luma_uc);
out_luma->write_array_no_check<8> (in_x, in_y + 1, luma_uc);
// process uv(4x1) (uv_x, uv_y)
uint32_t uv_x = x * 4, uv_y = y;
Float2 uv_blend[4];
Uchar2 uv_uc[4];
luma_mask[1] = luma_mask[2];
luma_mask[2] = luma_mask[4];
luma_mask[3] = luma_mask[6];
read_and_blend_uv_4 (in0_uv, in1_uv, luma_mask, uv_x, uv_y, uv_blend);
convert_to_uchar2_N<Float2, 4> (uv_blend, uv_uc);
out_uv->write_array_no_check<4> (uv_x, uv_y, uv_uc);
}
XCAM_LOG_DEBUG ("BlendTask work on range:[x:%d, width:%d, y:%d, height:%d]",
range.pos[0], range.pos_len[0], range.pos[1], range.pos_len[1]);
return XCAM_RETURN_NO_ERROR;
}
static inline void
minus_array_8 (float *orig, float *gauss, Uchar *ret)
{
#define ORG_MINUS_GAUSS(i) ret[i] = convert_to_uchar<float> ((orig[i] - gauss[i]) * 0.5f + 128.0f)
ORG_MINUS_GAUSS(0);
ORG_MINUS_GAUSS(1);
ORG_MINUS_GAUSS(2);
ORG_MINUS_GAUSS(3);
ORG_MINUS_GAUSS(4);
ORG_MINUS_GAUSS(5);
ORG_MINUS_GAUSS(6);
ORG_MINUS_GAUSS(7);
}
static inline void
interpolate_luma_int_row_8x1 (UcharImage* image, uint32_t fixed_x, uint32_t fixed_y, float *gauss_v, float* ret)
{
image->read_array<float, 5> (fixed_x, fixed_y, gauss_v);
ret[0] = gauss_v[0];
ret[1] = (gauss_v[0] + gauss_v[1]) * 0.5f;
ret[2] = gauss_v[1];
ret[3] = (gauss_v[1] + gauss_v[2]) * 0.5f;
ret[4] = gauss_v[2];
ret[5] = (gauss_v[2] + gauss_v[3]) * 0.5f;
ret[6] = gauss_v[3];
ret[7] = (gauss_v[3] + gauss_v[4]) * 0.5f;
}
static inline void
interpolate_luma_half_row_8x1 (UcharImage* image, uint32_t fixed_x, uint32_t next_y, float *last_gauss_v, float* ret)
{
float next_gauss_v[5];
float tmp;
image->read_array<float, 5> (fixed_x, next_y, next_gauss_v);
ret[0] = (last_gauss_v[0] + next_gauss_v[0]) / 2.0f;
ret[2] = (last_gauss_v[1] + next_gauss_v[1]) / 2.0f;
ret[4] = (last_gauss_v[2] + next_gauss_v[2]) / 2.0f;
ret[6] = (last_gauss_v[3] + next_gauss_v[3]) / 2.0f;
tmp = (last_gauss_v[4] + next_gauss_v[4]) / 2.0f;
ret[1] = (ret[0] + ret[2]) / 2.0f;
ret[3] = (ret[2] + ret[4]) / 2.0f;
ret[5] = (ret[4] + ret[6]) / 2.0f;
ret[7] = (ret[6] + tmp) / 2.0f;
}
void
LaplaceTask::interplate_luma_8x2 (
UcharImage *orig_luma, UcharImage *gauss_luma, UcharImage *out_luma,
uint32_t out_x, uint32_t out_y)
{
uint32_t gauss_x = out_x / 2, first_gauss_y = out_y / 2;
float inter_value[8];
float gauss_v[5];
float orig_v[8];
Uchar lap_ret[8];
//interplate instaed of coefficient
interpolate_luma_int_row_8x1 (gauss_luma, gauss_x, first_gauss_y, gauss_v, inter_value);
orig_luma->read_array_no_check<float, 8> (out_x, out_y, orig_v);
minus_array_8 (orig_v, inter_value, lap_ret);
out_luma->write_array_no_check<8> (out_x, out_y, lap_ret);
uint32_t next_gauss_y = first_gauss_y + 1;
interpolate_luma_half_row_8x1 (gauss_luma, gauss_x, next_gauss_y, gauss_v, inter_value);
orig_luma->read_array_no_check<float, 8> (out_x, out_y + 1, orig_v);
minus_array_8 (orig_v, inter_value, lap_ret);
out_luma->write_array_no_check<8> (out_x, out_y + 1, lap_ret);
}
static inline void
minus_array_uv_4 (Float2 *orig, Float2 *gauss, Uchar2 *ret)
{
#define ORG_MINUS_GAUSS_UV(i) orig[i] -= gauss[i]; orig[i] *= 0.5f; orig[i] += 128.0f
ORG_MINUS_GAUSS_UV(0);
ORG_MINUS_GAUSS_UV(1);
ORG_MINUS_GAUSS_UV(2);
ORG_MINUS_GAUSS_UV(3);
convert_to_uchar2_N<Float2, 4> (orig, ret);
}
static inline void
interpolate_uv_int_row_4x1 (Uchar2Image *image, uint32_t x, uint32_t y, Float2 *gauss_value, Float2 *ret)
{
image->read_array<Float2, 3> (x, y, gauss_value);
ret[0] = gauss_value[0];
ret[1] = gauss_value[0] + gauss_value[1];
ret[1] *= 0.5f;
ret[2] = gauss_value[1];
ret[3] = gauss_value[1] + gauss_value[2];
ret[3] *= 0.5f;
}
static inline void
interpolate_uv_half_row_4x1 (Uchar2Image *image, uint32_t x, uint32_t y, Float2 *gauss_value, Float2 *ret)
{
Float2 next_gauss_uv[3];
image->read_array<Float2, 3> (x, y, next_gauss_uv);
ret[0] = (gauss_value[0] + next_gauss_uv[0]) * 0.5f;
ret[2] = (gauss_value[1] + next_gauss_uv[1]) * 0.5f;
Float2 tmp = (gauss_value[2] + next_gauss_uv[2]) * 0.5f;
ret[1] = (ret[0] + ret[2]) * 0.5f;
ret[3] = (ret[2] + tmp) * 0.5f;
}
XCamReturn
LaplaceTask::work_range (const SmartPtr<Arguments> &base, const WorkRange &range)
{
SmartPtr<LaplaceTask::Args> args = base.dynamic_cast_ptr<LaplaceTask::Args> ();
XCAM_ASSERT (args.ptr ());
UcharImage *orig_luma = args->orig_luma.ptr (), *gauss_luma = args->gauss_luma.ptr (), *out_luma = args->out_luma.ptr ();
Uchar2Image *orig_uv = args->orig_uv.ptr (), *gauss_uv = args->gauss_uv.ptr (), *out_uv = args->out_uv.ptr ();
XCAM_ASSERT (orig_luma && orig_uv);
XCAM_ASSERT (gauss_luma && gauss_uv);
XCAM_ASSERT (out_luma && out_uv);
for (uint32_t y = range.pos[1]; y < range.pos[1] + range.pos_len[1]; ++y)
for (uint32_t x = range.pos[0]; x < range.pos[0] + range.pos_len[0]; ++x)
{
// 8x4 -pixels each time for luma
uint32_t out_x = x * 8, out_y = y * 4;
interplate_luma_8x2 (orig_luma, gauss_luma, out_luma, out_x, out_y);
interplate_luma_8x2 (orig_luma, gauss_luma, out_luma, out_x, out_y + 2);
// 4x2 uv
uint32_t out_uv_x = x * 4, out_uv_y = y * 2;
uint32_t gauss_uv_x = out_uv_x / 2, gauss_uv_y = out_uv_y / 2;
Float2 gauss_uv_value[3];
Float2 orig_uv_value[4];
Float2 inter_uv_value[4];
Uchar2 lap_uv_ret[4];
interpolate_uv_int_row_4x1 (gauss_uv, gauss_uv_x, gauss_uv_y, gauss_uv_value, inter_uv_value);
orig_uv->read_array_no_check<Float2, 4> (out_uv_x , out_uv_y, orig_uv_value);
minus_array_uv_4 (orig_uv_value, inter_uv_value, lap_uv_ret);
out_uv->write_array_no_check<4> (out_uv_x , out_uv_y, lap_uv_ret);
interpolate_uv_half_row_4x1 (gauss_uv, gauss_uv_x, gauss_uv_y + 1, gauss_uv_value, inter_uv_value);
orig_uv->read_array_no_check<Float2, 4> (out_uv_x , out_uv_y + 1, orig_uv_value);
minus_array_uv_4 (orig_uv_value, inter_uv_value, lap_uv_ret);
out_uv->write_array_no_check<4> (out_uv_x, out_uv_y + 1, lap_uv_ret);
}
return XCAM_RETURN_NO_ERROR;
}
static inline void
reconstruct_luma_8x1 (float *lap, float *up_sample, Uchar *result)
{
#define RECONSTRUCT_UP_SAMPLE(i) result[i] = convert_to_uchar<float>(up_sample[i] + lap[i] * 2.0f - 256.0f)
RECONSTRUCT_UP_SAMPLE(0);
RECONSTRUCT_UP_SAMPLE(1);
RECONSTRUCT_UP_SAMPLE(2);
RECONSTRUCT_UP_SAMPLE(3);
RECONSTRUCT_UP_SAMPLE(4);
RECONSTRUCT_UP_SAMPLE(5);
RECONSTRUCT_UP_SAMPLE(6);
RECONSTRUCT_UP_SAMPLE(7);
}
static inline void
reconstruct_luma_4x1 (Float2 *lap, Float2 *up_sample, Uchar2 *uv_uc)
{
#define RECONSTRUCT_UP_SAMPLE_UV(i) \
uv_uc[i].x = convert_to_uchar<float>(up_sample[i].x + lap[i].x * 2.0f - 256.0f); \
uv_uc[i].y = convert_to_uchar<float>(up_sample[i].y + lap[i].y * 2.0f - 256.0f)
RECONSTRUCT_UP_SAMPLE_UV (0);
RECONSTRUCT_UP_SAMPLE_UV (1);
RECONSTRUCT_UP_SAMPLE_UV (2);
RECONSTRUCT_UP_SAMPLE_UV (3);
}
XCamReturn
ReconstructTask::work_range (const SmartPtr<Arguments> &base, const WorkRange &range)
{
SmartPtr<ReconstructTask::Args> args = base.dynamic_cast_ptr<ReconstructTask::Args> ();
XCAM_ASSERT (args.ptr ());
UcharImage *lap_luma[2] = {args->lap_luma[0].ptr (), args->lap_luma[1].ptr ()};
UcharImage *gauss_luma = args->gauss_luma.ptr (), *out_luma = args->out_luma.ptr ();
Uchar2Image *lap_uv[2] = {args->lap_uv[0].ptr (), args->lap_uv[1].ptr ()};
Uchar2Image *gauss_uv = args->gauss_uv.ptr (), *out_uv = args->out_uv.ptr ();
UcharImage *mask_image = args->mask.ptr ();
XCAM_ASSERT (lap_luma[0] && lap_luma[1] && lap_uv[0] && lap_uv[1]);
XCAM_ASSERT (gauss_luma && gauss_uv);
XCAM_ASSERT (out_luma && out_uv);
XCAM_ASSERT (mask_image);
for (uint32_t y = range.pos[1]; y < range.pos[1] + range.pos_len[1]; ++y)
for (uint32_t x = range.pos[0]; x < range.pos[0] + range.pos_len[0]; ++x)
{
// 8x4 -pixels each time for luma
float luma_blend[8], luma_mask1[8], luma_mask2[8];
float luma_sample[8];
float gauss_data[5];
Uchar luma_uchar[8];
uint32_t in_x = x * 8, in_y = y * 4;
// luma 1st - line
read_and_blend_pixel_luma_8 (lap_luma[0], lap_luma[1], mask_image, in_x, in_y, luma_blend, luma_mask1);
interpolate_luma_int_row_8x1 (gauss_luma, in_x / 2, in_y / 2, gauss_data, luma_sample);
reconstruct_luma_8x1 (luma_blend, luma_sample, luma_uchar);
out_luma->write_array_no_check<8> (in_x, in_y, luma_uchar);
// luma 2nd -line
in_y += 1;
read_and_blend_pixel_luma_8 (lap_luma[0], lap_luma[1], mask_image, in_x, in_y, luma_blend, luma_mask1);
interpolate_luma_half_row_8x1 (gauss_luma, in_x / 2, in_y / 2 + 1, gauss_data, luma_sample);
reconstruct_luma_8x1 (luma_blend, luma_sample, luma_uchar);
out_luma->write_array_no_check<8> (in_x, in_y, luma_uchar);
// luma 3rd -line
in_y += 1;
read_and_blend_pixel_luma_8 (lap_luma[0], lap_luma[1], mask_image, in_x, in_y, luma_blend, luma_mask2);
interpolate_luma_int_row_8x1 (gauss_luma, in_x / 2, in_y / 2, gauss_data, luma_sample);
reconstruct_luma_8x1 (luma_blend, luma_sample, luma_uchar);
out_luma->write_array_no_check<8> (in_x, in_y, luma_uchar);
// luma 4th -line
in_y += 1;
read_and_blend_pixel_luma_8 (lap_luma[0], lap_luma[1], mask_image, in_x, in_y, luma_blend, luma_mask2);
interpolate_luma_half_row_8x1 (gauss_luma, in_x / 2, in_y / 2 + 1, gauss_data, luma_sample);
reconstruct_luma_8x1 (luma_blend, luma_sample, luma_uchar);
out_luma->write_array_no_check<8> (in_x, in_y, luma_uchar);
// 4x2-UV process UV
uint32_t uv_x = x * 4, uv_y = y * 2;
Float2 uv_blend[4];
Float2 gauss_uv_value[3];
Float2 up_sample_uv[4];
Uchar2 uv_uc[4];
luma_mask1[1] = luma_mask1[2];
luma_mask1[2] = luma_mask1[4];
luma_mask1[3] = luma_mask1[6];
luma_mask2[1] = luma_mask2[2];
luma_mask2[2] = luma_mask2[4];
luma_mask2[3] = luma_mask1[6];
//1st-line UV
read_and_blend_uv_4 (lap_uv[0], lap_uv[1], luma_mask1, uv_x, uv_y, uv_blend);
interpolate_uv_int_row_4x1 (gauss_uv, uv_x / 2, uv_y / 2, gauss_uv_value, up_sample_uv);
reconstruct_luma_4x1 (uv_blend, up_sample_uv, uv_uc);
out_uv->write_array_no_check<4> (uv_x, uv_y, uv_uc);
//2nd-line UV
uv_y += 1;
read_and_blend_uv_4 (lap_uv[0], lap_uv[1], luma_mask2, uv_x, uv_y, uv_blend);
interpolate_uv_half_row_4x1 (gauss_uv, uv_x / 2, uv_y / 2 + 1, gauss_uv_value, up_sample_uv);
reconstruct_luma_4x1 (uv_blend, up_sample_uv, uv_uc);
out_uv->write_array_no_check<4> (uv_x, uv_y, uv_uc);
}
return XCAM_RETURN_NO_ERROR;
}
}
}