modules/ocl/cl_image_handler.cpp

/*
 * cl_image_handler.cpp - CL image 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: Wind Yuan <feng.yuan@intel.com>
 */

#include "cl_image_handler.h"
#if HAVE_LIBDRM
#include "drm_display.h"
#include "cl_image_bo_buffer.h"
#include "drm_bo_buffer.h"
#endif
#include "cl_device.h"
#include "swapped_buffer.h"

namespace XCam {

#define XCAM_CL_IMAGE_HANDLER_DEFAULT_BUF_NUM 4

CLImageKernel::CLImageKernel (const SmartPtr<CLContext> &context, const char *name, bool enable)
    : CLKernel (context, name)
    , _enable (enable)
{
}

CLImageKernel::~CLImageKernel ()
{
}

/*
 * Default kernel arguments
 * arg0:
 *     input,   __read_only image2d_t
 * arg1:
 *     output,  __write_only image2d_t
 * suppose cl can get width/height pixels from
 * get_image_width/get_image_height
 */
XCamReturn
CLImageKernel::pre_execute ()
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    CLArgList args;
    CLWorkSize work_size;

    XCAM_FAIL_RETURN (
        ERROR, !is_arguments_set (), XCAM_RETURN_ERROR_PARAM,
        "cl image kernel(%s) pre_execute failed since arguments was set somewhere", get_kernel_name ());

    ret = prepare_arguments (args, work_size);
    XCAM_FAIL_RETURN (
        WARNING,
        ret == XCAM_RETURN_NO_ERROR, ret,
        "cl image kernel(%s) prepare arguments failed", get_kernel_name ());

    ret = set_arguments (args, work_size);
    XCAM_FAIL_RETURN (
        WARNING,
        ret == XCAM_RETURN_NO_ERROR, ret,
        "cl image kernel(%s) set_arguments failed", get_kernel_name ());

    return ret;
}

XCamReturn
CLImageKernel::prepare_arguments (
    CLArgList &args, CLWorkSize &work_size)
{
    XCAM_UNUSED (args);
    XCAM_UNUSED (work_size);

    XCAM_LOG_ERROR (
        "cl image kernel(%s) prepare_arguments error."
        "Did you forget to set_arguments or prepare_arguments was not derived", get_kernel_name ());
    return XCAM_RETURN_ERROR_CL;
}

CLImageHandler::CLImageHandler (const SmartPtr<CLContext> &context, const char *name)
    : _name (NULL)
    , _enable (true)
    , _context (context)
    , _buf_pool_type (CLImageHandler::CLVideoPoolType)
    , _disable_buf_pool (false)
    , _buf_pool_size (XCAM_CL_IMAGE_HANDLER_DEFAULT_BUF_NUM)
    , _buf_swap_flags ((uint32_t)(SwappedBuffer::OrderY0Y1) | (uint32_t)(SwappedBuffer::OrderUV0UV1))
    , _buf_swap_init_order (SwappedBuffer::OrderY0Y1)
    , _result_timestamp (XCam::InvalidTimestamp)
{
    XCAM_ASSERT (name);
    if (name)
        _name = strndup (name, XCAM_MAX_STR_SIZE);

    XCAM_OBJ_PROFILING_INIT;
}

CLImageHandler::~CLImageHandler ()
{
    if (_name)
        xcam_free (_name);
}

bool
CLImageHandler::enable_buf_pool_swap_flags (
    uint32_t flags,
    uint32_t init_order)
{
#if HAVE_LIBDRM
    _buf_swap_flags = flags;
    _buf_swap_init_order = init_order;

    SmartPtr<DrmBoBufferPool> pool = _buf_pool.dynamic_cast_ptr<DrmBoBufferPool> ();

    if (pool.ptr () && !pool->update_swap_init_order (init_order)) {
        XCAM_LOG_ERROR (
            "Handler(%s) update swap order(0x%04x) to buffer pool failed",
            XCAM_STR (get_name ()),
            init_order);
        return false;
    }
    return true;
#else
    XCAM_LOG_ERROR ("CLImageHandler doesn't support swapping flags");

    XCAM_UNUSED (flags);
    XCAM_UNUSED (init_order);
    return false;
#endif
}

