src/gallium/auxiliary/gallivm/lp_bld_format.h

   1 /**************************************************************************
   2  *
   3  * Copyright 2009 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #ifndef LP_BLD_FORMAT_H
  29 #define LP_BLD_FORMAT_H
  30
  31
  32 /**
  33  * @file
  34  * Pixel format helpers.
  35  */
  36
  37 #include "gallivm/lp_bld.h"
  38 #include "gallivm/lp_bld_init.h"
  39
  40 #include "pipe/p_format.h"
  41
  42 struct util_format_description;
  43 struct lp_type;
  44 struct lp_build_context;
  45
  46
  47 #define LP_BUILD_FORMAT_CACHE_DEBUG 0
  48 /*
  49  * Block cache
  50  *
  51  * Optional block cache to be used when unpacking big pixel blocks.
  52  * Must be a power of 2
  53  */
  54
  55 #define LP_BUILD_FORMAT_CACHE_SIZE 128
  56
  57 /*
  58  * Note: cache_data needs 16 byte alignment.
  59  */
  60 struct lp_build_format_cache
  61 {
  62    PIPE_ALIGN_VAR(16) uint32_t cache_data[LP_BUILD_FORMAT_CACHE_SIZE][4][4];
  63    uint64_t cache_tags[LP_BUILD_FORMAT_CACHE_SIZE];
  64 #if LP_BUILD_FORMAT_CACHE_DEBUG
  65    uint64_t cache_access_total;
  66    uint64_t cache_access_miss;
  67 #endif
  68 };
  69
  70
  71 enum {
  72    LP_BUILD_FORMAT_CACHE_MEMBER_DATA = 0,
  73    LP_BUILD_FORMAT_CACHE_MEMBER_TAGS,
  74 #if LP_BUILD_FORMAT_CACHE_DEBUG
  75    LP_BUILD_FORMAT_CACHE_MEMBER_ACCESS_TOTAL,
  76    LP_BUILD_FORMAT_CACHE_MEMBER_ACCESS_MISS,
  77 #endif
  78    LP_BUILD_FORMAT_CACHE_MEMBER_COUNT
  79 };
  80
  81
  82 LLVMTypeRef
  83 lp_build_format_cache_type(struct gallivm_state *gallivm);
  84
  85
  86 /*
  87  * AoS
  88  */
  89
  90 LLVMValueRef
  91 lp_build_format_swizzle_aos(const struct util_format_description *desc,
  92                             struct lp_build_context *bld,
  93                             LLVMValueRef unswizzled);
  94
  95 LLVMValueRef
  96 lp_build_pack_rgba_aos(struct gallivm_state *gallivm,
  97                        const struct util_format_description *desc,
  98                        LLVMValueRef rgba);
  99
 100 LLVMValueRef
 101 lp_build_fetch_rgba_aos(struct gallivm_state *gallivm,
 102                         const struct util_format_description *format_desc,
 103                         struct lp_type type,
 104                         boolean aligned,
 105                         LLVMValueRef base_ptr,
 106                         LLVMValueRef offset,
 107                         LLVMValueRef i,
 108                         LLVMValueRef j,
 109                         LLVMValueRef cache);
 110
 111 LLVMValueRef
 112 lp_build_fetch_rgba_aos_array(struct gallivm_state *gallivm,
 113                         const struct util_format_description *format_desc,
 114                         struct lp_type type,
 115                         LLVMValueRef base_ptr,
 116                         LLVMValueRef offset);
 117
 118
 119 /*
 120  * SoA
 121  */
 122
 123 void
 124 lp_build_format_swizzle_soa(const struct util_format_description *format_desc,
 125                             struct lp_build_context *bld,
 126                             const LLVMValueRef unswizzled[4],
 127                             LLVMValueRef swizzled_out[4]);
 128
 129 void
 130 lp_build_unpack_rgba_soa(struct gallivm_state *gallivm,
 131                          const struct util_format_description *format_desc,
 132                          struct lp_type type,
 133                          LLVMValueRef packed,
 134                          LLVMValueRef rgba_out[4]);
 135
 136 void
 137 lp_build_rgba8_to_fi32_soa(struct gallivm_state *gallivm,
 138                           struct lp_type dst_type,
 139                           LLVMValueRef packed,
 140                           LLVMValueRef *rgba);
 141
 142 void
 143 lp_build_fetch_rgba_soa(struct gallivm_state *gallivm,
 144                         const struct util_format_description *format_desc,
 145                         struct lp_type type,
 146                         boolean aligned,
 147                         LLVMValueRef base_ptr,
 148                         LLVMValueRef offsets,
 149                         LLVMValueRef i,
 150                         LLVMValueRef j,
 151                         LLVMValueRef cache,
 152                         LLVMValueRef rgba_out[4]);
 153
 154 /*
 155  * YUV
 156  */
 157
 158 LLVMValueRef
 159 lp_build_fetch_subsampled_rgba_aos(struct gallivm_state *gallivm,
 160                                    const struct util_format_description *format_desc,
 161                                    unsigned n,
 162                                    LLVMValueRef base_ptr,
 163                                    LLVMValueRef offset,
 164                                    LLVMValueRef i,
 165                                    LLVMValueRef j);
 166
 167
 168 LLVMValueRef
 169 lp_build_fetch_cached_texels(struct gallivm_state *gallivm,
 170                              const struct util_format_description *format_desc,
 171                              unsigned n,
 172                              LLVMValueRef base_ptr,
 173                              LLVMValueRef offset,
 174                              LLVMValueRef i,
 175                              LLVMValueRef j,
 176                              LLVMValueRef cache);
 177
 178
 179 /*
 180  * special float formats
 181  */
 182
 183 LLVMValueRef
 184 lp_build_float_to_smallfloat(struct gallivm_state *gallivm,
 185                              struct lp_type i32_type,
 186                              LLVMValueRef src,
 187                              unsigned mantissa_bits,
 188                              unsigned exponent_bits,
 189                              unsigned mantissa_start,
 190                              boolean has_sign);
 191
 192 LLVMValueRef
 193 lp_build_smallfloat_to_float(struct gallivm_state *gallivm,
 194                              struct lp_type f32_type,
 195                              LLVMValueRef src,
 196                              unsigned mantissa_bits,
 197                              unsigned exponent_bits,
 198                              unsigned mantissa_start,
 199                              boolean has_sign);
 200
 201 LLVMValueRef
 202 lp_build_float_to_r11g11b10(struct gallivm_state *gallivm,
 203                             LLVMValueRef *src);
 204
 205 void
 206 lp_build_r11g11b10_to_float(struct gallivm_state *gallivm,
 207                             LLVMValueRef src,
 208                             LLVMValueRef *dst);
 209
 210 void
 211 lp_build_rgb9e5_to_float(struct gallivm_state *gallivm,
 212                          LLVMValueRef src,
 213                          LLVMValueRef *dst);
 214
 215 LLVMValueRef
 216 lp_build_float_to_srgb_packed(struct gallivm_state *gallivm,
 217                               const struct util_format_description *dst_fmt,
 218                               struct lp_type src_type,
 219                               LLVMValueRef *src);
 220
 221 LLVMValueRef
 222 lp_build_srgb_to_linear(struct gallivm_state *gallivm,
 223                         struct lp_type src_type,
 224                         unsigned chan_bits,
 225                         LLVMValueRef src);
 226
 227
 228 #endif /* !LP_BLD_FORMAT_H */