/*
 * v4l2_device.h - 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>
 */

#ifndef XCAM_V4L2_DEVICE_H
#define XCAM_V4L2_DEVICE_H

#include <xcam_std.h>
#include <xcam_mutex.h>
#include <linux/videodev2.h>
#include <linux/v4l2-subdev.h>
#include <list>
#include <vector>

extern "C" {
    struct v4l2_event;
    struct v4l2_format;
    struct v4l2_fmtdesc;
    struct v4l2_frmsizeenum;
}

namespace XCam {
#define FMT_NUM_PLANES 1
#define POLL_STOP_RET 3

class V4l2Buffer;

class V4l2Device {
    friend class V4l2BufferProxy;
    typedef std::vector<SmartPtr<V4l2Buffer>> BufferPool;

public:
    V4l2Device (const char *name = NULL);
    virtual ~V4l2Device ();

    // before device open
    bool set_device_name (const char *name);
    bool set_sensor_id (int id);
    bool set_capture_mode (uint32_t capture_mode);
    bool set_mplanes_count (uint32_t planes_count);

    int get_fd () const {
        return _fd;
    }
    const char *get_device_name () const {
        return _name;
    }
    bool is_opened () const    {
        return (_fd != -1);
    }
    bool is_activated () const {
        return _active;
    }

    // set_mem_type must before set_format
    bool set_mem_type (enum v4l2_memory type);
    enum v4l2_memory get_mem_type () const {
        return _memory_type;
    }
    bool set_buf_type (enum v4l2_buf_type type);
    bool set_buf_sync (bool sync);
    enum v4l2_buf_type get_buf_type () const {
        return _buf_type;
    }
    void get_size (uint32_t &width, uint32_t &height) const {
        width = _format.fmt.pix.width;
        height = _format.fmt.pix.height;
    }
    uint32_t get_pixel_format () const {
        return _format.fmt.pix.pixelformat;
    }

    bool set_buffer_count (uint32_t buf_count);
    int get_buffer_count () {
        return _buf_count;
    }
    int get_queued_bufcnt () {
        return _queued_bufcnt;
    }

    // set_framerate must before set_format
    bool set_framerate (uint32_t n, uint32_t d);
    void get_framerate (uint32_t &n, uint32_t &d);

    virtual XCamReturn open ();
    virtual XCamReturn close ();

    XCamReturn query_cap(struct v4l2_capability &cap);
    XCamReturn get_crop (struct v4l2_crop &crop);
    XCamReturn set_crop (struct v4l2_crop &crop);
    // set_format
    virtual XCamReturn get_format (struct v4l2_format &format);
    XCamReturn set_format (struct v4l2_format &format);
    XCamReturn set_format (
        uint32_t width, uint32_t height, uint32_t pixelformat,
        enum v4l2_field field = V4L2_FIELD_NONE, uint32_t bytes_perline = 0);

    std::list<struct v4l2_fmtdesc> enum_formats ();

    virtual XCamReturn start (bool prepared = false);
    virtual XCamReturn stop ();
    XCamReturn prepare ();

    virtual int poll_event (int timeout_msec, int stop_fd);

    SmartPtr<V4l2Buffer> get_buffer_by_index (int index);
    virtual XCamReturn dequeue_buffer (SmartPtr<V4l2Buffer> &buf);
    virtual XCamReturn queue_buffer (SmartPtr<V4l2Buffer> &buf, bool locked = false);
    XCamReturn return_buffer (SmartPtr<V4l2Buffer> &buf);
    XCamReturn return_buffer_to_pool (SmartPtr<V4l2Buffer> &buf);
    // get free buf for type V4L2_BUF_TYPE_xxx_OUTPUT
    XCamReturn get_buffer (SmartPtr<V4l2Buffer> &buf, int index = -1) const;
    // use as less as possible
    virtual int io_control (int cmd, void *arg);
    virtual int get_use_type() { return 0;}
    virtual void set_use_type(int type) {}
    SmartPtr<V4l2Buffer> get_available_buffer ();

protected:

    //virtual functions, handle private actions on set_format
    virtual XCamReturn pre_set_format (struct v4l2_format &format);
    virtual XCamReturn post_set_format (struct v4l2_format &format);
    virtual XCamReturn allocate_buffer (
        SmartPtr<V4l2Buffer> &buf,
        const struct v4l2_format &format,
        const uint32_t index);
    virtual XCamReturn release_buffer (SmartPtr<V4l2Buffer> &buf);

private:
    XCamReturn request_buffer ();
    XCamReturn init_buffer_pool ();
    XCamReturn fini_buffer_pool ();

    XCAM_DEAD_COPY (V4l2Device);

protected:
    char               *_name;
    int                 _fd;
    int32_t             _sensor_id;
    uint32_t            _capture_mode;
    enum v4l2_buf_type  _buf_type;
    bool                _buf_sync;
    enum v4l2_memory    _memory_type;
    struct v4l2_plane  *_planes;

    struct v4l2_format  _format;
    uint32_t            _fps_n;
    uint32_t            _fps_d;

    bool                _active;

    // buffer pool
    BufferPool          _buf_pool;
    uint32_t            _buf_count;
    uint32_t            _queued_bufcnt;
    mutable Mutex      _buf_mutex;
    int32_t            _mplanes_count;
    XCamReturn buffer_new();
    XCamReturn buffer_del();
};

class V4l2SubDevice
    : public V4l2Device
{
public:
    explicit V4l2SubDevice (const char *name = NULL);

    virtual XCamReturn subscribe_event (int event);
    virtual XCamReturn unsubscribe_event (int event);
    virtual XCamReturn dequeue_event (struct v4l2_event &event);
    virtual XCamReturn get_selection (int pad, uint32_t target, struct v4l2_subdev_selection &select);
    virtual XCamReturn setFormat(struct v4l2_subdev_format &aFormat);
    virtual XCamReturn getFormat(struct v4l2_subdev_format &aFormat);
    virtual XCamReturn set_selection (struct v4l2_subdev_selection &aSelection);

    virtual XCamReturn start (bool prepared = false);
    virtual XCamReturn stop ();

private:
    XCAM_DEAD_COPY (V4l2SubDevice);
};

};
#endif // XCAM_V4L2_DEVICE_H