modules/ocl/cl_image_processor.cpp

/*
 * cl_image_processor.cpp - CL image processor
 *
 *  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_processor.h"
#include "cl_context.h"
#include "cl_device.h"
#include "cl_image_handler.h"
#include "cl_demo_handler.h"
#include "xcam_thread.h"

namespace XCam {

class CLHandlerThread
    : public Thread
{
public:
    CLHandlerThread (CLImageProcessor *processor)
        : Thread ("CLHandlerThread")
        , _processor (processor)
    {}
    ~CLHandlerThread () {}

    virtual bool loop ();

private:
    CLImageProcessor *_processor;
};

bool CLHandlerThread::loop ()
{
    XCAM_ASSERT (_processor);
    XCamReturn ret = _processor->process_cl_buffer_queue ();
    if (ret != XCAM_RETURN_NO_ERROR && ret != XCAM_RETURN_BYPASS)
        return false;
    return true;
}

class CLBufferNotifyThread
    : public Thread
{
public:
    CLBufferNotifyThread (CLImageProcessor *processor)
        : Thread ("CLBufNtfThrd")
        , _processor (processor)
    {}
    ~CLBufferNotifyThread () {}

    virtual bool loop ();

private:
    CLImageProcessor *_processor;
};

bool CLBufferNotifyThread::loop ()
{
    XCAM_ASSERT (_processor);
    XCamReturn ret = _processor->process_done_buffer ();
    if (ret < XCAM_RETURN_NO_ERROR)
        return false;
    return true;
}
CLImageProcessor::CLImageProcessor (const char* name)
    : ImageProcessor (name ? name : "CLImageProcessor")
    , _seq_num (0)
    , _keep_attached_buffer (false)
{
    _context = CLDevice::instance ()->get_context ();
    XCAM_ASSERT (_context.ptr());

    _handler_thread = new CLHandlerThread (this);
    XCAM_ASSERT (_handler_thread.ptr ());

    _done_buf_thread = new CLBufferNotifyThread (this);
    XCAM_ASSERT (_done_buf_thread.ptr ());

    XCAM_LOG_DEBUG ("CLImageProcessor constructed");
    XCAM_OBJ_PROFILING_INIT;
}

CLImageProcessor::~CLImageProcessor ()
{
    XCAM_LOG_DEBUG ("CLImageProcessor destructed");
}

void
CLImageProcessor::keep_attached_buf(bool flag)
{
    _keep_attached_buffer = flag;
}

bool
CLImageProcessor::add_handler (SmartPtr<CLImageHandler> &handler)
{
    XCAM_ASSERT (handler.ptr ());
    _handlers.push_back (handler);
    return true;
}

CLImageProcessor::ImageHandlerList::iterator
CLImageProcessor::handlers_begin ()
{
    return _handlers.begin ();
}

CLImageProcessor::ImageHandlerList::iterator
CLImageProcessor::handlers_end ()
{
    return _handlers.end ();
}

SmartPtr<CLContext>
CLImageProcessor::get_cl_context ()
{
    return _context;
}

bool
CLImageProcessor::can_process_result (SmartPtr<X3aResult> &result)
{
    XCAM_UNUSED (result);
    return false;
}

XCamReturn
CLImageProcessor::apply_3a_results (X3aResultList &results)
{
    XCAM_UNUSED (results);
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
CLImageProcessor::apply_3a_result (SmartPtr<X3aResult> &result)
{
    XCAM_UNUSED (result);
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
CLImageProcessor::process_buffer (SmartPtr<VideoBuffer> &input, SmartPtr<VideoBuffer> &output)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    XCAM_ASSERT (input.ptr ());

    // Always set to NULL,  output buf should be handled in CLBufferNotifyThread
    output = NULL;

    STREAM_LOCK;

    if (_handlers.empty()) {
        ret = create_handlers ();
    }

    XCAM_FAIL_RETURN (
        WARNING,
        !_handlers.empty () && ret == XCAM_RETURN_NO_ERROR,
        XCAM_RETURN_ERROR_CL,
        "CL image processor create handlers failed");

    SmartPtr<PriorityBuffer> p_buf = new PriorityBuffer;
    p_buf->set_seq_num (_seq_num++);
    p_buf->data = input;
    p_buf->handler = *(_handlers.begin ());

    XCAM_FAIL_RETURN (
        WARNING,
        _process_buffer_queue.push_priority_buf (p_buf),
        XCAM_RETURN_ERROR_UNKNOWN,
        "CLImageProcessor push priority buffer failed");

    return XCAM_RETURN_BYPASS;
}

XCamReturn
CLImageProcessor::process_done_buffer ()
{
    SmartPtr<VideoBuffer> done_buf = _done_buffer_queue.pop (-1);
    if (!done_buf.ptr ())
        return XCAM_RETURN_ERROR_THREAD;

    //notify buffer done, only in this thread
    notify_process_buffer_done (done_buf);
    return XCAM_RETURN_NO_ERROR;
}

uint32_t
CLImageProcessor::check_ready_buffers ()
{
    uint32_t ready_count = 0;
    bool is_ready_or_disabled = false;
    UnsafePriorityBufferList::iterator i = _not_ready_buffers.begin ();

    while (i != _not_ready_buffers.end()) {
        SmartPtr<PriorityBuffer> buf = *i;
        XCAM_ASSERT (buf.ptr () && buf->handler.ptr ());
        {
            is_ready_or_disabled = (!buf->handler->is_handler_enabled () || buf->handler->is_ready ());
        }
        if (is_ready_or_disabled) {
            ready_count ++;
            _process_buffer_queue.push_priority_buf (buf);
            _not_ready_buffers.erase (i++);
        } else
            ++i;
    }
    return ready_count;
}

XCamReturn
CLImageProcessor::process_cl_buffer_queue ()
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    SmartPtr<PriorityBuffer> p_buf;
    const int32_t timeout = 5000; // 5ms
    uint32_t ready_count = 0;

    {
        STREAM_LOCK;  // make sure handler APIs are protected
        check_ready_buffers ();
    }

    p_buf = _process_buffer_queue.pop (timeout);

    if (!p_buf.ptr ()) {
        //XCAM_LOG_DEBUG ("cl buffer queue stopped");
        return XCAM_RETURN_BYPASS;
    }

    SmartPtr<VideoBuffer> data = p_buf->data;
    SmartPtr<CLImageHandler> handler = p_buf->handler;
    SmartPtr <VideoBuffer> out_data;

    XCAM_ASSERT (data.ptr () && handler.ptr ());

    XCAM_LOG_DEBUG ("buf:%d, rank:%d\n", p_buf->seq_num, p_buf->rank);

    {
        STREAM_LOCK;
        if (handler->is_handler_enabled () && !handler->is_ready ()) {
            _not_ready_buffers.push_back (p_buf);
            return XCAM_RETURN_NO_ERROR;
        }

        ready_count = check_ready_buffers ();
        if (ready_count) {
            _process_buffer_queue.push_priority_buf (p_buf);
            return XCAM_RETURN_BYPASS;
        }

        ret = handler->execute (data, out_data);
        XCAM_FAIL_RETURN (
            WARNING,
            (ret == XCAM_RETURN_NO_ERROR || ret == XCAM_RETURN_BYPASS),
            ret,
            "CLImageProcessor execute image handler failed");
        XCAM_ASSERT (out_data.ptr ());
        if (ret == XCAM_RETURN_BYPASS)
            return ret;

        // for loop in handler, find next handler
        ImageHandlerList::iterator i_handler = _handlers.begin ();
        while (i_handler != _handlers.end ())
        {
            if (handler.ptr () == (*i_handler).ptr ()) {
                ++i_handler;
                break;
            }
            ++i_handler;
        }

        //skip all disabled handlers
        while (i_handler != _handlers.end () && !(*i_handler)->is_handler_enabled ())
            ++i_handler;

        if (i_handler != _handlers.end ())
            p_buf->handler = *i_handler;
        else
            p_buf->handler = NULL;
    }

    // buffer processed by all handlers, done
    if (!p_buf->handler.ptr ()) {
        if (!_keep_attached_buffer && out_data.ptr ())
            out_data->clear_attached_buffers ();

        XCAM_OBJ_PROFILING_START;
        CLDevice::instance()->get_context ()->finish ();
        XCAM_OBJ_PROFILING_END (get_name (), XCAM_OBJ_DUR_FRAME_NUM);

        // buffer done, push back
        _done_buffer_queue.push (out_data);
        return XCAM_RETURN_NO_ERROR;
    }

    p_buf->data = out_data;
    p_buf->down_rank ();

    XCAM_FAIL_RETURN (
        WARNING,
        _process_buffer_queue.push_priority_buf (p_buf),
        XCAM_RETURN_ERROR_UNKNOWN,
        "CLImageProcessor push priority buffer failed");

    return ret;
}

XCamReturn
CLImageProcessor::emit_start ()
{
    _done_buffer_queue.resume_pop ();
    _process_buffer_queue.resume_pop ();

    if (!_done_buf_thread->start ())
        return XCAM_RETURN_ERROR_THREAD;

    if (!_handler_thread->start ())
        return XCAM_RETURN_ERROR_THREAD;

    return XCAM_RETURN_NO_ERROR;
}

void
CLImageProcessor::emit_stop ()
{
    _process_buffer_queue.pause_pop();
    _done_buffer_queue.pause_pop ();


    for (ImageHandlerList::iterator i_handler = _handlers.begin ();
            i_handler != _handlers.end ();  ++i_handler) {
        (*i_handler)->emit_stop ();
    }

    _handler_thread->stop ();
    _done_buf_thread->stop ();
    _not_ready_buffers.clear ();
    _process_buffer_queue.clear ();
    _done_buffer_queue.clear ();
}

XCamReturn
CLImageProcessor::create_handlers ()
{
    SmartPtr<CLImageHandler> demo_handler;
    demo_handler = create_cl_demo_image_handler (_context);
    // demo_handler = create_cl_binary_demo_image_handler (_context);
    XCAM_FAIL_RETURN (
        WARNING,
        demo_handler.ptr (),
        XCAM_RETURN_ERROR_CL,
        "CLImageProcessor create demo handler failed");
    add_handler (demo_handler);

    return XCAM_RETURN_NO_ERROR;
}

};