video.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2019 Linaro Limited.
 * Copyright 2025 NXP
 *
 * 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_control;
 
enum video_buf_type {
        VIDEO_BUF_TYPE_INPUT,
        VIDEO_BUF_TYPE_OUTPUT,
};
 
struct video_format {
        enum video_buf_type type;
        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 {
        enum video_buf_type type;
        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 {
        enum video_buf_type type;
        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_signal_result {
        VIDEO_BUF_DONE,
        VIDEO_BUF_ABORTED,
        VIDEO_BUF_ERROR,
};
 
typedef int (*video_api_set_format_t)(const struct device *dev, struct video_format *fmt);
 
typedef int (*video_api_get_format_t)(const struct device *dev, struct video_format *fmt);
 
typedef int (*video_api_set_frmival_t)(const struct device *dev, struct video_frmival *frmival);
 
typedef int (*video_api_get_frmival_t)(const struct device *dev, struct video_frmival *frmival);
 
typedef int (*video_api_enum_frmival_t)(const struct device *dev, struct video_frmival_enum *fie);
 
typedef int (*video_api_enqueue_t)(const struct device *dev, struct video_buffer *buf);
 
typedef int (*video_api_dequeue_t)(const struct device *dev, struct video_buffer **buf,
                                   k_timeout_t timeout);
 
typedef int (*video_api_flush_t)(const struct device *dev, bool cancel);
 
typedef int (*video_api_set_stream_t)(const struct device *dev, bool enable,
                                      enum video_buf_type type);
 
typedef int (*video_api_ctrl_t)(const struct device *dev, uint32_t cid);
 
typedef int (*video_api_get_caps_t)(const struct device *dev, struct video_caps *caps);
 
typedef int (*video_api_set_signal_t)(const struct device *dev, struct k_poll_signal *sig);
 
__subsystem struct video_driver_api {
        /* mandatory callbacks */
        video_api_set_format_t set_format;
        video_api_get_format_t get_format;
        video_api_set_stream_t set_stream;
        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_ctrl_t set_ctrl;
        video_api_ctrl_t get_volatile_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, 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, fmt);
}
 
static inline int video_get_format(const struct device *dev, 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, fmt);
}
 
static inline int video_set_frmival(const struct device *dev, 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, frmival);
}
 
static inline int video_get_frmival(const struct device *dev, 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, frmival);
}
 
static inline int video_enum_frmival(const struct device *dev, 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, fie);
}
 
static inline int video_enqueue(const struct device *dev, 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, buf);
}
 
static inline int video_dequeue(const struct device *dev, 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, buf, timeout);
}
 
static inline int video_flush(const struct device *dev, 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, cancel);
}
 
static inline int video_stream_start(const struct device *dev, enum video_buf_type type)
{
        const struct video_driver_api *api = (const struct video_driver_api *)dev->api;
 
        if (api->set_stream == NULL) {
                return -ENOSYS;
        }
 
        return api->set_stream(dev, true, type);
}
 
static inline int video_stream_stop(const struct device *dev, enum video_buf_type type)
{
        const struct video_driver_api *api = (const struct video_driver_api *)dev->api;
        int ret;
 
        if (api->set_stream == NULL) {
                return -ENOSYS;
        }
 
        ret = api->set_stream(dev, false, type);
        video_flush(dev, true);
 
        return ret;
}
 
static inline int video_get_caps(const struct device *dev, 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, caps);
}
 
int video_set_ctrl(const struct device *dev, struct video_control *control);
 
int video_get_ctrl(const struct device *dev, struct video_control *control);
 
struct video_ctrl_query;
 
int video_query_ctrl(const struct device *dev, struct video_ctrl_query *cq);
 
void video_print_ctrl(const struct device *const dev, const struct video_ctrl_query *const cq);
 
static inline int video_set_signal(const struct device *dev, struct k_poll_signal *sig)
{
        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, sig);
}
 
struct video_buffer *video_buffer_aligned_alloc(size_t size, size_t align, k_timeout_t timeout);
 
struct video_buffer *video_buffer_alloc(size_t size, k_timeout_t timeout);
 
void video_buffer_release(struct video_buffer *buf);
 
int video_format_caps_index(const struct video_format_cap *fmts, const struct video_format *fmt,
                            size_t *idx);
 
static inline uint64_t video_frmival_nsec(const struct video_frmival *frmival)
{
        return (uint64_t)NSEC_PER_SEC * frmival->numerator / frmival->denominator;
}
 
void video_closest_frmival_stepwise(const struct video_frmival_stepwise *stepwise,
                                    const struct video_frmival *desired,
                                    struct video_frmival *match);
 
void video_closest_frmival(const struct device *dev, struct video_frmival_enum *match);
 
#define VIDEO_FOURCC(a, b, c, d)                                                                   \
        ((uint32_t)(a) | ((uint32_t)(b) << 8) | ((uint32_t)(c) << 16) | ((uint32_t)(d) << 24))
 
#define VIDEO_FOURCC_FROM_STR(str) VIDEO_FOURCC((str)[0], (str)[1], (str)[2], (str)[3])
 
