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 #include "main/imports.h"
29 #include "main/accum.h"
30 #include "main/api_exec.h"
31 #include "main/context.h"
32 #include "main/samplerobj.h"
33 #include "main/shaderobj.h"
34 #include "main/version.h"
35 #include "main/vtxfmt.h"
36 #include "main/hash.h"
37 #include "program/prog_cache.h"
38 #include "vbo/vbo.h"
39 #include "glapi/glapi.h"
40 #include "st_context.h"
41 #include "st_debug.h"
42 #include "st_cb_bitmap.h"
43 #include "st_cb_blit.h"
44 #include "st_cb_bufferobjects.h"
45 #include "st_cb_clear.h"
46 #include "st_cb_compute.h"
47 #include "st_cb_condrender.h"
48 #include "st_cb_copyimage.h"
49 #include "st_cb_drawpixels.h"
50 #include "st_cb_rasterpos.h"
51 #include "st_cb_drawtex.h"
52 #include "st_cb_eglimage.h"
53 #include "st_cb_fbo.h"
54 #include "st_cb_feedback.h"
55 #include "st_cb_msaa.h"
56 #include "st_cb_perfmon.h"
57 #include "st_cb_program.h"
58 #include "st_cb_queryobj.h"
59 #include "st_cb_readpixels.h"
60 #include "st_cb_texture.h"
61 #include "st_cb_xformfb.h"
62 #include "st_cb_flush.h"
63 #include "st_cb_syncobj.h"
64 #include "st_cb_strings.h"
65 #include "st_cb_texturebarrier.h"
66 #include "st_cb_viewport.h"
67 #include "st_atom.h"
68 #include "st_draw.h"
69 #include "st_extensions.h"
70 #include "st_gen_mipmap.h"
71 #include "st_pbo.h"
72 #include "st_program.h"
73 #include "st_sampler_view.h"
74 #include "st_vdpau.h"
75 #include "st_texture.h"
76 #include "pipe/p_context.h"
77 #include "util/u_inlines.h"
78 #include "util/u_upload_mgr.h"
79 #include "cso_cache/cso_context.h"
80
81
82 DEBUG_GET_ONCE_BOOL_OPTION(mesa_mvp_dp4, "MESA_MVP_DP4", FALSE)
83
84
85 /**
86 * Called via ctx->Driver.Enable()
87 */
st_Enable(struct gl_context * ctx,GLenum cap,GLboolean state)88 static void st_Enable(struct gl_context * ctx, GLenum cap, GLboolean state)
89 {
90 struct st_context *st = st_context(ctx);
91
92 switch (cap) {
93 case GL_DEBUG_OUTPUT:
94 case GL_DEBUG_OUTPUT_SYNCHRONOUS:
95 st_update_debug_callback(st);
96 break;
97 default:
98 break;
99 }
100 }
101
102
103 /**
104 * Called via ctx->Driver.QueryMemoryInfo()
105 */
106 static void
st_query_memory_info(struct gl_context * ctx,struct gl_memory_info * out)107 st_query_memory_info(struct gl_context *ctx, struct gl_memory_info *out)
108 {
109 struct pipe_screen *screen = st_context(ctx)->pipe->screen;
110 struct pipe_memory_info info;
111
112 assert(screen->query_memory_info);
113 if (!screen->query_memory_info)
114 return;
115
116 screen->query_memory_info(screen, &info);
117
118 out->total_device_memory = info.total_device_memory;
119 out->avail_device_memory = info.avail_device_memory;
120 out->total_staging_memory = info.total_staging_memory;
121 out->avail_staging_memory = info.avail_staging_memory;
122 out->device_memory_evicted = info.device_memory_evicted;
123 out->nr_device_memory_evictions = info.nr_device_memory_evictions;
124 }
125
126
127 uint64_t
st_get_active_states(struct gl_context * ctx)128 st_get_active_states(struct gl_context *ctx)
129 {
130 struct st_vertex_program *vp =
131 st_vertex_program(ctx->VertexProgram._Current);
132 struct st_tessctrl_program *tcp =
133 st_tessctrl_program(ctx->TessCtrlProgram._Current);
134 struct st_tesseval_program *tep =
135 st_tesseval_program(ctx->TessEvalProgram._Current);
136 struct st_geometry_program *gp =
137 st_geometry_program(ctx->GeometryProgram._Current);
138 struct st_fragment_program *fp =
139 st_fragment_program(ctx->FragmentProgram._Current);
140 struct st_compute_program *cp =
141 st_compute_program(ctx->ComputeProgram._Current);
142 uint64_t active_shader_states = 0;
143
144 if (vp)
145 active_shader_states |= vp->affected_states;
146 if (tcp)
147 active_shader_states |= tcp->affected_states;
148 if (tep)
149 active_shader_states |= tep->affected_states;
150 if (gp)
151 active_shader_states |= gp->affected_states;
152 if (fp)
153 active_shader_states |= fp->affected_states;
154 if (cp)
155 active_shader_states |= cp->affected_states;
156
157 /* Mark non-shader-resource shader states as "always active". */
158 return active_shader_states | ~ST_ALL_SHADER_RESOURCES;
159 }
160
161
162 /**
163 * Called via ctx->Driver.UpdateState()
164 */
st_invalidate_state(struct gl_context * ctx,GLbitfield new_state)165 void st_invalidate_state(struct gl_context * ctx, GLbitfield new_state)
166 {
167 struct st_context *st = st_context(ctx);
168
169 if (new_state & _NEW_BUFFERS) {
170 st->dirty |= ST_NEW_BLEND |
171 ST_NEW_DSA |
172 ST_NEW_FB_STATE |
173 ST_NEW_SAMPLE_MASK |
174 ST_NEW_SAMPLE_SHADING |
175 ST_NEW_FS_STATE |
176 ST_NEW_POLY_STIPPLE |
177 ST_NEW_VIEWPORT |
178 ST_NEW_RASTERIZER |
179 ST_NEW_SCISSOR |
180 ST_NEW_WINDOW_RECTANGLES;
181 } else {
182 /* These set a subset of flags set by _NEW_BUFFERS, so we only have to
183 * check them when _NEW_BUFFERS isn't set.
184 */
185 if (new_state & (_NEW_DEPTH |
186 _NEW_STENCIL))
187 st->dirty |= ST_NEW_DSA;
188
189 if (new_state & _NEW_PROGRAM)
190 st->dirty |= ST_NEW_RASTERIZER;
191
192 if (new_state & _NEW_SCISSOR)
193 st->dirty |= ST_NEW_RASTERIZER |
194 ST_NEW_SCISSOR |
195 ST_NEW_WINDOW_RECTANGLES;
196
197 if (new_state & _NEW_FOG)
198 st->dirty |= ST_NEW_FS_STATE;
199
200 if (new_state & _NEW_POLYGONSTIPPLE)
201 st->dirty |= ST_NEW_POLY_STIPPLE;
202
203 if (new_state & _NEW_VIEWPORT)
204 st->dirty |= ST_NEW_VIEWPORT;
205
206 if (new_state & _NEW_FRAG_CLAMP) {
207 if (st->clamp_frag_color_in_shader)
208 st->dirty |= ST_NEW_FS_STATE;
209 else
210 st->dirty |= ST_NEW_RASTERIZER;
211 }
212 }
213
214 if (new_state & _NEW_MULTISAMPLE) {
215 st->dirty |= ST_NEW_BLEND |
216 ST_NEW_SAMPLE_MASK |
217 ST_NEW_SAMPLE_SHADING |
218 ST_NEW_RASTERIZER |
219 ST_NEW_FS_STATE;
220 } else {
221 /* These set a subset of flags set by _NEW_MULTISAMPLE, so we only
222 * have to check them when _NEW_MULTISAMPLE isn't set.
223 */
224 if (new_state & (_NEW_LIGHT |
225 _NEW_LINE |
226 _NEW_POINT |
227 _NEW_POLYGON |
228 _NEW_TRANSFORM))
229 st->dirty |= ST_NEW_RASTERIZER;
230 }
231
232 if (new_state & (_NEW_PROJECTION |
233 _NEW_TRANSFORM) &&
234 st_user_clip_planes_enabled(ctx))
235 st->dirty |= ST_NEW_CLIP_STATE;
236
237 if (new_state & _NEW_COLOR)
238 st->dirty |= ST_NEW_BLEND |
239 ST_NEW_DSA;
240
241 if (new_state & _NEW_PIXEL)
242 st->dirty |= ST_NEW_PIXEL_TRANSFER;
243
244 if (new_state & _NEW_CURRENT_ATTRIB)
245 st->dirty |= ST_NEW_VERTEX_ARRAYS;
246
247 /* Update the vertex shader if ctx->Light._ClampVertexColor was changed. */
248 if (st->clamp_vert_color_in_shader && (new_state & _NEW_LIGHT))
249 st->dirty |= ST_NEW_VS_STATE;
250
251 /* Which shaders are dirty will be determined manually. */
252 if (new_state & _NEW_PROGRAM) {
253 st->gfx_shaders_may_be_dirty = true;
254 st->compute_shader_may_be_dirty = true;
255 /* This will mask out unused shader resources. */
256 st->active_states = st_get_active_states(ctx);
257 }
258
259 if (new_state & _NEW_TEXTURE) {
260 st->dirty |= st->active_states &
261 (ST_NEW_SAMPLER_VIEWS |
262 ST_NEW_SAMPLERS |
263 ST_NEW_IMAGE_UNITS);
264 if (ctx->FragmentProgram._Current &&
265 ctx->FragmentProgram._Current->ExternalSamplersUsed) {
266 st->dirty |= ST_NEW_FS_STATE;
267 }
268 }
269
270 if (new_state & _NEW_PROGRAM_CONSTANTS)
271 st->dirty |= st->active_states & ST_NEW_CONSTANTS;
272
273 /* This is the only core Mesa module we depend upon.
274 * No longer use swrast, swsetup, tnl.
275 */
276 _vbo_InvalidateState(ctx, new_state);
277 }
278
279
280 static void
st_destroy_context_priv(struct st_context * st,bool destroy_pipe)281 st_destroy_context_priv(struct st_context *st, bool destroy_pipe)
282 {
283 uint shader, i;
284
285 st_destroy_atoms( st );
286 st_destroy_draw( st );
287 st_destroy_clear(st);
288 st_destroy_bitmap(st);
289 st_destroy_drawpix(st);
290 st_destroy_drawtex(st);
291 st_destroy_perfmon(st);
292 st_destroy_pbo_helpers(st);
293
294 for (shader = 0; shader < ARRAY_SIZE(st->state.sampler_views); shader++) {
295 for (i = 0; i < ARRAY_SIZE(st->state.sampler_views[0]); i++) {
296 pipe_sampler_view_release(st->pipe,
297 &st->state.sampler_views[shader][i]);
298 }
299 }
300
301 u_upload_destroy(st->uploader);
302 if (st->indexbuf_uploader) {
303 u_upload_destroy(st->indexbuf_uploader);
304 }
305 if (st->constbuf_uploader) {
306 u_upload_destroy(st->constbuf_uploader);
307 }
308
309 /* free glDrawPixels cache data */
310 free(st->drawpix_cache.image);
311 pipe_resource_reference(&st->drawpix_cache.texture, NULL);
312
313 /* free glReadPixels cache data */
314 st_invalidate_readpix_cache(st);
315
316 cso_destroy_context(st->cso_context);
317
318 if (st->pipe && destroy_pipe)
319 st->pipe->destroy(st->pipe);
320
321 free( st );
322 }
323
324
325 static struct st_context *
st_create_context_priv(struct gl_context * ctx,struct pipe_context * pipe,const struct st_config_options * options)326 st_create_context_priv( struct gl_context *ctx, struct pipe_context *pipe,
327 const struct st_config_options *options)
328 {
329 struct pipe_screen *screen = pipe->screen;
330 uint i;
331 struct st_context *st = ST_CALLOC_STRUCT( st_context );
332
333 st->options = *options;
334
335 ctx->st = st;
336
337 st->ctx = ctx;
338 st->pipe = pipe;
339
340 /* XXX: this is one-off, per-screen init: */
341 st_debug_init();
342
343 /* state tracker needs the VBO module */
344 _vbo_CreateContext(ctx);
345
346 st->dirty = ST_ALL_STATES_MASK;
347
348 /* Create upload manager for vertex data for glBitmap, glDrawPixels,
349 * glClear, etc.
350 */
351 st->uploader = u_upload_create(pipe, 65536, PIPE_BIND_VERTEX_BUFFER,
352 PIPE_USAGE_STREAM);
353
354 if (!screen->get_param(screen, PIPE_CAP_USER_INDEX_BUFFERS)) {
355 st->indexbuf_uploader = u_upload_create(pipe, 128 * 1024,
356 PIPE_BIND_INDEX_BUFFER,
357 PIPE_USAGE_STREAM);
358 }
359
360 if (!screen->get_param(screen, PIPE_CAP_USER_CONSTANT_BUFFERS))
361 st->constbuf_uploader = u_upload_create(pipe, 128 * 1024,
362 PIPE_BIND_CONSTANT_BUFFER,
363 PIPE_USAGE_STREAM);
364
365 st->cso_context = cso_create_context(pipe);
366
367 st_init_atoms( st );
368 st_init_clear(st);
369 st_init_draw( st );
370 st_init_pbo_helpers(st);
371
372 /* Choose texture target for glDrawPixels, glBitmap, renderbuffers */
373 if (pipe->screen->get_param(pipe->screen, PIPE_CAP_NPOT_TEXTURES))
374 st->internal_target = PIPE_TEXTURE_2D;
375 else
376 st->internal_target = PIPE_TEXTURE_RECT;
377
378 /* Setup vertex element info for 'struct st_util_vertex'.
379 */
380 {
381 const unsigned slot = cso_get_aux_vertex_buffer_slot(st->cso_context);
382
383 /* If this assertion ever fails all state tracker calls to
384 * cso_get_aux_vertex_buffer_slot() should be audited. This
385 * particular call would have to be moved to just before each
386 * drawing call.
387 */
388 assert(slot == 0);
389
390 STATIC_ASSERT(sizeof(struct st_util_vertex) == 9 * sizeof(float));
391
392 memset(&st->util_velems, 0, sizeof(st->util_velems));
393 st->util_velems[0].src_offset = 0;
394 st->util_velems[0].vertex_buffer_index = slot;
395 st->util_velems[0].src_format = PIPE_FORMAT_R32G32B32_FLOAT;
396 st->util_velems[1].src_offset = 3 * sizeof(float);
397 st->util_velems[1].vertex_buffer_index = slot;
398 st->util_velems[1].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
399 st->util_velems[2].src_offset = 7 * sizeof(float);
400 st->util_velems[2].vertex_buffer_index = slot;
401 st->util_velems[2].src_format = PIPE_FORMAT_R32G32_FLOAT;
402 }
403
404 /* we want all vertex data to be placed in buffer objects */
405 vbo_use_buffer_objects(ctx);
406
407
408 /* make sure that no VBOs are left mapped when we're drawing. */
409 vbo_always_unmap_buffers(ctx);
410
411 /* Need these flags:
412 */
413 ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
414
415 ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
416
417 st->has_stencil_export =
418 screen->get_param(screen, PIPE_CAP_SHADER_STENCIL_EXPORT);
419 st->has_shader_model3 = screen->get_param(screen, PIPE_CAP_SM3);
420 st->has_etc1 = screen->is_format_supported(screen, PIPE_FORMAT_ETC1_RGB8,
421 PIPE_TEXTURE_2D, 0,
422 PIPE_BIND_SAMPLER_VIEW);
423 st->has_etc2 = screen->is_format_supported(screen, PIPE_FORMAT_ETC2_RGB8,
424 PIPE_TEXTURE_2D, 0,
425 PIPE_BIND_SAMPLER_VIEW);
426 st->prefer_blit_based_texture_transfer = screen->get_param(screen,
427 PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER);
428 st->force_persample_in_shader =
429 screen->get_param(screen, PIPE_CAP_SAMPLE_SHADING) &&
430 !screen->get_param(screen, PIPE_CAP_FORCE_PERSAMPLE_INTERP);
431 st->has_shareable_shaders = screen->get_param(screen,
432 PIPE_CAP_SHAREABLE_SHADERS);
433 st->needs_texcoord_semantic =
434 screen->get_param(screen, PIPE_CAP_TGSI_TEXCOORD);
435 st->apply_texture_swizzle_to_border_color =
436 !!(screen->get_param(screen, PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK) &
437 (PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_NV50 |
438 PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_R600));
439 st->has_time_elapsed =
440 screen->get_param(screen, PIPE_CAP_QUERY_TIME_ELAPSED);
441 st->has_half_float_packing =
442 screen->get_param(screen, PIPE_CAP_TGSI_PACK_HALF_FLOAT);
443 st->has_multi_draw_indirect =
444 screen->get_param(screen, PIPE_CAP_MULTI_DRAW_INDIRECT);
445
446 /* GL limits and extensions */
447 st_init_limits(pipe->screen, &ctx->Const, &ctx->Extensions);
448 st_init_extensions(pipe->screen, &ctx->Const,
449 &ctx->Extensions, &st->options, ctx->Mesa_DXTn);
450
451 if (st_have_perfmon(st)) {
452 ctx->Extensions.AMD_performance_monitor = GL_TRUE;
453 }
454
455 /* Enable shader-based fallbacks for ARB_color_buffer_float if needed. */
456 if (screen->get_param(screen, PIPE_CAP_VERTEX_COLOR_UNCLAMPED)) {
457 if (!screen->get_param(screen, PIPE_CAP_VERTEX_COLOR_CLAMPED)) {
458 st->clamp_vert_color_in_shader = GL_TRUE;
459 }
460
461 if (!screen->get_param(screen, PIPE_CAP_FRAGMENT_COLOR_CLAMPED)) {
462 st->clamp_frag_color_in_shader = GL_TRUE;
463 }
464
465 /* For drivers which cannot do color clamping, it's better to just
466 * disable ARB_color_buffer_float in the core profile, because
467 * the clamping is deprecated there anyway. */
468 if (ctx->API == API_OPENGL_CORE &&
469 (st->clamp_frag_color_in_shader || st->clamp_vert_color_in_shader)) {
470 st->clamp_vert_color_in_shader = GL_FALSE;
471 st->clamp_frag_color_in_shader = GL_FALSE;
472 ctx->Extensions.ARB_color_buffer_float = GL_FALSE;
473 }
474 }
475
476 /* called after _mesa_create_context/_mesa_init_point, fix default user
477 * settable max point size up
478 */
479 ctx->Point.MaxSize = MAX2(ctx->Const.MaxPointSize,
480 ctx->Const.MaxPointSizeAA);
481 /* For vertex shaders, make sure not to emit saturate when SM 3.0 is not supported */
482 ctx->Const.ShaderCompilerOptions[MESA_SHADER_VERTEX].EmitNoSat = !st->has_shader_model3;
483
484 if (!ctx->Extensions.ARB_gpu_shader5) {
485 for (i = 0; i < MESA_SHADER_STAGES; i++)
486 ctx->Const.ShaderCompilerOptions[i].EmitNoIndirectSampler = true;
487 }
488
489 /* Set which shader types can be compiled at link time. */
490 st->shader_has_one_variant[MESA_SHADER_VERTEX] =
491 st->has_shareable_shaders &&
492 !st->clamp_vert_color_in_shader;
493
494 st->shader_has_one_variant[MESA_SHADER_FRAGMENT] =
495 st->has_shareable_shaders &&
496 !st->clamp_frag_color_in_shader &&
497 !st->force_persample_in_shader;
498
499 st->shader_has_one_variant[MESA_SHADER_TESS_CTRL] = st->has_shareable_shaders;
500 st->shader_has_one_variant[MESA_SHADER_TESS_EVAL] = st->has_shareable_shaders;
501 st->shader_has_one_variant[MESA_SHADER_GEOMETRY] = st->has_shareable_shaders;
502 st->shader_has_one_variant[MESA_SHADER_COMPUTE] = st->has_shareable_shaders;
503
504 _mesa_compute_version(ctx);
505
506 if (ctx->Version == 0) {
507 /* This can happen when a core profile was requested, but the driver
508 * does not support some features of GL 3.1 or later.
509 */
510 st_destroy_context_priv(st, false);
511 return NULL;
512 }
513
514 _mesa_initialize_dispatch_tables(ctx);
515 _mesa_initialize_vbo_vtxfmt(ctx);
516
517 return st;
518 }
519
st_init_driver_flags(struct gl_driver_flags * f)520 static void st_init_driver_flags(struct gl_driver_flags *f)
521 {
522 f->NewArray = ST_NEW_VERTEX_ARRAYS;
523 f->NewRasterizerDiscard = ST_NEW_RASTERIZER;
524 f->NewUniformBuffer = ST_NEW_UNIFORM_BUFFER;
525 f->NewDefaultTessLevels = ST_NEW_TESS_STATE;
526 f->NewTextureBuffer = ST_NEW_SAMPLER_VIEWS;
527 f->NewAtomicBuffer = ST_NEW_ATOMIC_BUFFER;
528 f->NewShaderStorageBuffer = ST_NEW_STORAGE_BUFFER;
529 f->NewImageUnits = ST_NEW_IMAGE_UNITS;
530 }
531
st_create_context(gl_api api,struct pipe_context * pipe,const struct gl_config * visual,struct st_context * share,const struct st_config_options * options)532 struct st_context *st_create_context(gl_api api, struct pipe_context *pipe,
533 const struct gl_config *visual,
534 struct st_context *share,
535 const struct st_config_options *options)
536 {
537 struct gl_context *ctx;
538 struct gl_context *shareCtx = share ? share->ctx : NULL;
539 struct dd_function_table funcs;
540 struct st_context *st;
541
542 memset(&funcs, 0, sizeof(funcs));
543 st_init_driver_functions(pipe->screen, &funcs);
544
545 ctx = calloc(1, sizeof(struct gl_context));
546 if (!ctx)
547 return NULL;
548
549 if (!_mesa_initialize_context(ctx, api, visual, shareCtx, &funcs)) {
550 free(ctx);
551 return NULL;
552 }
553
554 st_init_driver_flags(&ctx->DriverFlags);
555
556 /* XXX: need a capability bit in gallium to query if the pipe
557 * driver prefers DP4 or MUL/MAD for vertex transformation.
558 */
559 if (debug_get_option_mesa_mvp_dp4())
560 ctx->Const.ShaderCompilerOptions[MESA_SHADER_VERTEX].OptimizeForAOS = GL_TRUE;
561
562 st = st_create_context_priv(ctx, pipe, options);
563 if (!st) {
564 _mesa_destroy_context(ctx);
565 }
566
567 return st;
568 }
569
570
571 /**
572 * Callback to release the sampler view attached to a texture object.
573 * Called by _mesa_HashWalk().
574 */
575 static void
destroy_tex_sampler_cb(GLuint id,void * data,void * userData)576 destroy_tex_sampler_cb(GLuint id, void *data, void *userData)
577 {
578 struct gl_texture_object *texObj = (struct gl_texture_object *) data;
579 struct st_context *st = (struct st_context *) userData;
580
581 st_texture_release_sampler_view(st, st_texture_object(texObj));
582 }
583
st_destroy_context(struct st_context * st)584 void st_destroy_context( struct st_context *st )
585 {
586 struct gl_context *ctx = st->ctx;
587 GLuint i;
588
589 _mesa_HashWalk(ctx->Shared->TexObjects, destroy_tex_sampler_cb, st);
590
591 st_reference_fragprog(st, &st->fp, NULL);
592 st_reference_geomprog(st, &st->gp, NULL);
593 st_reference_vertprog(st, &st->vp, NULL);
594 st_reference_tesscprog(st, &st->tcp, NULL);
595 st_reference_tesseprog(st, &st->tep, NULL);
596 st_reference_compprog(st, &st->cp, NULL);
597
598 /* release framebuffer surfaces */
599 for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {
600 pipe_surface_reference(&st->state.framebuffer.cbufs[i], NULL);
601 }
602 pipe_surface_reference(&st->state.framebuffer.zsbuf, NULL);
603 pipe_sampler_view_reference(&st->pixel_xfer.pixelmap_sampler_view, NULL);
604 pipe_resource_reference(&st->pixel_xfer.pixelmap_texture, NULL);
605
606 _vbo_DestroyContext(ctx);
607
608 st_destroy_program_variants(st);
609
610 _mesa_free_context_data(ctx);
611
612 /* This will free the st_context too, so 'st' must not be accessed
613 * afterwards. */
614 st_destroy_context_priv(st, true);
615 st = NULL;
616
617 free(ctx);
618 }
619
620 static void
st_emit_string_marker(struct gl_context * ctx,const GLchar * string,GLsizei len)621 st_emit_string_marker(struct gl_context *ctx, const GLchar *string, GLsizei len)
622 {
623 struct st_context *st = ctx->st;
624 st->pipe->emit_string_marker(st->pipe, string, len);
625 }
626
st_init_driver_functions(struct pipe_screen * screen,struct dd_function_table * functions)627 void st_init_driver_functions(struct pipe_screen *screen,
628 struct dd_function_table *functions)
629 {
630 _mesa_init_shader_object_functions(functions);
631 _mesa_init_sampler_object_functions(functions);
632
633 st_init_blit_functions(functions);
634 st_init_bufferobject_functions(screen, functions);
635 st_init_clear_functions(functions);
636 st_init_bitmap_functions(functions);
637 st_init_copy_image_functions(functions);
638 st_init_drawpixels_functions(functions);
639 st_init_rasterpos_functions(functions);
640
641 st_init_drawtex_functions(functions);
642
643 st_init_eglimage_functions(functions);
644
645 st_init_fbo_functions(functions);
646 st_init_feedback_functions(functions);
647 st_init_msaa_functions(functions);
648 st_init_perfmon_functions(functions);
649 st_init_program_functions(functions);
650 st_init_query_functions(functions);
651 st_init_cond_render_functions(functions);
652 st_init_readpixels_functions(functions);
653 st_init_texture_functions(functions);
654 st_init_texture_barrier_functions(functions);
655 st_init_flush_functions(screen, functions);
656 st_init_string_functions(functions);
657 st_init_viewport_functions(functions);
658 st_init_compute_functions(functions);
659
660 st_init_xformfb_functions(functions);
661 st_init_syncobj_functions(functions);
662
663 st_init_vdpau_functions(functions);
664
665 if (screen->get_param(screen, PIPE_CAP_STRING_MARKER))
666 functions->EmitStringMarker = st_emit_string_marker;
667
668 functions->Enable = st_Enable;
669 functions->UpdateState = st_invalidate_state;
670 functions->QueryMemoryInfo = st_query_memory_info;
671 }
672