1025 lines
38 KiB
C
1025 lines
38 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 Utilities for printing data format descriptors.
|
|
*/
|
|
|
|
/*
|
|
* Author: Andrew Garrard
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <KHR/khr_df.h>
|
|
#include "dfd.h"
|
|
|
|
enum {
|
|
// These constraints are not mandated by the spec and only used as a
|
|
// reasonable upper limit to stop parsing garbage data during print
|
|
MAX_NUM_BDFD_SAMPLES = 16,
|
|
MAX_NUM_DFD_BLOCKS = 10,
|
|
};
|
|
|
|
const char* dfdToStringVendorID(khr_df_vendorid_e value) {
|
|
switch (value) {
|
|
case KHR_DF_VENDORID_KHRONOS:
|
|
return "KHR_DF_VENDORID_KHRONOS";
|
|
|
|
case KHR_DF_VENDORID_MAX:
|
|
// These enum values are not meant for string representation. Ignore
|
|
break;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
const char* dfdToStringDescriptorType(khr_df_khr_descriptortype_e value) {
|
|
switch (value) {
|
|
case KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT:
|
|
return "KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT";
|
|
case KHR_DF_KHR_DESCRIPTORTYPE_ADDITIONAL_PLANES:
|
|
return "KHR_DF_KHR_DESCRIPTORTYPE_ADDITIONAL_PLANES";
|
|
case KHR_DF_KHR_DESCRIPTORTYPE_ADDITIONAL_DIMENSIONS:
|
|
return "KHR_DF_KHR_DESCRIPTORTYPE_ADDITIONAL_DIMENSIONS";
|
|
|
|
case KHR_DF_KHR_DESCRIPTORTYPE_NEEDED_FOR_WRITE_BIT:
|
|
case KHR_DF_KHR_DESCRIPTORTYPE_NEEDED_FOR_DECODE_BIT:
|
|
case KHR_DF_KHR_DESCRIPTORTYPE_MAX:
|
|
// These enum values are not meant for string representation. Ignore
|
|
break;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
const char* dfdToStringVersionNumber(khr_df_versionnumber_e value) {
|
|
switch (value) {
|
|
case KHR_DF_VERSIONNUMBER_1_1:
|
|
// case KHR_DF_VERSIONNUMBER_1_0: // Fallthrough, Matching values
|
|
return "KHR_DF_VERSIONNUMBER_1_1";
|
|
case KHR_DF_VERSIONNUMBER_1_2:
|
|
return "KHR_DF_VERSIONNUMBER_1_2";
|
|
case KHR_DF_VERSIONNUMBER_1_3:
|
|
return "KHR_DF_VERSIONNUMBER_1_3";
|
|
|
|
// case KHR_DF_VERSIONNUMBER_LATEST: // Fallthrough, Matching values
|
|
case KHR_DF_VERSIONNUMBER_MAX:
|
|
// These enum values are not meant for string representation. Ignore
|
|
break;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
const char* dfdToStringFlagsBit(uint32_t bit_index, bool bit_value) {
|
|
switch (bit_index) {
|
|
case 0:
|
|
return bit_value ? "KHR_DF_FLAG_ALPHA_PREMULTIPLIED" : "KHR_DF_FLAG_ALPHA_STRAIGHT";
|
|
default:
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
const char* dfdToStringTransferFunction(khr_df_transfer_e value) {
|
|
switch (value) {
|
|
case KHR_DF_TRANSFER_UNSPECIFIED:
|
|
return "KHR_DF_TRANSFER_UNSPECIFIED";
|
|
case KHR_DF_TRANSFER_LINEAR:
|
|
return "KHR_DF_TRANSFER_LINEAR";
|
|
case KHR_DF_TRANSFER_SRGB:
|
|
return "KHR_DF_TRANSFER_SRGB";
|
|
case KHR_DF_TRANSFER_ITU:
|
|
return "KHR_DF_TRANSFER_ITU";
|
|
case KHR_DF_TRANSFER_NTSC:
|
|
// case KHR_DF_TRANSFER_SMTPE170M: // Fallthrough, Matching values
|
|
return "KHR_DF_TRANSFER_NTSC";
|
|
case KHR_DF_TRANSFER_SLOG:
|
|
return "KHR_DF_TRANSFER_SLOG";
|
|
case KHR_DF_TRANSFER_SLOG2:
|
|
return "KHR_DF_TRANSFER_SLOG2";
|
|
case KHR_DF_TRANSFER_BT1886:
|
|
return "KHR_DF_TRANSFER_BT1886";
|
|
case KHR_DF_TRANSFER_HLG_OETF:
|
|
return "KHR_DF_TRANSFER_HLG_OETF";
|
|
case KHR_DF_TRANSFER_HLG_EOTF:
|
|
return "KHR_DF_TRANSFER_HLG_EOTF";
|
|
case KHR_DF_TRANSFER_PQ_EOTF:
|
|
return "KHR_DF_TRANSFER_PQ_EOTF";
|
|
case KHR_DF_TRANSFER_PQ_OETF:
|
|
return "KHR_DF_TRANSFER_PQ_OETF";
|
|
case KHR_DF_TRANSFER_DCIP3:
|
|
return "KHR_DF_TRANSFER_DCIP3";
|
|
case KHR_DF_TRANSFER_PAL_OETF:
|
|
return "KHR_DF_TRANSFER_PAL_OETF";
|
|
case KHR_DF_TRANSFER_PAL625_EOTF:
|
|
return "KHR_DF_TRANSFER_PAL625_EOTF";
|
|
case KHR_DF_TRANSFER_ST240:
|
|
return "KHR_DF_TRANSFER_ST240";
|
|
case KHR_DF_TRANSFER_ACESCC:
|
|
return "KHR_DF_TRANSFER_ACESCC";
|
|
case KHR_DF_TRANSFER_ACESCCT:
|
|
return "KHR_DF_TRANSFER_ACESCCT";
|
|
case KHR_DF_TRANSFER_ADOBERGB:
|
|
return "KHR_DF_TRANSFER_ADOBERGB";
|
|
|
|
case KHR_DF_TRANSFER_MAX:
|
|
// These enum values are not meant for string representation. Ignore
|
|
break;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
const char* dfdToStringColorPrimaries(khr_df_primaries_e value) {
|
|
switch (value) {
|
|
case KHR_DF_PRIMARIES_UNSPECIFIED:
|
|
return "KHR_DF_PRIMARIES_UNSPECIFIED";
|
|
case KHR_DF_PRIMARIES_BT709:
|
|
// case KHR_DF_PRIMARIES_SRGB: // Fallthrough, Matching values
|
|
return "KHR_DF_PRIMARIES_BT709";
|
|
case KHR_DF_PRIMARIES_BT601_EBU:
|
|
return "KHR_DF_PRIMARIES_BT601_EBU";
|
|
case KHR_DF_PRIMARIES_BT601_SMPTE:
|
|
return "KHR_DF_PRIMARIES_BT601_SMPTE";
|
|
case KHR_DF_PRIMARIES_BT2020:
|
|
return "KHR_DF_PRIMARIES_BT2020";
|
|
case KHR_DF_PRIMARIES_CIEXYZ:
|
|
return "KHR_DF_PRIMARIES_CIEXYZ";
|
|
case KHR_DF_PRIMARIES_ACES:
|
|
return "KHR_DF_PRIMARIES_ACES";
|
|
case KHR_DF_PRIMARIES_ACESCC:
|
|
return "KHR_DF_PRIMARIES_ACESCC";
|
|
case KHR_DF_PRIMARIES_NTSC1953:
|
|
return "KHR_DF_PRIMARIES_NTSC1953";
|
|
case KHR_DF_PRIMARIES_PAL525:
|
|
return "KHR_DF_PRIMARIES_PAL525";
|
|
case KHR_DF_PRIMARIES_DISPLAYP3:
|
|
return "KHR_DF_PRIMARIES_DISPLAYP3";
|
|
case KHR_DF_PRIMARIES_ADOBERGB:
|
|
return "KHR_DF_PRIMARIES_ADOBERGB";
|
|
|
|
case KHR_DF_PRIMARIES_MAX:
|
|
// These enum values are not meant for string representation. Ignore
|
|
break;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
const char* dfdToStringColorModel(khr_df_model_e value) {
|
|
switch (value) {
|
|
case KHR_DF_MODEL_UNSPECIFIED:
|
|
return "KHR_DF_MODEL_UNSPECIFIED";
|
|
case KHR_DF_MODEL_RGBSDA:
|
|
return "KHR_DF_MODEL_RGBSDA";
|
|
case KHR_DF_MODEL_YUVSDA:
|
|
return "KHR_DF_MODEL_YUVSDA";
|
|
case KHR_DF_MODEL_YIQSDA:
|
|
return "KHR_DF_MODEL_YIQSDA";
|
|
case KHR_DF_MODEL_LABSDA:
|
|
return "KHR_DF_MODEL_LABSDA";
|
|
case KHR_DF_MODEL_CMYKA:
|
|
return "KHR_DF_MODEL_CMYKA";
|
|
case KHR_DF_MODEL_XYZW:
|
|
return "KHR_DF_MODEL_XYZW";
|
|
case KHR_DF_MODEL_HSVA_ANG:
|
|
return "KHR_DF_MODEL_HSVA_ANG";
|
|
case KHR_DF_MODEL_HSLA_ANG:
|
|
return "KHR_DF_MODEL_HSLA_ANG";
|
|
case KHR_DF_MODEL_HSVA_HEX:
|
|
return "KHR_DF_MODEL_HSVA_HEX";
|
|
case KHR_DF_MODEL_HSLA_HEX:
|
|
return "KHR_DF_MODEL_HSLA_HEX";
|
|
case KHR_DF_MODEL_YCGCOA:
|
|
return "KHR_DF_MODEL_YCGCOA";
|
|
case KHR_DF_MODEL_YCCBCCRC:
|
|
return "KHR_DF_MODEL_YCCBCCRC";
|
|
case KHR_DF_MODEL_ICTCP:
|
|
return "KHR_DF_MODEL_ICTCP";
|
|
case KHR_DF_MODEL_CIEXYZ:
|
|
return "KHR_DF_MODEL_CIEXYZ";
|
|
case KHR_DF_MODEL_CIEXYY:
|
|
return "KHR_DF_MODEL_CIEXYY";
|
|
case KHR_DF_MODEL_BC1A:
|
|
// case KHR_DF_MODEL_DXT1A: // Fallthrough, Matching values
|
|
return "KHR_DF_MODEL_BC1A";
|
|
case KHR_DF_MODEL_BC2:
|
|
// case KHR_DF_MODEL_DXT2: // Fallthrough, Matching values
|
|
// case KHR_DF_MODEL_DXT3: // Fallthrough, Matching values
|
|
return "KHR_DF_MODEL_BC2";
|
|
case KHR_DF_MODEL_BC3:
|
|
// case KHR_DF_MODEL_DXT4: // Fallthrough, Matching values
|
|
// case KHR_DF_MODEL_DXT5: // Fallthrough, Matching values
|
|
return "KHR_DF_MODEL_BC3";
|
|
case KHR_DF_MODEL_BC4:
|
|
return "KHR_DF_MODEL_BC4";
|
|
case KHR_DF_MODEL_BC5:
|
|
return "KHR_DF_MODEL_BC5";
|
|
case KHR_DF_MODEL_BC6H:
|
|
return "KHR_DF_MODEL_BC6H";
|
|
case KHR_DF_MODEL_BC7:
|
|
return "KHR_DF_MODEL_BC7";
|
|
case KHR_DF_MODEL_ETC1:
|
|
return "KHR_DF_MODEL_ETC1";
|
|
case KHR_DF_MODEL_ETC2:
|
|
return "KHR_DF_MODEL_ETC2";
|
|
case KHR_DF_MODEL_ASTC:
|
|
return "KHR_DF_MODEL_ASTC";
|
|
case KHR_DF_MODEL_ETC1S:
|
|
return "KHR_DF_MODEL_ETC1S";
|
|
case KHR_DF_MODEL_PVRTC:
|
|
return "KHR_DF_MODEL_PVRTC";
|
|
case KHR_DF_MODEL_PVRTC2:
|
|
return "KHR_DF_MODEL_PVRTC2";
|
|
case KHR_DF_MODEL_UASTC:
|
|
return "KHR_DF_MODEL_UASTC";
|
|
|
|
case KHR_DF_MODEL_MAX:
|
|
// These enum values are not meant for string representation. Ignore
|
|
break;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
const char* dfdToStringSampleDatatypeQualifiers(uint32_t bit_index, bool bit_value) {
|
|
if (!bit_value)
|
|
return NULL;
|
|
|
|
switch (1u << bit_index) {
|
|
case KHR_DF_SAMPLE_DATATYPE_LINEAR:
|
|
return "KHR_DF_SAMPLE_DATATYPE_LINEAR";
|
|
case KHR_DF_SAMPLE_DATATYPE_EXPONENT:
|
|
return "KHR_DF_SAMPLE_DATATYPE_EXPONENT";
|
|
case KHR_DF_SAMPLE_DATATYPE_SIGNED:
|
|
return "KHR_DF_SAMPLE_DATATYPE_SIGNED";
|
|
case KHR_DF_SAMPLE_DATATYPE_FLOAT:
|
|
return "KHR_DF_SAMPLE_DATATYPE_FLOAT";
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
const char* dfdToStringChannelId(khr_df_model_e model, khr_df_model_channels_e value) {
|
|
switch (model) {
|
|
case KHR_DF_MODEL_RGBSDA:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_RGBSDA_RED:
|
|
return "KHR_DF_CHANNEL_RGBSDA_RED";
|
|
case KHR_DF_CHANNEL_RGBSDA_GREEN:
|
|
return "KHR_DF_CHANNEL_RGBSDA_GREEN";
|
|
case KHR_DF_CHANNEL_RGBSDA_BLUE:
|
|
return "KHR_DF_CHANNEL_RGBSDA_BLUE";
|
|
case KHR_DF_CHANNEL_RGBSDA_STENCIL:
|
|
return "KHR_DF_CHANNEL_RGBSDA_STENCIL";
|
|
case KHR_DF_CHANNEL_RGBSDA_DEPTH:
|
|
return "KHR_DF_CHANNEL_RGBSDA_DEPTH";
|
|
case KHR_DF_CHANNEL_RGBSDA_ALPHA:
|
|
return "KHR_DF_CHANNEL_RGBSDA_ALPHA";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_YUVSDA:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_YUVSDA_Y:
|
|
return "KHR_DF_CHANNEL_YUVSDA_Y";
|
|
case KHR_DF_CHANNEL_YUVSDA_U:
|
|
return "KHR_DF_CHANNEL_YUVSDA_U";
|
|
case KHR_DF_CHANNEL_YUVSDA_V:
|
|
return "KHR_DF_CHANNEL_YUVSDA_V";
|
|
case KHR_DF_CHANNEL_YUVSDA_STENCIL:
|
|
return "KHR_DF_CHANNEL_YUVSDA_STENCIL";
|
|
case KHR_DF_CHANNEL_YUVSDA_DEPTH:
|
|
return "KHR_DF_CHANNEL_YUVSDA_DEPTH";
|
|
case KHR_DF_CHANNEL_YUVSDA_ALPHA:
|
|
return "KHR_DF_CHANNEL_YUVSDA_ALPHA";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_YIQSDA:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_YIQSDA_Y:
|
|
return "KHR_DF_CHANNEL_YIQSDA_Y";
|
|
case KHR_DF_CHANNEL_YIQSDA_I:
|
|
return "KHR_DF_CHANNEL_YIQSDA_I";
|
|
case KHR_DF_CHANNEL_YIQSDA_Q:
|
|
return "KHR_DF_CHANNEL_YIQSDA_Q";
|
|
case KHR_DF_CHANNEL_YIQSDA_STENCIL:
|
|
return "KHR_DF_CHANNEL_YIQSDA_STENCIL";
|
|
case KHR_DF_CHANNEL_YIQSDA_DEPTH:
|
|
return "KHR_DF_CHANNEL_YIQSDA_DEPTH";
|
|
case KHR_DF_CHANNEL_YIQSDA_ALPHA:
|
|
return "KHR_DF_CHANNEL_YIQSDA_ALPHA";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_LABSDA:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_LABSDA_L:
|
|
return "KHR_DF_CHANNEL_LABSDA_L";
|
|
case KHR_DF_CHANNEL_LABSDA_A:
|
|
return "KHR_DF_CHANNEL_LABSDA_A";
|
|
case KHR_DF_CHANNEL_LABSDA_B:
|
|
return "KHR_DF_CHANNEL_LABSDA_B";
|
|
case KHR_DF_CHANNEL_LABSDA_STENCIL:
|
|
return "KHR_DF_CHANNEL_LABSDA_STENCIL";
|
|
case KHR_DF_CHANNEL_LABSDA_DEPTH:
|
|
return "KHR_DF_CHANNEL_LABSDA_DEPTH";
|
|
case KHR_DF_CHANNEL_LABSDA_ALPHA:
|
|
return "KHR_DF_CHANNEL_LABSDA_ALPHA";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_CMYKA:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_CMYKSDA_CYAN:
|
|
return "KHR_DF_CHANNEL_CMYKSDA_CYAN";
|
|
case KHR_DF_CHANNEL_CMYKSDA_MAGENTA:
|
|
return "KHR_DF_CHANNEL_CMYKSDA_MAGENTA";
|
|
case KHR_DF_CHANNEL_CMYKSDA_YELLOW:
|
|
return "KHR_DF_CHANNEL_CMYKSDA_YELLOW";
|
|
case KHR_DF_CHANNEL_CMYKSDA_BLACK:
|
|
return "KHR_DF_CHANNEL_CMYKSDA_BLACK";
|
|
case KHR_DF_CHANNEL_CMYKSDA_ALPHA:
|
|
return "KHR_DF_CHANNEL_CMYKSDA_ALPHA";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_XYZW:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_XYZW_X:
|
|
return "KHR_DF_CHANNEL_XYZW_X";
|
|
case KHR_DF_CHANNEL_XYZW_Y:
|
|
return "KHR_DF_CHANNEL_XYZW_Y";
|
|
case KHR_DF_CHANNEL_XYZW_Z:
|
|
return "KHR_DF_CHANNEL_XYZW_Z";
|
|
case KHR_DF_CHANNEL_XYZW_W:
|
|
return "KHR_DF_CHANNEL_XYZW_W";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_HSVA_ANG:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_HSVA_ANG_VALUE:
|
|
return "KHR_DF_CHANNEL_HSVA_ANG_VALUE";
|
|
case KHR_DF_CHANNEL_HSVA_ANG_SATURATION:
|
|
return "KHR_DF_CHANNEL_HSVA_ANG_SATURATION";
|
|
case KHR_DF_CHANNEL_HSVA_ANG_HUE:
|
|
return "KHR_DF_CHANNEL_HSVA_ANG_HUE";
|
|
case KHR_DF_CHANNEL_HSVA_ANG_ALPHA:
|
|
return "KHR_DF_CHANNEL_HSVA_ANG_ALPHA";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_HSLA_ANG:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_HSLA_ANG_LIGHTNESS:
|
|
return "KHR_DF_CHANNEL_HSLA_ANG_LIGHTNESS";
|
|
case KHR_DF_CHANNEL_HSLA_ANG_SATURATION:
|
|
return "KHR_DF_CHANNEL_HSLA_ANG_SATURATION";
|
|
case KHR_DF_CHANNEL_HSLA_ANG_HUE:
|
|
return "KHR_DF_CHANNEL_HSLA_ANG_HUE";
|
|
case KHR_DF_CHANNEL_HSLA_ANG_ALPHA:
|
|
return "KHR_DF_CHANNEL_HSLA_ANG_ALPHA";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_HSVA_HEX:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_HSVA_HEX_VALUE:
|
|
return "KHR_DF_CHANNEL_HSVA_HEX_VALUE";
|
|
case KHR_DF_CHANNEL_HSVA_HEX_SATURATION:
|
|
return "KHR_DF_CHANNEL_HSVA_HEX_SATURATION";
|
|
case KHR_DF_CHANNEL_HSVA_HEX_HUE:
|
|
return "KHR_DF_CHANNEL_HSVA_HEX_HUE";
|
|
case KHR_DF_CHANNEL_HSVA_HEX_ALPHA:
|
|
return "KHR_DF_CHANNEL_HSVA_HEX_ALPHA";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_HSLA_HEX:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_HSLA_HEX_LIGHTNESS:
|
|
return "KHR_DF_CHANNEL_HSLA_HEX_LIGHTNESS";
|
|
case KHR_DF_CHANNEL_HSLA_HEX_SATURATION:
|
|
return "KHR_DF_CHANNEL_HSLA_HEX_SATURATION";
|
|
case KHR_DF_CHANNEL_HSLA_HEX_HUE:
|
|
return "KHR_DF_CHANNEL_HSLA_HEX_HUE";
|
|
case KHR_DF_CHANNEL_HSLA_HEX_ALPHA:
|
|
return "KHR_DF_CHANNEL_HSLA_HEX_ALPHA";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_YCGCOA:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_YCGCOA_Y:
|
|
return "KHR_DF_CHANNEL_YCGCOA_Y";
|
|
case KHR_DF_CHANNEL_YCGCOA_CG:
|
|
return "KHR_DF_CHANNEL_YCGCOA_CG";
|
|
case KHR_DF_CHANNEL_YCGCOA_CO:
|
|
return "KHR_DF_CHANNEL_YCGCOA_CO";
|
|
case KHR_DF_CHANNEL_YCGCOA_ALPHA:
|
|
return "KHR_DF_CHANNEL_YCGCOA_ALPHA";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_CIEXYZ:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_CIEXYZ_X:
|
|
return "KHR_DF_CHANNEL_CIEXYZ_X";
|
|
case KHR_DF_CHANNEL_CIEXYZ_Y:
|
|
return "KHR_DF_CHANNEL_CIEXYZ_Y";
|
|
case KHR_DF_CHANNEL_CIEXYZ_Z:
|
|
return "KHR_DF_CHANNEL_CIEXYZ_Z";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_CIEXYY:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_CIEXYY_X:
|
|
return "KHR_DF_CHANNEL_CIEXYY_X";
|
|
case KHR_DF_CHANNEL_CIEXYY_YCHROMA:
|
|
return "KHR_DF_CHANNEL_CIEXYY_YCHROMA";
|
|
case KHR_DF_CHANNEL_CIEXYY_YLUMA:
|
|
return "KHR_DF_CHANNEL_CIEXYY_YLUMA";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_BC1A:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_BC1A_COLOR:
|
|
return "KHR_DF_CHANNEL_BC1A_COLOR";
|
|
case KHR_DF_CHANNEL_BC1A_ALPHA:
|
|
return "KHR_DF_CHANNEL_BC1A_ALPHA";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_BC2:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_BC2_COLOR:
|
|
return "KHR_DF_CHANNEL_BC2_COLOR";
|
|
case KHR_DF_CHANNEL_BC2_ALPHA:
|
|
return "KHR_DF_CHANNEL_BC2_ALPHA";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_BC3:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_BC3_COLOR:
|
|
return "KHR_DF_CHANNEL_BC3_COLOR";
|
|
case KHR_DF_CHANNEL_BC3_ALPHA:
|
|
return "KHR_DF_CHANNEL_BC3_ALPHA";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_BC4:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_BC4_DATA:
|
|
return "KHR_DF_CHANNEL_BC4_DATA";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_BC5:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_BC5_RED:
|
|
return "KHR_DF_CHANNEL_BC5_RED";
|
|
case KHR_DF_CHANNEL_BC5_GREEN:
|
|
return "KHR_DF_CHANNEL_BC5_GREEN";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_BC6H:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_BC6H_COLOR:
|
|
return "KHR_DF_CHANNEL_BC6H_COLOR";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_BC7:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_BC7_COLOR:
|
|
return "KHR_DF_CHANNEL_BC7_COLOR";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_ETC1:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_ETC1_COLOR:
|
|
return "KHR_DF_CHANNEL_ETC1_COLOR";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_ETC2:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_ETC2_RED:
|
|
return "KHR_DF_CHANNEL_ETC2_RED";
|
|
case KHR_DF_CHANNEL_ETC2_GREEN:
|
|
return "KHR_DF_CHANNEL_ETC2_GREEN";
|
|
case KHR_DF_CHANNEL_ETC2_COLOR:
|
|
return "KHR_DF_CHANNEL_ETC2_COLOR";
|
|
case KHR_DF_CHANNEL_ETC2_ALPHA:
|
|
return "KHR_DF_CHANNEL_ETC2_ALPHA";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_ASTC:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_ASTC_DATA:
|
|
return "KHR_DF_CHANNEL_ASTC_DATA";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_ETC1S:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_ETC1S_RGB:
|
|
return "KHR_DF_CHANNEL_ETC1S_RGB";
|
|
case KHR_DF_CHANNEL_ETC1S_RRR:
|
|
return "KHR_DF_CHANNEL_ETC1S_RRR";
|
|
case KHR_DF_CHANNEL_ETC1S_GGG:
|
|
return "KHR_DF_CHANNEL_ETC1S_GGG";
|
|
case KHR_DF_CHANNEL_ETC1S_AAA:
|
|
return "KHR_DF_CHANNEL_ETC1S_AAA";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_PVRTC:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_PVRTC_COLOR:
|
|
return "KHR_DF_CHANNEL_PVRTC_COLOR";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_PVRTC2:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_PVRTC2_COLOR:
|
|
return "KHR_DF_CHANNEL_PVRTC2_COLOR";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
case KHR_DF_MODEL_UASTC:
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_UASTC_RGB:
|
|
return "KHR_DF_CHANNEL_UASTC_RGB";
|
|
case KHR_DF_CHANNEL_UASTC_RGBA:
|
|
return "KHR_DF_CHANNEL_UASTC_RGBA";
|
|
case KHR_DF_CHANNEL_UASTC_RRR:
|
|
return "KHR_DF_CHANNEL_UASTC_RRR";
|
|
case KHR_DF_CHANNEL_UASTC_RRRG:
|
|
return "KHR_DF_CHANNEL_UASTC_RRRG";
|
|
case KHR_DF_CHANNEL_UASTC_RG:
|
|
return "KHR_DF_CHANNEL_UASTC_RG";
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (value) {
|
|
case KHR_DF_CHANNEL_UNSPECIFIED_0:
|
|
return "KHR_DF_CHANNEL_UNSPECIFIED_0";
|
|
case KHR_DF_CHANNEL_UNSPECIFIED_1:
|
|
return "KHR_DF_CHANNEL_UNSPECIFIED_1";
|
|
case KHR_DF_CHANNEL_UNSPECIFIED_2:
|
|
return "KHR_DF_CHANNEL_UNSPECIFIED_2";
|
|
case KHR_DF_CHANNEL_UNSPECIFIED_3:
|
|
return "KHR_DF_CHANNEL_UNSPECIFIED_3";
|
|
case KHR_DF_CHANNEL_UNSPECIFIED_4:
|
|
return "KHR_DF_CHANNEL_UNSPECIFIED_4";
|
|
case KHR_DF_CHANNEL_UNSPECIFIED_5:
|
|
return "KHR_DF_CHANNEL_UNSPECIFIED_5";
|
|
case KHR_DF_CHANNEL_UNSPECIFIED_6:
|
|
return "KHR_DF_CHANNEL_UNSPECIFIED_6";
|
|
case KHR_DF_CHANNEL_UNSPECIFIED_7:
|
|
return "KHR_DF_CHANNEL_UNSPECIFIED_7";
|
|
case KHR_DF_CHANNEL_UNSPECIFIED_8:
|
|
return "KHR_DF_CHANNEL_UNSPECIFIED_8";
|
|
case KHR_DF_CHANNEL_UNSPECIFIED_9:
|
|
return "KHR_DF_CHANNEL_UNSPECIFIED_9";
|
|
case KHR_DF_CHANNEL_UNSPECIFIED_10:
|
|
return "KHR_DF_CHANNEL_UNSPECIFIED_10";
|
|
case KHR_DF_CHANNEL_UNSPECIFIED_11:
|
|
return "KHR_DF_CHANNEL_UNSPECIFIED_11";
|
|
case KHR_DF_CHANNEL_UNSPECIFIED_12:
|
|
return "KHR_DF_CHANNEL_UNSPECIFIED_12";
|
|
case KHR_DF_CHANNEL_UNSPECIFIED_13:
|
|
return "KHR_DF_CHANNEL_UNSPECIFIED_13";
|
|
case KHR_DF_CHANNEL_UNSPECIFIED_14:
|
|
return "KHR_DF_CHANNEL_UNSPECIFIED_14";
|
|
case KHR_DF_CHANNEL_UNSPECIFIED_15:
|
|
return "KHR_DF_CHANNEL_UNSPECIFIED_15";
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* @internal
|
|
*/
|
|
static void printFlagBits(uint32_t flags, const char*(*toStringFn)(uint32_t, bool)) {
|
|
bool first = true;
|
|
for (uint32_t bit_index = 0; bit_index < 32; ++bit_index) {
|
|
uint32_t bit_mask = 1u << bit_index;
|
|
bool bit_value = (bit_mask & (uint32_t) flags) != 0;
|
|
|
|
const char* comma = first ? "" : ", ";
|
|
const char* str = toStringFn(bit_index, bit_value);
|
|
if (str) {
|
|
printf("%s%s", comma, str);
|
|
first = false;
|
|
} else if (bit_value) {
|
|
printf("%s%u", comma, bit_mask);
|
|
first = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @internal
|
|
*/
|
|
static void printFlagBitsJSON(uint32_t indent, const char* nl, uint32_t flags, const char*(*toStringFn)(uint32_t, bool)) {
|
|
bool first = true;
|
|
for (uint32_t bit_index = 0; bit_index < 32; ++bit_index) {
|
|
uint32_t bit_mask = 1u << bit_index;
|
|
bool bit_value = (bit_mask & (uint32_t) flags) != 0;
|
|
|
|
const char* str = toStringFn(bit_index, bit_value);
|
|
if (str) {
|
|
printf("%s%s%*s\"%s\"", first ? "" : ",", first ? "" : nl, indent, "", str);
|
|
first = false;
|
|
} else if (bit_value) {
|
|
printf("%s%s%*s%u", first ? "" : ",", first ? "" : nl, indent, "", bit_mask);
|
|
first = false;
|
|
}
|
|
}
|
|
if (!first)
|
|
printf("%s", nl);
|
|
}
|
|
|
|
/**
|
|
* @~English
|
|
* @brief Print a human-readable interpretation of a data format descriptor.
|
|
*
|
|
* @param DFD Pointer to a data format descriptor.
|
|
* @param dataSize The maximum size that can be considered as part of the DFD.
|
|
**/
|
|
void printDFD(uint32_t *DFD, uint32_t dataSize)
|
|
{
|
|
#define PRINT_ENUM(VALUE, TO_STRING_FN) { \
|
|
int value = VALUE; \
|
|
const char* str = TO_STRING_FN(value); \
|
|
if (str) \
|
|
printf("%s", str); \
|
|
else \
|
|
printf("%u", value); \
|
|
}
|
|
|
|
const uint32_t sizeof_dfdTotalSize = sizeof(uint32_t);
|
|
const uint32_t sizeof_DFDBHeader = sizeof(uint32_t) * 2;
|
|
const uint32_t sizeof_BDFD = sizeof(uint32_t) * KHR_DF_WORD_SAMPLESTART;
|
|
const uint32_t sizeof_BDFDSample = sizeof(uint32_t) * KHR_DF_WORD_SAMPLEWORDS;
|
|
|
|
uint32_t dfdTotalSize = dataSize >= sizeof_dfdTotalSize ? DFD[0] : 0;
|
|
uint32_t remainingSize = dfdTotalSize < dataSize ? dfdTotalSize : dataSize;
|
|
if (remainingSize < sizeof_dfdTotalSize)
|
|
return; // Invalid DFD: dfdTotalSize must be present
|
|
|
|
uint32_t* block = DFD + 1;
|
|
remainingSize -= sizeof_dfdTotalSize;
|
|
|
|
printf("DFD total bytes: %u\n", dfdTotalSize);
|
|
|
|
for (int i = 0; i < MAX_NUM_DFD_BLOCKS; ++i) { // At most only iterate MAX_NUM_DFD_BLOCKS block
|
|
if (remainingSize < sizeof_DFDBHeader)
|
|
break; // Invalid DFD: Missing or partial block header
|
|
|
|
const khr_df_vendorid_e vendorID = KHR_DFDVAL(block, VENDORID);
|
|
const khr_df_khr_descriptortype_e descriptorType = KHR_DFDVAL(block, DESCRIPTORTYPE);
|
|
const khr_df_versionnumber_e versionNumber = KHR_DFDVAL(block, VERSIONNUMBER);
|
|
const uint32_t blockSize = KHR_DFDVAL(block, DESCRIPTORBLOCKSIZE);
|
|
|
|
printf("Vendor ID: ");
|
|
PRINT_ENUM(vendorID, dfdToStringVendorID);
|
|
printf("\nDescriptor type: ");
|
|
PRINT_ENUM(descriptorType, dfdToStringDescriptorType);
|
|
printf("\nVersion: ");
|
|
PRINT_ENUM(versionNumber, dfdToStringVersionNumber);
|
|
printf("\nDescriptor block size: %u", blockSize);
|
|
printf("\n");
|
|
|
|
if (vendorID == KHR_DF_VENDORID_KHRONOS && descriptorType == KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT) {
|
|
if (remainingSize < sizeof_BDFD)
|
|
break; // Invalid DFD: Missing or partial basic DFD block
|
|
|
|
const int model = KHR_DFDVAL(block, MODEL);
|
|
|
|
khr_df_flags_e flags = KHR_DFDVAL(block, FLAGS);
|
|
printf("Flags: 0x%X (", flags);
|
|
printFlagBits(flags, dfdToStringFlagsBit);
|
|
printf(")\nTransfer: ");
|
|
PRINT_ENUM(KHR_DFDVAL(block, TRANSFER), dfdToStringTransferFunction);
|
|
printf("\nPrimaries: ");
|
|
PRINT_ENUM(KHR_DFDVAL(block, PRIMARIES), dfdToStringColorPrimaries);
|
|
printf("\nModel: ");
|
|
PRINT_ENUM(model, dfdToStringColorModel);
|
|
printf("\n");
|
|
|
|
printf("Dimensions: %u, %u, %u, %u\n",
|
|
KHR_DFDVAL(block, TEXELBLOCKDIMENSION0) + 1,
|
|
KHR_DFDVAL(block, TEXELBLOCKDIMENSION1) + 1,
|
|
KHR_DFDVAL(block, TEXELBLOCKDIMENSION2) + 1,
|
|
KHR_DFDVAL(block, TEXELBLOCKDIMENSION3) + 1);
|
|
printf("Plane bytes: %u, %u, %u, %u, %u, %u, %u, %u\n",
|
|
KHR_DFDVAL(block, BYTESPLANE0),
|
|
KHR_DFDVAL(block, BYTESPLANE1),
|
|
KHR_DFDVAL(block, BYTESPLANE2),
|
|
KHR_DFDVAL(block, BYTESPLANE3),
|
|
KHR_DFDVAL(block, BYTESPLANE4),
|
|
KHR_DFDVAL(block, BYTESPLANE5),
|
|
KHR_DFDVAL(block, BYTESPLANE6),
|
|
KHR_DFDVAL(block, BYTESPLANE7));
|
|
|
|
int samples = (blockSize - sizeof_BDFD) / sizeof_BDFDSample;
|
|
if (samples > MAX_NUM_BDFD_SAMPLES)
|
|
samples = MAX_NUM_BDFD_SAMPLES; // Too many BDFD samples
|
|
for (int sample = 0; sample < samples; ++sample) {
|
|
if (remainingSize < sizeof_BDFD + (sample + 1) * sizeof_BDFDSample)
|
|
break; // Invalid DFD: Missing or partial basic DFD sample
|
|
|
|
khr_df_model_channels_e channelType = KHR_DFDSVAL(block, sample, CHANNELID);
|
|
printf("Sample %u:\n", sample);
|
|
|
|
khr_df_sample_datatype_qualifiers_e qualifiers = KHR_DFDSVAL(block, sample, QUALIFIERS);
|
|
printf(" Qualifiers: 0x%X (", qualifiers);
|
|
printFlagBits(qualifiers, dfdToStringSampleDatatypeQualifiers);
|
|
printf(")\n");
|
|
printf(" Channel Type: 0x%X", channelType);
|
|
{
|
|
const char* str = dfdToStringChannelId(model, channelType);
|
|
if (str)
|
|
printf(" (%s)\n", str);
|
|
else
|
|
printf(" (%u)\n", channelType);
|
|
}
|
|
printf(" Length: %u bits Offset: %u\n",
|
|
KHR_DFDSVAL(block, sample, BITLENGTH) + 1,
|
|
KHR_DFDSVAL(block, sample, BITOFFSET));
|
|
printf(" Position: %u, %u, %u, %u\n",
|
|
KHR_DFDSVAL(block, sample, SAMPLEPOSITION0),
|
|
KHR_DFDSVAL(block, sample, SAMPLEPOSITION1),
|
|
KHR_DFDSVAL(block, sample, SAMPLEPOSITION2),
|
|
KHR_DFDSVAL(block, sample, SAMPLEPOSITION3));
|
|
printf(" Lower: 0x%08x\n Upper: 0x%08x\n",
|
|
KHR_DFDSVAL(block, sample, SAMPLELOWER),
|
|
KHR_DFDSVAL(block, sample, SAMPLEUPPER));
|
|
}
|
|
} else if (vendorID == KHR_DF_VENDORID_KHRONOS && descriptorType == KHR_DF_KHR_DESCRIPTORTYPE_ADDITIONAL_DIMENSIONS) {
|
|
// TODO: Implement DFD print for ADDITIONAL_DIMENSIONS
|
|
} else if (vendorID == KHR_DF_VENDORID_KHRONOS && descriptorType == KHR_DF_KHR_DESCRIPTORTYPE_ADDITIONAL_PLANES) {
|
|
// TODO: Implement DFD print for ADDITIONAL_PLANES
|
|
} else {
|
|
printf("Unknown block\n");
|
|
}
|
|
|
|
const uint32_t advance = sizeof_DFDBHeader > blockSize ? sizeof_DFDBHeader : blockSize;
|
|
if (advance > remainingSize)
|
|
break;
|
|
remainingSize -= advance;
|
|
block += advance / 4;
|
|
}
|
|
#undef PRINT_ENUM
|
|
}
|
|
|
|
/**
|
|
* @~English
|
|
* @brief Print a JSON interpretation of a data format descriptor.
|
|
*
|
|
* @param DFD Pointer to a data format descriptor.
|
|
* @param dataSize The maximum size that can be considered as part of the DFD.
|
|
* @param base_indent The number of indentations to include at the front of every line
|
|
* @param indent_width The number of spaces to add with each nested scope
|
|
* @param minified Specifies whether the JSON output should be minified
|
|
**/
|
|
void printDFDJSON(uint32_t* DFD, uint32_t dataSize, uint32_t base_indent, uint32_t indent_width, bool minified)
|
|
{
|
|
if (minified) {
|
|
base_indent = 0;
|
|
indent_width = 0;
|
|
}
|
|
const char* space = minified ? "" : " ";
|
|
const char* nl = minified ? "" : "\n";
|
|
|
|
#define LENGTH_OF_INDENT(INDENT) ((base_indent + INDENT) * indent_width)
|
|
|
|
/** Prints an enum as string or number */
|
|
#define PRINT_ENUM(INDENT, NAME, VALUE, TO_STRING_FN, COMMA) { \
|
|
int value = VALUE; \
|
|
printf("%*s\"" NAME "\":%s", LENGTH_OF_INDENT(INDENT), "", space); \
|
|
const char* str = TO_STRING_FN(value); \
|
|
if (str) \
|
|
printf("\"%s\"", str); \
|
|
else \
|
|
printf("%u", value); \
|
|
printf(COMMA "%s", nl); \
|
|
}
|
|
|
|
/** Prints an enum as string or number if the to string function fails with a trailing comma*/
|
|
#define PRINT_ENUM_C(INDENT, NAME, VALUE, TO_STRING_FN) \
|
|
PRINT_ENUM(INDENT, NAME, VALUE, TO_STRING_FN, ",")
|
|
|
|
/** Prints an enum as string or number if the to string function fails without a trailing comma*/
|
|
#define PRINT_ENUM_E(INDENT, NAME, VALUE, TO_STRING_FN) \
|
|
PRINT_ENUM(INDENT, NAME, VALUE, TO_STRING_FN, "")
|
|
|
|
#define PRINT_INDENT(INDENT, FMT, ...) { \
|
|
printf("%*s" FMT, LENGTH_OF_INDENT(INDENT), "", __VA_ARGS__); \
|
|
}
|
|
|
|
#define PRINT_INDENT_NOARG(INDENT, FMT) { \
|
|
printf("%*s" FMT, LENGTH_OF_INDENT(INDENT), ""); \
|
|
}
|
|
|
|
const uint32_t sizeof_dfdTotalSize = sizeof(uint32_t);
|
|
const uint32_t sizeof_DFDBHeader = sizeof(uint32_t) * 2;
|
|
const uint32_t sizeof_BDFD = sizeof(uint32_t) * KHR_DF_WORD_SAMPLESTART;
|
|
const uint32_t sizeof_BDFDSample = sizeof(uint32_t) * KHR_DF_WORD_SAMPLEWORDS;
|
|
|
|
uint32_t dfdTotalSize = dataSize >= sizeof_dfdTotalSize ? DFD[0] : 0;
|
|
PRINT_INDENT(0, "\"totalSize\":%s%u,%s", space, dfdTotalSize, nl)
|
|
|
|
uint32_t remainingSize = dfdTotalSize < dataSize ? dfdTotalSize : dataSize;
|
|
if (remainingSize < sizeof_dfdTotalSize) {
|
|
PRINT_INDENT(0, "\"blocks\":%s[]%s", space, nl) // Print empty blocks to confirm to the json scheme
|
|
return; // Invalid DFD: dfdTotalSize must be present
|
|
}
|
|
|
|
uint32_t* block = DFD + 1;
|
|
remainingSize -= sizeof_dfdTotalSize;
|
|
PRINT_INDENT(0, "\"blocks\":%s[", space)
|
|
|
|
for (int i = 0; i < MAX_NUM_DFD_BLOCKS; ++i) { // At most only iterate MAX_NUM_DFD_BLOCKS block
|
|
if (remainingSize < sizeof_DFDBHeader)
|
|
break; // Invalid DFD: Missing or partial block header
|
|
|
|
const khr_df_vendorid_e vendorID = KHR_DFDVAL(block, VENDORID);
|
|
const khr_df_khr_descriptortype_e descriptorType = KHR_DFDVAL(block, DESCRIPTORTYPE);
|
|
const khr_df_versionnumber_e versionNumber = KHR_DFDVAL(block, VERSIONNUMBER);
|
|
const uint32_t blockSize = KHR_DFDVAL(block, DESCRIPTORBLOCKSIZE);
|
|
|
|
const int model = KHR_DFDVAL(block, MODEL);
|
|
|
|
if (i == 0) {
|
|
printf("%s", nl);
|
|
} else {
|
|
printf(",%s", nl);
|
|
}
|
|
PRINT_INDENT(1, "{%s", nl)
|
|
PRINT_ENUM_C(2, "vendorId", vendorID, dfdToStringVendorID);
|
|
PRINT_ENUM_C(2, "descriptorType", descriptorType, dfdToStringDescriptorType);
|
|
PRINT_ENUM_C(2, "versionNumber", versionNumber, dfdToStringVersionNumber);
|
|
PRINT_INDENT(2, "\"descriptorBlockSize\":%s%u", space, blockSize)
|
|
|
|
if (vendorID == KHR_DF_VENDORID_KHRONOS && descriptorType == KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT) {
|
|
if (remainingSize < sizeof_BDFD) {
|
|
// Invalid DFD: Missing or partial basic DFD block
|
|
printf("%s", nl);
|
|
PRINT_INDENT(1, "}%s", nl) // End of block
|
|
break;
|
|
}
|
|
|
|
printf(",%s", nl);
|
|
PRINT_INDENT(2, "\"flags\":%s[%s", space, nl)
|
|
khr_df_flags_e flags = KHR_DFDVAL(block, FLAGS);
|
|
printFlagBitsJSON(LENGTH_OF_INDENT(3), nl, flags, dfdToStringFlagsBit);
|
|
PRINT_INDENT(2, "],%s", nl)
|
|
|
|
PRINT_ENUM_C(2, "transferFunction", KHR_DFDVAL(block, TRANSFER), dfdToStringTransferFunction);
|
|
PRINT_ENUM_C(2, "colorPrimaries", KHR_DFDVAL(block, PRIMARIES), dfdToStringColorPrimaries);
|
|
PRINT_ENUM_C(2, "colorModel", model, dfdToStringColorModel);
|
|
PRINT_INDENT(2, "\"texelBlockDimension\":%s[%u,%s%u,%s%u,%s%u],%s", space,
|
|
KHR_DFDVAL(block, TEXELBLOCKDIMENSION0) + 1, space,
|
|
KHR_DFDVAL(block, TEXELBLOCKDIMENSION1) + 1, space,
|
|
KHR_DFDVAL(block, TEXELBLOCKDIMENSION2) + 1, space,
|
|
KHR_DFDVAL(block, TEXELBLOCKDIMENSION3) + 1, nl)
|
|
PRINT_INDENT(2, "\"bytesPlane\":%s[%u,%s%u,%s%u,%s%u,%s%u,%s%u,%s%u,%s%u],%s", space,
|
|
KHR_DFDVAL(block, BYTESPLANE0), space,
|
|
KHR_DFDVAL(block, BYTESPLANE1), space,
|
|
KHR_DFDVAL(block, BYTESPLANE2), space,
|
|
KHR_DFDVAL(block, BYTESPLANE3), space,
|
|
KHR_DFDVAL(block, BYTESPLANE4), space,
|
|
KHR_DFDVAL(block, BYTESPLANE5), space,
|
|
KHR_DFDVAL(block, BYTESPLANE6), space,
|
|
KHR_DFDVAL(block, BYTESPLANE7), nl)
|
|
|
|
PRINT_INDENT(2, "\"samples\":%s[%s", space, nl)
|
|
int samples = (blockSize - sizeof_BDFD) / sizeof_BDFDSample;
|
|
if (samples > MAX_NUM_BDFD_SAMPLES)
|
|
samples = MAX_NUM_BDFD_SAMPLES;
|
|
for (int sample = 0; sample < samples; ++sample) {
|
|
if (remainingSize < sizeof_BDFD + (sample + 1) * sizeof_BDFDSample)
|
|
break; // Invalid DFD: Missing or partial basic DFD sample
|
|
|
|
if (sample != 0)
|
|
printf(",%s", nl);
|
|
PRINT_INDENT(3, "{%s", nl)
|
|
|
|
khr_df_sample_datatype_qualifiers_e qualifiers = KHR_DFDSVAL(block, sample, QUALIFIERS);
|
|
if (qualifiers == 0) {
|
|
PRINT_INDENT(4, "\"qualifiers\":%s[],%s", space, nl)
|
|
|
|
} else {
|
|
PRINT_INDENT(4, "\"qualifiers\":%s[%s", space, nl)
|
|
printFlagBitsJSON(LENGTH_OF_INDENT(5), nl, qualifiers, dfdToStringSampleDatatypeQualifiers);
|
|
PRINT_INDENT(4, "],%s", nl)
|
|
}
|
|
|
|
khr_df_model_channels_e channelType = KHR_DFDSVAL(block, sample, CHANNELID);
|
|
const char* channelStr = dfdToStringChannelId(model, channelType);
|
|
if (channelStr)
|
|
PRINT_INDENT(4, "\"channelType\":%s\"%s\",%s", space, channelStr, nl)
|
|
else
|
|
PRINT_INDENT(4, "\"channelType\":%s%u,%s", space, channelType, nl)
|
|
|
|
PRINT_INDENT(4, "\"bitLength\":%s%u,%s", space, KHR_DFDSVAL(block, sample, BITLENGTH), nl)
|
|
PRINT_INDENT(4, "\"bitOffset\":%s%u,%s", space, KHR_DFDSVAL(block, sample, BITOFFSET), nl)
|
|
PRINT_INDENT(4, "\"samplePosition\":%s[%u,%s%u,%s%u,%s%u],%s", space,
|
|
KHR_DFDSVAL(block, sample, SAMPLEPOSITION0), space,
|
|
KHR_DFDSVAL(block, sample, SAMPLEPOSITION1), space,
|
|
KHR_DFDSVAL(block, sample, SAMPLEPOSITION2), space,
|
|
KHR_DFDSVAL(block, sample, SAMPLEPOSITION3), nl)
|
|
|
|
if (qualifiers & KHR_DF_SAMPLE_DATATYPE_SIGNED) {
|
|
PRINT_INDENT(4, "\"sampleLower\":%s%d,%s", space, KHR_DFDSVAL(block, sample, SAMPLELOWER), nl)
|
|
PRINT_INDENT(4, "\"sampleUpper\":%s%d%s", space, KHR_DFDSVAL(block, sample, SAMPLEUPPER), nl)
|
|
} else {
|
|
PRINT_INDENT(4, "\"sampleLower\":%s%u,%s", space, (unsigned int) KHR_DFDSVAL(block, sample, SAMPLELOWER), nl)
|
|
PRINT_INDENT(4, "\"sampleUpper\":%s%u%s", space, (unsigned int) KHR_DFDSVAL(block, sample, SAMPLEUPPER), nl)
|
|
}
|
|
|
|
PRINT_INDENT_NOARG(3, "}")
|
|
}
|
|
printf("%s", nl);
|
|
PRINT_INDENT(2, "]%s", nl) // End of samples
|
|
} else if (vendorID == KHR_DF_VENDORID_KHRONOS && descriptorType == KHR_DF_KHR_DESCRIPTORTYPE_ADDITIONAL_DIMENSIONS) {
|
|
printf("%s", nl);
|
|
// printf(",%s", nl); // If there is extra member printed
|
|
// TODO: Implement DFD print for ADDITIONAL_DIMENSIONS
|
|
} else if (vendorID == KHR_DF_VENDORID_KHRONOS && descriptorType == KHR_DF_KHR_DESCRIPTORTYPE_ADDITIONAL_PLANES) {
|
|
printf("%s", nl);
|
|
// printf(",%s", nl); // If there is extra member printed
|
|
// TODO: Implement DFD print for ADDITIONAL_PLANES
|
|
} else {
|
|
printf("%s", nl);
|
|
// printf(",%s", nl); // If there is extra member printed
|
|
// TODO: What to do with unknown blocks for json?
|
|
// Unknown block data in binary?
|
|
}
|
|
|
|
PRINT_INDENT_NOARG(1, "}") // End of block
|
|
|
|
const uint32_t advance = sizeof_DFDBHeader > blockSize ? sizeof_DFDBHeader : blockSize;
|
|
if (advance > remainingSize)
|
|
break;
|
|
remainingSize -= advance;
|
|
block += advance / 4;
|
|
}
|
|
printf("%s", nl);
|
|
PRINT_INDENT(0, "]%s", nl) // End of blocks
|
|
|
|
#undef PRINT_ENUM
|
|
#undef PRINT_ENUM_C
|
|
#undef PRINT_ENUM_E
|
|
#undef PRINT_INDENT
|
|
#undef PRINT_INDENT_NOARG
|
|
}
|