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>
 
#include <zephyr/drivers/video-controls.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
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;
};
 
struct video_buffer {
        void *driver_data;
        uint8_t *buffer;
        uint32_t size;
        uint32_t bytesused;
        uint32_t timestamp;
};
 
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_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_set_ctrl_t get_ctrl;
        video_api_set_signal_t set_signal;
};
 
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_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 */
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_VIDEO_H_ */