bool
CLImageHandler::add_kernel (const SmartPtr<CLImageKernel> &kernel)
{
    _kernels.push_back (kernel);
    return true;
}

bool
CLImageHandler::enable_handler (bool enable)
{
    _enable = enable;
    return true;
}

bool
CLImageHandler::is_handler_enabled () const
{
    return _enable;
}

XCamReturn
CLImageHandler::create_buffer_pool (const VideoBufferInfo &video_info)
{
    if (_buf_pool.ptr ())
        return XCAM_RETURN_ERROR_PARAM;

    SmartPtr<BufferPool> buffer_pool;
    if (_buf_pool_type == CLImageHandler::CLVideoPoolType) {
        buffer_pool = new CLVideoBufferPool ();
    }
#if HAVE_LIBDRM
    else {
        SmartPtr<DrmDisplay> display = DrmDisplay::instance ();
        XCAM_FAIL_RETURN(
            WARNING,
            display.ptr (),
            XCAM_RETURN_ERROR_CL,
            "CLImageHandler(%s) failed to get drm dispay", XCAM_STR (_name));

        if (_buf_pool_type == CLImageHandler::DrmBoPoolType) {
            buffer_pool = new DrmBoBufferPool (display);
        } else if (_buf_pool_type == CLImageHandler::CLBoPoolType) {
            buffer_pool = new CLBoBufferPool (display, get_context ());
        }
    }
#endif
    XCAM_FAIL_RETURN(
        WARNING,
        buffer_pool.ptr (),
        XCAM_RETURN_ERROR_CL,
        "CLImageHandler(%s) create buffer pool failed, pool_type:%d",
        XCAM_STR (_name), (int32_t)_buf_pool_type);

    XCAM_ASSERT (buffer_pool.ptr ());
    // buffer_pool->set_swap_flags (_buf_swap_flags, _buf_swap_init_order);
    buffer_pool->set_video_info (video_info);

    XCAM_FAIL_RETURN(
        WARNING,
        buffer_pool->reserve (_buf_pool_size),
        XCAM_RETURN_ERROR_CL,
        "CLImageHandler(%s) failed to init drm buffer pool", XCAM_STR (_name));

    _buf_pool = buffer_pool;
    return XCAM_RETURN_NO_ERROR;
}

bool CLImageHandler::is_ready ()
{
    if (_disable_buf_pool)
        return true;
    if (!_buf_pool.ptr ())  //execute not triggered
        return true;
    if (_buf_pool->has_free_buffers ())
        return true;
    return false;
}

