/*
 * drm_buffer.cpp - DRM Buffer Implementation
 *
 *  Copyright (c) 2021 Rockchip 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.
 *
 */
#include "drm_buffer.h"

#include <drm/drm.h>
#include <sys/mman.h>
#include <xf86drm.h>

#include <memory>
#include <string>

#include "dma_buffer.h"
#include "drm_device.h"
#include "xcam_defs.h"
#include "xcam_log.h"

namespace XCam {

DrmBuffer::~DrmBuffer() {
    for (auto it = dma_bufs_.begin(); it != dma_bufs_.end();) {
        dma_bufs_.erase(it);
    }
    auto dev = drm_device_.lock();
    if (dev != nullptr) {
        dev->DestroyDumbObject(dumb_object_);
    }
}

DrmBuffer::DrmBuffer(const std::shared_ptr<DrmDevice>& dev,
                     std::unique_ptr<DrmDumbObject> dumb_object)
    : drm_device_(std::weak_ptr<DrmDevice>(dev)) {
    dumb_object_ = std::move(dumb_object);
    for (int i = 0; i < dumb_object_->num_planes; i++) {
        dma_bufs_.push_back(std::unique_ptr<DmaBuffer>(
            new DmaBuffer(dumb_object_->fds[i], dumb_object_->sizes[i])));
    }
}

int DrmBuffer::numPlanes() { return dma_bufs_.size(); }

uint8_t* DrmBuffer::map(unsigned int plane) {
    if (plane >= dma_bufs_.size()) {
        return nullptr;
    }
    auto&& buf = dma_bufs_.at(plane);
    if (!buf->mapped()) {
        auto dev = drm_device_.lock();
        dev->RequestMapDumbObject(dumb_object_, plane);
    }
    auto ptr = reinterpret_cast<uint8_t*>(buf->map());
    buf->beginCpuAccess(DmaBufferDirection::kBidirectional);
    return ptr;
}

uint8_t* DrmBuffer::map() { return map(0); }

bool DrmBuffer::unmap(unsigned int plane) {
    if (plane >= dma_bufs_.size()) {
        return false;
    }
    auto&& buf = dma_bufs_.at(plane);
    buf->endCpuAccess(DmaBufferDirection::kBidirectional);
    buf->unmap();
    return true;
}

bool DrmBuffer::unmap() { return unmap(0); }

int DrmBuffer::getFd(unsigned int plane) {
    if (plane >= dma_bufs_.size()) {
        return -1;
    }
    return dma_bufs_.at(plane)->getFd();
}

size_t DrmBuffer::getSize() { return getSize(0); }

size_t DrmBuffer::getSize(unsigned int plane) { return dma_bufs_.at(plane)->getSize(); }

int DrmBuffer::get_fd() { return getFd(0); }

DrmDumbObject* DrmBuffer::get_bo() { return dumb_object_.get(); }

DrmBufferProxy::DrmBufferProxy(const VideoBufferInfo& info, const SmartPtr<DrmBuffer>& data)
    : BufferProxy(info, data) {
    XCAM_ASSERT(data.ptr());
}

DrmDumbObject* DrmBufferProxy::get_bo() {
    auto data   = get_buffer_data();
    auto buffer = data.dynamic_cast_ptr<DrmBuffer>();

    XCAM_FAIL_RETURN(WARNING, buffer.ptr(), NULL, "DrmBuffer get_buffer_data failed with NULL");

    return buffer->get_bo();
}

const int DrmBufferProxy::GetFd() {
    auto data   = get_buffer_data();
    auto buffer = data.dynamic_cast_ptr<DrmBuffer>();

    return buffer->get_fd();
}

DrmBufferPool::DrmBufferPool(std::shared_ptr<DrmDevice> device) : drm_device_(device) {}

bool DrmBufferPool::fixate_video_info(VideoBufferInfo& info) {
    VideoBufferInfo out_info;

    out_info.init(info.format, info.width, info.height, info.aligned_width, info.aligned_height);

    info = out_info;

    return true;
}

SmartPtr<BufferData> DrmBufferPool::allocate_data(const VideoBufferInfo& buffer_info) {
    SmartPtr<DrmBuffer> buffer_data;
    auto bo = drm_device_->CreateDumbObject(buffer_info.aligned_width, buffer_info.aligned_height,
                                            buffer_info.color_bits, 1);
    if (bo != nullptr) {
        buffer_data = new DrmBuffer(drm_device_, std::move(bo));
    }
    return buffer_data;
}

SmartPtr<BufferProxy> DrmBufferPool::create_buffer_from_data(SmartPtr<BufferData>& data) {
    const VideoBufferInfo& info     = get_video_info();
    SmartPtr<DrmBuffer> buffer_data = data.dynamic_cast_ptr<DrmBuffer>();
    XCAM_ASSERT(buffer_data.ptr());

    SmartPtr<DrmBufferProxy> out_buf = new DrmBufferProxy(info, buffer_data);
    XCAM_ASSERT(out_buf.ptr());
    return out_buf;
}

}  // namespace XCam