#define VIDEO_FOURCC_TO_STR(fourcc)                                                                \
        ((char[]){                                                                                 \
                (char)((fourcc) & 0xFF),                                                           \
                (char)(((fourcc) >> 8) & 0xFF),                                                    \
                (char)(((fourcc) >> 16) & 0xFF),                                                   \
                (char)(((fourcc) >> 24) & 0xFF),                                                   \
                '\0'                                                                               \
        })
 
#define VIDEO_PIX_FMT_SBGGR8 VIDEO_FOURCC('B', 'A', '8', '1')
 
#define VIDEO_PIX_FMT_SGBRG8 VIDEO_FOURCC('G', 'B', 'R', 'G')
 
#define VIDEO_PIX_FMT_SGRBG8 VIDEO_FOURCC('G', 'R', 'B', 'G')
 
#define VIDEO_PIX_FMT_SRGGB8 VIDEO_FOURCC('R', 'G', 'G', 'B')
 
#define VIDEO_PIX_FMT_SBGGR10P VIDEO_FOURCC('p', 'B', 'A', 'A')
 
#define VIDEO_PIX_FMT_SGBRG10P VIDEO_FOURCC('p', 'G', 'A', 'A')
 
#define VIDEO_PIX_FMT_SGRBG10P VIDEO_FOURCC('p', 'g', 'A', 'A')
 
#define VIDEO_PIX_FMT_SRGGB10P VIDEO_FOURCC('p', 'R', 'A', 'A')
 
#define VIDEO_PIX_FMT_SBGGR12P VIDEO_FOURCC('p', 'B', 'C', 'C')
 
#define VIDEO_PIX_FMT_SGBRG12P VIDEO_FOURCC('p', 'G', 'C', 'C')
 
#define VIDEO_PIX_FMT_SGRBG12P VIDEO_FOURCC('p', 'g', 'C', 'C')
 
#define VIDEO_PIX_FMT_SRGGB12P VIDEO_FOURCC('p', 'R', 'C', 'C')
 
#define VIDEO_PIX_FMT_SBGGR14P VIDEO_FOURCC('p', 'B', 'E', 'E')
 
#define VIDEO_PIX_FMT_SGBRG14P VIDEO_FOURCC('p', 'G', 'E', 'E')
 
#define VIDEO_PIX_FMT_SGRBG14P VIDEO_FOURCC('p', 'g', 'E', 'E')
 
#define VIDEO_PIX_FMT_SRGGB14P VIDEO_FOURCC('p', 'R', 'E', 'E')
 
#define VIDEO_PIX_FMT_SBGGR10 VIDEO_FOURCC('B', 'G', '1', '0')
 
#define VIDEO_PIX_FMT_SGBRG10 VIDEO_FOURCC('G', 'B', '1', '0')
 
#define VIDEO_PIX_FMT_SGRBG10 VIDEO_FOURCC('B', 'A', '1', '0')
 
#define VIDEO_PIX_FMT_SRGGB10 VIDEO_FOURCC('R', 'G', '1', '0')
 
#define VIDEO_PIX_FMT_SBGGR12 VIDEO_FOURCC('B', 'G', '1', '2')
 
#define VIDEO_PIX_FMT_SGBRG12 VIDEO_FOURCC('G', 'B', '1', '2')
 
#define VIDEO_PIX_FMT_SGRBG12 VIDEO_FOURCC('B', 'A', '1', '2')
 
#define VIDEO_PIX_FMT_SRGGB12 VIDEO_FOURCC('R', 'G', '1', '2')
 
#define VIDEO_PIX_FMT_SBGGR14 VIDEO_FOURCC('B', 'G', '1', '4')
 
#define VIDEO_PIX_FMT_SGBRG14 VIDEO_FOURCC('G', 'B', '1', '4')
 
#define VIDEO_PIX_FMT_SGRBG14 VIDEO_FOURCC('G', 'R', '1', '4')
 
#define VIDEO_PIX_FMT_SRGGB14 VIDEO_FOURCC('R', 'G', '1', '4')
 
#define VIDEO_PIX_FMT_SBGGR16 VIDEO_FOURCC('B', 'Y', 'R', '2')
 
#define VIDEO_PIX_FMT_SGBRG16 VIDEO_FOURCC('G', 'B', '1', '6')
 
#define VIDEO_PIX_FMT_SGRBG16 VIDEO_FOURCC('G', 'R', '1', '6')
 
#define VIDEO_PIX_FMT_SRGGB16 VIDEO_FOURCC('R', 'G', '1', '6')
 
#define VIDEO_PIX_FMT_GREY VIDEO_FOURCC('G', 'R', 'E', 'Y')
 
#define VIDEO_PIX_FMT_Y10P VIDEO_FOURCC('Y', '1', '0', 'P')
 
#define VIDEO_PIX_FMT_Y12P VIDEO_FOURCC('Y', '1', '2', 'P')
 
#define VIDEO_PIX_FMT_Y14P VIDEO_FOURCC('Y', '1', '4', 'P')
 
