video.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2019 Linaro Limited.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_VIDEO_H_
#define ZEPHYR_INCLUDE_VIDEO_H_
 
#include <zephyr/device.h>
#include <stddef.h>
#include <zephyr/kernel.h>
 
#include <zephyr/types.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/*
 * Flag used by @ref video_caps structure to indicate endpoint operates on
 * buffers the size of the video frame
 */
#define LINE_COUNT_HEIGHT (-1)
 
struct video_format {
        uint32_t pixelformat;
        uint32_t width;
        uint32_t height;
        uint32_t pitch;
};
 
struct video_format_cap {
        uint32_t pixelformat;
        uint32_t width_min;
        uint32_t width_max;
        uint32_t height_min;
        uint32_t height_max;
        uint16_t width_step;
        uint16_t height_step;
};
 
struct video_caps {
        const struct video_format_cap *format_caps;
        uint8_t min_vbuf_count;
        int16_t min_line_count;
        int16_t max_line_count;
};
 
struct video_buffer {
        void *driver_data;
        uint8_t *buffer;
        uint32_t size;
        uint32_t bytesused;
        uint32_t timestamp;
        uint16_t line_offset;
};
 
enum video_frmival_type {
        VIDEO_FRMIVAL_TYPE_DISCRETE = 1,
        VIDEO_FRMIVAL_TYPE_STEPWISE = 2,
};
 
struct video_frmival {
        uint32_t numerator;
        uint32_t denominator;
};
 
struct video_frmival_stepwise {
        struct video_frmival min;
        struct video_frmival max;
        struct video_frmival step;
};
 
struct video_frmival_enum {
        uint32_t index;
        const struct video_format *format;
        enum video_frmival_type type;
        union {
                struct video_frmival discrete;
                struct video_frmival_stepwise stepwise;
        };
};
 
enum video_endpoint_id {
        VIDEO_EP_NONE = -1,
        VIDEO_EP_ALL = -2,
        VIDEO_EP_IN = -3,
        VIDEO_EP_OUT = -4,
};
 
enum video_signal_result {
        VIDEO_BUF_DONE,
        VIDEO_BUF_ABORTED,
        VIDEO_BUF_ERROR,
};
 
typedef int (*video_api_set_format_t)(const struct device *dev, enum video_endpoint_id ep,
                                      struct video_format *fmt);
 
typedef int (*video_api_get_format_t)(const struct device *dev, enum video_endpoint_id ep,
                                      struct video_format *fmt);
 
typedef int (*video_api_set_frmival_t)(const struct device *dev, enum video_endpoint_id ep,
                                       struct video_frmival *frmival);
 
typedef int (*video_api_get_frmival_t)(const struct device *dev, enum video_endpoint_id ep,
                                       struct video_frmival *frmival);
 
typedef int (*video_api_enum_frmival_t)(const struct device *dev, enum video_endpoint_id ep,
                                        struct video_frmival_enum *fie);
 
typedef int (*video_api_enqueue_t)(const struct device *dev, enum video_endpoint_id ep,
                                   struct video_buffer *buf);
 
typedef int (*video_api_dequeue_t)(const struct device *dev, enum video_endpoint_id ep,
                                   struct video_buffer **buf, k_timeout_t timeout);
 
typedef int (*video_api_flush_t)(const struct device *dev, enum video_endpoint_id ep, bool cancel);
 
typedef int (*video_api_stream_start_t)(const struct device *dev);
 
typedef int (*video_api_stream_stop_t)(const struct device *dev);
 
typedef int (*video_api_set_ctrl_t)(const struct device *dev, unsigned int cid, void *value);
 
typedef int (*video_api_get_ctrl_t)(const struct device *dev, unsigned int cid, void *value);
 
typedef int (*video_api_get_caps_t)(const struct device *dev, enum video_endpoint_id ep,
                                    struct video_caps *caps);
 
typedef int (*video_api_set_signal_t)(const struct device *dev, enum video_endpoint_id ep,
                                      struct k_poll_signal *signal);
 
