← Back to branch summary

~mmach/netext73/mesa-haswell

« back to all changes in this revision

Viewing changes to src/gallium/auxiliary/gallivm/lp_bld_format.h

  • Committer: mmach
  • Date: 2022-09-22 19:56:13 UTC
  • Revision ID: netbit73@gmail.com-20220922195613-wtik9mmy20tmor0i
2022-09-22 21:17:09

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
void
155
 
lp_build_store_rgba_soa(struct gallivm_state *gallivm,
156
 
                        const struct util_format_description *format_desc,
157
 
                        struct lp_type type,
158
 
                        LLVMValueRef exec_mask,
159
 
                        LLVMValueRef base_ptr,
160
 
                        LLVMValueRef offset,
161
 
                        LLVMValueRef out_of_bounds,
162
 
                        const LLVMValueRef rgba_in[4]);
163
 
 
164
 
/*
165
 
 * YUV
166
 
 */
167
 
 
168
 
LLVMValueRef
169
 
lp_build_fetch_subsampled_rgba_aos(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
 
 
177
 
 
178
 
/*
179
 
 * S3TC
180
 
 */
181
 
 
182
 
LLVMValueRef
183
 
lp_build_fetch_s3tc_rgba_aos(struct gallivm_state *gallivm,
184
 
                             const struct util_format_description *format_desc,
185
 
                             unsigned n,
186
 
                             LLVMValueRef base_ptr,
187
 
                             LLVMValueRef offset,
188
 
                             LLVMValueRef i,
189
 
                             LLVMValueRef j,
190
 
                             LLVMValueRef cache);
191
 
 
192
 
/*
193
 
 * RGTC
194
 
 */
195
 
 
196
 
LLVMValueRef
197
 
lp_build_fetch_rgtc_rgba_aos(struct gallivm_state *gallivm,
198
 
                             const struct util_format_description *format_desc,
199
 
                             unsigned n,
200
 
                             LLVMValueRef base_ptr,
201
 
                             LLVMValueRef offset,
202
 
                             LLVMValueRef i,
203
 
                             LLVMValueRef j,
204
 
                             LLVMValueRef cache);
205
 
 
206
 
/*
207
 
 * special float formats
208
 
 */
209
 
 
210
 
LLVMValueRef
211
 
lp_build_float_to_smallfloat(struct gallivm_state *gallivm,
212
 
                             struct lp_type i32_type,
213
 
                             LLVMValueRef src,
214
 
                             unsigned mantissa_bits,
215
 
                             unsigned exponent_bits,
216
 
                             unsigned mantissa_start,
217
 
                             boolean has_sign);
218
 
 
219
 
LLVMValueRef
220
 
lp_build_smallfloat_to_float(struct gallivm_state *gallivm,
221
 
                             struct lp_type f32_type,
222
 
                             LLVMValueRef src,
223
 
                             unsigned mantissa_bits,
224
 
                             unsigned exponent_bits,
225
 
                             unsigned mantissa_start,
226
 
                             boolean has_sign);
227
 
 
228
 
LLVMValueRef
229
 
lp_build_float_to_r11g11b10(struct gallivm_state *gallivm,
230
 
                            const LLVMValueRef *src);
231
 
 
232
 
void
233
 
lp_build_r11g11b10_to_float(struct gallivm_state *gallivm,
234
 
                            LLVMValueRef src,
235
 
                            LLVMValueRef *dst);
236
 
 
237
 
void
238
 
lp_build_rgb9e5_to_float(struct gallivm_state *gallivm,
239
 
                         LLVMValueRef src,
240
 
                         LLVMValueRef *dst);
241
 
 
242
 
LLVMValueRef
243
 
lp_build_float_to_srgb_packed(struct gallivm_state *gallivm,
244
 
                              const struct util_format_description *dst_fmt,
245
 
                              struct lp_type src_type,
246
 
                              LLVMValueRef *src);
247
 
 
248
 
LLVMValueRef
249
 
lp_build_srgb_to_linear(struct gallivm_state *gallivm,
250
 
                        struct lp_type src_type,
251
 
                        unsigned chan_bits,
252
 
                        LLVMValueRef src);
253
 
 
254
 
 
255
 
#endif /* !LP_BLD_FORMAT_H */