video.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019 Linaro Limited.
 * Copyright 2025 NXP
 * Copyright (c) 2025 STMicroelectronics
 *
 * 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
 
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;
        uint32_t size;
};

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;
        size_t buf_align;
};

struct video_buffer {
        /* It must be kept as first field of the struct if used for @ref k_fifo APIs. */
        void *driver_data;
        enum video_buf_type type;
        uint8_t *buffer;
        uint8_t index;
        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,   
};

enum video_selection_target {
        VIDEO_SEL_TGT_CROP,
        VIDEO_SEL_TGT_CROP_BOUND,
        VIDEO_SEL_TGT_NATIVE_SIZE,
        VIDEO_SEL_TGT_COMPOSE,
        VIDEO_SEL_TGT_COMPOSE_BOUND,
};

struct video_rect {
        uint32_t left;
        uint32_t top;
        uint32_t width;
        uint32_t height;
};

struct video_selection {
        enum video_buf_type type;
        enum video_selection_target target;
        struct video_rect rect;
};

typedef int (*video_api_format_t)(const struct device *dev, struct video_format *fmt);

typedef int (*video_api_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_transform_cap_t)(const struct device *const dev,
                                         const struct video_format_cap *const cap,
                                         struct video_format_cap *const res_cap,
                                         enum video_buf_type type, uint16_t ind);

typedef int (*video_api_set_signal_t)(const struct device *dev, struct k_poll_signal *sig);

typedef int (*video_api_selection_t)(const struct device *dev, struct video_selection *sel);
 
__subsystem struct video_driver_api {
        /* mandatory callbacks */
        video_api_format_t set_format;
        video_api_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_frmival_t set_frmival;
        video_api_frmival_t get_frmival;
        video_api_enum_frmival_t enum_frmival;
        video_api_selection_t set_selection;
        video_api_selection_t get_selection;
        video_api_transform_cap_t transform_cap;
};

static inline int video_set_format(const struct device *dev, struct video_format *fmt)
{
        const struct video_driver_api *api;
 
        if (dev == NULL || fmt == NULL) {
                return -EINVAL;
        }
 
        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;
 
        if (dev == NULL || fmt == NULL) {
                return -EINVAL;
        }
 
        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;
 
        if (dev == NULL || frmival == NULL) {
                return -EINVAL;
        }
 
        if (frmival->numerator == 0 || frmival->denominator == 0) {
                return -EINVAL;
        }
 
        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;
 
        if (dev == NULL || frmival == NULL) {
                return -EINVAL;
        }
 
        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;
 
        if (dev == NULL || fie == NULL || fie->format == NULL) {
                return -EINVAL;
        }
 
        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 (dev == NULL || buf == NULL || buf->buffer == NULL) {
                return -EINVAL;
        }
 
        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;
 
        if (dev == NULL || buf == NULL) {
                return -EINVAL;
        }
 
        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;
 
        if (dev == NULL) {
                return -EINVAL;
        }
 
        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;
 
        if (dev == NULL) {
                return -EINVAL;
        }
 
        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;
        int ret;
 
        if (dev == NULL) {
                return -EINVAL;
        }
 
        api = (const struct video_driver_api *)dev->api;
        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;
 
        if (dev == NULL || caps == NULL ||
            (caps->type != VIDEO_BUF_TYPE_INPUT && caps->type != VIDEO_BUF_TYPE_OUTPUT)) {
                return -EINVAL;
        }
 
        api = (const struct video_driver_api *)dev->api;
        if (api->get_caps == NULL) {
                return -ENOSYS;
        }
 
        return api->get_caps(dev, caps);
}

static inline int video_transform_cap(const struct device *const dev,
                                      const struct video_format_cap *const cap,
                                      struct video_format_cap *const res_cap,
                                      enum video_buf_type type, uint16_t ind)
{
        const struct video_driver_api *api;
 
        if (dev == NULL || cap == NULL || res_cap == NULL ||
            (type != VIDEO_BUF_TYPE_INPUT && type != VIDEO_BUF_TYPE_OUTPUT)) {
                return -EINVAL;
        }
 
        api = (const struct video_driver_api *)dev->api;
        if (api->transform_cap == NULL) {
                return -ENOSYS;
        }
 
        return api->transform_cap(dev, cap, res_cap, type, ind);
}

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(struct video_ctrl_query *cq);

void video_print_ctrl(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;
 
        if (dev == NULL || sig == NULL) {
                return -EINVAL;
        }
 
        api = (const struct video_driver_api *)dev->api;
        if (api->set_signal == NULL) {
                return -ENOSYS;
        }
 
        return api->set_signal(dev, sig);
}

static inline int video_set_selection(const struct device *dev, struct video_selection *sel)
{
        const struct video_driver_api *api;
 
        if (dev == NULL || sel == NULL) {
                return -EINVAL;
        }
 
        api = (const struct video_driver_api *)dev->api;
        if (api->set_selection == NULL) {
                return -ENOSYS;
        }
 
        return api->set_selection(dev, sel);
}

static inline int video_get_selection(const struct device *dev, struct video_selection *sel)
{
        const struct video_driver_api *api;
 
        if (dev == NULL || sel == NULL) {
                return -EINVAL;
        }
 
        api = (const struct video_driver_api *)dev->api;
        if (api->get_selection == NULL) {
                return -ENOSYS;
        }
 
        return api->get_selection(dev, sel);
}

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)
{
        if (frmival == NULL || frmival->denominator == 0) {
                return -EINVAL;
        }
 
        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);

