You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1026 lines
28 KiB
1026 lines
28 KiB
/*
|
|
* This confidential and proprietary software may be used only as
|
|
* authorised by a licensing agreement from ARM Limited
|
|
* (C) COPYRIGHT 2018-2022 ARM Limited
|
|
* ALL RIGHTS RESERVED
|
|
* The entire notice above must be reproduced on all authorised
|
|
* copies and copies may only be made to the extent permitted
|
|
* by a licensing agreement from ARM Limited.
|
|
*/
|
|
|
|
#ifndef _MALI_FOURCC_H_
|
|
#define _MALI_FOURCC_H_
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif /* __cplusplus */
|
|
|
|
#include <drm_fourcc.h>
|
|
/* Including stddef.h because libdrm version we use doesn't define size_t
|
|
* like versions after 1a2a42c8bfa25.
|
|
*/
|
|
#include <stddef.h>
|
|
#include <drm.h>
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include <assert.h>
|
|
|
|
#if defined(MALI_PRIVATE_FOURCC) && MALI_PRIVATE_FOURCC
|
|
#include "mali_private_fourcc.h"
|
|
#endif /* defined(MALI_PRIVATE_FOURCC) && MALI_PRIVATE_FOURCC */
|
|
|
|
/* FOURCCs for formats that exist upstream, but may not be in the drm_fourcc.h header included above.
|
|
*
|
|
* Below we define DRM FOURCC formats that are upstreamed, but may not be in the drm_fourcc.h header that we include
|
|
* above, merely because that header is too old. As drm_fourcc.h is an external header that we cannot control, the best
|
|
* we can do is to define here the missing formats.
|
|
*/
|
|
#ifndef DRM_FORMAT_R8
|
|
#define DRM_FORMAT_R8 fourcc_code('R', '8', ' ', ' ')
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_INVALID
|
|
#define DRM_FORMAT_INVALID 0
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_P010
|
|
#define DRM_FORMAT_P010 fourcc_code('P', '0', '1', '0')
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_P016
|
|
#define DRM_FORMAT_P016 fourcc_code('P', '0', '1', '6')
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_Y0L2
|
|
#define DRM_FORMAT_Y0L2 fourcc_code('Y', '0', 'L', '2')
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_P210
|
|
#define DRM_FORMAT_P210 fourcc_code('P', '2', '1', '0')
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_Y210
|
|
#define DRM_FORMAT_Y210 fourcc_code('Y', '2', '1', '0')
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_Y410
|
|
#define DRM_FORMAT_Y410 fourcc_code('Y', '4', '1', '0')
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_YUV420_8BIT
|
|
#define DRM_FORMAT_YUV420_8BIT fourcc_code('Y', 'U', '0', '8')
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_YUV420_10BIT
|
|
#define DRM_FORMAT_YUV420_10BIT fourcc_code('Y', 'U', '1', '0')
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_ABGR16161616F
|
|
#define DRM_FORMAT_ABGR16161616F fourcc_code('A', 'B', '4', 'H')
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_R16
|
|
#define DRM_FORMAT_R16 fourcc_code('R', '1', '6', ' ')
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_GR1616
|
|
#define DRM_FORMAT_GR1616 fourcc_code('G', 'R', '3', '2')
|
|
#endif
|
|
|
|
/*
|
|
* 2 plane YCbCr
|
|
* index 0 = Y plane, [39:0] Y3:Y2:Y1:Y0 little endian
|
|
* index 1 = Cr:Cb plane, [39:0] Cr1:Cb1:Cr0:Cb0 little endian
|
|
*/
|
|
#ifndef DRM_FORMAT_NV15
|
|
#define DRM_FORMAT_NV15 fourcc_code('N', 'V', '1', '5') /* 2x2 subsampled Cr:Cb plane */
|
|
#endif
|
|
|
|
/*
|
|
* 3 plane non-subsampled (444) YCbCr
|
|
* 16 bits per component, but only 10 bits are used and 6 bits are padded
|
|
* index 0: Y plane, [15:0] Y:x [10:6] little endian
|
|
* index 1: Cb plane, [15:0] Cb:x [10:6] little endian
|
|
* index 2: Cr plane, [15:0] Cr:x [10:6] little endian
|
|
*/
|
|
#ifndef DRM_FORMAT_Q410
|
|
#define DRM_FORMAT_Q410 fourcc_code('Q', '4', '1', '0')
|
|
#endif
|
|
|
|
/*
|
|
* 3 plane non-subsampled (444) YCrCb
|
|
* 16 bits per component, but only 10 bits are used and 6 bits are padded
|
|
* index 0: Y plane, [15:0] Y:x [10:6] little endian
|
|
* index 1: Cr plane, [15:0] Cr:x [10:6] little endian
|
|
* index 2: Cb plane, [15:0] Cb:x [10:6] little endian
|
|
*/
|
|
#ifndef DRM_FORMAT_Q401
|
|
#define DRM_FORMAT_Q401 fourcc_code('Q', '4', '0', '1')
|
|
#endif
|
|
|
|
/*
|
|
* RGBA format with 10-bit components packed in 64-bit per pixel, with 6 bits of unused padding per component:
|
|
* [63:0] A:x:B:x:G:x:R:x 10:6:10:6:10:6:10:6 little endian
|
|
*/
|
|
#ifndef DRM_FORMAT_AXBXGXRX106106106106
|
|
#define DRM_FORMAT_AXBXGXRX106106106106 fourcc_code('A', 'B', '1', '0')
|
|
#endif
|
|
|
|
/* FOURCCs for formats that do not currently exist upstream, but should.
|
|
*
|
|
* Formats defined in this file MUST have at least one user via the winsys interface. For formats only used internally
|
|
* (e.g formats only used for PBuffers or YUV intermediate formats), the cobj_surface_format interface should be used
|
|
* directly.
|
|
*
|
|
* Formats defined here _should_ be in the process of being upstreamed.
|
|
*
|
|
* Temporary FOURCCs have the pattern [A][r][m][0-9A-Za-z].
|
|
* The corresponding macros must have the form ARM_DRM_FORMAT_xxx
|
|
* The following temporary FOURCCs have already been used:
|
|
* Arm0: ARM_DRM_FORMAT_NV15
|
|
* Arm1: ARM_DRM_FORMAT_Q410
|
|
* Arm2: ARM_DRM_FORMAT_Q401
|
|
* Arm3: ARM_DRM_FORMAT_AXBXGXRX106106106106
|
|
*
|
|
* Once upstreamed the ARM_DRM_FORMAT_xxxx definition below should be removed.
|
|
* These temporary FOURCCs should not be re-used. For example, Arm0 should only be used for
|
|
* ARM_DRM_FORMAT_NV15 and must not be used for a different format, even after ARM_DRM_FORMAT_NV15
|
|
* is upstreamed and its definition is removed from this file.
|
|
*
|
|
* WARNING: Both the macro name and the FOURCC value are very likely to change when these formats are upstreamed. As
|
|
* such, there is *no* API or ABI stability guarantee for formats defined in this file.
|
|
*/
|
|
|
|
/* DRM FOURCC modifiers that exist upstream, but may not be in a drm_fourcc.h
|
|
*
|
|
* These values can be considered stable, but are defined here if required to support building against older
|
|
* drm_fourcc.h.
|
|
*
|
|
* Initial support for AFBC modifiers included in Linux 4.19-rc1: ce6058039
|
|
*/
|
|
#ifndef DRM_FORMAT_MOD_VENDOR_ARM
|
|
#define DRM_FORMAT_MOD_VENDOR_ARM 0x08
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_MOD_VENDOR_NONE
|
|
#define DRM_FORMAT_MOD_VENDOR_NONE 0
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_RESERVED
|
|
#define DRM_FORMAT_RESERVED ((1ULL << 56) - 1)
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_MOD_INVALID
|
|
#define DRM_FORMAT_MOD_INVALID fourcc_mod_code(NONE, DRM_FORMAT_RESERVED)
|
|
#endif
|
|
|
|
#ifndef fourcc_mod_code
|
|
#define fourcc_mod_code(vendor, val) ((((__u64)DRM_FORMAT_MOD_VENDOR_##vendor) << 56) | ((val)&0x00ffffffffffffffULL))
|
|
#endif
|
|
|
|
/*
|
|
* The top 4 bits (out of the 56 bits alloted for specifying vendor specific
|
|
* modifiers) denote the category for modifiers. Currently we have three
|
|
* categories of modifiers ie AFBC, MISC and AFRC. We can have a maximum of
|
|
* sixteen different categories.
|
|
*/
|
|
#ifndef DRM_FORMAT_MOD_ARM_CODE
|
|
#define DRM_FORMAT_MOD_ARM_CODE(__type, __val) \
|
|
fourcc_mod_code(ARM, ((((__u64)(__type)) << 52) | ((__val)&0x000fffffffffffffULL)))
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_MOD_ARM_TYPE_MASK
|
|
#define DRM_FORMAT_MOD_ARM_TYPE_MASK 0xf
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_MOD_ARM_TYPE_AFBC
|
|
#define DRM_FORMAT_MOD_ARM_TYPE_AFBC 0x00
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_MOD_ARM_TYPE_MISC
|
|
#define DRM_FORMAT_MOD_ARM_TYPE_MISC 0x01
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_MOD_ARM_TYPE_AFRC
|
|
#define DRM_FORMAT_MOD_ARM_TYPE_AFRC 0x02
|
|
#endif
|
|
|
|
/*
|
|
* Arm 16x16 Block U-Interleaved modifier
|
|
*
|
|
* This is copied from linux kernel. It divides the image
|
|
* into 16x16 pixel blocks. Blocks are stored linearly in order, but pixels
|
|
* in the block are reordered.
|
|
*/
|
|
#ifndef DRM_FORMAT_MOD_ARM_16X16_BLOCK_U_INTERLEAVED
|
|
#define DRM_FORMAT_MOD_ARM_16X16_BLOCK_U_INTERLEAVED DRM_FORMAT_MOD_ARM_CODE(DRM_FORMAT_MOD_ARM_TYPE_MISC, 1ULL)
|
|
#endif
|
|
|
|
/*
|
|
* Tiled, 16x16 block linear modifier.
|
|
*
|
|
* This fourcc modifier is an alias to an existing fourcc modifier
|
|
* that is already upstreamed however this one has vendor neutral naming.
|
|
*
|
|
* This is a simple tiled layout using tiles of 16x16 pixels in a row-major
|
|
* layout. For YCbCr formats Cb/Cr components are taken in such a way that
|
|
* they correspond to their 16x16 luma block.
|
|
*/
|
|
#ifndef DRM_FORMAT_MOD_GENERIC_16_16_TILE
|
|
#define DRM_FORMAT_MOD_GENERIC_16_16_TILE ((((__u64)0x04) << 56) | (2 & 0x00ffffffffffffffULL))
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_MOD_ARM_AFBC
|
|
#define DRM_FORMAT_MOD_ARM_AFBC(__afbc_mode) DRM_FORMAT_MOD_ARM_CODE(DRM_FORMAT_MOD_ARM_TYPE_AFBC, __afbc_mode)
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_MOD_ARM_AFRC
|
|
#define DRM_FORMAT_MOD_ARM_AFRC(__afrc_mode) DRM_FORMAT_MOD_ARM_CODE(DRM_FORMAT_MOD_ARM_TYPE_AFRC, __afrc_mode)
|
|
#endif
|
|
|
|
/* AFBC superblock size */
|
|
#ifndef AFBC_FORMAT_MOD_BLOCK_SIZE_16x16
|
|
#define AFBC_FORMAT_MOD_BLOCK_SIZE_16x16 ((__u64)0x1)
|
|
#endif
|
|
|
|
#ifndef AFBC_FORMAT_MOD_BLOCK_SIZE_32x8
|
|
#define AFBC_FORMAT_MOD_BLOCK_SIZE_32x8 ((__u64)0x2)
|
|
#endif
|
|
|
|
#ifndef AFBC_FORMAT_MOD_BLOCK_SIZE_MASK
|
|
#define AFBC_FORMAT_MOD_BLOCK_SIZE_MASK ((__u64)0xf)
|
|
#endif
|
|
|
|
/* AFBC lossless transform */
|
|
#ifndef AFBC_FORMAT_MOD_YTR
|
|
#define AFBC_FORMAT_MOD_YTR (((__u64)1) << 4)
|
|
#endif
|
|
|
|
/* AFBC block-split */
|
|
#ifndef AFBC_FORMAT_MOD_SPLIT
|
|
#define AFBC_FORMAT_MOD_SPLIT (((__u64)1) << 5)
|
|
#endif
|
|
|
|
/* AFBC sparse layout */
|
|
#ifndef AFBC_FORMAT_MOD_SPARSE
|
|
#define AFBC_FORMAT_MOD_SPARSE (((__u64)1) << 6)
|
|
#endif
|
|
|
|
/* AFBC copy-block restrict */
|
|
#ifndef AFBC_FORMAT_MOD_CBR
|
|
#define AFBC_FORMAT_MOD_CBR (((__u64)1) << 7)
|
|
#endif
|
|
|
|
/* AFBC tiled layout */
|
|
#ifndef AFBC_FORMAT_MOD_TILED
|
|
#define AFBC_FORMAT_MOD_TILED (((__u64)1) << 8)
|
|
#endif
|
|
|
|
/* AFBC solid color blocks */
|
|
#ifndef AFBC_FORMAT_MOD_SC
|
|
#define AFBC_FORMAT_MOD_SC (((__u64)1) << 9)
|
|
#endif
|
|
|
|
/* AFBC 1.3 block sizes */
|
|
#ifndef AFBC_FORMAT_MOD_BLOCK_SIZE_64x4
|
|
#define AFBC_FORMAT_MOD_BLOCK_SIZE_64x4 ((__u64)0x3)
|
|
#endif
|
|
|
|
#ifndef AFBC_FORMAT_MOD_BLOCK_SIZE_32x8_64x4
|
|
#define AFBC_FORMAT_MOD_BLOCK_SIZE_32x8_64x4 ((__u64)0x4)
|
|
#endif
|
|
|
|
/* AFBC double-buffer */
|
|
#ifndef AFBC_FORMAT_MOD_DB
|
|
#define AFBC_FORMAT_MOD_DB (((__u64)1) << 10)
|
|
#endif
|
|
|
|
/* AFBC buffer content hints */
|
|
#ifndef AFBC_FORMAT_MOD_BCH
|
|
#define AFBC_FORMAT_MOD_BCH (((__u64)1) << 11)
|
|
#endif
|
|
|
|
/* AFBC uncompressed storage mode */
|
|
#ifndef AFBC_FORMAT_MOD_USM
|
|
#define AFBC_FORMAT_MOD_USM (((__u64)1) << 12)
|
|
#endif
|
|
|
|
#ifndef DRM_FORMAT_MOD_LINEAR
|
|
#define DRM_FORMAT_MOD_LINEAR 0
|
|
#endif
|
|
|
|
/*
|
|
* AFRC coding unit size.
|
|
*
|
|
* Indicates the coding unit size in bytes for one or more planes in an AFRC
|
|
* encoded buffer. The coding unit size for chrominance is the same for both
|
|
* Cb and Cr, which may be stored in separate planes.
|
|
*
|
|
* For RGBA formats, AFRC_FORMAT_MOD_CU_SIZE_P0 must be specified.
|
|
* For YUV formats, both AFRC_FORMAT_MOD_CU_SIZE_P0 and
|
|
* AFRC_FORMAT_MOD_CU_SIZE_P12 must be specified.
|
|
*/
|
|
#ifndef AFRC_FORMAT_MOD_CU_SIZE_MASK
|
|
#define AFRC_FORMAT_MOD_CU_SIZE_MASK 0xf
|
|
#endif
|
|
|
|
#ifndef AFRC_FORMAT_MOD_CU_SIZE_16
|
|
#define AFRC_FORMAT_MOD_CU_SIZE_16 (1ULL)
|
|
#endif
|
|
|
|
#ifndef AFRC_FORMAT_MOD_CU_SIZE_24
|
|
#define AFRC_FORMAT_MOD_CU_SIZE_24 (2ULL)
|
|
#endif
|
|
|
|
#ifndef AFRC_FORMAT_MOD_CU_SIZE_32
|
|
#define AFRC_FORMAT_MOD_CU_SIZE_32 (3ULL)
|
|
#endif
|
|
|
|
#ifndef AFRC_FORMAT_MOD_CU_SIZE_P0
|
|
#define AFRC_FORMAT_MOD_CU_SIZE_P0(__afrc_cu_size) (__afrc_cu_size)
|
|
#endif
|
|
|
|
#ifndef AFRC_FORMAT_MOD_CU_SIZE_P12
|
|
#define AFRC_FORMAT_MOD_CU_SIZE_P12(__afrc_cu_size) ((__afrc_cu_size) << 4)
|
|
#endif
|
|
|
|
/*
|
|
* AFRC scanline memory layout.
|
|
*
|
|
* Indicates scanline memory layout is in use for an AFRC encoded
|
|
* buffer. The memory layout is the same for all planes.
|
|
*/
|
|
#ifndef AFRC_FORMAT_MOD_LAYOUT_SCAN
|
|
#define AFRC_FORMAT_MOD_LAYOUT_SCAN ((1ULL) << 8)
|
|
#endif
|
|
|
|
/* DRM FOURCC modifiers that do not currently exist upstream, but should.
|
|
*
|
|
* Format modifiers defined here _should_ be in the process of being upstreamed.
|
|
*
|
|
* WARNING: Both the macro name and the FOURCC modifier value are very likely
|
|
* to change when these format modifiers are upstreamed. As such, there is *no*
|
|
* API or ABI stability guarantee for format modifiers defined in this file.
|
|
*/
|
|
|
|
|
|
/* Below here are utilities to aid use of the drm_fourcc values - there is no intention to
|
|
* upstream these */
|
|
|
|
#define fourcc_mod_code_get_vendor(val) ((val) >> 56)
|
|
#define fourcc_mod_code_get_type(val) (((val) >> 52) & DRM_FORMAT_MOD_ARM_TYPE_MASK)
|
|
|
|
/* Returns true if the modifier describes an AFBC format. */
|
|
static inline bool drm_fourcc_modifier_is_afbc(uint64_t modifier)
|
|
{
|
|
uint32_t vendor = fourcc_mod_code_get_vendor(modifier);
|
|
uint32_t type = fourcc_mod_code_get_type(modifier);
|
|
return DRM_FORMAT_MOD_VENDOR_ARM == vendor && DRM_FORMAT_MOD_ARM_TYPE_AFBC == type;
|
|
}
|
|
|
|
/* Returns true if the modifier describes an AFRC format. */
|
|
static inline bool drm_fourcc_modifier_is_afrc(uint64_t modifier)
|
|
{
|
|
uint32_t vendor = fourcc_mod_code_get_vendor(modifier);
|
|
uint32_t type = fourcc_mod_code_get_type(modifier);
|
|
return DRM_FORMAT_MOD_VENDOR_ARM == vendor && DRM_FORMAT_MOD_ARM_TYPE_AFRC == type;
|
|
}
|
|
|
|
/* Returns true if the modifier describes an 16x16 block linear YUV format. */
|
|
static inline bool drm_fourcc_modifier_is_block_linear_yuv(uint64_t modifier)
|
|
{
|
|
return modifier == DRM_FORMAT_MOD_GENERIC_16_16_TILE;
|
|
}
|
|
|
|
/* Returns the number of planes represented by a fourcc format. */
|
|
static inline uint32_t drm_fourcc_format_get_num_planes(uint32_t format)
|
|
{
|
|
switch (format)
|
|
{
|
|
default:
|
|
return 0;
|
|
|
|
case DRM_FORMAT_C8:
|
|
case DRM_FORMAT_R8:
|
|
case DRM_FORMAT_RGB332:
|
|
case DRM_FORMAT_BGR233:
|
|
case DRM_FORMAT_XRGB4444:
|
|
case DRM_FORMAT_XBGR4444:
|
|
case DRM_FORMAT_RGBX4444:
|
|
case DRM_FORMAT_BGRX4444:
|
|
case DRM_FORMAT_ARGB4444:
|
|
case DRM_FORMAT_ABGR4444:
|
|
case DRM_FORMAT_RGBA4444:
|
|
case DRM_FORMAT_BGRA4444:
|
|
case DRM_FORMAT_XRGB1555:
|
|
case DRM_FORMAT_XBGR1555:
|
|
case DRM_FORMAT_RGBX5551:
|
|
case DRM_FORMAT_BGRX5551:
|
|
case DRM_FORMAT_ARGB1555:
|
|
case DRM_FORMAT_ABGR1555:
|
|
case DRM_FORMAT_RGBA5551:
|
|
case DRM_FORMAT_BGRA5551:
|
|
case DRM_FORMAT_RGB565:
|
|
case DRM_FORMAT_BGR565:
|
|
case DRM_FORMAT_RGB888:
|
|
case DRM_FORMAT_BGR888:
|
|
case DRM_FORMAT_XRGB8888:
|
|
case DRM_FORMAT_XBGR8888:
|
|
case DRM_FORMAT_RGBX8888:
|
|
case DRM_FORMAT_BGRX8888:
|
|
case DRM_FORMAT_ARGB8888:
|
|
case DRM_FORMAT_ABGR8888:
|
|
case DRM_FORMAT_RGBA8888:
|
|
case DRM_FORMAT_BGRA8888:
|
|
case DRM_FORMAT_XRGB2101010:
|
|
case DRM_FORMAT_XBGR2101010:
|
|
case DRM_FORMAT_RGBX1010102:
|
|
case DRM_FORMAT_BGRX1010102:
|
|
case DRM_FORMAT_ARGB2101010:
|
|
case DRM_FORMAT_ABGR2101010:
|
|
case DRM_FORMAT_RGBA1010102:
|
|
case DRM_FORMAT_BGRA1010102:
|
|
case DRM_FORMAT_YUYV:
|
|
case DRM_FORMAT_YVYU:
|
|
case DRM_FORMAT_UYVY:
|
|
case DRM_FORMAT_VYUY:
|
|
case DRM_FORMAT_AYUV:
|
|
case DRM_FORMAT_ABGR16161616F:
|
|
case DRM_FORMAT_AXBXGXRX106106106106:
|
|
case DRM_FORMAT_R16:
|
|
case DRM_FORMAT_GR1616:
|
|
case DRM_FORMAT_Y410:
|
|
case DRM_FORMAT_Y0L2:
|
|
case DRM_FORMAT_Y210:
|
|
case DRM_FORMAT_YUV420_8BIT:
|
|
case DRM_FORMAT_YUV420_10BIT:
|
|
#if defined(MALI_PRIVATE_FOURCC) && MALI_PRIVATE_FOURCC
|
|
case ARM_PRIV_DRM_FORMAT_AYUV2101010:
|
|
case ARM_PRIV_DRM_FORMAT_YUYV10101010:
|
|
case ARM_PRIV_DRM_FORMAT_VYUY10101010:
|
|
#endif /* defined(MALI_PRIVATE_FOURCC) && MALI_PRIVATE_FOURCC */
|
|
return 1;
|
|
|
|
case DRM_FORMAT_NV12:
|
|
case DRM_FORMAT_NV21:
|
|
case DRM_FORMAT_NV16:
|
|
case DRM_FORMAT_NV61:
|
|
case DRM_FORMAT_P010:
|
|
case DRM_FORMAT_P016:
|
|
case DRM_FORMAT_P210:
|
|
case DRM_FORMAT_NV15:
|
|
#if defined(MALI_PRIVATE_FOURCC) && MALI_PRIVATE_FOURCC
|
|
case ARM_PRIV_DRM_FORMAT_Y_UV422_10BIT:
|
|
#endif /* defined(MALI_PRIVATE_FOURCC) && MALI_PRIVATE_FOURCC */
|
|
return 2;
|
|
|
|
case DRM_FORMAT_YUV410:
|
|
case DRM_FORMAT_YVU410:
|
|
case DRM_FORMAT_YUV411:
|
|
case DRM_FORMAT_YVU411:
|
|
case DRM_FORMAT_YUV420:
|
|
case DRM_FORMAT_YVU420:
|
|
case DRM_FORMAT_YUV422:
|
|
case DRM_FORMAT_YVU422:
|
|
case DRM_FORMAT_YUV444:
|
|
case DRM_FORMAT_YVU444:
|
|
case DRM_FORMAT_Q410:
|
|
case DRM_FORMAT_Q401:
|
|
return 3;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the string representation of the given FOURCC.
|
|
*
|
|
* @param format A FOURCC format which is known by the DDK.
|
|
*
|
|
* @return The string representation of @p format, or "UNKNOWN-FOURCC" for formats not known by the DDK.
|
|
*/
|
|
static inline const char *drm_fourcc_format_to_string(uint32_t format)
|
|
{
|
|
switch (format)
|
|
{
|
|
case DRM_FORMAT_C8:
|
|
return "DRM_FORMAT_C8";
|
|
case DRM_FORMAT_R8:
|
|
return "DRM_FORMAT_R8";
|
|
case DRM_FORMAT_RGB332:
|
|
return "DRM_FORMAT_RGB332";
|
|
case DRM_FORMAT_BGR233:
|
|
return "DRM_FORMAT_BGR233";
|
|
case DRM_FORMAT_XRGB4444:
|
|
return "DRM_FORMAT_XRGB4444";
|
|
case DRM_FORMAT_XBGR4444:
|
|
return "DRM_FORMAT_XBGR4444";
|
|
case DRM_FORMAT_RGBX4444:
|
|
return "DRM_FORMAT_RGBX4444";
|
|
case DRM_FORMAT_BGRX4444:
|
|
return "DRM_FORMAT_BGRX4444";
|
|
case DRM_FORMAT_ARGB4444:
|
|
return "DRM_FORMAT_ARGB4444";
|
|
case DRM_FORMAT_ABGR4444:
|
|
return "DRM_FORMAT_ABGR4444";
|
|
case DRM_FORMAT_RGBA4444:
|
|
return "DRM_FORMAT_RGBA4444";
|
|
case DRM_FORMAT_BGRA4444:
|
|
return "DRM_FORMAT_BGRA4444";
|
|
case DRM_FORMAT_XRGB1555:
|
|
return "DRM_FORMAT_XRGB1555";
|
|
case DRM_FORMAT_XBGR1555:
|
|
return "DRM_FORMAT_XBGR1555";
|
|
case DRM_FORMAT_RGBX5551:
|
|
return "DRM_FORMAT_RGBX5551";
|
|
case DRM_FORMAT_BGRX5551:
|
|
return "DRM_FORMAT_BGRX5551";
|
|
case DRM_FORMAT_ARGB1555:
|
|
return "DRM_FORMAT_ARGB1555";
|
|
case DRM_FORMAT_ABGR1555:
|
|
return "DRM_FORMAT_ABGR1555";
|
|
case DRM_FORMAT_RGBA5551:
|
|
return "DRM_FORMAT_RGBA5551";
|
|
case DRM_FORMAT_BGRA5551:
|
|
return "DRM_FORMAT_BGRA5551";
|
|
case DRM_FORMAT_RGB565:
|
|
return "DRM_FORMAT_RGB565";
|
|
case DRM_FORMAT_BGR565:
|
|
return "DRM_FORMAT_BGR565";
|
|
case DRM_FORMAT_RGB888:
|
|
return "DRM_FORMAT_RGB888";
|
|
case DRM_FORMAT_BGR888:
|
|
return "DRM_FORMAT_BGR888";
|
|
case DRM_FORMAT_XRGB8888:
|
|
return "DRM_FORMAT_XRGB8888";
|
|
case DRM_FORMAT_XBGR8888:
|
|
return "DRM_FORMAT_XBGR8888";
|
|
case DRM_FORMAT_RGBX8888:
|
|
return "DRM_FORMAT_RGBX8888";
|
|
case DRM_FORMAT_BGRX8888:
|
|
return "DRM_FORMAT_BGRX8888";
|
|
case DRM_FORMAT_ARGB8888:
|
|
return "DRM_FORMAT_ARGB8888";
|
|
case DRM_FORMAT_ABGR8888:
|
|
return "DRM_FORMAT_ABGR8888";
|
|
case DRM_FORMAT_RGBA8888:
|
|
return "DRM_FORMAT_RGBA8888";
|
|
case DRM_FORMAT_BGRA8888:
|
|
return "DRM_FORMAT_BGRA8888";
|
|
case DRM_FORMAT_XRGB2101010:
|
|
return "DRM_FORMAT_XRGB2101010";
|
|
case DRM_FORMAT_XBGR2101010:
|
|
return "DRM_FORMAT_XBGR2101010";
|
|
case DRM_FORMAT_RGBX1010102:
|
|
return "DRM_FORMAT_RGBX1010102";
|
|
case DRM_FORMAT_BGRX1010102:
|
|
return "DRM_FORMAT_BGRX1010102";
|
|
case DRM_FORMAT_ARGB2101010:
|
|
return "DRM_FORMAT_ARGB2101010";
|
|
case DRM_FORMAT_ABGR2101010:
|
|
return "DRM_FORMAT_ABGR2101010";
|
|
case DRM_FORMAT_RGBA1010102:
|
|
return "DRM_FORMAT_RGBA1010102";
|
|
case DRM_FORMAT_BGRA1010102:
|
|
return "DRM_FORMAT_BGRA1010102";
|
|
case DRM_FORMAT_YUYV:
|
|
return "DRM_FORMAT_YUYV";
|
|
case DRM_FORMAT_YVYU:
|
|
return "DRM_FORMAT_YVYU";
|
|
case DRM_FORMAT_UYVY:
|
|
return "DRM_FORMAT_UYVY";
|
|
case DRM_FORMAT_VYUY:
|
|
return "DRM_FORMAT_VYUY";
|
|
case DRM_FORMAT_AYUV:
|
|
return "DRM_FORMAT_AYUV";
|
|
case DRM_FORMAT_ABGR16161616F:
|
|
return "DRM_FORMAT_ABGR16161616F";
|
|
case DRM_FORMAT_R16:
|
|
return "DRM_FORMAT_R16";
|
|
case DRM_FORMAT_GR1616:
|
|
return "DRM_FORMAT_GR1616";
|
|
case DRM_FORMAT_Y410:
|
|
return "DRM_FORMAT_Y410";
|
|
case DRM_FORMAT_Y0L2:
|
|
return "DRM_FORMAT_Y0L2";
|
|
case DRM_FORMAT_Y210:
|
|
return "DRM_FORMAT_Y210";
|
|
case DRM_FORMAT_YUV420_8BIT:
|
|
return "DRM_FORMAT_YUV420_8BIT";
|
|
case DRM_FORMAT_YUV420_10BIT:
|
|
return "DRM_FORMAT_YUV420_10BIT";
|
|
case DRM_FORMAT_NV12:
|
|
return "DRM_FORMAT_NV12";
|
|
case DRM_FORMAT_NV21:
|
|
return "DRM_FORMAT_NV21";
|
|
case DRM_FORMAT_NV16:
|
|
return "DRM_FORMAT_NV16";
|
|
case DRM_FORMAT_NV61:
|
|
return "DRM_FORMAT_NV61";
|
|
case DRM_FORMAT_P010:
|
|
return "DRM_FORMAT_P010";
|
|
case DRM_FORMAT_P016:
|
|
return "DRM_FORMAT_P016";
|
|
case DRM_FORMAT_P210:
|
|
return "DRM_FORMAT_P210";
|
|
case DRM_FORMAT_YUV410:
|
|
return "DRM_FORMAT_YUV410";
|
|
case DRM_FORMAT_YVU410:
|
|
return "DRM_FORMAT_YVU410";
|
|
case DRM_FORMAT_YUV411:
|
|
return "DRM_FORMAT_YUV411";
|
|
case DRM_FORMAT_YVU411:
|
|
return "DRM_FORMAT_YVU411";
|
|
case DRM_FORMAT_YUV420:
|
|
return "DRM_FORMAT_YUV420";
|
|
case DRM_FORMAT_YVU420:
|
|
return "DRM_FORMAT_YVU420";
|
|
case DRM_FORMAT_YUV422:
|
|
return "DRM_FORMAT_YUV422";
|
|
case DRM_FORMAT_YVU422:
|
|
return "DRM_FORMAT_YVU422";
|
|
case DRM_FORMAT_YUV444:
|
|
return "DRM_FORMAT_YUV444";
|
|
case DRM_FORMAT_YVU444:
|
|
return "DRM_FORMAT_YVU444";
|
|
case DRM_FORMAT_NV15:
|
|
return "DRM_FORMAT_NV15";
|
|
case DRM_FORMAT_Q410:
|
|
return "DRM_FORMAT_Q410";
|
|
case DRM_FORMAT_Q401:
|
|
return "DRM_FORMAT_Q401";
|
|
case DRM_FORMAT_AXBXGXRX106106106106:
|
|
return "DRM_FORMAT_AXBXGXRX106106106106";
|
|
#if defined(MALI_PRIVATE_FOURCC) && MALI_PRIVATE_FOURCC
|
|
case ARM_PRIV_DRM_FORMAT_AYUV2101010:
|
|
return "ARM_PRIV_DRM_FORMAT_AYUV2101010";
|
|
case ARM_PRIV_DRM_FORMAT_YUYV10101010:
|
|
return "ARM_PRIV_DRM_FORMAT_YUYV10101010";
|
|
case ARM_PRIV_DRM_FORMAT_VYUY10101010:
|
|
return "ARM_PRIV_DRM_FORMAT_VYUY10101010";
|
|
case ARM_PRIV_DRM_FORMAT_Y_UV422_10BIT:
|
|
return "ARM_PRIV_DRM_FORMAT_Y_UV422_10BIT";
|
|
#endif /* defined(MALI_PRIVATE_FOURCC) && MALI_PRIVATE_FOURCC */
|
|
case DRM_FORMAT_INVALID:
|
|
return "DRM_FORMAT_INVALID";
|
|
default:
|
|
return "UNKNOWN-FOURCC";
|
|
}
|
|
}
|
|
|
|
/* Returns the bits per pixel of the format. Supports only single plane non-YUV formats. */
|
|
static inline uint32_t drm_fourcc_format_get_bits_per_pixel(uint32_t format)
|
|
{
|
|
switch (format)
|
|
{
|
|
default:
|
|
return 0;
|
|
|
|
case DRM_FORMAT_C8:
|
|
case DRM_FORMAT_R8:
|
|
case DRM_FORMAT_RGB332:
|
|
case DRM_FORMAT_BGR233:
|
|
return 8;
|
|
|
|
case DRM_FORMAT_XRGB4444:
|
|
case DRM_FORMAT_XBGR4444:
|
|
case DRM_FORMAT_RGBX4444:
|
|
case DRM_FORMAT_BGRX4444:
|
|
case DRM_FORMAT_ARGB4444:
|
|
case DRM_FORMAT_ABGR4444:
|
|
case DRM_FORMAT_RGBA4444:
|
|
case DRM_FORMAT_BGRA4444:
|
|
case DRM_FORMAT_XRGB1555:
|
|
case DRM_FORMAT_XBGR1555:
|
|
case DRM_FORMAT_RGBX5551:
|
|
case DRM_FORMAT_BGRX5551:
|
|
case DRM_FORMAT_ARGB1555:
|
|
case DRM_FORMAT_ABGR1555:
|
|
case DRM_FORMAT_RGBA5551:
|
|
case DRM_FORMAT_BGRA5551:
|
|
case DRM_FORMAT_RGB565:
|
|
case DRM_FORMAT_BGR565:
|
|
return 16;
|
|
|
|
case DRM_FORMAT_RGB888:
|
|
case DRM_FORMAT_BGR888:
|
|
return 24;
|
|
|
|
case DRM_FORMAT_XRGB8888:
|
|
case DRM_FORMAT_XBGR8888:
|
|
case DRM_FORMAT_RGBX8888:
|
|
case DRM_FORMAT_BGRX8888:
|
|
case DRM_FORMAT_ARGB8888:
|
|
case DRM_FORMAT_ABGR8888:
|
|
case DRM_FORMAT_RGBA8888:
|
|
case DRM_FORMAT_BGRA8888:
|
|
case DRM_FORMAT_XRGB2101010:
|
|
case DRM_FORMAT_XBGR2101010:
|
|
case DRM_FORMAT_RGBX1010102:
|
|
case DRM_FORMAT_BGRX1010102:
|
|
case DRM_FORMAT_ARGB2101010:
|
|
case DRM_FORMAT_ABGR2101010:
|
|
case DRM_FORMAT_RGBA1010102:
|
|
case DRM_FORMAT_BGRA1010102:
|
|
return 32;
|
|
|
|
case DRM_FORMAT_ABGR16161616F:
|
|
case DRM_FORMAT_AXBXGXRX106106106106:
|
|
return 64;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Return whether a FOURCC format is YUV.
|
|
*
|
|
* @param format A FOURCC format known by the DDK.
|
|
*
|
|
* @return Whether @p format is a YUV format. This function returns @c false for FOURCCs not known by the DDK,
|
|
* i.e. those for which drm_fourcc_format_to_string() returns "UNKNOWN-FOURCC".
|
|
*/
|
|
static inline bool drm_fourcc_is_yuv(uint32_t format)
|
|
{
|
|
switch (format)
|
|
{
|
|
case DRM_FORMAT_YUYV:
|
|
case DRM_FORMAT_YVYU:
|
|
case DRM_FORMAT_UYVY:
|
|
case DRM_FORMAT_VYUY:
|
|
case DRM_FORMAT_AYUV:
|
|
case DRM_FORMAT_Y410:
|
|
case DRM_FORMAT_Y0L2:
|
|
case DRM_FORMAT_Y210:
|
|
case DRM_FORMAT_YUV420_8BIT:
|
|
case DRM_FORMAT_YUV420_10BIT:
|
|
case DRM_FORMAT_NV12:
|
|
case DRM_FORMAT_NV21:
|
|
case DRM_FORMAT_NV16:
|
|
case DRM_FORMAT_NV61:
|
|
case DRM_FORMAT_P010:
|
|
case DRM_FORMAT_P016:
|
|
case DRM_FORMAT_P210:
|
|
case DRM_FORMAT_YUV410:
|
|
case DRM_FORMAT_YVU410:
|
|
case DRM_FORMAT_YUV411:
|
|
case DRM_FORMAT_YVU411:
|
|
case DRM_FORMAT_YUV420:
|
|
case DRM_FORMAT_YVU420:
|
|
case DRM_FORMAT_YUV422:
|
|
case DRM_FORMAT_YVU422:
|
|
case DRM_FORMAT_YUV444:
|
|
case DRM_FORMAT_YVU444:
|
|
case DRM_FORMAT_NV15:
|
|
case DRM_FORMAT_Q410:
|
|
case DRM_FORMAT_Q401:
|
|
#if defined(MALI_PRIVATE_FOURCC) && MALI_PRIVATE_FOURCC
|
|
case ARM_PRIV_DRM_FORMAT_AYUV2101010:
|
|
case ARM_PRIV_DRM_FORMAT_YUYV10101010:
|
|
case ARM_PRIV_DRM_FORMAT_VYUY10101010:
|
|
case ARM_PRIV_DRM_FORMAT_Y_UV422_10BIT:
|
|
#endif /* defined(MALI_PRIVATE_FOURCC) && MALI_PRIVATE_FOURCC */
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Returns YUV FOURCC subsampling rate.
|
|
*
|
|
* @param format A FOURCC format known by the DDK.
|
|
*
|
|
* @return Subsampling of a YUV @p format. This function returns 0 for formats not known by the DDK.
|
|
*/
|
|
static inline uint32_t drm_fourcc_get_yuv_subsampling(uint32_t format)
|
|
{
|
|
switch (format)
|
|
{
|
|
case DRM_FORMAT_Q410:
|
|
case DRM_FORMAT_Q401:
|
|
case DRM_FORMAT_Y410:
|
|
case DRM_FORMAT_AYUV:
|
|
case DRM_FORMAT_YUV444:
|
|
case DRM_FORMAT_YVU444:
|
|
case DRM_FORMAT_NV24:
|
|
case DRM_FORMAT_NV42:
|
|
return 444;
|
|
case DRM_FORMAT_Y210:
|
|
case DRM_FORMAT_P210:
|
|
case DRM_FORMAT_NV16:
|
|
case DRM_FORMAT_YUYV:
|
|
case DRM_FORMAT_YVYU:
|
|
case DRM_FORMAT_UYVY:
|
|
case DRM_FORMAT_VYUY:
|
|
case DRM_FORMAT_NV61:
|
|
case DRM_FORMAT_YUV422:
|
|
case DRM_FORMAT_YVU422:
|
|
return 422;
|
|
case DRM_FORMAT_P010:
|
|
case DRM_FORMAT_Y0L2:
|
|
case DRM_FORMAT_YUV420_10BIT:
|
|
case DRM_FORMAT_NV15:
|
|
case DRM_FORMAT_NV12:
|
|
case DRM_FORMAT_NV21:
|
|
case DRM_FORMAT_YUV420:
|
|
case DRM_FORMAT_YVU420:
|
|
case DRM_FORMAT_YUV420_8BIT:
|
|
return 420;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the number of components for the given plane for AFRC.
|
|
*
|
|
* @param fourcc FOURCC value of the format.
|
|
* @param plane Format's plane index
|
|
*
|
|
* @return Number of components for the given plane, -1 on failure.
|
|
*/
|
|
static int get_afrc_components_per_plane(uint32_t fourcc, int plane)
|
|
{
|
|
switch (fourcc)
|
|
{
|
|
case DRM_FORMAT_BGR888:
|
|
assert(plane == 0);
|
|
return 3;
|
|
case DRM_FORMAT_ABGR8888:
|
|
case DRM_FORMAT_XBGR8888:
|
|
assert(plane == 0);
|
|
return 4;
|
|
case DRM_FORMAT_NV12:
|
|
case DRM_FORMAT_NV21:
|
|
case DRM_FORMAT_P010:
|
|
case DRM_FORMAT_P210:
|
|
case DRM_FORMAT_NV16:
|
|
assert(plane <= 1);
|
|
return plane == 0 ? 1 : 2;
|
|
case DRM_FORMAT_Q410:
|
|
case DRM_FORMAT_YUV420:
|
|
case DRM_FORMAT_YVU420:
|
|
case DRM_FORMAT_YUV444:
|
|
assert(plane <= 2);
|
|
return 1;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the paging tile dimensions for AFRC.
|
|
*
|
|
* @param modifier Format's modifier value.
|
|
* @param width The location where the width of the paging tile will be set
|
|
* @param height The location where the height of the paging tile will be set
|
|
*
|
|
*/
|
|
static void get_afrc_paging_tile_dimensions(uint64_t modifier, uint32_t *width, uint32_t *height)
|
|
{
|
|
if (modifier & AFRC_FORMAT_MOD_LAYOUT_SCAN)
|
|
{
|
|
*width = 16;
|
|
*height = 4;
|
|
}
|
|
else
|
|
{
|
|
*width = 8;
|
|
*height = 8;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the clump dimensions of an AFRC tile block
|
|
*
|
|
* @param fourcc FOURCC value of the format.
|
|
* @param modifier Modifier value.
|
|
* @param plane Format's plane index.
|
|
* @param width The location where the width of the clump dimension will be set
|
|
* @param height The location where the height of the clump dimension will be set
|
|
*
|
|
* @return 0 on success, -1 on failure.
|
|
*/
|
|
static int get_afrc_clump_dimensions(uint32_t fourcc, uint64_t modifier, int plane, uint32_t *width, uint32_t *height)
|
|
{
|
|
switch (get_afrc_components_per_plane(fourcc, plane))
|
|
{
|
|
case 1:
|
|
/* If there is a single component in a plane, the tile clump dimensions match paging tile dimensions */
|
|
get_afrc_paging_tile_dimensions(modifier, width, height);
|
|
break;
|
|
case 2:
|
|
*width = 8;
|
|
*height = 4;
|
|
break;
|
|
case 3:
|
|
case 4:
|
|
*width = 4;
|
|
*height = 4;
|
|
break;
|
|
default:
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the number of vertical samples in a single block for the given plane.
|
|
*
|
|
* @param fourcc FOURCC value of the format.
|
|
* @param modifier Modifier value.
|
|
* @param plane Format's plane index
|
|
*
|
|
* @return Number of vertical samples on success, -1 on failure.
|
|
*
|
|
* Note: implemented for uncompressed, AFRC and block linear formats only.
|
|
*/
|
|
static inline int drm_format_get_block_height(uint32_t fourcc, uint64_t modifier, int plane)
|
|
{
|
|
if (drm_fourcc_modifier_is_block_linear_yuv(modifier))
|
|
{
|
|
int height = 16;
|
|
if (plane > 0 && drm_fourcc_get_yuv_subsampling(fourcc) == 420)
|
|
{
|
|
height /= 2;
|
|
}
|
|
return height;
|
|
}
|
|
else if (drm_fourcc_modifier_is_afrc(modifier))
|
|
{
|
|
uint32_t block_w = 0, block_h = 0;
|
|
if (get_afrc_clump_dimensions(fourcc, modifier, plane, &block_w, &block_h) == 0)
|
|
{
|
|
return (int)block_h;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
else if (modifier == DRM_FORMAT_MOD_LINEAR)
|
|
{
|
|
return fourcc == DRM_FORMAT_Y0L2 ? 2 : 1;
|
|
}
|
|
else
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the number of horizontal samples in a single block for the given plane.
|
|
*
|
|
* @param fourcc FOURCC value of the format.
|
|
* @param modifier Modifier value.
|
|
* @param plane Format's plane index
|
|
*
|
|
* @return Number of horizontal samples on success, -1 on failure.
|
|
*
|
|
* Note: implemented for uncompressed, AFRC and block linear formats only.
|
|
*/
|
|
static inline int drm_format_get_block_width(uint32_t fourcc, uint64_t modifier, int plane)
|
|
{
|
|
int width = -1;
|
|
if (drm_fourcc_modifier_is_block_linear_yuv(modifier))
|
|
{
|
|
width = 16;
|
|
const int subsampling = drm_fourcc_get_yuv_subsampling(fourcc);
|
|
if (plane > 0 && ((subsampling == 422) || (subsampling == 420)))
|
|
{
|
|
width /= 2;
|
|
}
|
|
}
|
|
else if (modifier == DRM_FORMAT_MOD_LINEAR)
|
|
{
|
|
switch (fourcc)
|
|
{
|
|
case DRM_FORMAT_Y0L2:
|
|
width = 2;
|
|
break;
|
|
case DRM_FORMAT_NV15:
|
|
width = 4;
|
|
if (plane > 0)
|
|
{
|
|
width = 2;
|
|
}
|
|
break;
|
|
default:
|
|
width = 1;
|
|
break;
|
|
}
|
|
}
|
|
else if (drm_fourcc_modifier_is_afrc(modifier))
|
|
{
|
|
uint32_t block_w = 0, block_h = 0;
|
|
if (get_afrc_clump_dimensions(fourcc, modifier, plane, &block_w, &block_h) == 0)
|
|
{
|
|
width = (int)block_w;
|
|
}
|
|
}
|
|
|
|
return width;
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif /* __cplusplus */
|
|
|
|
#endif /* _MALI_FOURCC_H_ */
|