formats.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019 Linaro Limited.
 * Copyright 2025 NXP
 * Copyright (c) 2025 STMicroelectronics
 * SPDX-FileCopyrightText: Copyright The Zephyr Project Contributors
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_VIDEO_FORMATS_H
#define ZEPHYR_INCLUDE_VIDEO_FORMATS_H

 
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif

#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_FOREACH_BAYER(X, ...)                                             \
        VIDEO_FOREACH_BAYER_PADDED(X, __VA_ARGS__)                              \
        VIDEO_FOREACH_BAYER_MIPI_PACKED(X, __VA_ARGS__)                         \
        VIDEO_FOREACH_BAYER_NON_PACKED(X, __VA_ARGS__)

#define VIDEO_FOREACH_BAYER_PADDED(X, ...)                                      \
        X(VIDEO_PIX_FMT_SBGGR8P16, __VA_ARGS__)                                 \
        X(VIDEO_PIX_FMT_SGBRG8P16, __VA_ARGS__)                                 \
        X(VIDEO_PIX_FMT_SGRBG8P16, __VA_ARGS__)                                 \
        X(VIDEO_PIX_FMT_SRGGB8P16, __VA_ARGS__)

#define VIDEO_PIX_FMT_SBGGR8P16 VIDEO_FOURCC('p', 'B', '8', '2')

#define VIDEO_PIX_FMT_SGBRG8P16 VIDEO_FOURCC('p', 'G', '8', '2')

#define VIDEO_PIX_FMT_SGRBG8P16 VIDEO_FOURCC('p', 'g', '8', '2')

#define VIDEO_PIX_FMT_SRGGB8P16 VIDEO_FOURCC('p', 'R', '8', '2')

#define VIDEO_FOREACH_BAYER_MIPI_PACKED(X, ...)                                 \
        X(VIDEO_PIX_FMT_SBGGR10P, __VA_ARGS__)                                  \
        X(VIDEO_PIX_FMT_SGBRG10P, __VA_ARGS__)                                  \
        X(VIDEO_PIX_FMT_SGRBG10P, __VA_ARGS__)                                  \
        X(VIDEO_PIX_FMT_SRGGB10P, __VA_ARGS__)                                  \
        X(VIDEO_PIX_FMT_SBGGR12P, __VA_ARGS__)                                  \
        X(VIDEO_PIX_FMT_SGBRG12P, __VA_ARGS__)                                  \
        X(VIDEO_PIX_FMT_SGRBG12P, __VA_ARGS__)                                  \
        X(VIDEO_PIX_FMT_SRGGB12P, __VA_ARGS__)                                  \
        X(VIDEO_PIX_FMT_SBGGR14P, __VA_ARGS__)                                  \
        X(VIDEO_PIX_FMT_SGBRG14P, __VA_ARGS__)                                  \
        X(VIDEO_PIX_FMT_SGRBG14P, __VA_ARGS__)                                  \
        X(VIDEO_PIX_FMT_SRGGB14P, __VA_ARGS__)

#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_FOREACH_BAYER_NON_PACKED(X, ...)                                  \
        X(VIDEO_PIX_FMT_SBGGR8, __VA_ARGS__)                                    \
        X(VIDEO_PIX_FMT_SGBRG8, __VA_ARGS__)                                    \
        X(VIDEO_PIX_FMT_SGRBG8, __VA_ARGS__)                                    \
        X(VIDEO_PIX_FMT_SRGGB8, __VA_ARGS__)                                    \
        X(VIDEO_PIX_FMT_SGBRG10, __VA_ARGS__)                                   \
        X(VIDEO_PIX_FMT_SGRBG10, __VA_ARGS__)                                   \
        X(VIDEO_PIX_FMT_SRGGB10, __VA_ARGS__)                                   \
        X(VIDEO_PIX_FMT_SBGGR12, __VA_ARGS__)                                   \
        X(VIDEO_PIX_FMT_SGBRG12, __VA_ARGS__)                                   \
        X(VIDEO_PIX_FMT_SGRBG12, __VA_ARGS__)                                   \
        X(VIDEO_PIX_FMT_SRGGB12, __VA_ARGS__)                                   \
        X(VIDEO_PIX_FMT_SBGGR14, __VA_ARGS__)                                   \
        X(VIDEO_PIX_FMT_SGBRG14, __VA_ARGS__)                                   \
        X(VIDEO_PIX_FMT_SGRBG14, __VA_ARGS__)                                   \
        X(VIDEO_PIX_FMT_SRGGB14, __VA_ARGS__)                                   \
        X(VIDEO_PIX_FMT_SBGGR16, __VA_ARGS__)                                   \
        X(VIDEO_PIX_FMT_SGBRG16, __VA_ARGS__)                                   \
        X(VIDEO_PIX_FMT_SGRBG16, __VA_ARGS__)                                   \
        X(VIDEO_PIX_FMT_SRGGB16, __VA_ARGS__)

