Debian Codegraph @

src/gallium/drivers/nouveau/nv50/nv50_blit.h

raw
1
2 #ifndef __NV50_BLIT_H__
3 #define __NV50_BLIT_H__
4
5 #include "util/u_inlines.h"
6 #include "util/format/u_format.h"
7
8 void *
9 nv50_blitter_make_fp(struct pipe_context *,
10 unsigned mode,
11 enum pipe_texture_target);
12
13 unsigned
14 nv50_blit_select_mode(const struct pipe_blit_info *);
15
16 /* Converted to a pipe->blit. */
17 void
18 nv50_resource_resolve(struct pipe_context *, const struct pipe_resolve_info *);
19
20 #define NV50_BLIT_MODE_PASS 0 /* pass through TEX $t0/$s0 output */
21 #define NV50_BLIT_MODE_Z24S8 1 /* encode ZS values for RGBA unorm8 */
22 #define NV50_BLIT_MODE_S8Z24 2
23 #define NV50_BLIT_MODE_X24S8 3
24 #define NV50_BLIT_MODE_S8X24 4
25 #define NV50_BLIT_MODE_Z24X8 5
26 #define NV50_BLIT_MODE_X8Z24 6
27 #define NV50_BLIT_MODE_ZS 7 /* put $t0/$s0 into R, $t1/$s1 into G */
28 #define NV50_BLIT_MODE_XS 8 /* put $t1/$s1 into G */
29 #define NV50_BLIT_MODE_INT_CLAMP 9 /* unsigned to signed integer conversion */
30 #define NV50_BLIT_MODES 10
31
32 /* CUBE and RECT textures are reinterpreted as 2D(_ARRAY) */
33 #define NV50_BLIT_TEXTURE_BUFFER 0
34 #define NV50_BLIT_TEXTURE_1D 1
35 #define NV50_BLIT_TEXTURE_2D 2
36 #define NV50_BLIT_TEXTURE_3D 3
37 #define NV50_BLIT_TEXTURE_1D_ARRAY 4
38 #define NV50_BLIT_TEXTURE_2D_ARRAY 5
39 #define NV50_BLIT_MAX_TEXTURE_TYPES 6
40
41 static inline unsigned
42 nv50_blit_texture_type(enum pipe_texture_target target)
43 {
44 switch (target) {
45 case PIPE_TEXTURE_1D: return NV50_BLIT_TEXTURE_1D;
46 case PIPE_TEXTURE_2D: return NV50_BLIT_TEXTURE_2D;
47 case PIPE_TEXTURE_3D: return NV50_BLIT_TEXTURE_3D;
48 case PIPE_TEXTURE_1D_ARRAY: return NV50_BLIT_TEXTURE_1D_ARRAY;
49 case PIPE_TEXTURE_2D_ARRAY: return NV50_BLIT_TEXTURE_2D_ARRAY;
50 default:
51 assert(target == PIPE_BUFFER);
52 return NV50_BLIT_TEXTURE_BUFFER;
53 }
54 }
55
56 static inline enum glsl_sampler_dim
57 nv50_blit_get_glsl_sampler_dim(enum pipe_texture_target target)
58 {
59 switch (target) {
60 case PIPE_TEXTURE_1D: return GLSL_SAMPLER_DIM_1D;
61 case PIPE_TEXTURE_2D: return GLSL_SAMPLER_DIM_2D;
62 case PIPE_TEXTURE_3D: return GLSL_SAMPLER_DIM_3D;
63 case PIPE_TEXTURE_1D_ARRAY: return GLSL_SAMPLER_DIM_1D;
64 case PIPE_TEXTURE_2D_ARRAY: return GLSL_SAMPLER_DIM_2D;
65 default:
66 assert(target == PIPE_BUFFER);
67 return GLSL_SAMPLER_DIM_BUF;
68 }
69 }
70
71 static inline bool
72 nv50_blit_is_array(enum pipe_texture_target target) {
73 return (target == PIPE_TEXTURE_1D_ARRAY) ||
74 (target == PIPE_TEXTURE_2D_ARRAY);
75 }
76
77 static inline enum pipe_texture_target
78 nv50_blit_reinterpret_pipe_texture_target(enum pipe_texture_target target)
79 {
80 switch (target) {
81 case PIPE_TEXTURE_CUBE:
82 case PIPE_TEXTURE_CUBE_ARRAY:
83 return PIPE_TEXTURE_2D_ARRAY;
84 case PIPE_TEXTURE_RECT:
85 return PIPE_TEXTURE_2D;
86 default:
87 return target;
88 }
89 }
90
91 static inline unsigned
92 nv50_blit_get_filter(const struct pipe_blit_info *info)
93 {
94 if (info->dst.resource->nr_samples < info->src.resource->nr_samples)
95 return (util_format_is_depth_or_stencil(info->src.format) ||
96 util_format_is_pure_integer(info->src.format)) ? 0 : 1;
97
98 if (info->filter != PIPE_TEX_FILTER_LINEAR)
99 return 0;
100
101 if ((info->dst.box.width == info->src.box.width ||
102 info->dst.box.width == -info->src.box.width) &&
103 (info->dst.box.height == info->src.box.height ||
104 info->dst.box.height == -info->src.box.height))
105 return 0;
106
107 return 1;
108 }
109
110 /* Since shaders cannot export stencil, we cannot copy stencil values when
111 * rendering to ZETA, so we attach the ZS surface to a colour render target.
112 */
113 static inline enum pipe_format
114 nv50_blit_zeta_to_colour_format(enum pipe_format format)
115 {
116 switch (format) {
117 case PIPE_FORMAT_Z16_UNORM:
118 return PIPE_FORMAT_R16_UNORM;
119 case PIPE_FORMAT_Z24_UNORM_S8_UINT:
120 case PIPE_FORMAT_S8_UINT_Z24_UNORM:
121 case PIPE_FORMAT_Z24X8_UNORM:
122 case PIPE_FORMAT_X8Z24_UNORM:
123 case PIPE_FORMAT_X24S8_UINT:
124 case PIPE_FORMAT_S8X24_UINT:
125 return PIPE_FORMAT_R8G8B8A8_UNORM;
126 case PIPE_FORMAT_Z32_FLOAT:
127 return PIPE_FORMAT_R32_FLOAT;
128 case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
129 case PIPE_FORMAT_X32_S8X24_UINT:
130 return PIPE_FORMAT_R32G32_FLOAT;
131 default:
132 assert(0);
133 return PIPE_FORMAT_NONE;
134 }
135 }
136
137
138 static inline uint16_t
139 nv50_blit_derive_color_mask(const struct pipe_blit_info *info)
140 {
141 const unsigned mask = info->mask;
142
143 uint16_t color_mask = 0;
144
145 switch (info->dst.format) {
146 case PIPE_FORMAT_Z24X8_UNORM:
147 case PIPE_FORMAT_X24S8_UINT:
148 case PIPE_FORMAT_Z24_UNORM_S8_UINT:
149 if (mask & PIPE_MASK_S)
150 color_mask |= 0x1000;
151 if (mask & PIPE_MASK_Z)
152 color_mask |= 0x0111;
153 break;
154 case PIPE_FORMAT_X8Z24_UNORM:
155 case PIPE_FORMAT_S8X24_UINT:
156 case PIPE_FORMAT_S8_UINT_Z24_UNORM:
157 if (mask & PIPE_MASK_S)
158 color_mask |= 0x0001;
159 if (mask & PIPE_MASK_Z)
160 color_mask |= 0x1110;
161 break;
162 default:
163 if (mask & (PIPE_MASK_R | PIPE_MASK_Z)) color_mask |= 0x0001;
164 if (mask & (PIPE_MASK_G | PIPE_MASK_S)) color_mask |= 0x0010;
165 if (mask & PIPE_MASK_B) color_mask |= 0x0100;
166 if (mask & PIPE_MASK_A) color_mask |= 0x1000;
167 break;
168 }
169
170 return color_mask;
171 }
172
173 static inline uint32_t
174 nv50_blit_eng2d_get_mask(const struct pipe_blit_info *info)
175 {
176 uint32_t mask = 0;
177
178 switch (info->dst.format) {
179 case PIPE_FORMAT_Z24X8_UNORM:
180 case PIPE_FORMAT_X24S8_UINT:
181 case PIPE_FORMAT_Z24_UNORM_S8_UINT:
182 if (info->mask & PIPE_MASK_Z) mask |= 0x00ffffff;
183 if (info->mask & PIPE_MASK_S) mask |= 0xff000000;
184 break;
185 case PIPE_FORMAT_X8Z24_UNORM:
186 case PIPE_FORMAT_S8X24_UINT:
187 case PIPE_FORMAT_S8_UINT_Z24_UNORM:
188 if (info->mask & PIPE_MASK_Z) mask |= 0xffffff00;
189 if (info->mask & PIPE_MASK_S) mask |= 0x000000ff;
190 break;
191 default:
192 mask = 0xffffffff;
193 break;
194 }
195 return mask;
196 }
197
198 #if NOUVEAU_DRIVER == 0xc0
199 # define nv50_format_table nvc0_format_table
200 #endif
201
202 /* return true for formats that can be converted among each other by NVC0_2D */
203 static inline bool
204 nv50_2d_dst_format_faithful(enum pipe_format format)
205 {
206 const uint64_t mask =
207 NV50_ENG2D_SUPPORTED_FORMATS &
208 ~NV50_ENG2D_NOCONVERT_FORMATS;
209 uint8_t id = nv50_format_table[format].rt;
210 return (id >= 0xc0) && (mask & (1ULL << (id - 0xc0)));
211 }
212 static inline bool
213 nv50_2d_src_format_faithful(enum pipe_format format)
214 {
215 const uint64_t mask =
216 NV50_ENG2D_SUPPORTED_FORMATS &
217 ~(NV50_ENG2D_LUMINANCE_FORMATS | NV50_ENG2D_INTENSITY_FORMATS);
218 uint8_t id = nv50_format_table[format].rt;
219 return (id >= 0xc0) && (mask & (1ULL << (id - 0xc0)));
220 }
221
222 static inline bool
223 nv50_2d_format_supported(enum pipe_format format)
224 {
225 uint8_t id = nv50_format_table[format].rt;
226 return (id >= 0xc0) &&
227 (NV50_ENG2D_SUPPORTED_FORMATS & (1ULL << (id - 0xc0)));
228 }
229
230 static inline bool
231 nv50_2d_dst_format_ops_supported(enum pipe_format format)
232 {
233 uint8_t id = nv50_format_table[format].rt;
234 return (id >= 0xc0) &&
235 (NV50_ENG2D_OPERATION_FORMATS & (1ULL << (id - 0xc0)));
236 }
237
238 #endif /* __NV50_BLIT_H__ */