__subsystem struct video_driver_api {
        /* mandatory callbacks */
        video_api_set_format_t set_format;
        video_api_get_format_t get_format;
        video_api_stream_start_t stream_start;
        video_api_stream_stop_t stream_stop;
        video_api_get_caps_t get_caps;
        /* optional callbacks */
        video_api_enqueue_t enqueue;
        video_api_dequeue_t dequeue;
        video_api_flush_t flush;
        video_api_set_ctrl_t set_ctrl;
        video_api_get_ctrl_t get_ctrl;
        video_api_set_signal_t set_signal;
        video_api_set_frmival_t set_frmival;
        video_api_get_frmival_t get_frmival;
        video_api_enum_frmival_t enum_frmival;
};
 
static inline int video_set_format(const struct device *dev, enum video_endpoint_id ep,
                                   struct video_format *fmt)
{
        const struct video_driver_api *api = (const struct video_driver_api *)dev->api;
 
        if (api->set_format == NULL) {
                return -ENOSYS;
        }
 
        return api->set_format(dev, ep, fmt);
}
 
static inline int video_get_format(const struct device *dev, enum video_endpoint_id ep,
                                   struct video_format *fmt)
{
        const struct video_driver_api *api = (const struct video_driver_api *)dev->api;
 
        if (api->get_format == NULL) {
                return -ENOSYS;
        }
 
        return api->get_format(dev, ep, fmt);
}
 
static inline int video_set_frmival(const struct device *dev, enum video_endpoint_id ep,
                                    struct video_frmival *frmival)
{
        const struct video_driver_api *api = (const struct video_driver_api *)dev->api;
 
        if (api->set_frmival == NULL) {
                return -ENOSYS;
        }
 
        return api->set_frmival(dev, ep, frmival);
}
 
static inline int video_get_frmival(const struct device *dev, enum video_endpoint_id ep,
                                    struct video_frmival *frmival)
{
        const struct video_driver_api *api = (const struct video_driver_api *)dev->api;
 
        if (api->get_frmival == NULL) {
                return -ENOSYS;
        }
 
        return api->get_frmival(dev, ep, frmival);
}
 
static inline int video_enum_frmival(const struct device *dev, enum video_endpoint_id ep,
                                     struct video_frmival_enum *fie)
{
        const struct video_driver_api *api = (const struct video_driver_api *)dev->api;
 
        if (api->enum_frmival == NULL) {
                return -ENOSYS;
        }
 
        return api->enum_frmival(dev, ep, fie);
}
 
static inline int video_enqueue(const struct device *dev, enum video_endpoint_id ep,
                                struct video_buffer *buf)
{
        const struct video_driver_api *api = (const struct video_driver_api *)dev->api;
 
        if (api->enqueue == NULL) {
                return -ENOSYS;
        }
 
        return api->enqueue(dev, ep, buf);
}
 
static inline int video_dequeue(const struct device *dev, enum video_endpoint_id ep,
                                struct video_buffer **buf, k_timeout_t timeout)
{
        const struct video_driver_api *api = (const struct video_driver_api *)dev->api;
 
        if (api->dequeue == NULL) {
                return -ENOSYS;
        }
 
        return api->dequeue(dev, ep, buf, timeout);
}
 
static inline int video_flush(const struct device *dev, enum video_endpoint_id ep, bool cancel)
{
        const struct video_driver_api *api = (const struct video_driver_api *)dev->api;
 
        if (api->flush == NULL) {
                return -ENOSYS;
        }
 
        return api->flush(dev, ep, cancel);
}
 
static inline int video_stream_start(const struct device *dev)
{
        const struct video_driver_api *api = (const struct video_driver_api *)dev->api;
 
        if (api->stream_start == NULL) {
                return -ENOSYS;
        }
 
        return api->stream_start(dev);
}
 
static inline int video_stream_stop(const struct device *dev)
{
        const struct video_driver_api *api = (const struct video_driver_api *)dev->api;
        int ret;
 
        if (api->stream_stop == NULL) {
                return -ENOSYS;
        }
 
        ret = api->stream_stop(dev);
        video_flush(dev, VIDEO_EP_ALL, true);
 
        return ret;
}
 
