/*
 * v4l2_device.cpp - v4l2 device
 *
 *  Copyright (c) 2014-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>
 * Author: John Ye <john.ye@intel.com>
 */
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <poll.h>
#include <sys/mman.h>
#include "fake_v4l2_device.h"
#include "v4l2_buffer_proxy.h"

namespace XCam {


XCamReturn
FakeV4l2Device::open ()
{
    struct v4l2_streamparm param;

    if (is_opened()) {
        XCAM_LOG_DEBUG ("device(%s) was already opened", XCAM_STR(_name));
        return XCAM_RETURN_NO_ERROR;
    }

    if (!_name) {
        XCAM_LOG_DEBUG ("v4l2 device open failed, there's no device name");
        return XCAM_RETURN_ERROR_PARAM;
    }
    _fd = ::open (_name, O_RDWR);
    if (_fd == -1) {
        XCAM_LOG_ERROR ("open device(%s) failed", _name);
        return XCAM_RETURN_ERROR_IOCTL;
    } else {
        XCAM_LOG_DEBUG ("open device(%s) successed, fd: %d", _name, _fd);
    }

    if (create_notify_pipe () < 0) {
        XCAM_LOG_ERROR ("create virtual tx pipe failed");
        return XCAM_RETURN_ERROR_PARAM;
    }


    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
FakeV4l2Device::close ()
{

    if (!is_opened())
        return XCAM_RETURN_NO_ERROR;
    ::close (_fd);
    _fd = -1;
    destroy_notify_pipe ();
    XCAM_LOG_INFO ("device(%s) closed", XCAM_STR (_name));
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
FakeV4l2Device::start () {
    _active = true;

    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
FakeV4l2Device::stop () {
    _active = false;
    _buf_list.clear();
    return XCAM_RETURN_NO_ERROR;
}

int
FakeV4l2Device::create_notify_pipe ()
{
    int status = 0;

    destroy_notify_pipe ();
    status = pipe(_pipe_fd);
    if (status < 0) {
        XCAM_LOG_ERROR("Failed to create virtual tx notify poll pipe: %s", strerror(errno));
        goto exit_error;
    }
    status = fcntl(_pipe_fd[0], F_SETFL, O_NONBLOCK);
    if (status < 0) {
        XCAM_LOG_ERROR("Fail to set event virtual tx notify pipe flag: %s", strerror(errno));
        goto exit_error;
    }
    status = fcntl(_pipe_fd[1], F_SETFL, O_NONBLOCK);
    if (status < 0) {
        XCAM_LOG_ERROR("Fail to set event virtual tx notify pipe flag: %s", strerror(errno));
        goto exit_error;
    }
    return status;
exit_error:
    destroy_notify_pipe();
    return status;
}

void FakeV4l2Device::destroy_notify_pipe () {
    if (_pipe_fd[0] != -1 || _pipe_fd[1] != -1) {
        ::close(_pipe_fd[0]);
        ::close(_pipe_fd[1]);
        _pipe_fd[0] = -1;
        _pipe_fd[1] = -1;
    }
}

int
FakeV4l2Device::io_control (int cmd, void *arg)
{
    if (_fd <= 0)
        return -1;

    if ((int)VIDIOC_DQBUF == cmd) {
        struct v4l2_buffer *v4l2_buf = (struct v4l2_buffer *)arg;
        v4l2_buf->index = get_available_buffer_index();
        _mutex.lock();
        struct rk_aiq_vbuf_info vb_info;
        if(!_buf_list.empty()) {
            vb_info = _buf_list.front();
            _buf_list.pop_front();
            v4l2_buf->m.planes[0].length = vb_info.data_length;
            v4l2_buf->m.planes[0].bytesused = vb_info.data_length;
            v4l2_buf->sequence = vb_info.frame_id;
            v4l2_buf->m.planes[0].m.userptr = (unsigned long)vb_info.data_addr;
            v4l2_buf->reserved = vb_info.data_fd;
            gettimeofday(&v4l2_buf->timestamp, NULL);
        }
        _mutex.unlock();
    }
    return 0;
}

XCamReturn FakeV4l2Device::get_format (struct v4l2_format &format)
{
    if (is_activated ()) {
        format = _format;
        return XCAM_RETURN_NO_ERROR;
    }

    if (!is_opened ())
        return XCAM_RETURN_ERROR_IOCTL;
#if 0
    xcam_mem_clear (format);
    format.type = _buf_type;

    if (this->io_control (VIDIOC_G_FMT, &format) < 0) {
        // FIXME: also log the device name?
        XCAM_LOG_ERROR("Fail to get format via ioctl VIDVIO_G_FMT.");
        return XCAM_RETURN_ERROR_IOCTL;
    }
    //TODO
    format.fmt.pix.width = 3840;
    format.fmt.pix.height = 2160;
    format.fmt.pix.pixelformat = V4L2_PIX_FMT_SGBRG10;
    format.fmt.pix.bytesperline = 0;
    format.fmt.pix.sizeimage = 10506240;
#endif
    return XCAM_RETURN_NO_ERROR;
}

int
FakeV4l2Device::poll_event (int timeout_msec, int stop_fd)
{
    int num_fds = stop_fd == -1 ? 1 : 2;
    struct pollfd poll_fds[num_fds];
    int ret = 0;

    XCAM_ASSERT (_fd > 0);

    memset(poll_fds, 0, sizeof(poll_fds));
    poll_fds[0].fd = _pipe_fd[0];
    poll_fds[0].events = (POLLPRI | POLLIN | POLLOUT);

    if (stop_fd != -1) {
        poll_fds[1].fd = stop_fd;
        poll_fds[1].events = POLLPRI | POLLIN | POLLOUT;
        poll_fds[1].revents = 0;
    }

    ret = poll (poll_fds, num_fds, timeout_msec);
    if (ret > 0) {
        if (stop_fd != -1) {
            if (poll_fds[1].revents & (POLLIN | POLLPRI)) {
                XCAM_LOG_DEBUG ("%s: Poll returning from flush", __FUNCTION__);
                return POLL_STOP_RET;
            }
        }

        if (poll_fds[0].revents & (POLLIN | POLLPRI)) {
            char buf[8];
            read(_pipe_fd[0], buf, sizeof(buf));
            XCAM_LOG_DEBUG ("%s: Poll returning timer pipe", __FUNCTION__);
        }

    }

    return ret;
}

XCamReturn
FakeV4l2Device::dequeue_buffer(SmartPtr<V4l2Buffer> &buf)
{
    struct v4l2_buffer v4l2_buf;
    struct v4l2_plane planes[FMT_NUM_PLANES];

    if (!is_activated()) {
        XCAM_LOG_ERROR (
            "device(%s) dequeue buffer failed since not activated", XCAM_STR (_name));
        return XCAM_RETURN_ERROR_PARAM;
    }

    xcam_mem_clear (v4l2_buf);
    v4l2_buf.type = _buf_type;
    v4l2_buf.memory = _memory_type;

    if (V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE == _buf_type ||
            V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE == _buf_type) {
        memset(planes, 0, sizeof(struct v4l2_plane) * FMT_NUM_PLANES);
        v4l2_buf.m.planes = planes;
        v4l2_buf.length = FMT_NUM_PLANES;
    }

    if (this->io_control (VIDIOC_DQBUF, &v4l2_buf) < 0) {
        XCAM_LOG_ERROR ("device(%s) fail to dequeue buffer.", XCAM_STR (_name));
        return XCAM_RETURN_ERROR_IOCTL;
    }

    if (V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE == _buf_type ||
            V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE == _buf_type) {
        XCAM_LOG_DEBUG ("device(%s) dequeue buffer index:%d, memory:%d, type:%d, multiply planar:%d, length:%d, fd:%d,ptr:%p",
                        XCAM_STR (_name), v4l2_buf.index, v4l2_buf.memory,
                        v4l2_buf.type, v4l2_buf.length, v4l2_buf.m.planes[0].length, v4l2_buf.m.planes[0].m.fd, v4l2_buf.m.planes[0].m.userptr);

        if (V4L2_MEMORY_DMABUF == _memory_type) {
            XCAM_LOG_DEBUG ("device(%s) multi planar index:%d, fd: %d",
                            XCAM_STR (_name), v4l2_buf.index, v4l2_buf.m.planes[0].m.fd);
        }
    } else {
        XCAM_LOG_DEBUG ("device(%s) dequeue buffer index:%d, length: %d",
                        XCAM_STR (_name), v4l2_buf.index, v4l2_buf.length);
    }

    if (v4l2_buf.index >= _buf_count) {
        XCAM_LOG_ERROR (
            "device(%s) dequeue wrong buffer index:%d",
            XCAM_STR (_name), v4l2_buf.index);
        return XCAM_RETURN_ERROR_ISP;
    }

    SmartLock auto_lock(_buf_mutex);

    buf = _buf_pool [v4l2_buf.index];
    buf->set_timestamp (v4l2_buf.timestamp);
    buf->set_timecode (v4l2_buf.timecode);
    buf->set_sequence (v4l2_buf.sequence);
    if (!V4L2_TYPE_IS_OUTPUT(buf->get_buf ().type))
        buf->set_queued(false);
    if (V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE == _buf_type ||
        V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE == _buf_type) {
        buf->set_length (v4l2_buf.m.planes[0].length);
       // if (_use_type != 2) {
            buf->set_expbuf_usrptr(v4l2_buf.m.planes[0].m.userptr);
            buf->set_expbuf_fd(v4l2_buf.reserved);
    //    }
    } else {
        buf->set_length (v4l2_buf.length);
    }
    _queued_bufcnt--;

    return XCAM_RETURN_NO_ERROR;
}

uint32_t
FakeV4l2Device::get_available_buffer_index ()
{
    uint32_t idx = 0;
    SmartPtr<V4l2Buffer> buf;
    _buf_mutex.lock();
     for (; idx<_buf_count; idx++) {
        buf = _buf_pool[idx];
        if (buf->get_queued()) {
            break;
        }
     }
     _buf_mutex.unlock();
     return idx;
}

void
FakeV4l2Device::enqueue_rawbuffer(struct rk_aiq_vbuf_info *vbinfo)
{
    if (vbinfo != NULL) {
        _mutex.lock();
        _buf_list.push_back(*vbinfo);
        _mutex.unlock();
    }
}
static int icnt = 0;
void
FakeV4l2Device::on_timer_proc ()
{
    if (!_buf_list.empty() && _queued_bufcnt) {
        if (_pipe_fd[1] != -1) {
            char buf = 0xf;  // random value to write to flush fd.
            unsigned int size = write(_pipe_fd[1], &buf, sizeof(char));
            if (size != sizeof(char))
                XCAM_LOG_ERROR("Flush write not completed");
        }
    }
}

};