• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /**************************************************************************
2  *
3  * Copyright 2007 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  /*
29   * Authors:
30   *   Keith Whitwell <keithw@vmware.com>
31   *   Brian Paul
32   */
33 
34 
35 #include "main/context.h"
36 #include "main/macros.h"
37 #include "main/mtypes.h"
38 #include "main/samplerobj.h"
39 #include "main/teximage.h"
40 #include "main/texobj.h"
41 #include "program/prog_instruction.h"
42 
43 #include "st_context.h"
44 #include "st_atom.h"
45 #include "st_sampler_view.h"
46 #include "st_texture.h"
47 #include "st_format.h"
48 #include "st_cb_texture.h"
49 #include "pipe/p_context.h"
50 #include "util/u_format.h"
51 #include "util/u_inlines.h"
52 #include "cso_cache/cso_context.h"
53 
54 
55 /**
56  * Get a pipe_sampler_view object from a texture unit.
57  */
58 void
st_update_single_texture(struct st_context * st,struct pipe_sampler_view ** sampler_view,GLuint texUnit,bool glsl130_or_later,bool ignore_srgb_decode)59 st_update_single_texture(struct st_context *st,
60                          struct pipe_sampler_view **sampler_view,
61                          GLuint texUnit, bool glsl130_or_later,
62                          bool ignore_srgb_decode)
63 {
64    struct gl_context *ctx = st->ctx;
65    const struct gl_sampler_object *samp;
66    struct gl_texture_object *texObj;
67    struct st_texture_object *stObj;
68 
69    samp = _mesa_get_samplerobj(ctx, texUnit);
70 
71    texObj = ctx->Texture.Unit[texUnit]._Current;
72    assert(texObj);
73 
74    stObj = st_texture_object(texObj);
75 
76    if (unlikely(texObj->Target == GL_TEXTURE_BUFFER)) {
77       *sampler_view = st_get_buffer_sampler_view_from_stobj(st, stObj);
78       return;
79    }
80 
81    if (!st_finalize_texture(ctx, st->pipe, texObj, 0) ||
82        !stObj->pt) {
83       /* out of mem */
84       *sampler_view = NULL;
85       return;
86    }
87 
88    if (texObj->TargetIndex == TEXTURE_EXTERNAL_INDEX &&
89        stObj->pt->screen->resource_changed)
90          stObj->pt->screen->resource_changed(stObj->pt->screen, stObj->pt);
91 
92    *sampler_view =
93       st_get_texture_sampler_view_from_stobj(st, stObj, samp,
94                                              glsl130_or_later,
95                                              ignore_srgb_decode);
96 }
97 
98 
99 
100 static void
update_textures(struct st_context * st,enum pipe_shader_type shader_stage,const struct gl_program * prog,struct pipe_sampler_view ** sampler_views,unsigned * out_num_textures)101 update_textures(struct st_context *st,
102                 enum pipe_shader_type shader_stage,
103                 const struct gl_program *prog,
104                 struct pipe_sampler_view **sampler_views,
105                 unsigned *out_num_textures)
106 {
107    const GLuint old_max = *out_num_textures;
108    GLbitfield samplers_used = prog->SamplersUsed;
109    GLbitfield texel_fetch_samplers = prog->info.textures_used_by_txf;
110    GLbitfield free_slots = ~prog->SamplersUsed;
111    GLbitfield external_samplers_used = prog->ExternalSamplersUsed;
112    GLuint unit;
113 
114    if (samplers_used == 0x0 && old_max == 0)
115       return;
116 
117    unsigned num_textures = 0;
118 
119    /* prog->sh.data is NULL if it's ARB_fragment_program */
120    bool glsl130 = (prog->sh.data ? prog->sh.data->Version : 0) >= 130;
121 
122    /* loop over sampler units (aka tex image units) */
123    for (unit = 0; samplers_used || unit < old_max;
124         unit++, samplers_used >>= 1, texel_fetch_samplers >>= 1) {
125       struct pipe_sampler_view *sampler_view = NULL;
126 
127       if (samplers_used & 1) {
128          const GLuint texUnit = prog->SamplerUnits[unit];
129 
130          /* The EXT_texture_sRGB_decode extension says:
131           *
132           *    "The conversion of sRGB color space components to linear color
133           *     space is always performed if the texel lookup function is one
134           *     of the texelFetch builtin functions.
135           *
136           *     Otherwise, if the texel lookup function is one of the texture
137           *     builtin functions or one of the texture gather functions, the
138           *     conversion of sRGB color space components to linear color space
139           *     is controlled by the TEXTURE_SRGB_DECODE_EXT parameter.
140           *
141           *     If the TEXTURE_SRGB_DECODE_EXT parameter is DECODE_EXT, the
142           *     conversion of sRGB color space components to linear color space
143           *     is performed.
144           *
145           *     If the TEXTURE_SRGB_DECODE_EXT parameter is SKIP_DECODE_EXT,
146           *     the value is returned without decoding. However, if the texture
147           *     is also [statically] accessed with a texelFetch function, then
148           *     the result of texture builtin functions and/or texture gather
149           *     functions may be returned with decoding or without decoding."
150           *
151           * Note: the "statically" will be added to the language per
152           *       https://cvs.khronos.org/bugzilla/show_bug.cgi?id=14934
153           *
154           * So we simply ignore the setting entirely for samplers that are
155           * (statically) accessed with a texelFetch function.
156           */
157          st_update_single_texture(st, &sampler_view, texUnit, glsl130,
158                                   texel_fetch_samplers & 1);
159          num_textures = unit + 1;
160       }
161 
162       pipe_sampler_view_reference(&(sampler_views[unit]), sampler_view);
163    }
164 
165    /* For any external samplers with multiplaner YUV, stuff the additional
166     * sampler views we need at the end.
167     *
168     * Trying to cache the sampler view in the stObj looks painful, so just
169     * re-create the sampler view for the extra planes each time.  Main use
170     * case is video playback (ie. fps games wouldn't be using this) so I
171     * guess no point to try to optimize this feature.
172     */
173    while (unlikely(external_samplers_used)) {
174       GLuint unit = u_bit_scan(&external_samplers_used);
175       GLuint extra = 0;
176       struct st_texture_object *stObj =
177             st_get_texture_object(st->ctx, prog, unit);
178       struct pipe_sampler_view tmpl;
179 
180       if (!stObj)
181          continue;
182 
183       /* use original view as template: */
184       tmpl = *sampler_views[unit];
185 
186       switch (st_get_view_format(stObj)) {
187       case PIPE_FORMAT_NV12:
188          /* we need one additional R8G8 view: */
189          tmpl.format = PIPE_FORMAT_RG88_UNORM;
190          tmpl.swizzle_g = PIPE_SWIZZLE_Y;   /* tmpl from Y plane is R8 */
191          extra = u_bit_scan(&free_slots);
192          sampler_views[extra] =
193                st->pipe->create_sampler_view(st->pipe, stObj->pt->next, &tmpl);
194          break;
195       case PIPE_FORMAT_IYUV:
196          /* we need two additional R8 views: */
197          tmpl.format = PIPE_FORMAT_R8_UNORM;
198          extra = u_bit_scan(&free_slots);
199          sampler_views[extra] =
200                st->pipe->create_sampler_view(st->pipe, stObj->pt->next, &tmpl);
201          extra = u_bit_scan(&free_slots);
202          sampler_views[extra] =
203                st->pipe->create_sampler_view(st->pipe, stObj->pt->next->next, &tmpl);
204          break;
205       default:
206          break;
207       }
208 
209       num_textures = MAX2(num_textures, extra + 1);
210    }
211 
212    cso_set_sampler_views(st->cso_context,
213                          shader_stage,
214                          num_textures,
215                          sampler_views);
216    *out_num_textures = num_textures;
217 }
218 
219 
220 
221 void
st_update_vertex_textures(struct st_context * st)222 st_update_vertex_textures(struct st_context *st)
223 {
224    const struct gl_context *ctx = st->ctx;
225 
226    if (ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits > 0) {
227       update_textures(st,
228                       PIPE_SHADER_VERTEX,
229                       ctx->VertexProgram._Current,
230                       st->state.sampler_views[PIPE_SHADER_VERTEX],
231                       &st->state.num_sampler_views[PIPE_SHADER_VERTEX]);
232    }
233 }
234 
235 
236 void
st_update_fragment_textures(struct st_context * st)237 st_update_fragment_textures(struct st_context *st)
238 {
239    const struct gl_context *ctx = st->ctx;
240 
241    update_textures(st,
242                    PIPE_SHADER_FRAGMENT,
243                    ctx->FragmentProgram._Current,
244                    st->state.sampler_views[PIPE_SHADER_FRAGMENT],
245                    &st->state.num_sampler_views[PIPE_SHADER_FRAGMENT]);
246 }
247 
248 
249 void
st_update_geometry_textures(struct st_context * st)250 st_update_geometry_textures(struct st_context *st)
251 {
252    const struct gl_context *ctx = st->ctx;
253 
254    if (ctx->GeometryProgram._Current) {
255       update_textures(st,
256                       PIPE_SHADER_GEOMETRY,
257                       ctx->GeometryProgram._Current,
258                       st->state.sampler_views[PIPE_SHADER_GEOMETRY],
259                       &st->state.num_sampler_views[PIPE_SHADER_GEOMETRY]);
260    }
261 }
262 
263 
264 void
st_update_tessctrl_textures(struct st_context * st)265 st_update_tessctrl_textures(struct st_context *st)
266 {
267    const struct gl_context *ctx = st->ctx;
268 
269    if (ctx->TessCtrlProgram._Current) {
270       update_textures(st,
271                       PIPE_SHADER_TESS_CTRL,
272                       ctx->TessCtrlProgram._Current,
273                       st->state.sampler_views[PIPE_SHADER_TESS_CTRL],
274                       &st->state.num_sampler_views[PIPE_SHADER_TESS_CTRL]);
275    }
276 }
277 
278 
279 void
st_update_tesseval_textures(struct st_context * st)280 st_update_tesseval_textures(struct st_context *st)
281 {
282    const struct gl_context *ctx = st->ctx;
283 
284    if (ctx->TessEvalProgram._Current) {
285       update_textures(st,
286                       PIPE_SHADER_TESS_EVAL,
287                       ctx->TessEvalProgram._Current,
288                       st->state.sampler_views[PIPE_SHADER_TESS_EVAL],
289                       &st->state.num_sampler_views[PIPE_SHADER_TESS_EVAL]);
290    }
291 }
292 
293 
294 void
st_update_compute_textures(struct st_context * st)295 st_update_compute_textures(struct st_context *st)
296 {
297    const struct gl_context *ctx = st->ctx;
298 
299    if (ctx->ComputeProgram._Current) {
300       update_textures(st,
301                       PIPE_SHADER_COMPUTE,
302                       ctx->ComputeProgram._Current,
303                       st->state.sampler_views[PIPE_SHADER_COMPUTE],
304                       &st->state.num_sampler_views[PIPE_SHADER_COMPUTE]);
305    }
306 }
307