static inline int video_get_caps(const struct device *dev, enum video_endpoint_id ep,
                                 struct video_caps *caps)
{
        const struct video_driver_api *api = (const struct video_driver_api *)dev->api;
 
        if (api->get_caps == NULL) {
                return -ENOSYS;
        }
 
        return api->get_caps(dev, ep, caps);
}
 
static inline int video_set_ctrl(const struct device *dev, unsigned int cid, void *value)
{
        const struct video_driver_api *api = (const struct video_driver_api *)dev->api;
 
        if (api->set_ctrl == NULL) {
                return -ENOSYS;
        }
 
        return api->set_ctrl(dev, cid, value);
}
 
static inline int video_get_ctrl(const struct device *dev, unsigned int cid, void *value)
{
        const struct video_driver_api *api = (const struct video_driver_api *)dev->api;
 
        if (api->get_ctrl == NULL) {
                return -ENOSYS;
        }
 
        return api->get_ctrl(dev, cid, value);
}
 
static inline int video_set_signal(const struct device *dev, enum video_endpoint_id ep,
                                   struct k_poll_signal *signal)
{
        const struct video_driver_api *api = (const struct video_driver_api *)dev->api;
 
        if (api->set_signal == NULL) {
                return -ENOSYS;
        }
 
        return api->set_signal(dev, ep, signal);
}
 
struct video_buffer *video_buffer_aligned_alloc(size_t size, size_t align);
 
struct video_buffer *video_buffer_alloc(size_t size);
 
void video_buffer_release(struct video_buffer *buf);
 
/* fourcc - four-character-code */
#define video_fourcc(a, b, c, d)                                                                   \
        ((uint32_t)(a) | ((uint32_t)(b) << 8) | ((uint32_t)(c) << 16) | ((uint32_t)(d) << 24))
 
#define VIDEO_PIX_FMT_BGGR8 video_fourcc('B', 'G', 'G', 'R') /*  8  BGBG.. GRGR.. */
#define VIDEO_PIX_FMT_GBRG8 video_fourcc('G', 'B', 'R', 'G') /*  8  GBGB.. RGRG.. */
#define VIDEO_PIX_FMT_GRBG8 video_fourcc('G', 'R', 'B', 'G') /*  8  GRGR.. BGBG.. */
#define VIDEO_PIX_FMT_RGGB8 video_fourcc('R', 'G', 'G', 'B') /*  8  RGRG.. GBGB.. */
 
#define VIDEO_PIX_FMT_RGB565 video_fourcc('R', 'G', 'B', 'P') /* 16  RGB-5-6-5 */
 
#define VIDEO_PIX_FMT_XRGB32 video_fourcc('B', 'X', '2', '4') /* 32  XRGB-8-8-8-8 */
 
#define VIDEO_PIX_FMT_YUYV video_fourcc('Y', 'U', 'Y', 'V') /* 16  Y0-Cb0 Y1-Cr0 */
 
#define VIDEO_PIX_FMT_XYUV32 video_fourcc('X', 'Y', 'U', 'V') /* 32  XYUV-8-8-8-8 */
 
#define VIDEO_PIX_FMT_JPEG video_fourcc('J', 'P', 'E', 'G') /*  8  JPEG */
 
static inline unsigned int video_pix_fmt_bpp(uint32_t pixfmt)
{
        switch (pixfmt) {
        case VIDEO_PIX_FMT_BGGR8:
        case VIDEO_PIX_FMT_GBRG8:
        case VIDEO_PIX_FMT_GRBG8:
        case VIDEO_PIX_FMT_RGGB8:
                return 1;
        case VIDEO_PIX_FMT_RGB565:
        case VIDEO_PIX_FMT_YUYV:
                return 2;
        case VIDEO_PIX_FMT_XRGB32:
        case VIDEO_PIX_FMT_XYUV32:
                return 4;
        default:
                return 0;
        }
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_VIDEO_H_ */