diff options
Diffstat (limited to 'src/panfrost/encoder/pan_format.c')
-rw-r--r-- | src/panfrost/encoder/pan_format.c | 282 |
1 files changed, 282 insertions, 0 deletions
diff --git a/src/panfrost/encoder/pan_format.c b/src/panfrost/encoder/pan_format.c new file mode 100644 index 00000000000..80253072e89 --- /dev/null +++ b/src/panfrost/encoder/pan_format.c @@ -0,0 +1,282 @@ +/* + * Copyright (C) 2019 Collabora, Ltd. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * Authors: + * Alyssa Rosenzweig <alyssa.rosenzweig@collabora.com> + */ + +#include <stdio.h> +#include "panfrost-job.h" +#include "pan_texture.h" + +static unsigned +panfrost_translate_channel_width(unsigned size) +{ + switch (size) { + case 4: + return MALI_CHANNEL_4; + case 8: + return MALI_CHANNEL_8; + case 16: + return MALI_CHANNEL_16; + case 32: + return MALI_CHANNEL_32; + default: + unreachable("Invalid format width\n"); + } +} + +static unsigned +panfrost_translate_channel_type(unsigned type, unsigned size, bool norm) +{ + switch (type) { + case UTIL_FORMAT_TYPE_UNSIGNED: + return norm ? MALI_FORMAT_UNORM : MALI_FORMAT_UINT; + + case UTIL_FORMAT_TYPE_SIGNED: + return norm ? MALI_FORMAT_SNORM : MALI_FORMAT_SINT; + + case UTIL_FORMAT_TYPE_FLOAT: + /* fp16 -- SINT, fp32 -- UNORM ... gotta use those bits */ + + if (size == 16) + return MALI_FORMAT_SINT; + else if (size == 32) + return MALI_FORMAT_UNORM; + else + unreachable("Invalid float size"); + + default: + unreachable("Invalid type"); + } +} + +/* Constructs a mali_format satisfying the specified Gallium format + * description */ + +enum mali_format +panfrost_find_format(const struct util_format_description *desc) +{ + /* Find first non-VOID channel */ + struct util_format_channel_description chan = desc->channel[0]; + + for (unsigned c = 0; c < 4; ++c) + { + if (desc->channel[c].type == UTIL_FORMAT_TYPE_VOID) + continue; + + chan = desc->channel[c]; + break; + } + + /* Check for special formats */ + switch (desc->format) + { + case PIPE_FORMAT_NV12: + return MALI_NV12; + + case PIPE_FORMAT_R10G10B10X2_UNORM: + case PIPE_FORMAT_B10G10R10X2_UNORM: + case PIPE_FORMAT_R10G10B10A2_UNORM: + case PIPE_FORMAT_B10G10R10A2_UNORM: + return MALI_RGB10_A2_UNORM; + + case PIPE_FORMAT_R10G10B10X2_SNORM: + case PIPE_FORMAT_R10G10B10A2_SNORM: + case PIPE_FORMAT_B10G10R10A2_SNORM: + return MALI_RGB10_A2_SNORM; + + case PIPE_FORMAT_R10G10B10A2_UINT: + case PIPE_FORMAT_B10G10R10A2_UINT: + case PIPE_FORMAT_R10G10B10A2_USCALED: + case PIPE_FORMAT_B10G10R10A2_USCALED: + return MALI_RGB10_A2UI; + + case PIPE_FORMAT_R10G10B10A2_SSCALED: + case PIPE_FORMAT_B10G10R10A2_SSCALED: + return MALI_RGB10_A2I; + + case PIPE_FORMAT_Z32_UNORM: + return MALI_Z32_UNORM; + + case PIPE_FORMAT_Z24X8_UNORM: + case PIPE_FORMAT_Z24_UNORM_S8_UINT: + /* Midgard has no dedicated samplers for Z24S8 and Z24X8 + * formats, and the GPU expects the depth to be encoded in an + * IEEE 32-bit float. Turn all Z24_UNORM variants into R32UI + * and let the shader do the conversion using bfe+fmul + * instructions. + */ + return MALI_R32UI; + + case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT: + /* Z32F = R32F to the hardware */ + return MALI_R32F; + + case PIPE_FORMAT_B5G6R5_UNORM: + return MALI_RGB565; + + case PIPE_FORMAT_B5G5R5A1_UNORM: + return MALI_RGB5_A1_UNORM; + + case PIPE_FORMAT_A1B5G5R5_UNORM: + case PIPE_FORMAT_X1B5G5R5_UNORM: + /* Not supported - this is backwards from OpenGL! */ + assert(0); + break; + + case PIPE_FORMAT_R32_FIXED: + return MALI_R32_FIXED; + case PIPE_FORMAT_R32G32_FIXED: + return MALI_RG32_FIXED; + case PIPE_FORMAT_R32G32B32_FIXED: + return MALI_RGB32_FIXED; + case PIPE_FORMAT_R32G32B32A32_FIXED: + return MALI_RGBA32_FIXED; + + case PIPE_FORMAT_R11G11B10_FLOAT: + return MALI_R11F_G11F_B10F; + case PIPE_FORMAT_R9G9B9E5_FLOAT: + return MALI_R9F_G9F_B9F_E5F; + + case PIPE_FORMAT_ETC1_RGB8: + case PIPE_FORMAT_ETC2_RGB8: + case PIPE_FORMAT_ETC2_SRGB8: + return MALI_ETC2_RGB8; + + case PIPE_FORMAT_ETC2_RGB8A1: + case PIPE_FORMAT_ETC2_SRGB8A1: + return MALI_ETC2_RGB8A1; + + case PIPE_FORMAT_ETC2_RGBA8: + case PIPE_FORMAT_ETC2_SRGBA8: + return MALI_ETC2_RGBA8; + + case PIPE_FORMAT_ETC2_R11_UNORM: + return MALI_ETC2_R11_UNORM; + case PIPE_FORMAT_ETC2_R11_SNORM: + return MALI_ETC2_R11_SNORM; + + case PIPE_FORMAT_ETC2_RG11_UNORM: + return MALI_ETC2_RG11_UNORM; + case PIPE_FORMAT_ETC2_RG11_SNORM: + return MALI_ETC2_RG11_SNORM; + + default: + /* Fallthrough to default */ + break; + } + + if (desc->layout == UTIL_FORMAT_LAYOUT_ASTC) { + if (desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) + return MALI_ASTC_SRGB_SUPP; + else + return MALI_ASTC_HDR_SUPP; + } + + /* Formats must match in channel count */ + assert(desc->nr_channels >= 1 && desc->nr_channels <= 4); + unsigned format = MALI_NR_CHANNELS(desc->nr_channels); + + switch (chan.type) + { + case UTIL_FORMAT_TYPE_UNSIGNED: + case UTIL_FORMAT_TYPE_SIGNED: + case UTIL_FORMAT_TYPE_FIXED: + /* Channel width */ + format |= panfrost_translate_channel_width(chan.size); + + /* Channel type */ + format |= panfrost_translate_channel_type(chan.type, chan.size, chan.normalized); + break; + + case UTIL_FORMAT_TYPE_FLOAT: + /* Float formats use a special width and encode width + * with type mixed */ + + format |= MALI_CHANNEL_FLOAT; + format |= panfrost_translate_channel_type(chan.type, chan.size, chan.normalized); + break; + + default: + printf("%s\n", util_format_name(desc->format)); + unreachable("Invalid format type"); + } + + return (enum mali_format) format; +} + +/* Is a format encoded like Z24S8 and therefore compatible for render? */ + +bool +panfrost_is_z24s8_variant(enum pipe_format fmt) +{ + switch (fmt) { + case PIPE_FORMAT_Z24_UNORM_S8_UINT: + case PIPE_FORMAT_Z24X8_UNORM: + return true; + default: + return false; + } +} + +/* Translate a PIPE swizzle quad to a 12-bit Mali swizzle code. PIPE + * swizzles line up with Mali swizzles for the XYZW01, but PIPE swizzles have + * an additional "NONE" field that we have to mask out to zero. Additionally, + * PIPE swizzles are sparse but Mali swizzles are packed */ + +unsigned +panfrost_translate_swizzle_4(const unsigned char swizzle[4]) +{ + unsigned out = 0; + + for (unsigned i = 0; i < 4; ++i) { + unsigned translated = (swizzle[i] > PIPE_SWIZZLE_1) ? PIPE_SWIZZLE_0 : swizzle[i]; + out |= (translated << (3*i)); + } + + return out; +} + +void +panfrost_invert_swizzle(const unsigned char *in, unsigned char *out) +{ + /* First, default to all zeroes to prevent uninitialized junk */ + + for (unsigned c = 0; c < 4; ++c) + out[c] = PIPE_SWIZZLE_0; + + /* Now "do" what the swizzle says */ + + for (unsigned c = 0; c < 4; ++c) { + unsigned char i = in[c]; + + /* Who cares? */ + assert(PIPE_SWIZZLE_X == 0); + if (i > PIPE_SWIZZLE_W) + continue; + + /* Invert */ + unsigned idx = i - PIPE_SWIZZLE_X; + out[idx] = PIPE_SWIZZLE_X + c; + } +} |