src/gallium/drivers/panfrost/pan_format.c

   1 /*
   2  * © Copyright 2018 Alyssa Rosenzweig
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  *
  23  */
  24
  25 #include "pan_format.h"
  26
  27 /* From panwrap/panwrap-decoder, but we don't want to bring in all those headers */
  28 char *panwrap_format_name(enum mali_format format);
  29
  30 /* Construct a default swizzle based on the number of components */
  31
  32 static unsigned
  33 panfrost_translate_swizzle(enum pipe_swizzle s)
  34 {
  35         switch (s) {
  36         case PIPE_SWIZZLE_X:
  37                 return MALI_CHANNEL_RED;
  38
  39         case PIPE_SWIZZLE_Y:
  40                 return MALI_CHANNEL_GREEN;
  41
  42         case PIPE_SWIZZLE_Z:
  43                 return MALI_CHANNEL_BLUE;
  44
  45         case PIPE_SWIZZLE_W:
  46                 return MALI_CHANNEL_ALPHA;
  47
  48         case PIPE_SWIZZLE_0:
  49         case PIPE_SWIZZLE_NONE:
  50                 return MALI_CHANNEL_ZERO;
  51
  52         case PIPE_SWIZZLE_1:
  53                 return MALI_CHANNEL_ONE;
  54
  55         default:
  56                 unreachable("INvalid swizzle");
  57         }
  58 }
  59
  60 /* Translate a Gallium swizzle quad to a 12-bit Mali swizzle code */
  61
  62 unsigned
  63 panfrost_translate_swizzle_4(const unsigned char swizzle[4])
  64 {
  65         unsigned out = 0;
  66
  67         for (unsigned i = 0; i < 4; ++i) {
  68                 unsigned translated = panfrost_translate_swizzle(swizzle[i]);
  69                 out |= (translated << (3*i));
  70         }
  71
  72         return out;
  73 }
  74
  75 unsigned
  76 panfrost_get_default_swizzle(unsigned components)
  77 {
  78         unsigned char default_swizzles[4][4] = {
  79                 {PIPE_SWIZZLE_X, PIPE_SWIZZLE_0, PIPE_SWIZZLE_0, PIPE_SWIZZLE_1},
  80                 {PIPE_SWIZZLE_X, PIPE_SWIZZLE_Y, PIPE_SWIZZLE_0, PIPE_SWIZZLE_1},
  81                 {PIPE_SWIZZLE_X, PIPE_SWIZZLE_Y, PIPE_SWIZZLE_Z, PIPE_SWIZZLE_1},
  82                 {PIPE_SWIZZLE_X, PIPE_SWIZZLE_Y, PIPE_SWIZZLE_Z, PIPE_SWIZZLE_W},
  83         };
  84
  85         assert(components >= 1 && components <= 4);
  86         return panfrost_translate_swizzle_4(default_swizzles[components - 1]);
  87 }
  88
  89 static unsigned
  90 panfrost_translate_channel_width(unsigned size)
  91 {
  92         switch (size) {
  93         case 4:
  94                 return MALI_CHANNEL_4;
  95         case 8:
  96                 return MALI_CHANNEL_8;
  97         case 16:
  98                 return MALI_CHANNEL_16;
  99         case 32:
 100                 return MALI_CHANNEL_32;
 101         default:
 102                 unreachable("Invalid width");
 103         }
 104 }
 105
 106 static unsigned
 107 panfrost_translate_channel_type(unsigned type, unsigned size, bool norm)
 108 {
 109         switch (type) {
 110         case UTIL_FORMAT_TYPE_UNSIGNED:
 111                 return norm ? MALI_FORMAT_UNORM : MALI_FORMAT_UINT;
 112
 113         case UTIL_FORMAT_TYPE_SIGNED:
 114                 return norm ? MALI_FORMAT_SNORM : MALI_FORMAT_SINT;
 115
 116         case UTIL_FORMAT_TYPE_FLOAT:
 117                 if (size == 16) {
 118                         /* With FLOAT, fp16 */
 119                         return MALI_FORMAT_SINT;
 120                 } else if (size == 32) {
 121                         /* With FLOAT< fp32 */
 122                         return MALI_FORMAT_UNORM;
 123                 } else {
 124                         assert(0);
 125                         return 0;
 126                 }
 127
 128         default:
 129                 unreachable("Invalid type");
 130         }
 131 }
 132
 133 /* Constructs a mali_format satisfying the specified Gallium format
 134  * description */
 135
 136 enum mali_format
 137 panfrost_find_format(const struct util_format_description *desc) {
 138         /* Find first non-VOID channel */
 139         struct util_format_channel_description chan = desc->channel[0];
 140
 141         for (unsigned c = 0; c < 4; ++c)
 142         {
 143                 if (desc->channel[c].type == UTIL_FORMAT_TYPE_VOID)
 144                         continue;
 145
 146                 chan = desc->channel[c];
 147                 break;
 148         }
 149
 150         /* Check for special formats */
 151         switch (desc->format)
 152         {
 153         case PIPE_FORMAT_YV12:
 154         case PIPE_FORMAT_YV16:
 155         case PIPE_FORMAT_IYUV:
 156         case PIPE_FORMAT_NV21:
 157                 fprintf(stderr, "YUV format type %s (%d) is not yet supported, but it's probably close to NV12!\n", desc->name, desc->format);
 158                 assert(0);
 159                 break;
 160
 161         case PIPE_FORMAT_NV12:
 162                 return MALI_NV12;
 163
 164         case PIPE_FORMAT_R10G10B10X2_UNORM:
 165         case PIPE_FORMAT_B10G10R10X2_UNORM:
 166         case PIPE_FORMAT_R10G10B10A2_UNORM:
 167         case PIPE_FORMAT_B10G10R10A2_UNORM:
 168                 return MALI_RGB10_A2_UNORM;
 169
 170         case PIPE_FORMAT_R10G10B10X2_SNORM:
 171         case PIPE_FORMAT_R10G10B10A2_SNORM:
 172         case PIPE_FORMAT_B10G10R10A2_SNORM:
 173                 return MALI_RGB10_A2_SNORM;
 174
 175         case PIPE_FORMAT_R10G10B10A2_UINT:
 176         case PIPE_FORMAT_B10G10R10A2_UINT:
 177                 return MALI_RGB10_A2UI;
 178
 179         case PIPE_FORMAT_R10G10B10A2_SSCALED:
 180         case PIPE_FORMAT_B10G10R10A2_SSCALED:
 181                 return MALI_RGB10_A2I;
 182
 183         case PIPE_FORMAT_Z32_UNORM:
 184         case PIPE_FORMAT_Z24X8_UNORM:
 185                 return MALI_Z32_UNORM;
 186
 187         case PIPE_FORMAT_B5G6R5_UNORM:
 188                 return MALI_RGB565;
 189
 190         case PIPE_FORMAT_B5G5R5A1_UNORM:
 191                 return MALI_RGB5_A1_UNORM;
 192
 193         case PIPE_FORMAT_A1B5G5R5_UNORM:
 194         case PIPE_FORMAT_X1B5G5R5_UNORM:
 195                 /* Not supported - this is backwards from OpenGL! */
 196                 assert(0);
 197                 break;
 198
 199         case PIPE_FORMAT_R32_FIXED:
 200                 return MALI_R32_FIXED;
 201         case PIPE_FORMAT_R32G32_FIXED:
 202                 return MALI_RG32_FIXED;
 203         case PIPE_FORMAT_R32G32B32_FIXED:
 204                 return MALI_RGB32_FIXED;
 205         case PIPE_FORMAT_R32G32B32A32_FIXED:
 206                 return MALI_RGBA32_FIXED;
 207
 208         case PIPE_FORMAT_R11G11B10_FLOAT:
 209                 return MALI_R11F_G11F_B10F;
 210         case PIPE_FORMAT_R9G9B9E5_FLOAT:
 211                 return MALI_R9F_G9F_B9F_E5F;
 212
 213         default:
 214                 /* Fallthrough to default */
 215                 break;
 216         }
 217
 218         /* Formats must match in channel count */
 219         assert(desc->nr_channels >= 1 && desc->nr_channels <= 4);
 220         unsigned format = MALI_NR_CHANNELS(desc->nr_channels);
 221
 222         switch (chan.type)
 223         {
 224         case UTIL_FORMAT_TYPE_UNSIGNED:
 225         case UTIL_FORMAT_TYPE_SIGNED:
 226         case UTIL_FORMAT_TYPE_FIXED:
 227                 /* Channel width */
 228                 format |= panfrost_translate_channel_width(chan.size);
 229
 230                 /* Channel type */
 231                 format |= panfrost_translate_channel_type(chan.type, chan.size, chan.normalized);
 232                 break;
 233
 234         case UTIL_FORMAT_TYPE_FLOAT:
 235                 /* Float formats use a special width and encode width
 236                  * with type mixed */
 237
 238                 format |= MALI_CHANNEL_FLOAT;
 239                 format |= panfrost_translate_channel_type(chan.type, chan.size, chan.normalized);
 240                 break;
 241
 242         default:
 243                 printf("%s\n", util_format_name(desc->format));
 244                 unreachable("Invalid format type");
 245         }
 246
 247         return (enum mali_format) format;
 248 }
 249
 250