/*
 * cl_image_bo_buffer.cpp - cl image bo buffer
 *
 *  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_bo_buffer.h"
#include "cl_memory.h"
#include "swapped_buffer.h"


namespace XCam {

CLImageBoData::CLImageBoData (SmartPtr<DrmDisplay> &display, SmartPtr<CLImage> &image, drm_intel_bo *bo)
    : DrmBoData (display, bo)
    , _image (image)
{
    XCAM_ASSERT (image->get_mem_id ());
}

int
CLImageBoData::get_fd ()
{
    if (!_image.ptr())
        return -1;
    return _image->export_fd ();
}

CLImageBoBuffer::CLImageBoBuffer (const VideoBufferInfo &info, const SmartPtr<CLImageBoData> &data)
    : BufferProxy (info, data)
    , DrmBoBuffer (info, data)
{
}

SmartPtr<CLImage>
CLImageBoBuffer::get_cl_image ()
{
    SmartPtr<BufferData> data = get_buffer_data ();
    SmartPtr<CLImageBoData> image = data.dynamic_cast_ptr<CLImageBoData> ();

    XCAM_FAIL_RETURN(
        WARNING,
        image.ptr(),
        NULL,
        "CLImageBoBuffer get_buffer_data failed with NULL");
    return image->get_image ();
}

SmartPtr<SwappedBuffer>
CLImageBoBuffer::create_new_swap_buffer (
    const VideoBufferInfo &info, SmartPtr<BufferData> &data)
{
    XCAM_ASSERT (get_buffer_data ().ptr () == data.ptr ());

    SmartPtr<CLImageBoData> bo = data.dynamic_cast_ptr<CLImageBoData> ();

    XCAM_FAIL_RETURN(
        WARNING,
        bo.ptr(),
        NULL,
        "CLImageBoBuffer create_new_swap_buffer failed with NULL buffer data");

    return new CLImageBoBuffer (info, bo);
}

CLBoBufferPool::CLBoBufferPool (SmartPtr<DrmDisplay> &display, SmartPtr<CLContext> &context)
    : DrmBoBufferPool (display)
    , _context (context)
{
    XCAM_ASSERT (context.ptr ());
    XCAM_LOG_DEBUG ("CLBoBufferPool constructed");
}

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

SmartPtr<CLImageBoData>
CLBoBufferPool::create_image_bo (const VideoBufferInfo &info)
{
    int32_t mem_fd = -1;
    SmartPtr<DrmDisplay> display = get_drm_display ();
    drm_intel_bo *bo = NULL;
    CLImageDesc desc;
    SmartPtr<CLImageBoData> data;
    SmartPtr<CLImage> image;
    uint32_t swap_flags = get_swap_flags ();
    uint32_t extra_array_size = 0;
    if (swap_flags & (uint32_t)(SwappedBuffer::SwapY))
        ++extra_array_size;
    if (swap_flags & (uint32_t)(SwappedBuffer::SwapUV))
        ++extra_array_size;

    if (info.components == 1)
        image = new CLImage2D (_context, info, CL_MEM_READ_WRITE);
    else
        image = new CLImage2DArray (_context, info, CL_MEM_READ_WRITE, extra_array_size);
    XCAM_FAIL_RETURN (
        WARNING,
        image.ptr () && image->get_mem_id (),
        NULL,
        "CLBoBufferPool create image failed");

    desc = image->get_image_desc ();
    mem_fd = image->export_fd ();
    XCAM_FAIL_RETURN (
        WARNING,
        mem_fd >= 0,
        NULL,
        "CLBoBufferPool export image fd failed");

    bo = display->create_drm_bo_from_fd (mem_fd, desc.size);
    XCAM_FAIL_RETURN (
        WARNING,
        bo,
        NULL,
        "CLBoBufferPool bind fd to bo failed");

    data = new CLImageBoData (display, image, bo);
    XCAM_FAIL_RETURN (
        WARNING,
        data.ptr (),
        NULL,
        "CLBoBufferPool bind CLImage to CLImageBoData failed");
    return data;
}

bool
CLBoBufferPool::fixate_video_info (VideoBufferInfo &info)
{
    bool need_reset_info = false;
    uint32_t i = 0;
    SmartPtr<CLImage> image;
    uint32_t swap_flags = get_swap_flags ();
    SmartPtr<CLImageBoData> image_data = create_image_bo (info);
    XCAM_FAIL_RETURN (
        WARNING,
        image_data.ptr (),
        NULL,
        "CLBoBufferPool fixate_video_info failed");

    image = image_data->get_image ();
    XCAM_ASSERT (image.ptr ());

    CLImageDesc desc = image->get_image_desc ();
    if (desc.row_pitch != info.strides [0] || desc.size != info.size)
        need_reset_info = true;

    for (i = 1; i < info.components && !need_reset_info; ++i) {
        XCAM_ASSERT (desc.slice_pitch && desc.array_size >= info.components);
        if (desc.row_pitch != info.strides [i] ||
                info.offsets [i] != desc.slice_pitch * i)
            need_reset_info = true;
    }
    if (need_reset_info) {
        VideoBufferPlanarInfo plane_info;
        info.get_planar_info (plane_info, 0);
        uint32_t aligned_width = desc.row_pitch / plane_info.pixel_bytes;
        uint32_t aligned_height = info.aligned_height;
        if (info.components > 0)
            aligned_height = desc.slice_pitch / desc.row_pitch;
        info.init (info.format, info.width, info.height, aligned_width, aligned_height, desc.size);
        for (i = 1; i < info.components; ++i) {
            info.offsets[i] = desc.slice_pitch * i;
            info.strides[i] = desc.row_pitch;
        }
    }

    if (swap_flags && desc.array_size >= 2) {
        if (swap_flags & (uint32_t)(SwappedBuffer::SwapY)) {
            _swap_offsets[SwappedBuffer::SwapYOffset0] = info.offsets[0];
            _swap_offsets[SwappedBuffer::SwapYOffset1] = desc.slice_pitch * 2;
        }
        if (swap_flags & (uint32_t)(SwappedBuffer::SwapUV)) {
            _swap_offsets[SwappedBuffer::SwapUVOffset0] = info.offsets[1];
            _swap_offsets[SwappedBuffer::SwapUVOffset1] = desc.slice_pitch * (desc.array_size - 1);
        }
    }

    if(!init_swap_order (info)) {
        XCAM_LOG_ERROR ("CLBoBufferPool: fix video info faield to init swap order");
        return false;
    }

    add_data_unsafe (image_data);

    return true;
}

SmartPtr<BufferData>
CLBoBufferPool::allocate_data (const VideoBufferInfo &buffer_info)
{
    SmartPtr<CLImageBoData> image_data = create_image_bo (buffer_info);
    return image_data;
}

SmartPtr<BufferProxy>
CLBoBufferPool::create_buffer_from_data (SmartPtr<BufferData> &data)
{
    const VideoBufferInfo & info = get_video_info ();
    SmartPtr<CLImageBoData> image_data = data.dynamic_cast_ptr<CLImageBoData> ();
    XCAM_ASSERT (image_data.ptr ());

    SmartPtr<CLImageBoBuffer> out_buf = new CLImageBoBuffer (info, image_data);
    XCAM_ASSERT (out_buf.ptr ());
    out_buf->set_swap_info (_swap_flags, _swap_offsets);
    return out_buf;
}

};