#define VIDEO_PIX_FMT_RGB565X VIDEO_FOURCC('R', 'G', 'B', 'R')
 
#define VIDEO_PIX_FMT_RGB565 VIDEO_FOURCC('R', 'G', 'B', 'P')
 
#define VIDEO_PIX_FMT_BGR24 VIDEO_FOURCC('B', 'G', 'R', '3')
 
#define VIDEO_PIX_FMT_RGB24 VIDEO_FOURCC('R', 'G', 'B', '3')
 
#define VIDEO_PIX_FMT_ARGB32 VIDEO_FOURCC('B', 'A', '2', '4')
 
#define VIDEO_PIX_FMT_ABGR32 VIDEO_FOURCC('A', 'R', '2', '4')
 
#define VIDEO_PIX_FMT_RGBA32 VIDEO_FOURCC('A', 'B', '2', '4')
 
#define VIDEO_PIX_FMT_BGRA32 VIDEO_FOURCC('R', 'A', '2', '4')
 
#define VIDEO_PIX_FMT_XRGB32 VIDEO_FOURCC('B', 'X', '2', '4')
 
#define VIDEO_PIX_FMT_YUYV VIDEO_FOURCC('Y', 'U', 'Y', 'V')
 
#define VIDEO_PIX_FMT_YVYU VIDEO_FOURCC('Y', 'V', 'Y', 'U')
 
#define VIDEO_PIX_FMT_VYUY VIDEO_FOURCC('V', 'Y', 'U', 'Y')
 
#define VIDEO_PIX_FMT_UYVY VIDEO_FOURCC('U', 'Y', 'V', 'Y')
 
#define VIDEO_PIX_FMT_XYUV32 VIDEO_FOURCC('X', 'Y', 'U', 'V')
 
#define VIDEO_PIX_FMT_JPEG VIDEO_FOURCC('J', 'P', 'E', 'G')
 
static inline unsigned int video_bits_per_pixel(uint32_t pixfmt)
{
        switch (pixfmt) {
        case VIDEO_PIX_FMT_SBGGR8:
        case VIDEO_PIX_FMT_SGBRG8:
        case VIDEO_PIX_FMT_SGRBG8:
        case VIDEO_PIX_FMT_SRGGB8:
        case VIDEO_PIX_FMT_GREY:
                return 8;
        case VIDEO_PIX_FMT_SBGGR10P:
        case VIDEO_PIX_FMT_SGBRG10P:
        case VIDEO_PIX_FMT_SGRBG10P:
        case VIDEO_PIX_FMT_SRGGB10P:
        case VIDEO_PIX_FMT_Y10P:
                return 10;
        case VIDEO_PIX_FMT_SBGGR12P:
        case VIDEO_PIX_FMT_SGBRG12P:
        case VIDEO_PIX_FMT_SGRBG12P:
        case VIDEO_PIX_FMT_SRGGB12P:
        case VIDEO_PIX_FMT_Y12P:
                return 12;
        case VIDEO_PIX_FMT_SBGGR14P:
        case VIDEO_PIX_FMT_SGBRG14P:
        case VIDEO_PIX_FMT_SGRBG14P:
        case VIDEO_PIX_FMT_SRGGB14P:
        case VIDEO_PIX_FMT_Y14P:
                return 14;
        case VIDEO_PIX_FMT_RGB565:
        case VIDEO_PIX_FMT_YUYV:
        case VIDEO_PIX_FMT_YVYU:
        case VIDEO_PIX_FMT_UYVY:
        case VIDEO_PIX_FMT_VYUY:
        case VIDEO_PIX_FMT_SBGGR10:
        case VIDEO_PIX_FMT_SGBRG10:
        case VIDEO_PIX_FMT_SGRBG10:
        case VIDEO_PIX_FMT_SRGGB10:
        case VIDEO_PIX_FMT_SBGGR12:
        case VIDEO_PIX_FMT_SGBRG12:
        case VIDEO_PIX_FMT_SGRBG12:
        case VIDEO_PIX_FMT_SRGGB12:
        case VIDEO_PIX_FMT_SBGGR14:
        case VIDEO_PIX_FMT_SGBRG14:
        case VIDEO_PIX_FMT_SGRBG14:
        case VIDEO_PIX_FMT_SRGGB14:
        case VIDEO_PIX_FMT_SBGGR16:
        case VIDEO_PIX_FMT_SGBRG16:
        case VIDEO_PIX_FMT_SGRBG16:
        case VIDEO_PIX_FMT_SRGGB16:
                return 16;
        case VIDEO_PIX_FMT_BGR24:
        case VIDEO_PIX_FMT_RGB24:
                return 24;
        case VIDEO_PIX_FMT_XRGB32:
        case VIDEO_PIX_FMT_XYUV32:
        case VIDEO_PIX_FMT_ARGB32:
        case VIDEO_PIX_FMT_ABGR32:
        case VIDEO_PIX_FMT_RGBA32:
        case VIDEO_PIX_FMT_BGRA32:
                return 32;
        default:
                /* Variable number of bits per pixel or unknown format */
                return 0;
        }
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_VIDEO_H_ */