XCamReturn CLImageHandler::prepare_buffer_pool_video_info (
    const VideoBufferInfo &input,
    VideoBufferInfo &output)
{
    output = input;
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
CLImageHandler::prepare_parameters (SmartPtr<VideoBuffer> &input, SmartPtr<VideoBuffer> &output)
{
    XCAM_UNUSED (input);
    XCAM_UNUSED (output);
    XCAM_ASSERT (input.ptr () && output.ptr ());
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
CLImageHandler::ensure_parameters (SmartPtr<VideoBuffer> &input, SmartPtr<VideoBuffer> &output)
{
    XCamReturn ret = prepare_parameters (input, output);
    XCAM_FAIL_RETURN(
        WARNING, ret == XCAM_RETURN_NO_ERROR || ret == XCAM_RETURN_BYPASS, ret,
        "CLImageHandler(%s) failed to prepare_parameters", XCAM_STR (_name));

    reset_buf_cache (input, output);
    return ret;
}

void
CLImageHandler::reset_buf_cache (const SmartPtr<VideoBuffer>& input, const SmartPtr<VideoBuffer>& output)
{
    _input_buf_cache = input;
    _output_buf_cache = output;
}

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

    if (_disable_buf_pool)
        return XCAM_RETURN_NO_ERROR;

    if (!_buf_pool.ptr ()) {
        VideoBufferInfo output_video_info;

        ret = prepare_buffer_pool_video_info (input->get_video_info (), output_video_info);
        XCAM_FAIL_RETURN(
            WARNING,
            ret == XCAM_RETURN_NO_ERROR,
            ret,
            "CLImageHandler(%s) prepare output video info failed", XCAM_STR (_name));

        ret = create_buffer_pool (output_video_info);
        XCAM_FAIL_RETURN(
            WARNING,
            ret == XCAM_RETURN_NO_ERROR,
            ret,
            "CLImageHandler(%s) ensure drm buffer pool failed", XCAM_STR (_name));
    }

    output = _buf_pool->get_buffer (_buf_pool);
    XCAM_FAIL_RETURN(
        WARNING,
        output.ptr(),
        XCAM_RETURN_ERROR_UNKNOWN,
        "CLImageHandler(%s) failed to get drm buffer from pool", XCAM_STR (_name));

    // TODO, need consider output is not sync up with input buffer
    output->set_timestamp (input->get_timestamp ());
    output->copy_attaches (input);

    return XCAM_RETURN_NO_ERROR;
}

void
CLImageHandler::emit_stop ()
{
    for (KernelList::iterator i_kernel = _kernels.begin ();
            i_kernel != _kernels.end ();  ++i_kernel) {
        (*i_kernel)->pre_stop ();
    }

    if (_buf_pool.ptr ())
        _buf_pool->stop ();
}

SmartPtr<VideoBuffer> &
CLImageHandler::get_input_buf ()
{
    XCAM_ASSERT (_input_buf_cache.ptr ());
    return _input_buf_cache;
}

SmartPtr<VideoBuffer> &
CLImageHandler::get_output_buf ()
{
    XCAM_ASSERT (_output_buf_cache.ptr ());
    return _output_buf_cache;
}

XCamReturn
CLImageHandler::execute_kernel (SmartPtr<CLImageKernel> &kernel)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    if (!kernel->is_enabled ())
        return XCAM_RETURN_NO_ERROR;

    if (!kernel->is_arguments_set ()) {
        XCAM_FAIL_RETURN (
            WARNING,
            (ret = kernel->pre_execute ()) == XCAM_RETURN_NO_ERROR, ret,
            "cl_image_handler(%s) pre_execute kernel(%s) failed",
            XCAM_STR (_name), kernel->get_kernel_name ());
    }

    CLArgList args = kernel->get_args ();
    ret = kernel->execute (kernel, false);
    XCAM_FAIL_RETURN (
        WARNING, ret == XCAM_RETURN_NO_ERROR || ret == XCAM_RETURN_BYPASS, ret,
        "cl_image_handler(%s) execute kernel(%s) failed",
        XCAM_STR (_name), kernel->get_kernel_name ());

#if 0
    ret = kernel->post_execute (args);
    XCAM_FAIL_RETURN (
        WARNING,
        (ret == XCAM_RETURN_NO_ERROR || ret == XCAM_RETURN_BYPASS),
        ret,
        "cl_image_handler(%s) post_execute kernel(%s) failed",
        XCAM_STR (_name), kernel->get_kernel_name ());
#endif

    return ret;
}

XCamReturn
CLImageHandler::execute_kernels ()
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    for (KernelList::iterator i_kernel = _kernels.begin ();
            i_kernel != _kernels.end (); ++i_kernel) {
        SmartPtr<CLImageKernel> &kernel = *i_kernel;

        XCAM_FAIL_RETURN (
            WARNING, kernel.ptr(), XCAM_RETURN_ERROR_PARAM,
            "kernel empty");

        ret = execute_kernel (kernel);

        if (ret != XCAM_RETURN_NO_ERROR)
            break;
    }

    return ret;
}

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

    XCAM_FAIL_RETURN (
        WARNING,
        !_kernels.empty (),
        XCAM_RETURN_ERROR_PARAM,
        "cl_image_handler(%s) no image kernel set", XCAM_STR (_name));

    if (!is_handler_enabled ()) {
        output = input;
        return XCAM_RETURN_NO_ERROR;
    }

    XCAM_FAIL_RETURN (
        WARNING,
        (ret = prepare_output_buf (input, output)) == XCAM_RETURN_NO_ERROR,
        ret,
        "cl_image_handler (%s) prepare output buf failed", XCAM_STR (_name));
    XCAM_ASSERT (output.ptr ());

    ret = ensure_parameters (input, output);
    XCAM_FAIL_RETURN (
        WARNING, (ret == XCAM_RETURN_NO_ERROR || ret == XCAM_RETURN_BYPASS), ret,
        "cl_image_handler (%s) ensure parameters failed", XCAM_STR (_name));

    if (ret == XCAM_RETURN_BYPASS)
        return ret;

    XCAM_OBJ_PROFILING_START;
    ret = execute_kernels ();

    reset_buf_cache (NULL, NULL);

