xref: /external/libxcam/modules/ocl/cl_blender.cpp

/*
 * cl_blender.cpp - CL 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_blender.h"
#include "cl_device.h"

namespace XCam {

CLBlenderScaleKernel::CLBlenderScaleKernel (const SmartPtr<CLContext> &context, bool is_uv)
    : CLImageKernel (context)
    , _is_uv (is_uv)
{
}

XCamReturn
CLBlenderScaleKernel::prepare_arguments (CLArgList &args, CLWorkSize &work_size)
{
    SmartPtr<CLContext> context = get_context ();

    SmartPtr<CLImage> image_in = get_input_image ();
    SmartPtr<CLImage> image_out = get_output_image ();
    XCAM_ASSERT (image_in.ptr () && image_out.ptr ());
    int output_offset_x;
    uint32_t output_width, output_height;
    get_output_info (output_width, output_height, output_offset_x);

    args.push_back (new CLMemArgument (image_in));
    args.push_back (new CLMemArgument (image_out));
    args.push_back (new CLArgumentT<int> (output_offset_x));
    args.push_back (new CLArgumentT<uint32_t> (output_width));
    args.push_back (new CLArgumentT<uint32_t> (output_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 (output_width, work_size.local[0]);
    work_size.global[1] = XCAM_ALIGN_UP (output_height, work_size.local[1]);

    return XCAM_RETURN_NO_ERROR;
}

CLBlender::CLBlender (
    const SmartPtr<CLContext> &context, const char *name,
    bool need_uv, CLBlenderScaleMode scale_mode)
    : CLImageHandler (context, name)
    , Blender (XCAM_CL_BLENDER_ALIGNMENT_X, XCAM_CL_BLENDER_ALIGNMENT_Y)
    , _need_uv (need_uv)
    , _swap_input_index (false)
    , _scale_mode (scale_mode)
{
    XCAM_ASSERT (get_alignment_x () == XCAM_CL_BLENDER_ALIGNMENT_X);
    XCAM_ASSERT (get_alignment_y () == XCAM_CL_BLENDER_ALIGNMENT_Y);
}

bool
CLBlender::set_input_merge_area (const Rect &area, uint32_t index)
{
    Rect tmp_area = area;
    if (_scale_mode == CLBlenderScaleGlobal)
        tmp_area.width = get_merge_window ().width;

    bool ret = Blender::set_input_merge_area (tmp_area, index);

    if (ret && _scale_mode == CLBlenderScaleGlobal) {
        XCAM_ASSERT (fabs((int32_t)(area.width - get_merge_window ().width)) < XCAM_CL_BLENDER_ALIGNMENT_X);
    }

    return ret;
}

XCamReturn
CLBlender::prepare_buffer_pool_video_info (
    const VideoBufferInfo &input,
    VideoBufferInfo &output)
{
    uint32_t output_width, output_height;
    get_output_size (output_width, output_height);
    XCAM_ASSERT (output_height == input.height);

    // aligned at least XCAM_BLENDER_ALIGNED_WIDTH
    uint32_t aligned_width = XCAM_MAX (16, XCAM_CL_BLENDER_ALIGNMENT_X);
    output.init (
        input.format, output_width, output_height,
        XCAM_ALIGN_UP(output_width, aligned_width), XCAM_ALIGN_UP(output_height, 16));
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
CLBlender::prepare_parameters (SmartPtr<VideoBuffer> &input, SmartPtr<VideoBuffer> &output)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    XCAM_ASSERT (input.ptr () && output.ptr ());
    SmartPtr<VideoBuffer> input0, input1;

    SmartPtr<VideoBuffer> next = input->find_typed_attach<VideoBuffer> ();
    XCAM_FAIL_RETURN(
        WARNING,
        next.ptr (),
        XCAM_RETURN_ERROR_PARAM,
        "CLBlender(%s) does NOT find second buffer in attachment", get_name());

    if (_swap_input_index) {
        input0 = next;
        input1 = input;
    } else {
        input0 = input;
        input1 = next;
    }

    SmartPtr<CLContext> context = get_context ();
    const VideoBufferInfo &in0_info = input0->get_video_info ();
    const VideoBufferInfo &in1_info = input1->get_video_info ();
    const VideoBufferInfo &out_info = output->get_video_info ();

    if (!get_input_valid_area (0).width) {
        Rect area;
        area.width = in0_info.width;
        area.height = in0_info.height;
        set_input_valid_area (area, 0);
    }
    if (!get_input_valid_area (1).width) {
        Rect area;
        area.width = in1_info.width;
        area.height = in1_info.height;
        set_input_valid_area (area, 1);
    }

    if (!is_merge_window_set ()) {
        Rect merge_window;
        XCAM_FAIL_RETURN (
            WARNING,
            auto_calc_merge_window (get_input_valid_area(0).width, get_input_valid_area(1).width, out_info.width, merge_window),
            XCAM_RETURN_ERROR_PARAM,
            "CLBlender(%s) auto calculate merge window failed", get_name ());

        merge_window.pos_y = 0;
        merge_window.height = out_info.height;
        set_merge_window (merge_window);

        Rect area;
        area.width = merge_window.width;
        area.height = merge_window.height;
        area.pos_x = merge_window.pos_x;
        set_input_merge_area (area, 0);
        area.pos_x = 0;
        set_input_merge_area (area, 1);
    }

    ret = allocate_cl_buffers (context, input0, input1, output);
    return ret;
}

SmartPtr<Blender>
create_ocl_blender ()
{
    SmartPtr<CLContext> context = CLDevice::instance ()->get_context ();
    XCAM_FAIL_RETURN (
        ERROR, context.ptr (), NULL,
        "create ocl blender failed to get cl context");
    SmartPtr<CLBlender> blender = create_pyramid_blender (context, 2, true, false).dynamic_cast_ptr<CLBlender> ();
    XCAM_FAIL_RETURN (
        ERROR, blender.ptr (), NULL,
        "create ocl blender failed to get pyramid blender");
    return blender;
}

};