#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_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_FOREACH_GRAYSCALE(X, ...)                                         \
        VIDEO_FOREACH_GRAYSCALE_NON_PACKED(X, __VA_ARGS__)                      \
        VIDEO_FOREACH_GRAYSCALE_PADDED(X, __VA_ARGS__)                          \
        VIDEO_FOREACH_GRAYSCALE_MIPI_PACKED(X, __VA_ARGS__)

#define VIDEO_FOREACH_GRAYSCALE_NON_PACKED(X, ...)                              \
        X(VIDEO_PIX_FMT_GREY, __VA_ARGS__)                                      \
        X(VIDEO_PIX_FMT_Y10, __VA_ARGS__)                                       \
        X(VIDEO_PIX_FMT_Y12, __VA_ARGS__)                                       \
        X(VIDEO_PIX_FMT_Y14, __VA_ARGS__)                                       \
        X(VIDEO_PIX_FMT_Y16, __VA_ARGS__)

#define VIDEO_PIX_FMT_GREY VIDEO_FOURCC('G', 'R', 'E', 'Y')

#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_FOREACH_GRAYSCALE_PADDED(X, ...)                                  \
        X(VIDEO_PIX_FMT_Y8P16, __VA_ARGS__)

#define VIDEO_PIX_FMT_Y8P16 VIDEO_FOURCC('Y', '8', 'P', '2')

#define VIDEO_FOREACH_GRAYSCALE_MIPI_PACKED(X, ...)                             \
        X(VIDEO_PIX_FMT_Y10P, __VA_ARGS__)                                      \
        X(VIDEO_PIX_FMT_Y12P, __VA_ARGS__)                                      \
        X(VIDEO_PIX_FMT_Y14P, __VA_ARGS__)

#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_FOREACH_RGB(X, ...)                                               \
        VIDEO_FOREACH_RGB_PACKED(X, __VA_ARGS__)                                \
        VIDEO_FOREACH_RGB_NON_PACKED(X, __VA_ARGS__)                            \
        VIDEO_FOREACH_RGB_ALPHA(X, __VA_ARGS__)                                 \
        VIDEO_FOREACH_RGB_PADDED(X, __VA_ARGS__)

#define VIDEO_FOREACH_RGB_PACKED(X, ...)                                        \
        X(VIDEO_PIX_FMT_RGB565X, __VA_ARGS__)                                   \
        X(VIDEO_PIX_FMT_RGB565, __VA_ARGS__)

#define VIDEO_PIX_FMT_RGB565X VIDEO_FOURCC('R', 'G', 'B', 'R')

#define VIDEO_PIX_FMT_RGB565 VIDEO_FOURCC('R', 'G', 'B', 'P')

#define VIDEO_FOREACH_RGB_NON_PACKED(X, ...)                                    \
        X(VIDEO_PIX_FMT_BGR24, __VA_ARGS__)                                     \
        X(VIDEO_PIX_FMT_RGB24, __VA_ARGS__)

#define VIDEO_PIX_FMT_BGR24 VIDEO_FOURCC('B', 'G', 'R', '3')

#define VIDEO_PIX_FMT_RGB24 VIDEO_FOURCC('R', 'G', 'B', '3')

#define VIDEO_FOREACH_RGB_ALPHA(X, ...)                                         \
        X(VIDEO_PIX_FMT_ARGB32, __VA_ARGS__)                                    \
        X(VIDEO_PIX_FMT_ABGR32, __VA_ARGS__)                                    \
        X(VIDEO_PIX_FMT_RGBA32, __VA_ARGS__)                                    \
        X(VIDEO_PIX_FMT_BGRA32, __VA_ARGS__)

#define VIDEO_PIX_FMT_ARGB32 VIDEO_FOURCC('B', 'A', '2', '4')

#define VIDEO_PIX_FMT_BGRA32 VIDEO_FOURCC('A', 'R', '2', '4')

#define VIDEO_PIX_FMT_RGBA32 VIDEO_FOURCC('A', 'B', '2', '4')

#define VIDEO_PIX_FMT_ABGR32 VIDEO_FOURCC('R', 'A', '2', '4')

#define VIDEO_FOREACH_RGB_PADDED(X, ...)                                        \
        X(VIDEO_PIX_FMT_XRGB32, __VA_ARGS__)

#define VIDEO_PIX_FMT_XRGB32 VIDEO_FOURCC('B', 'X', '2', '4')

#define VIDEO_PIX_FMT_XBGR32 VIDEO_FOURCC('R', 'X', '2', '4')

#define VIDEO_PIX_FMT_BGRX32 VIDEO_FOURCC('X', 'R', '2', '4')

#define VIDEO_PIX_FMT_RGBX32 VIDEO_FOURCC('X', 'B', '2', '4')



#define VIDEO_FOREACH_YUV(X, ...)                                               \
        VIDEO_FOREACH_YUV_FULL_PLANAR(X, __VA_ARGS__)                           \
        VIDEO_FOREACH_YUV_NON_PLANAR(X, __VA_ARGS__)                            \
        VIDEO_FOREACH_YUV_SEMI_PLANAR(X, __VA_ARGS__)

