/*
 * cl_bayer_basic_handler.cpp - CL bayer basic 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_utils.h"
#include "cl_bayer_basic_handler.h"
#include "xcam_thread.h"

#define GROUP_CELL_X_SIZE 64
#define GROUP_CELL_Y_SIZE 4

#define STATS_3A_CELL_X_SIZE 8
#define STATS_3A_CELL_Y_SIZE GROUP_CELL_Y_SIZE

#define STANDARD_3A_STATS_SIZE 8

#define ENABLE_IMAGE_2D_INPUT 0

namespace XCam {

static const XCamKernelInfo kernel_bayer_basic_info = {
    "kernel_bayer_basic",
#include "kernel_bayer_basic.clx"
    , 0,
};

struct BayerPostData {
    SmartPtr<VideoBuffer> image_buffer;
    SmartPtr<CLBuffer>    stats_cl_buf;
};

class CLBayer3AStatsThread
    : public Thread
{
public:
    CLBayer3AStatsThread (CLBayerBasicImageHandler *handler)
        : Thread ("CLBayer3AStatsThread")
        , _handler (handler)
    {}
    ~CLBayer3AStatsThread () {}

    virtual bool emit_stop ();
    bool queue_stats (SmartPtr<VideoBuffer> &buf, SmartPtr<CLBuffer> &stats);
    SmartPtr<VideoBuffer> pop_buf ();
protected:
    virtual bool loop ();
    virtual void stopped ();

private:
    CLBayerBasicImageHandler     *_handler;
    SafeList<BayerPostData>      _stats_process_list;
    SafeList<VideoBuffer>        _buffer_done_list;
};

bool
CLBayer3AStatsThread::emit_stop ()
{
    _stats_process_list.pause_pop ();
    _buffer_done_list.pause_pop ();

    _stats_process_list.wakeup ();
    _buffer_done_list.wakeup ();

    return Thread::emit_stop ();
}

bool
CLBayer3AStatsThread::queue_stats (SmartPtr<VideoBuffer> &buf, SmartPtr<CLBuffer> &stats)
{
    XCAM_FAIL_RETURN (
        WARNING,
        buf.ptr () && stats.ptr (),
        false,
        "cl bayer 3a-stats thread has error buffer/stats to queue");

    SmartPtr<BayerPostData> data = new BayerPostData;
    XCAM_ASSERT (data.ptr ());
    data->image_buffer = buf;
    data->stats_cl_buf = stats;

    return _stats_process_list.push (data);
}

SmartPtr<VideoBuffer>
CLBayer3AStatsThread::pop_buf ()
{
    return _buffer_done_list.pop ();
}

void
CLBayer3AStatsThread::stopped ()
{
    _stats_process_list.clear ();
    _buffer_done_list.clear ();
}

bool
CLBayer3AStatsThread::loop ()
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    SmartPtr<BayerPostData> data;
    data = _stats_process_list.pop ();
    if (!data.ptr ()) {
        XCAM_LOG_INFO ("cl bayer 3a-stats thread is going to stop, processing data empty");
        return false;
    }

    XCAM_ASSERT (data->image_buffer.ptr ());
    XCAM_ASSERT (data->stats_cl_buf.ptr ());
    XCAM_ASSERT (_handler);

    ret = _handler->process_stats_buffer (data->image_buffer, data->stats_cl_buf);
    XCAM_FAIL_RETURN (
        WARNING,
        ret == XCAM_RETURN_NO_ERROR,
        false,
        "cl bayer 3a-stats thread has error buffer on kernel post processing");

    XCAM_FAIL_RETURN (
        ERROR,
        _buffer_done_list.push (data->image_buffer),
        false,
        "cl bayer 3a-stats thread failed to queue done-buffers");
    return true;
}

CLBayerBasicImageKernel::CLBayerBasicImageKernel (const SmartPtr<CLContext> &context)
    : CLImageKernel (context, "kernel_bayer_basic")
{
}

XCamReturn
CLBayerBasicImageHandler::process_stats_buffer (SmartPtr<VideoBuffer> &buffer, SmartPtr<CLBuffer> &cl_stats)
{
    SmartPtr<X3aStats> stats_3a;
    SmartPtr<CLContext> context = get_context ();

    XCAM_OBJ_PROFILING_START;

    context->finish ();
    stats_3a = _3a_stats_context->copy_stats_out (cl_stats);
    if (!stats_3a.ptr ()) {
        XCAM_LOG_DEBUG ("copy 3a stats failed, maybe handler stopped");
        return XCAM_RETURN_ERROR_CL;
    }

    stats_3a->set_timestamp (buffer->get_timestamp ());
    buffer->attach_buffer (stats_3a);

    if (cl_stats.ptr ())
        _3a_stats_context->release_buffer (cl_stats);

    XCAM_OBJ_PROFILING_END ("3a_stats_cpu_copy(async)", XCAM_OBJ_DUR_FRAME_NUM);

    return post_stats (stats_3a);
}

CLBayerBasicImageHandler::CLBayerBasicImageHandler (
    const SmartPtr<CLContext> &context, const char *name)
    : CLImageHandler (context, name)
    , _is_first_buf (true)
{
    _blc_config.level_gr = XCAM_CL_BLC_DEFAULT_LEVEL;
    _blc_config.level_r = XCAM_CL_BLC_DEFAULT_LEVEL;
    _blc_config.level_b = XCAM_CL_BLC_DEFAULT_LEVEL;
    _blc_config.level_gb = XCAM_CL_BLC_DEFAULT_LEVEL;
    _blc_config.color_bits = 10;

    _wb_config.r_gain = 1.0;
    _wb_config.gr_gain = 1.0;
    _wb_config.gb_gain = 1.0;
    _wb_config.b_gain = 1.0;

    for(int i = 0; i < XCAM_GAMMA_TABLE_SIZE; i++)
        _gamma_table[i] = (float)i / 256.0f;
    _gamma_table[XCAM_GAMMA_TABLE_SIZE] = 0.9999f;

    _3a_stats_context = new CL3AStatsCalculatorContext (context);
    XCAM_ASSERT (_3a_stats_context.ptr ());
    _3a_stats_thread = new CLBayer3AStatsThread (this);
    XCAM_ASSERT (_3a_stats_thread.ptr ());

    XCAM_OBJ_PROFILING_INIT;
}

CLBayerBasicImageHandler::~CLBayerBasicImageHandler ()
{
    _3a_stats_thread->stop ();
    _3a_stats_context->clean_up_data ();
}

void
CLBayerBasicImageHandler::set_stats_bits (uint32_t stats_bits)
{
    XCAM_ASSERT (_3a_stats_context.ptr ());
    _3a_stats_context->set_bit_depth (stats_bits);
}

bool
CLBayerBasicImageHandler::set_bayer_kernel (SmartPtr<CLBayerBasicImageKernel> &kernel)
{
    SmartPtr<CLImageKernel> image_kernel = kernel;
    add_kernel (image_kernel);
    _bayer_kernel = kernel;
    return true;
}

bool
CLBayerBasicImageHandler::set_blc_config (const XCam3aResultBlackLevel &blc)
{
    _blc_config.level_r = (float)blc.r_level;
    _blc_config.level_gr = (float)blc.gr_level;
    _blc_config.level_gb = (float)blc.gb_level;
    _blc_config.level_b = (float)blc.b_level;
    //_blc_config.color_bits = 0;
    return true;
}

bool
CLBayerBasicImageHandler::set_wb_config (const XCam3aResultWhiteBalance &wb)
{
    _wb_config.r_gain = (float)wb.r_gain;
    _wb_config.gr_gain = (float)wb.gr_gain;
    _wb_config.gb_gain = (float)wb.gb_gain;
    _wb_config.b_gain = (float)wb.b_gain;
    return true;
}

bool
CLBayerBasicImageHandler::set_gamma_table (const XCam3aResultGammaTable &gamma)
{
    for(int i = 0; i < XCAM_GAMMA_TABLE_SIZE; i++)
        _gamma_table[i] = (float)gamma.table[i] / 256.0f;

    return true;
}

void
CLBayerBasicImageHandler::emit_stop ()
{
    _3a_stats_context->pre_stop ();
    _3a_stats_thread->emit_stop ();
}

XCamReturn
CLBayerBasicImageHandler::prepare_buffer_pool_video_info (
    const VideoBufferInfo &input,
    VideoBufferInfo &output)
{
    uint32_t format = XCAM_PIX_FMT_SGRBG16_planar;
    bool format_inited = output.init (format, input.width / 2 , input.height / 2);

    XCAM_FAIL_RETURN (
        WARNING,
        format_inited,
        XCAM_RETURN_ERROR_PARAM,
        "CL image handler(%s) output format(%s) unsupported",
        get_name (), xcam_fourcc_to_string (format));

    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
CLBayerBasicImageHandler::prepare_parameters (
    SmartPtr<VideoBuffer> &input, SmartPtr<VideoBuffer> &output)
{
    SmartPtr<CLContext> context = get_context ();
    const VideoBufferInfo & in_video_info = input->get_video_info ();
    const VideoBufferInfo & out_video_info = output->get_video_info ();
    CLImageDesc in_image_info;
    CLImageDesc out_image_info;
    CLArgList args;
    CLWorkSize work_size;

    XCAM_ASSERT (_bayer_kernel.ptr ());

    if (!_3a_stats_context->is_ready () &&
            !_3a_stats_context->allocate_data (
                in_video_info,
                STANDARD_3A_STATS_SIZE / STATS_3A_CELL_X_SIZE,
                STANDARD_3A_STATS_SIZE / STATS_3A_CELL_Y_SIZE)) {
        XCAM_LOG_WARNING ("CL3AStatsCalculatorContext allocate data failed");
        return XCAM_RETURN_ERROR_MEM;
    }

    if (_is_first_buf) {
        XCAM_FAIL_RETURN (
            WARNING, _3a_stats_thread->start (), XCAM_RETURN_ERROR_THREAD,
            "cl bayer basic handler start 3a stats thread failed");
    }

    in_image_info.format.image_channel_order = CL_RGBA;
    in_image_info.format.image_channel_data_type = CL_UNSIGNED_INT32; //CL_UNORM_INT16;
    in_image_info.width = in_video_info.aligned_width / 8;
    in_image_info.height = in_video_info.height;
    in_image_info.row_pitch = in_video_info.strides[0];

    out_image_info.format.image_channel_order = CL_RGBA;
    out_image_info.format.image_channel_data_type = CL_UNSIGNED_INT32; //CL_UNORM_INT16;
    out_image_info.width = out_video_info.width  / 8;
    out_image_info.height = out_video_info.aligned_height * 4;
    out_image_info.row_pitch = out_video_info.strides[0];

#if ENABLE_IMAGE_2D_INPUT
    SmartPtr<CLImage> image_in = convert_to_climage (context, input, in_image_info);
#else
    SmartPtr<CLBuffer> buffer_in = convert_to_clbuffer (context, input);
#endif
    uint32_t input_aligned_width = in_video_info.strides[0] / (2 * 8); // ushort8
    SmartPtr<CLImage> image_out = convert_to_climage (context, output, out_image_info);

    uint32_t out_aligned_height = out_video_info.aligned_height;
    _blc_config.color_bits = in_video_info.color_bits;

    SmartPtr<CLBuffer> gamma_table_buffer = new CLBuffer(
        context, sizeof(float) * (XCAM_GAMMA_TABLE_SIZE + 1),
        CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR, &_gamma_table);

    _stats_cl_buffer = _3a_stats_context->get_buffer ();
    XCAM_FAIL_RETURN (
        WARNING,
        _stats_cl_buffer.ptr () && _stats_cl_buffer->is_valid (),
        XCAM_RETURN_ERROR_PARAM,
        "CLBayerBasic handler get 3a stats buffer failed");

    XCAM_FAIL_RETURN (
        WARNING,
        image_out->is_valid (),
        XCAM_RETURN_ERROR_MEM,
        "cl image handler(%s) out memory not available", XCAM_STR(get_name ()));

    //set args;
#if ENABLE_IMAGE_2D_INPUT
    args.push_back (new CLMemArgument (image_in));
#else
    args.push_back (new CLMemArgument (buffer_in));
#endif
    args.push_back (new CLArgumentT<uint32_t> (input_aligned_width));
    args.push_back (new CLMemArgument (image_out));
    args.push_back (new CLArgumentT<uint32_t> (out_aligned_height));
    args.push_back (new CLArgumentT<CLBLCConfig> (_blc_config));
    args.push_back (new CLArgumentT<CLWBConfig> (_wb_config));
    args.push_back (new CLMemArgument (gamma_table_buffer));
    args.push_back (new CLMemArgument (_stats_cl_buffer));

    work_size.dim = XCAM_DEFAULT_IMAGE_DIM;
    work_size.local[0] = 16;
    work_size.local[1] = 2;
    work_size.global[0] = XCAM_ALIGN_UP(out_video_info.width, GROUP_CELL_X_SIZE) / GROUP_CELL_X_SIZE * work_size.local[0];
    work_size.global[1] = XCAM_ALIGN_UP(out_video_info.aligned_height, GROUP_CELL_Y_SIZE) / GROUP_CELL_Y_SIZE * work_size.local[1];

    //printf ("work_size:g(%d, %d), l(%d, %d)\n", work_size.global[0], work_size.global[1], work_size.local[0], work_size.local[1]);
    XCAM_ASSERT (_bayer_kernel.ptr ());
    XCamReturn ret = _bayer_kernel->set_arguments (args, work_size);
    XCAM_FAIL_RETURN (
        WARNING, ret == XCAM_RETURN_NO_ERROR, ret,
        "bayer basic kernel set arguments failed.");

    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
CLBayerBasicImageHandler::execute_done (SmartPtr<VideoBuffer> &output)
{
    XCAM_FAIL_RETURN (
        ERROR, _3a_stats_thread->queue_stats (output, _stats_cl_buffer), XCAM_RETURN_ERROR_UNKNOWN,
        "cl bayer basic handler(%s) process 3a stats failed", XCAM_STR (get_name ()));

    _stats_cl_buffer.release ();

    if (_is_first_buf) {
        _is_first_buf = false;
        return XCAM_RETURN_BYPASS;
    }

    SmartPtr<VideoBuffer> done_buf = _3a_stats_thread->pop_buf ();
    XCAM_FAIL_RETURN (
        WARNING,
        done_buf.ptr (),
        XCAM_RETURN_ERROR_MEM,
        "cl bayer handler(%s) failed to get done buffer", get_name ());
    output = done_buf;

    return XCAM_RETURN_NO_ERROR;
}


XCamReturn
CLBayerBasicImageHandler::post_stats (const SmartPtr<X3aStats> &stats)
{
    if (_stats_callback.ptr ())
        return _stats_callback->x3a_stats_ready (stats);

    return XCAM_RETURN_NO_ERROR;
}


SmartPtr<CLImageHandler>
create_cl_bayer_basic_image_handler (const SmartPtr<CLContext> &context, bool enable_gamma, uint32_t stats_bits)
{
    SmartPtr<CLBayerBasicImageHandler> bayer_planar_handler;
    SmartPtr<CLBayerBasicImageKernel> basic_kernel;
    char build_options[1024];

    bayer_planar_handler = new CLBayerBasicImageHandler (context, "cl_handler_bayer_basic");
    bayer_planar_handler->set_stats_bits (stats_bits);
    basic_kernel = new CLBayerBasicImageKernel (context);
    XCAM_ASSERT (basic_kernel.ptr ());

    xcam_mem_clear (build_options);
    snprintf (build_options, sizeof (build_options),
              " -DENABLE_GAMMA=%d "
              " -DENABLE_IMAGE_2D_INPUT=%d "
              " -DSTATS_BITS=%d ",
              (enable_gamma ? 1 : 0),
              ENABLE_IMAGE_2D_INPUT,
              stats_bits);
    XCAM_FAIL_RETURN (
        ERROR, basic_kernel->build_kernel (kernel_bayer_basic_info, build_options) == XCAM_RETURN_NO_ERROR, NULL,
        "build bayer-basic kernel(%s) failed", kernel_bayer_basic_info.kernel_name);

    XCAM_ASSERT (basic_kernel->is_valid ());
    bayer_planar_handler->set_bayer_kernel (basic_kernel);

    return bayer_planar_handler;
}

};