/*
 * cl_context.cpp - CL context
 *
 *  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_context.h"
#include "cl_kernel.h"
#include "cl_device.h"
#include <utility>

#undef XCAM_CL_MAX_STR_SIZE
#define XCAM_CL_MAX_STR_SIZE 1024

namespace XCam {

class CLKernel;

void
CLContext::context_pfn_notify (
    const char* erro_info,
    const void *private_info,
    size_t cb,
    void *user_data
)
{
    CLContext *context = (CLContext*) user_data;
    XCAM_UNUSED (context);
    XCAM_UNUSED (private_info);
    XCAM_UNUSED (cb);
    XCAM_LOG_DEBUG ("cl context pfn error:%s", XCAM_STR (erro_info));
}

void CLContext::program_pfn_notify (
    cl_program program, void *user_data)
{
    CLContext *context = (CLContext*) user_data;
    char kernel_names [XCAM_CL_MAX_STR_SIZE];

    XCAM_UNUSED (context);
    xcam_mem_clear (kernel_names);
    //clGetProgramInfo (program, CL_PROGRAM_KERNEL_NAMES, sizeof (kernel_names) - 1, kernel_names, NULL);
    //XCAM_LOG_DEBUG ("cl program report error on kernels: %s", kernel_names);
}

CLContext::CLContext (SmartPtr<CLDevice> &device)
    : _context_id (NULL)
    , _device (device)
{
    if (!init_context ()) {
        XCAM_LOG_DEBUG ("CL init context failed");
    }

    XCAM_LOG_DEBUG ("CLContext constructed");
}

CLContext::~CLContext ()
{
    destroy_context ();
    XCAM_LOG_DEBUG ("CLContext destructed");
}

void
CLContext::terminate ()
{
    //_kernel_map.clear ();
    _cmd_queue_list.clear ();
}

bool
CLContext::init_context ()
{
    cl_context context_id = NULL;
    cl_int err_code = 0;
    cl_device_id device_id = _device->get_device_id ();

    XCAM_ASSERT (_context_id == NULL);

    if (!_device->is_inited()) {
        XCAM_LOG_DEBUG ("create cl context failed since device ");
        return false;
    }

    context_id =
        clCreateContext (NULL, 1, &device_id,
                         CLContext::context_pfn_notify, this,
                         &err_code);
    if (err_code != CL_SUCCESS)
    {
        XCAM_LOG_WARNING ("create cl context failed, error:%d", err_code);
        return false;
    }
    _context_id = context_id;
    return true;
}

bool
CLContext::init_cmd_queue (SmartPtr<CLContext> &self)
{
    XCAM_ASSERT (_cmd_queue_list.empty ());
    XCAM_ASSERT (self.ptr() == this);
    SmartPtr<CLCommandQueue> cmd_queue = create_cmd_queue (self);
    if (!cmd_queue.ptr ())
        return false;

    _cmd_queue_list.push_back (cmd_queue);
    return true;
}

SmartPtr<CLCommandQueue>
CLContext::get_default_cmd_queue ()
{
    CLCmdQueueList::iterator iter;

    XCAM_ASSERT (!_cmd_queue_list.empty ());
    if (_cmd_queue_list.empty ())
        return NULL;
    iter = _cmd_queue_list.begin ();
    return *iter;
}

void
CLContext::destroy_context ()
{
    if (!is_valid ())
        return;
    clReleaseContext (_context_id);
    _context_id = NULL;
}

XCamReturn
CLContext::execute_kernel (
    CLKernel *kernel,
    CLCommandQueue *queue,
    const cl_event *events_wait, uint32_t num_of_events_wait,
    cl_event *event_out)
{
    cl_int error_code = CL_SUCCESS;
    cl_command_queue cmd_queue_id = NULL;
    cl_kernel kernel_id = kernel->get_kernel_id ();
    uint32_t work_dims = kernel->get_work_dims ();
    const size_t *global_sizes = kernel->get_work_global_size ();
    const size_t *local_sizes = kernel->get_work_local_size ();

    XCAM_ASSERT (kernel);

    if (queue == NULL) {
        SmartPtr<CLCommandQueue> cmd_queue = get_default_cmd_queue ();
        queue = cmd_queue.ptr ();
    }
    XCAM_ASSERT (queue);

    cmd_queue_id = queue->get_cmd_queue_id ();

    error_code =
        clEnqueueNDRangeKernel (
            cmd_queue_id, kernel_id,
            work_dims, NULL, global_sizes, local_sizes,
            num_of_events_wait, events_wait,
            event_out);

    XCAM_FAIL_RETURN(
        WARNING,
        error_code == CL_SUCCESS,
        XCAM_RETURN_ERROR_CL,
        "execute kernel(%s) failed with error_code:%d",
        kernel->get_kernel_name (), error_code);

    return XCAM_RETURN_NO_ERROR;
}

SmartPtr<CLCommandQueue>
CLContext::create_cmd_queue (SmartPtr<CLContext> &self)
{
    cl_device_id device_id = _device->get_device_id ();
    cl_command_queue cmd_queue_id = NULL;
    cl_int err_code = 0;
    SmartPtr<CLCommandQueue> result;

    XCAM_ASSERT (self.ptr() == this);

    cmd_queue_id = clCreateCommandQueue (_context_id, device_id, 0, &err_code);
    if (err_code != CL_SUCCESS) {
        XCAM_LOG_WARNING ("create CL command queue failed.");
        return NULL;
    }

    result = new CLCommandQueue (self, cmd_queue_id);
    return result;
}

cl_kernel
CLContext::generate_kernel_id (
    CLKernel *kernel,
    const uint8_t *source, size_t length,
    CLContext::KernelBuildType type)
{
    struct CLProgram {
        cl_program id;

        CLProgram ()
            : id (NULL)
        {}
        ~CLProgram () {
            if (id)
                clReleaseProgram (id);
        }
    };

    CLProgram program;
    cl_kernel kernel_id = NULL;
    cl_int error_code = CL_SUCCESS;
    cl_device_id device_id = _device->get_device_id ();
    const char * name = kernel->get_kernel_name ();

    XCAM_ASSERT (source && length);
    XCAM_ASSERT (name);

    switch (type) {
    case KERNEL_BUILD_SOURCE:
        program.id =
            clCreateProgramWithSource (
                _context_id, 1,
                (const char**)(&source), (const size_t *)&length,
                &error_code);
        break;
    case KERNEL_BUILD_BINARY:
        program.id =
            clCreateProgramWithBinary (
                _context_id, 1, &device_id,
                (const size_t *)&length, (const uint8_t**)(&source),
                NULL, &error_code);
        break;
    }

    XCAM_FAIL_RETURN (
        WARNING,
        error_code == CL_SUCCESS,
        NULL,
        "cl create program failed with error_cod:%d", error_code);
    XCAM_ASSERT (program.id);

    error_code = clBuildProgram (program.id, 1, &device_id, NULL, CLContext::program_pfn_notify, this);
    if (error_code != CL_SUCCESS) {
        char error_log [XCAM_CL_MAX_STR_SIZE];
        xcam_mem_clear (error_log);
        clGetProgramBuildInfo (program.id, device_id, CL_PROGRAM_BUILD_LOG, sizeof (error_log) - 1, error_log, NULL);
        XCAM_LOG_WARNING ("CL build program failed on %s, build log:%s", name, error_log);
        return NULL;
    }

    kernel_id = clCreateKernel (program.id, name, &error_code);
    XCAM_FAIL_RETURN (
        WARNING,
        error_code == CL_SUCCESS,
        NULL,
        "cl create kernel(%s) failed with error_cod:%d", name, error_code);

    return kernel_id;
}

void
CLContext::destroy_kernel_id (cl_kernel &kernel_id)
{
    if (kernel_id) {
        clReleaseKernel (kernel_id);
        kernel_id = NULL;
    }
}

#if 0
bool
CLContext::insert_kernel (SmartPtr<CLKernel> &kernel)
{
    std::string kernel_name = kernel->get_kernel_name ();
    CLKernelMap::iterator i_pos = _kernel_map.lower_bound (kernel_name);

    XCAM_ASSERT (!kernel_name.empty());
    if (i_pos != _kernel_map.end () && !_kernel_map.key_comp ()(kernel_name, i_pos->first)) {
        // need update
        i_pos->second = kernel;
        XCAM_LOG_DEBUG ("kernel:%s already exist in context, now update to new one", kernel_name.c_str());
        return true;
    }

    _kernel_map.insert (i_pos, std::make_pair (kernel_name, kernel));
    return true;
}
#endif

cl_mem
CLContext::create_va_image (const cl_libva_image &image_info)
{
    cl_mem mem_id = NULL;
    cl_int errcode = CL_SUCCESS;
    if (!is_valid())
        return NULL;

    mem_id = clCreateImageFromLibvaIntel (_context_id, &image_info, &errcode);
    XCAM_FAIL_RETURN(
        WARNING,
        errcode == CL_SUCCESS,
        NULL,
        "create cl memory from va image failed");
    return mem_id;
}

void
CLContext::destroy_mem (cl_mem mem_id)
{
    if (mem_id)
        clReleaseMemObject (mem_id);
}

CLCommandQueue::CLCommandQueue (SmartPtr<CLContext> &context, cl_command_queue id)
    : _context (context)
    , _cmd_queue_id (id)
{
    XCAM_ASSERT (context.ptr ());
    XCAM_ASSERT (id);
    XCAM_LOG_DEBUG ("CLCommandQueue constructed");
}

CLCommandQueue::~CLCommandQueue ()
{
    destroy ();
    XCAM_LOG_DEBUG ("CLCommandQueue desstructed");
}

void
CLCommandQueue::destroy ()
{
    if (_cmd_queue_id == NULL)
        return;

    clReleaseCommandQueue (_cmd_queue_id);
    _cmd_queue_id = NULL;
}

};