#define VIDEO_FOREACH_YUV_NON_PLANAR(X, ...)                                    \
        X(VIDEO_PIX_FMT_YUYV, __VA_ARGS__)                                      \
        X(VIDEO_PIX_FMT_YVYU, __VA_ARGS__)                                      \
        X(VIDEO_PIX_FMT_VYUY, __VA_ARGS__)                                      \
        X(VIDEO_PIX_FMT_UYVY, __VA_ARGS__)                                      \
        X(VIDEO_PIX_FMT_YUV24, __VA_ARGS__)                                     \
        X(VIDEO_PIX_FMT_XYUV32, __VA_ARGS__)

#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_FOREACH_YUV_SEMI_PLANAR(X, ...)                                   \
        X(VIDEO_PIX_FMT_NV12, __VA_ARGS__)                                      \
        X(VIDEO_PIX_FMT_NV21, __VA_ARGS__)                                      \
        X(VIDEO_PIX_FMT_NV16, __VA_ARGS__)                                      \
        X(VIDEO_PIX_FMT_NV61, __VA_ARGS__)                                      \
        X(VIDEO_PIX_FMT_NV24, __VA_ARGS__)                                      \
        X(VIDEO_PIX_FMT_NV42, __VA_ARGS__)

#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_FOREACH_YUV_FULL_PLANAR(X, ...)                                   \
        X(VIDEO_PIX_FMT_YUV420, __VA_ARGS__)                                    \
        X(VIDEO_PIX_FMT_YVU420, __VA_ARGS__)

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

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



#define VIDEO_FOREACH_COMPRESSED(X, ...)                                        \
        X(VIDEO_PIX_FMT_JPEG, __VA_ARGS__)                                      \
        X(VIDEO_PIX_FMT_H264, __VA_ARGS__)                                      \
        X(VIDEO_PIX_FMT_H264_NO_SC, __VA_ARGS__)                                \
        X(VIDEO_PIX_FMT_PNG, __VA_ARGS__)

#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', ' ')


#define _VIDEO_FMT_OR_EQ(pixfmt_a, pixfmt_b) || ((pixfmt_a) == (pixfmt_b))

#define VIDEO_FMT_IS_GRAYSCALE(pixfmt)                                          \
        (0 VIDEO_FOREACH_GRAYSCALE(_VIDEO_FMT_OR_EQ, pixfmt))

#define VIDEO_FMT_IS_BAYER(pixfmt)                                              \
        (0 VIDEO_FOREACH_BAYER(_VIDEO_FMT_OR_EQ, pixfmt))

#define VIDEO_FMT_IS_RGB(pixfmt)                                                \
        (0 VIDEO_FOREACH_RGB(_VIDEO_FMT_OR_EQ, pixfmt))

#define VIDEO_FMT_IS_YUV(pixfmt)                                                \
        (0 VIDEO_FOREACH_YUV(_VIDEO_FMT_OR_EQ, pixfmt))

#define VIDEO_FMT_IS_MIPI_PACKED(pixfmt)                                        \
        (0 VIDEO_FOREACH_BAYER_MIPI_PACKED(_VIDEO_FMT_OR_EQ, pixfmt)            \
           VIDEO_FOREACH_GRAYSCALE_MIPI_PACKED(_VIDEO_FMT_OR_EQ, pixfmt))

#define VIDEO_FMT_IS_PADDED(pixfmt)                                             \
        (0 VIDEO_FOREACH_BAYER_PADDED(_VIDEO_FMT_OR_EQ, pixfmt)                 \
           VIDEO_FOREACH_GRAYSCALE_PADDED(_VIDEO_FMT_OR_EQ, pixfmt))

#define VIDEO_FMT_IS_SEMI_PLANAR(pixfmt)                                        \
        (0 VIDEO_FOREACH_YUV_SEMI_PLANAR(_VIDEO_FMT_OR_EQ, pixfmt))

#define VIDEO_FMT_IS_FULL_PLANAR(pixfmt)                                        \
        (0 VIDEO_FOREACH_YUV_FULL_PLANAR(_VIDEO_FMT_OR_EQ, pixfmt))

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_SBGGR8P16:
        case VIDEO_PIX_FMT_SGBRG8P16:
        case VIDEO_PIX_FMT_SGRBG8P16:
        case VIDEO_PIX_FMT_SRGGB8P16:
        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_Y8P16:
        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:
                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_XYUV32:
        case VIDEO_PIX_FMT_ARGB32:
        case VIDEO_PIX_FMT_ABGR32:
        case VIDEO_PIX_FMT_RGBA32:
        case VIDEO_PIX_FMT_BGRA32:
        case VIDEO_PIX_FMT_XRGB32:
        case VIDEO_PIX_FMT_XBGR32:
        case VIDEO_PIX_FMT_RGBX32:
        case VIDEO_PIX_FMT_BGRX32:
                return 32;
        default:
                /* Variable number of bits per pixel or unknown format */
                return 0;
        }
}
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_VIDEO_FORMATS_H */