#if ENABLE_PROFILING
    get_context ()->finish ();
#endif
    XCAM_OBJ_PROFILING_END (XCAM_STR (_name), XCAM_OBJ_DUR_FRAME_NUM);

    XCAM_FAIL_RETURN (
        WARNING, (ret == XCAM_RETURN_NO_ERROR || ret == XCAM_RETURN_BYPASS), ret,
        "cl_image_handler (%s) execute kernels failed", XCAM_STR (_name));

    if (ret != XCAM_RETURN_NO_ERROR)
        return ret;

    ret = execute_done (output);
    return ret;
}

XCamReturn
CLImageHandler::execute_done (SmartPtr<VideoBuffer> &output)
{
    XCAM_UNUSED (output);
    return XCAM_RETURN_NO_ERROR;
}

void
CLImageHandler::set_3a_result (SmartPtr<X3aResult> &result)
{
    if (!result.ptr ())
        return;

    int64_t ts = result->get_timestamp ();
    _result_timestamp = (ts != XCam::InvalidTimestamp) ? ts : _result_timestamp;

    X3aResultList::iterator i_res = _3a_results.begin ();
    for (; i_res != _3a_results.end(); ++i_res) {
        if (result->get_type () == (*i_res)->get_type ()) {
            (*i_res) = result;
            break;
        }
    }

    if (i_res == _3a_results.end ()) {
        _3a_results.push_back (result);
    }
}

SmartPtr<X3aResult>
CLImageHandler::get_3a_result (XCam3aResultType type)
{
    X3aResultList::iterator i_res = _3a_results.begin ();
    SmartPtr<X3aResult> res;

    for ( ; i_res != _3a_results.end(); ++i_res) {
        if (type == (*i_res)->get_type ()) {
            res = (*i_res);
            break;
        }
    }
    return res;
}

bool
CLImageHandler::append_kernels (SmartPtr<CLImageHandler> handler)
{
    XCAM_ASSERT (!handler->_kernels.empty ());
    _kernels.insert (_kernels.end (), handler->_kernels.begin (), handler->_kernels.end ());
    return true;
}

CLCloneImageHandler::CLCloneImageHandler (const SmartPtr<CLContext> &context, const char *name)
    : CLImageHandler (context, name)
    , _clone_flags (SwappedBuffer::SwapNone)
{
}

XCamReturn
CLCloneImageHandler::prepare_output_buf (SmartPtr<VideoBuffer> &input, SmartPtr<VideoBuffer> &output)
{
#if HAVE_LIBDRM
    XCAM_FAIL_RETURN (
        ERROR,
        _clone_flags != (uint32_t)(SwappedBuffer::SwapNone),
        XCAM_RETURN_ERROR_PARAM,
        "CLCloneImageHandler(%s) clone output buffer failed since clone_flags none",
        XCAM_STR (get_name ()));

    XCAM_ASSERT (input.ptr ());
    SmartPtr<SwappedBuffer> swap_input = input.dynamic_cast_ptr<DrmBoBuffer> ();
    XCAM_ASSERT (swap_input.ptr ());
    SmartPtr<SwappedBuffer> swap_output = swap_input->swap_clone (swap_input, _clone_flags);
    SmartPtr<DrmBoBuffer> swapped_buf = swap_output.dynamic_cast_ptr<DrmBoBuffer> ();
    XCAM_FAIL_RETURN (
        ERROR,
        swapped_buf.ptr (),
        XCAM_RETURN_ERROR_UNKNOWN,
        "CLCloneImageHandler(%s) clone output buffer failed(clone_flags:%d)",
        XCAM_STR (get_name ()), _clone_flags);

    output = swapped_buf;
    return XCAM_RETURN_NO_ERROR;
#else
    XCAM_LOG_ERROR ("CLCloneImageHandler doesn't support DrmBoBuffer");

    XCAM_UNUSED (input);
    XCAM_UNUSED (output);
    return XCAM_RETURN_ERROR_PARAM;
#endif
}

};