460 lines
22 KiB
C
460 lines
22 KiB
C
/* -*- tab-width: 4; -*- */
|
|
/* vi: set sw=2 ts=4 expandtab: */
|
|
|
|
/* Copyright 2019-2020 The Khronos Group Inc.
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
/**
|
|
* @file
|
|
* @~English
|
|
* @brief Utility for interpreting a data format descriptor.
|
|
* @author Andrew Garrard
|
|
*/
|
|
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <KHR/khr_df.h>
|
|
#include "dfd.h"
|
|
|
|
static uint32_t bit_ceil(uint32_t x) {
|
|
x -= 1;
|
|
for (uint32_t i = 0; i < sizeof(x) * 8; ++i)
|
|
if (1u << i > x)
|
|
return 1u << i;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @~English
|
|
* @brief Interpret a Data Format Descriptor for a simple format.
|
|
*
|
|
* Handles "simple" cases that can be translated to things a GPU can access.
|
|
* For simplicity, it ignores the compressed formats, which are generally a
|
|
* single sample (and I believe are all defined to be little-endian in their
|
|
* in-memory layout, even if some documentation confuses this). Focuses on
|
|
* the layout and ignores sRGB except for reporting if that is the transfer
|
|
* function by way of a bit in the returned value.
|
|
*
|
|
* @param[in] DFD Pointer to a Data Format Descriptor to interpret,
|
|
* described as 32-bit words in native endianness.
|
|
* Note that this is the whole descriptor, not just
|
|
* the basic descriptor block.
|
|
* @param R[in,out] Pointer to struct to receive information about the decoded
|
|
* red channel, the Y channel, if YUV, or the depth channel,
|
|
* if any.
|
|
* @param G[in,out] Pointer to struct to receive information about the decoded
|
|
* green channel, the U (Cb) channel, if YUV, or the stencil
|
|
* channel, if any.
|
|
* @param B[in,out] Pointer to struct to receive information about the decoded
|
|
* blue channel, if any or the V (Cr) channel, if YUV.
|
|
* @param A[in,out] Pointer to struct to receive information about the decoded
|
|
* alpha channel, if any or the second Y channel, if YUV and
|
|
* any.
|
|
* @param wordBytes[in,out] Pointer to a uint32_t to receive the byte size of
|
|
* the channels (unpacked) or total size (packed).
|
|
*
|
|
* @return An enumerant describing the decoded value,
|
|
* or an error code in case of failure.
|
|
*
|
|
* The mapping of YUV channels to the parameter names used here is based on
|
|
* the channel ids in @c khr_df.h and is different from the convention used
|
|
* in format names in the Vulkan specification where G == Y, R = Cr and B = Cb.
|
|
**/
|
|
enum InterpretDFDResult interpretDFD(const uint32_t *DFD,
|
|
InterpretedDFDChannel *R,
|
|
InterpretedDFDChannel *G,
|
|
InterpretedDFDChannel *B,
|
|
InterpretedDFDChannel *A,
|
|
uint32_t *wordBytes)
|
|
{
|
|
/* DFD points to the whole descriptor, not the basic descriptor block. */
|
|
/* Make everything else relative to the basic descriptor block. */
|
|
const uint32_t *BDFDB = DFD+1;
|
|
|
|
uint32_t numSamples = KHR_DFDSAMPLECOUNT(BDFDB);
|
|
if (numSamples == 0)
|
|
return i_UNSUPPORTED_CHANNEL_TYPES;
|
|
|
|
int determinedEndianness = 0;
|
|
enum InterpretDFDResult result = 0; /* Build this up incrementally. */
|
|
|
|
bool isDepthStencil = false;
|
|
|
|
/* Clear these so following code doesn't get confused. */
|
|
R->offset = R->size = 0;
|
|
G->offset = G->size = 0;
|
|
B->offset = B->size = 0;
|
|
A->offset = A->size = 0;
|
|
|
|
/* First rule out the multiple planes case (trivially) */
|
|
/* - that is, we check that only bytesPlane0 is non-zero. */
|
|
/* This means we don't handle multi-plane YUV, even if the API could. */
|
|
/* (We rely on KHR_DF_WORD_BYTESPLANE0..3 being the same and */
|
|
/* KHR_DF_WORD_BYTESPLANE4..7 being the same as a short cut.) */
|
|
if ((BDFDB[KHR_DF_WORD_BYTESPLANE0] & ~KHR_DF_MASK_BYTESPLANE0)
|
|
|| BDFDB[KHR_DF_WORD_BYTESPLANE4]) return i_UNSUPPORTED_MULTIPLE_PLANES;
|
|
|
|
/* If this is a packed format, we work out our offsets differently. */
|
|
/* We assume a packed format has channels that aren't byte-aligned. */
|
|
/* If we have a format in which every channel is byte-aligned *and* packed, */
|
|
/* we have the RGBA/ABGR ambiguity; we *probably* don't want the packed */
|
|
/* version in this case, and if hardware has to pack it and swizzle, */
|
|
/* that's up to the hardware to special-case. */
|
|
for (uint32_t sampleCounter = 0; sampleCounter < numSamples; ++sampleCounter) {
|
|
uint32_t offset = KHR_DFDSVAL(BDFDB, sampleCounter, BITOFFSET);
|
|
uint32_t length = KHR_DFDSVAL(BDFDB, sampleCounter, BITLENGTH) + 1;
|
|
if ((offset & 0x7U) || ((offset + length) & 0x7U)) {
|
|
result |= i_PACKED_FORMAT_BIT;
|
|
/* Once we're packed, we're packed, no need to keep checking. */
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Check data types.
|
|
bool hasSigned = false;
|
|
bool hasFloat = false;
|
|
bool hasNormalized = false;
|
|
bool hasFixed = false;
|
|
khr_df_model_e model = KHR_DFDVAL(BDFDB, MODEL);
|
|
|
|
// Note: We're ignoring 9995, which is weird and worth special-casing
|
|
// rather than trying to generalise to all float formats.
|
|
for (uint32_t i = 0; i < numSamples; ++i) {
|
|
const bool isSigned = (KHR_DFDSVAL(BDFDB, i, QUALIFIERS) & KHR_DF_SAMPLE_DATATYPE_SIGNED) != 0;
|
|
const bool isFloat = (KHR_DFDSVAL(BDFDB, i, QUALIFIERS) & KHR_DF_SAMPLE_DATATYPE_FLOAT) != 0;
|
|
|
|
// We define "unnormalized" as "sample_upper = 1" or "sample_upper = 1.0f".
|
|
// We don't check whether any non-1 normalization value is correct
|
|
// (i.e. set to the maximum bit value, and check min value) on
|
|
// the assumption that we're looking at a format which *came* from
|
|
// an API we can support.
|
|
bool isFixed;
|
|
bool isNormalized;
|
|
if (isFloat) {
|
|
isNormalized = *(float*) (void*) &BDFDB[KHR_DF_WORD_SAMPLESTART +
|
|
KHR_DF_WORD_SAMPLEWORDS * i +
|
|
KHR_DF_SAMPLEWORD_SAMPLEUPPER] != 1.0f;
|
|
isFixed = false;
|
|
} else {
|
|
uint32_t sampleUpper = KHR_DFDSVAL(BDFDB, i, SAMPLEUPPER);
|
|
uint32_t maxVal = 1U << KHR_DFDSVAL(BDFDB, i, BITLENGTH);
|
|
if (!isSigned) maxVal <<= 1;
|
|
maxVal--;
|
|
isFixed = 1U < sampleUpper && sampleUpper < maxVal;
|
|
isNormalized = !isFixed && sampleUpper != 1U;
|
|
}
|
|
hasSigned |= isSigned;
|
|
hasFixed |= isFixed;
|
|
hasFloat |= isFloat;
|
|
// By our definition the normalizedness of a single bit channel (like in RGBA 5:5:5:1)
|
|
// is ambiguous. Ignore these during normalized checks.
|
|
if (KHR_DFDSVAL(BDFDB, i, BITLENGTH) > 0)
|
|
hasNormalized |= isNormalized;
|
|
}
|
|
result |= hasSigned ? i_SIGNED_FORMAT_BIT : 0;
|
|
result |= hasFloat ? i_FLOAT_FORMAT_BIT : 0;
|
|
result |= hasNormalized ? i_NORMALIZED_FORMAT_BIT : 0;
|
|
result |= hasFixed ? i_FIXED_FORMAT_BIT : 0;
|
|
|
|
// Checks based on color model
|
|
if (model == KHR_DF_MODEL_YUVSDA) {
|
|
result |= i_NORMALIZED_FORMAT_BIT;
|
|
result |= i_COMPRESSED_FORMAT_BIT;
|
|
result |= i_YUVSDA_FORMAT_BIT;
|
|
|
|
for (uint32_t i = 0; i < numSamples; ++i) {
|
|
switch (KHR_DFDSVAL(BDFDB, i, CHANNELID)) {
|
|
case KHR_DF_CHANNEL_YUVSDA_Y:
|
|
case KHR_DF_CHANNEL_YUVSDA_U:
|
|
case KHR_DF_CHANNEL_YUVSDA_V:
|
|
case KHR_DF_CHANNEL_YUVSDA_A:
|
|
break;
|
|
case KHR_DF_CHANNEL_YUVSDA_DEPTH:
|
|
case KHR_DF_CHANNEL_YUVSDA_STENCIL:
|
|
isDepthStencil = true;
|
|
break;
|
|
default:
|
|
return i_UNSUPPORTED_CHANNEL_TYPES;
|
|
}
|
|
}
|
|
|
|
// Determine wordBytes
|
|
uint32_t largestSampleSize = 0;
|
|
for (uint32_t i = 0; i < numSamples; ++i) {
|
|
uint32_t length = KHR_DFDSVAL(BDFDB, i, BITLENGTH) + 1;
|
|
if (largestSampleSize < length)
|
|
largestSampleSize = length;
|
|
}
|
|
*wordBytes = ((result & i_PACKED_FORMAT_BIT) ? 4 : 1) * bit_ceil(largestSampleSize) / 8;
|
|
|
|
} else if (KHR_DFDVAL(BDFDB, MODEL) == KHR_DF_MODEL_RGBSDA) {
|
|
/* Check if transfer is sRGB. */
|
|
if (KHR_DFDVAL(BDFDB, TRANSFER) == KHR_DF_TRANSFER_SRGB) result |= i_SRGB_FORMAT_BIT;
|
|
|
|
/* We only support samples at coordinate 0,0,0,0. */
|
|
/* (We could confirm this from texel_block_dimensions in 1.2, but */
|
|
/* the interpretation might change in later versions.) */
|
|
for (uint32_t sampleCounter = 0; sampleCounter < numSamples; ++sampleCounter) {
|
|
if (KHR_DFDSVAL(BDFDB, sampleCounter, SAMPLEPOSITION_ALL))
|
|
return i_UNSUPPORTED_MULTIPLE_SAMPLE_LOCATIONS;
|
|
}
|
|
}
|
|
|
|
if (model == KHR_DF_MODEL_RGBSDA || model == KHR_DF_MODEL_YUVSDA) {
|
|
/* The values of the DEPTH and STENCIL tokens are the same for */
|
|
/* RGBSDA and YUVSDA. */
|
|
/* For Depth/Stencil formats mixed channels are allowed */
|
|
for (uint32_t sampleCounter = 0; sampleCounter < numSamples; ++sampleCounter) {
|
|
switch (KHR_DFDSVAL(BDFDB, sampleCounter, CHANNELID)) {
|
|
case KHR_DF_CHANNEL_RGBSDA_DEPTH:
|
|
case KHR_DF_CHANNEL_RGBSDA_STENCIL:
|
|
isDepthStencil = true;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Check for mixed channels
|
|
if (!isDepthStencil) {
|
|
for (uint32_t i = 0; i < numSamples; ++i) {
|
|
const bool isSigned = (KHR_DFDSVAL(BDFDB, i, QUALIFIERS) & KHR_DF_SAMPLE_DATATYPE_SIGNED) != 0;
|
|
const bool isFloat = (KHR_DFDSVAL(BDFDB, i, QUALIFIERS) & KHR_DF_SAMPLE_DATATYPE_FLOAT) != 0;
|
|
|
|
if (isSigned != hasSigned)
|
|
return i_UNSUPPORTED_MIXED_CHANNELS;
|
|
if (isFloat != hasFloat)
|
|
return i_UNSUPPORTED_MIXED_CHANNELS;
|
|
|
|
// Note: We don't check for inconsistent normalization, because
|
|
// channels composed of multiple samples will have 0 in the
|
|
// lower/upper range. Single bit channels are also ambiguous.
|
|
// This heuristic should handle 64-bit integers, too.
|
|
}
|
|
}
|
|
|
|
/* This all relies on the channel id values for RGB being equal to */
|
|
/* those for YUV. */
|
|
|
|
/* Remember: the canonical ordering of samples is to start with */
|
|
/* the lowest bit of the channel/location which touches bit 0 of */
|
|
/* the data, when the latter is concatenated in little-endian order, */
|
|
/* and then progress until all the bits of that channel/location */
|
|
/* have been processed. Multiple channels sharing the same source */
|
|
/* bits are processed in channel ID order. (I should clarify this */
|
|
/* for partially-shared data, but it doesn't really matter so long */
|
|
/* as everything is consecutive, except to make things canonical.) */
|
|
/* Note: For standard formats we could determine big/little-endianness */
|
|
/* simply from whether the first sample starts in bit 0; technically */
|
|
/* it's possible to have a format with unaligned channels wherein the */
|
|
/* first channel starts at bit 0 and is one byte, yet other channels */
|
|
/* take more bytes or aren't aligned (e.g. D24S8), but this should be */
|
|
/* irrelevant for the formats that we support. */
|
|
if ((result & i_PACKED_FORMAT_BIT)) {
|
|
/* A packed format. */
|
|
uint32_t currentChannel = ~0U; /* Don't start matched. */
|
|
uint32_t currentBitOffset = 0;
|
|
uint32_t currentByteOffset = 0;
|
|
uint32_t currentBitLength = 0;
|
|
*wordBytes = (BDFDB[KHR_DF_WORD_BYTESPLANE0] & 0xFFU);
|
|
for (uint32_t sampleCounter = 0; sampleCounter < numSamples; ++sampleCounter) {
|
|
uint32_t sampleBitOffset = KHR_DFDSVAL(BDFDB, sampleCounter, BITOFFSET);
|
|
uint32_t sampleByteOffset = sampleBitOffset >> 3U;
|
|
/* The sample bitLength field stores the bit length - 1. */
|
|
uint32_t sampleBitLength = KHR_DFDSVAL(BDFDB, sampleCounter, BITLENGTH) + 1;
|
|
uint32_t sampleChannel = KHR_DFDSVAL(BDFDB, sampleCounter, CHANNELID);
|
|
InterpretedDFDChannel *sampleChannelPtr;
|
|
switch (sampleChannel) {
|
|
case KHR_DF_CHANNEL_RGBSDA_RED:
|
|
sampleChannelPtr = R;
|
|
break;
|
|
case KHR_DF_CHANNEL_RGBSDA_GREEN:
|
|
sampleChannelPtr = G;
|
|
break;
|
|
case KHR_DF_CHANNEL_RGBSDA_BLUE:
|
|
sampleChannelPtr = B;
|
|
break;
|
|
case KHR_DF_CHANNEL_RGBSDA_DEPTH:
|
|
sampleChannelPtr = R;
|
|
break;
|
|
case KHR_DF_CHANNEL_RGBSDA_STENCIL:
|
|
sampleChannelPtr = G;
|
|
break;
|
|
case KHR_DF_CHANNEL_RGBSDA_ALPHA:
|
|
sampleChannelPtr = A;
|
|
break;
|
|
default:
|
|
return i_UNSUPPORTED_CHANNEL_TYPES;
|
|
}
|
|
if (sampleChannel == currentChannel) {
|
|
/* Continuation of the same channel. */
|
|
/* Since a big (>32-bit) channel isn't "packed", */
|
|
/* this should only happen in big-endian, or if */
|
|
/* we have a wacky format that we won't support. */
|
|
if (sampleByteOffset == currentByteOffset - 1U && /* One byte earlier */
|
|
((currentBitOffset + currentBitLength) & 7U) == 0 && /* Already at the end of a byte */
|
|
(sampleBitOffset & 7U) == 0) { /* Start at the beginning of the byte */
|
|
/* All is good, continue big-endian. */
|
|
/* N.B. We shouldn't be here if we decided we were little-endian, */
|
|
/* so we don't bother to check that disagreement. */
|
|
result |= i_BIG_ENDIAN_FORMAT_BIT;
|
|
determinedEndianness = 1;
|
|
} else {
|
|
/* Oh dear. */
|
|
/* We could be little-endian, but not with any standard format. */
|
|
/* More likely we've got something weird that we can't support. */
|
|
return i_UNSUPPORTED_NONTRIVIAL_ENDIANNESS;
|
|
}
|
|
/* Remember where we are. */
|
|
currentBitOffset = sampleBitOffset;
|
|
currentByteOffset = sampleByteOffset;
|
|
currentBitLength = sampleBitLength;
|
|
/* Accumulate the bit length. */
|
|
sampleChannelPtr->size += sampleBitLength;
|
|
} else {
|
|
/* Everything is new. Hopefully. */
|
|
currentChannel = sampleChannel;
|
|
currentBitOffset = sampleBitOffset;
|
|
currentByteOffset = sampleByteOffset;
|
|
currentBitLength = sampleBitLength;
|
|
if (sampleChannelPtr->size) {
|
|
if (model == KHR_DF_MODEL_YUVSDA && sampleChannel == KHR_DF_CHANNEL_YUVSDA_Y) {
|
|
if (sampleChannelPtr == R) {
|
|
/* We've got another Y channel. Record details in A. */
|
|
if (A->size == 0) {
|
|
sampleChannelPtr = A;
|
|
} else {
|
|
/* Uh-oh, we've already got a second Y or an alpha channel. */
|
|
return i_UNSUPPORTED_CHANNEL_TYPES;
|
|
}
|
|
}
|
|
} else {
|
|
/* Uh-oh, we've seen this channel before. */
|
|
return i_UNSUPPORTED_NONTRIVIAL_ENDIANNESS;
|
|
}
|
|
}
|
|
/* For now, record the bit offset in little-endian terms, */
|
|
/* because we may not know to reverse it yet. */
|
|
sampleChannelPtr->offset = sampleBitOffset;
|
|
sampleChannelPtr->size = sampleBitLength;
|
|
}
|
|
}
|
|
if ((result & i_BIG_ENDIAN_FORMAT_BIT)) {
|
|
/* Our bit offsets to bit 0 of each channel are in little-endian terms. */
|
|
/* We need to do a byte swap to work out where they should be. */
|
|
/* We assume, for sanity, that byte sizes are a power of two for this. */
|
|
uint32_t offsetMask = (*wordBytes - 1U) << 3U;
|
|
R->offset ^= offsetMask;
|
|
G->offset ^= offsetMask;
|
|
B->offset ^= offsetMask;
|
|
A->offset ^= offsetMask;
|
|
}
|
|
} else {
|
|
/* Not a packed format. */
|
|
/* Everything is byte-aligned. */
|
|
/* Question is whether there multiple samples per channel. */
|
|
uint32_t currentChannel = ~0U; /* Don't start matched. */
|
|
uint32_t currentByteOffset = 0;
|
|
uint32_t currentByteLength = 0;
|
|
for (uint32_t sampleCounter = 0; sampleCounter < numSamples; ++sampleCounter) {
|
|
uint32_t sampleByteOffset = KHR_DFDSVAL(BDFDB, sampleCounter, BITOFFSET) >> 3U;
|
|
uint32_t sampleByteLength = (KHR_DFDSVAL(BDFDB, sampleCounter, BITLENGTH) + 1) >> 3U;
|
|
uint32_t sampleChannel = KHR_DFDSVAL(BDFDB, sampleCounter, CHANNELID);
|
|
InterpretedDFDChannel *sampleChannelPtr;
|
|
switch (sampleChannel) {
|
|
case KHR_DF_CHANNEL_RGBSDA_RED:
|
|
sampleChannelPtr = R;
|
|
break;
|
|
case KHR_DF_CHANNEL_RGBSDA_GREEN:
|
|
sampleChannelPtr = G;
|
|
break;
|
|
case KHR_DF_CHANNEL_RGBSDA_BLUE:
|
|
sampleChannelPtr = B;
|
|
break;
|
|
case KHR_DF_CHANNEL_RGBSDA_DEPTH:
|
|
sampleChannelPtr = R;
|
|
break;
|
|
case KHR_DF_CHANNEL_RGBSDA_STENCIL:
|
|
sampleChannelPtr = G;
|
|
break;
|
|
case KHR_DF_CHANNEL_RGBSDA_ALPHA:
|
|
sampleChannelPtr = A;
|
|
break;
|
|
default:
|
|
return i_UNSUPPORTED_CHANNEL_TYPES;
|
|
}
|
|
if (sampleChannel == currentChannel) {
|
|
/* Continuation of the same channel. */
|
|
/* Either big-endian, or little-endian with a very large channel. */
|
|
if (sampleByteOffset == currentByteOffset - 1) { /* One byte earlier */
|
|
if (determinedEndianness && !(result & i_BIG_ENDIAN_FORMAT_BIT)) {
|
|
return i_UNSUPPORTED_NONTRIVIAL_ENDIANNESS;
|
|
}
|
|
/* All is good, continue big-endian. */
|
|
result |= i_BIG_ENDIAN_FORMAT_BIT;
|
|
determinedEndianness = 1;
|
|
/* Update the start */
|
|
sampleChannelPtr->offset = sampleByteOffset;
|
|
} else if (sampleByteOffset == currentByteOffset + currentByteLength) {
|
|
if (determinedEndianness && (result & i_BIG_ENDIAN_FORMAT_BIT)) {
|
|
return i_UNSUPPORTED_NONTRIVIAL_ENDIANNESS;
|
|
}
|
|
/* All is good, continue little-endian. */
|
|
determinedEndianness = 1;
|
|
} else {
|
|
/* Oh dear. */
|
|
/* We could be little-endian, but not with any standard format. */
|
|
/* More likely we've got something weird that we can't support. */
|
|
return i_UNSUPPORTED_NONTRIVIAL_ENDIANNESS;
|
|
}
|
|
/* Remember where we are. */
|
|
currentByteOffset = sampleByteOffset;
|
|
currentByteLength = sampleByteLength;
|
|
/* Accumulate the byte length. */
|
|
sampleChannelPtr->size += sampleByteLength;
|
|
/* Assume these are all the same. */
|
|
*wordBytes = sampleChannelPtr->size;
|
|
} else {
|
|
/* Everything is new. Hopefully. */
|
|
currentChannel = sampleChannel;
|
|
currentByteOffset = sampleByteOffset;
|
|
currentByteLength = sampleByteLength;
|
|
if (sampleChannelPtr->size) {
|
|
if (model == KHR_DF_MODEL_YUVSDA && sampleChannel == KHR_DF_CHANNEL_YUVSDA_Y) {
|
|
if (sampleChannelPtr == R) {
|
|
/* We've got another Y channel. Record details in A. */
|
|
if (A->size == 0) {
|
|
sampleChannelPtr = A;
|
|
} else {
|
|
/* Uh-oh, we've already got a second Y or an alpha channel. */
|
|
return i_UNSUPPORTED_CHANNEL_TYPES;
|
|
}
|
|
}
|
|
} else {
|
|
/* Uh-oh, we've seen this channel before. */
|
|
return i_UNSUPPORTED_NONTRIVIAL_ENDIANNESS;
|
|
}
|
|
}
|
|
/* For now, record the byte offset in little-endian terms, */
|
|
/* because we may not know to reverse it yet. */
|
|
sampleChannelPtr->offset = sampleByteOffset;
|
|
sampleChannelPtr->size = sampleByteLength;
|
|
/* Assume these are all the same. */
|
|
*wordBytes = sampleByteLength;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
return i_UNSUPPORTED_CHANNEL_TYPES;
|
|
}
|
|
|
|
if (isDepthStencil) {
|
|
/* For Depth/Stencil formats wordBytes is determined by the required alignment of */
|
|
/* the larger channel. */
|
|
uint32_t largerSize = R->size > G->size ? R->size : G->size;
|
|
*wordBytes = bit_ceil(largerSize);
|
|
}
|
|
|
|
return result;
|
|
}
|