int64_t video_get_csi_link_freq(const struct device *dev, uint8_t bpp, uint8_t lane_nb);

int video_estimate_fmt_size(struct video_format *fmt);

int video_set_compose_format(const struct device *dev, struct video_format *fmt);

int video_transfer_buffer(const struct device *src, const struct device *sink,
                          enum video_buf_type src_type, enum video_buf_type sink_type,
                          k_timeout_t timeout);


#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_Y4 VIDEO_FOURCC('Y', '0', '4', ' ')

#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_Y10 VIDEO_FOURCC('Y', '1', '0', ' ')

#define VIDEO_PIX_FMT_Y12 VIDEO_FOURCC('Y', '1', '2', ' ')

#define VIDEO_PIX_FMT_Y14 VIDEO_FOURCC('Y', '1', '4', ' ')

#define VIDEO_PIX_FMT_Y16 VIDEO_FOURCC('Y', '1', '6', ' ')



#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_YUV24 VIDEO_FOURCC('Y', 'U', 'V', '3')

#define VIDEO_PIX_FMT_NV12 VIDEO_FOURCC('N', 'V', '1', '2')

#define VIDEO_PIX_FMT_NV21 VIDEO_FOURCC('N', 'V', '2', '1')

#define VIDEO_PIX_FMT_NV16 VIDEO_FOURCC('N', 'V', '1', '6')

 
#define VIDEO_PIX_FMT_NV61 VIDEO_FOURCC('N', 'V', '6', '1')

#define VIDEO_PIX_FMT_NV24 VIDEO_FOURCC('N', 'V', '2', '4')

#define VIDEO_PIX_FMT_NV42 VIDEO_FOURCC('N', 'V', '4', '2')

#define VIDEO_PIX_FMT_YUV420 VIDEO_FOURCC('Y', 'U', '1', '2')

#define VIDEO_PIX_FMT_YVU420 VIDEO_FOURCC('Y', 'V', '1', '2')



#define VIDEO_PIX_FMT_JPEG VIDEO_FOURCC('J', 'P', 'E', 'G')

#define VIDEO_PIX_FMT_H264 VIDEO_FOURCC('H', '2', '6', '4')

#define VIDEO_PIX_FMT_H264_NO_SC VIDEO_FOURCC('A', 'V', 'C', '1')

#define VIDEO_PIX_FMT_PNG VIDEO_FOURCC('P', 'N', '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:
        case VIDEO_PIX_FMT_NV12:
        case VIDEO_PIX_FMT_NV21:
        case VIDEO_PIX_FMT_YUV420:
        case VIDEO_PIX_FMT_YVU420:
                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:
        case VIDEO_PIX_FMT_Y10:
        case VIDEO_PIX_FMT_Y12:
        case VIDEO_PIX_FMT_Y14:
        case VIDEO_PIX_FMT_Y16:
        case VIDEO_PIX_FMT_NV16:
        case VIDEO_PIX_FMT_NV61:
        case VIDEO_PIX_FMT_Y4:
                return 16;
        case VIDEO_PIX_FMT_BGR24:
        case VIDEO_PIX_FMT_RGB24:
        case VIDEO_PIX_FMT_NV24:
        case VIDEO_PIX_FMT_NV42:
        case VIDEO_PIX_FMT_YUV24:
                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;
        }
}



#define VIDEO_MIPI_CSI2_DT_NULL                 0x10
#define VIDEO_MIPI_CSI2_DT_BLANKING             0x11
#define VIDEO_MIPI_CSI2_DT_EMBEDDED_8           0x12
#define VIDEO_MIPI_CSI2_DT_YUV420_8             0x18
#define VIDEO_MIPI_CSI2_DT_YUV420_10            0x19
#define VIDEO_MIPI_CSI2_DT_YUV420_CSPS_8        0x1c
#define VIDEO_MIPI_CSI2_DT_YUV420_CSPS_10       0x1d
#define VIDEO_MIPI_CSI2_DT_YUV422_8             0x1e
#define VIDEO_MIPI_CSI2_DT_YUV422_10            0x1f
#define VIDEO_MIPI_CSI2_DT_RGB444               0x20
#define VIDEO_MIPI_CSI2_DT_RGB555               0x21
#define VIDEO_MIPI_CSI2_DT_RGB565               0x22
#define VIDEO_MIPI_CSI2_DT_RGB666               0x23
#define VIDEO_MIPI_CSI2_DT_RGB888               0x24
#define VIDEO_MIPI_CSI2_DT_RAW6                 0x28
#define VIDEO_MIPI_CSI2_DT_RAW7                 0x29
#define VIDEO_MIPI_CSI2_DT_RAW8                 0x2a
#define VIDEO_MIPI_CSI2_DT_RAW10                0x2b
#define VIDEO_MIPI_CSI2_DT_RAW12                0x2c
#define VIDEO_MIPI_CSI2_DT_RAW14                0x2d

#define VIDEO_MIPI_CSI2_DT_USER(n)      (0x30 + (n))

 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_VIDEO_H_ */