static void i915_set_fragment_sampler_views(struct pipe_context *pipe, unsigned num, struct pipe_sampler_view **views) { struct i915_context *i915 = i915_context(pipe); uint i; assert(num <= PIPE_MAX_SAMPLERS); /* Check for no-op */ if (num == i915->num_fragment_sampler_views && !memcmp(i915->fragment_sampler_views, views, num * sizeof(struct pipe_sampler_view *))) return; for (i = 0; i < num; i++) { /* Note: we're using pipe_sampler_view_release() here to work around * a possible crash when the old view belongs to another context that * was already destroyed. */ pipe_sampler_view_release(pipe, &i915->fragment_sampler_views[i]); pipe_sampler_view_reference(&i915->fragment_sampler_views[i], views[i]); } for (i = num; i < i915->num_fragment_sampler_views; i++) pipe_sampler_view_release(pipe, &i915->fragment_sampler_views[i]); i915->num_fragment_sampler_views = num; i915->dirty |= I915_NEW_SAMPLER_VIEW; }
static void st_destroy_context_priv( struct st_context *st ) { uint shader, i; st_destroy_atoms( st ); st_destroy_draw( st ); st_destroy_generate_mipmap(st); st_destroy_clear(st); st_destroy_bitmap(st); st_destroy_drawpix(st); st_destroy_drawtex(st); for (shader = 0; shader < Elements(st->state.sampler_views); shader++) { for (i = 0; i < Elements(st->state.sampler_views[0]); i++) { pipe_sampler_view_release(st->pipe, &st->state.sampler_views[shader][i]); } } if (st->default_texture) { st->ctx->Driver.DeleteTexture(st->ctx, st->default_texture); st->default_texture = NULL; } u_upload_destroy(st->uploader); if (st->indexbuf_uploader) { u_upload_destroy(st->indexbuf_uploader); } if (st->constbuf_uploader) { u_upload_destroy(st->constbuf_uploader); } free( st ); }
static void llvmpipe_set_sampler_views(struct pipe_context *pipe, unsigned shader, unsigned start, unsigned num, struct pipe_sampler_view **views) { struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe); uint i; assert(num <= PIPE_MAX_SHADER_SAMPLER_VIEWS); assert(shader < PIPE_SHADER_TYPES); assert(start + num <= Elements(llvmpipe->sampler_views[shader])); draw_flush(llvmpipe->draw); /* set the new sampler views */ for (i = 0; i < num; i++) { /* Note: we're using pipe_sampler_view_release() here to work around * a possible crash when the old view belongs to another context that * was already destroyed. */ pipe_sampler_view_release(pipe, &llvmpipe->sampler_views[shader][start + i]); /* * Warn if someone tries to set a view created in a different context * (which is why we need the hack above in the first place). * An assert would be better but st/mesa relies on it... */ if (views[i] && views[i]->context != pipe) { debug_printf("Illegal setting of sampler_view %d created in another " "context\n", i); } pipe_sampler_view_reference(&llvmpipe->sampler_views[shader][start + i], views[i]); } /* find highest non-null sampler_views[] entry */ { unsigned j = MAX2(llvmpipe->num_sampler_views[shader], start + num); while (j > 0 && llvmpipe->sampler_views[shader][j - 1] == NULL) j--; llvmpipe->num_sampler_views[shader] = j; } if (shader == PIPE_SHADER_VERTEX || shader == PIPE_SHADER_GEOMETRY) { draw_set_sampler_views(llvmpipe->draw, shader, llvmpipe->sampler_views[shader], llvmpipe->num_sampler_views[shader]); } else { llvmpipe->dirty |= LP_NEW_SAMPLER_VIEW; } }
/** * Release all sampler views attached to the given texture object, regardless * of the context. */ void st_texture_release_all_sampler_views(struct st_context *st, struct st_texture_object *stObj) { GLuint i; /* XXX This should use sampler_views[i]->pipe, not st->pipe */ for (i = 0; i < stObj->num_sampler_views; ++i) pipe_sampler_view_release(st->pipe, &stObj->sampler_views[i]); }
/** called via ctx->Driver.DeleteTextureObject() */ static void st_DeleteTextureObject(struct gl_context *ctx, struct gl_texture_object *texObj) { struct st_context *st = st_context(ctx); struct st_texture_object *stObj = st_texture_object(texObj); if (stObj->pt) pipe_resource_reference(&stObj->pt, NULL); if (stObj->sampler_view) { pipe_sampler_view_release(st->pipe, &stObj->sampler_view); } _mesa_delete_texture_object(ctx, texObj); }
static void llvmpipe_set_sampler_views(struct pipe_context *pipe, unsigned shader, unsigned start, unsigned num, struct pipe_sampler_view **views) { struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe); uint i; assert(num <= PIPE_MAX_SHADER_SAMPLER_VIEWS); assert(shader < PIPE_SHADER_TYPES); assert(start + num <= Elements(llvmpipe->sampler_views[shader])); draw_flush(llvmpipe->draw); /* set the new sampler views */ for (i = 0; i < num; i++) { /* Note: we're using pipe_sampler_view_release() here to work around * a possible crash when the old view belongs to another context that * was already destroyed. */ pipe_sampler_view_release(pipe, &llvmpipe->sampler_views[shader][start + i]); pipe_sampler_view_reference(&llvmpipe->sampler_views[shader][start + i], views[i]); } /* find highest non-null sampler_views[] entry */ { unsigned j = MAX2(llvmpipe->num_sampler_views[shader], start + num); while (j > 0 && llvmpipe->sampler_views[shader][j - 1] == NULL) j--; llvmpipe->num_sampler_views[shader] = j; } if (shader == PIPE_SHADER_VERTEX || shader == PIPE_SHADER_GEOMETRY) { draw_set_sampler_views(llvmpipe->draw, shader, llvmpipe->sampler_views[shader], llvmpipe->num_sampler_views[shader]); } llvmpipe->dirty |= LP_NEW_SAMPLER_VIEW; }
/** * Called via ctx->Driver.AllocTextureImageBuffer(). * If the texture object/buffer already has space for the indicated image, * we're done. Otherwise, allocate memory for the new texture image. */ static GLboolean st_AllocTextureImageBuffer(struct gl_context *ctx, struct gl_texture_image *texImage) { struct st_context *st = st_context(ctx); struct st_texture_image *stImage = st_texture_image(texImage); struct st_texture_object *stObj = st_texture_object(texImage->TexObject); const GLuint level = texImage->Level; GLuint width = texImage->Width; GLuint height = texImage->Height; GLuint depth = texImage->Depth; DBG("%s\n", __FUNCTION__); assert(!stImage->TexData); assert(!stImage->pt); /* xxx this might be wrong */ /* Look if the parent texture object has space for this image */ if (stObj->pt && level <= stObj->pt->last_level && st_texture_match_image(stObj->pt, texImage)) { /* this image will fit in the existing texture object's memory */ pipe_resource_reference(&stImage->pt, stObj->pt); return GL_TRUE; } /* The parent texture object does not have space for this image */ pipe_resource_reference(&stObj->pt, NULL); pipe_sampler_view_release(st->pipe, &stObj->sampler_view); if (!guess_and_alloc_texture(st, stObj, stImage)) { /* Probably out of memory. * Try flushing any pending rendering, then retry. */ st_finish(st); if (!guess_and_alloc_texture(st, stObj, stImage)) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage"); return GL_FALSE; } } if (stObj->pt && st_texture_match_image(stObj->pt, texImage)) { /* The image will live in the object's mipmap memory */ pipe_resource_reference(&stImage->pt, stObj->pt); assert(stImage->pt); return GL_TRUE; } else { /* Create a new, temporary texture/resource/buffer to hold this * one texture image. Note that when we later access this image * (either for mapping or copying) we'll want to always specify * mipmap level=0, even if the image represents some other mipmap * level. */ enum pipe_format format = st_mesa_format_to_pipe_format(texImage->TexFormat); GLuint bindings = default_bindings(st, format); GLuint ptWidth, ptHeight, ptDepth, ptLayers; st_gl_texture_dims_to_pipe_dims(stObj->base.Target, width, height, depth, &ptWidth, &ptHeight, &ptDepth, &ptLayers); stImage->pt = st_texture_create(st, gl_target_to_pipe(stObj->base.Target), format, 0, /* lastLevel */ ptWidth, ptHeight, ptDepth, ptLayers, bindings); return stImage->pt != NULL; } }
/** * Called during state validation. When this function is finished, * the texture object should be ready for rendering. * \return GL_TRUE for success, GL_FALSE for failure (out of mem) */ GLboolean st_finalize_texture(struct gl_context *ctx, struct pipe_context *pipe, struct gl_texture_object *tObj) { struct st_context *st = st_context(ctx); struct st_texture_object *stObj = st_texture_object(tObj); const GLuint nr_faces = (stObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1; GLuint face; struct st_texture_image *firstImage; enum pipe_format firstImageFormat; GLuint ptWidth, ptHeight, ptDepth, ptLayers; if (_mesa_is_texture_complete(tObj, &tObj->Sampler)) { /* The texture is complete and we know exactly how many mipmap levels * are present/needed. This is conditional because we may be called * from the st_generate_mipmap() function when the texture object is * incomplete. In that case, we'll have set stObj->lastLevel before * we get here. */ if (stObj->base.Sampler.MinFilter == GL_LINEAR || stObj->base.Sampler.MinFilter == GL_NEAREST) stObj->lastLevel = stObj->base.BaseLevel; else stObj->lastLevel = stObj->base._MaxLevel; } firstImage = st_texture_image(stObj->base.Image[0][stObj->base.BaseLevel]); assert(firstImage); /* If both firstImage and stObj point to a texture which can contain * all active images, favour firstImage. Note that because of the * completeness requirement, we know that the image dimensions * will match. */ if (firstImage->pt && firstImage->pt != stObj->pt && (!stObj->pt || firstImage->pt->last_level >= stObj->pt->last_level)) { pipe_resource_reference(&stObj->pt, firstImage->pt); pipe_sampler_view_release(st->pipe, &stObj->sampler_view); } /* Find gallium format for the Mesa texture */ firstImageFormat = st_mesa_format_to_pipe_format(firstImage->base.TexFormat); /* Find size of level=0 Gallium mipmap image, plus number of texture layers */ { GLuint width, height, depth; if (!guess_base_level_size(stObj->base.Target, firstImage->base.Width2, firstImage->base.Height2, firstImage->base.Depth2, firstImage->base.Level, &width, &height, &depth)) { width = stObj->width0; height = stObj->height0; depth = stObj->depth0; } /* convert GL dims to Gallium dims */ st_gl_texture_dims_to_pipe_dims(stObj->base.Target, width, height, depth, &ptWidth, &ptHeight, &ptDepth, &ptLayers); } /* If we already have a gallium texture, check that it matches the texture * object's format, target, size, num_levels, etc. */ if (stObj->pt) { if (stObj->pt->target != gl_target_to_pipe(stObj->base.Target) || !st_sampler_compat_formats(stObj->pt->format, firstImageFormat) || stObj->pt->last_level < stObj->lastLevel || stObj->pt->width0 != ptWidth || stObj->pt->height0 != ptHeight || stObj->pt->depth0 != ptDepth || stObj->pt->array_size != ptLayers) { /* The gallium texture does not match the Mesa texture so delete the * gallium texture now. We'll make a new one below. */ pipe_resource_reference(&stObj->pt, NULL); pipe_sampler_view_release(st->pipe, &stObj->sampler_view); st->dirty.st |= ST_NEW_FRAMEBUFFER; } } /* May need to create a new gallium texture: */ if (!stObj->pt) { GLuint bindings = default_bindings(st, firstImageFormat); stObj->pt = st_texture_create(st, gl_target_to_pipe(stObj->base.Target), firstImageFormat, stObj->lastLevel, ptWidth, ptHeight, ptDepth, ptLayers, bindings); if (!stObj->pt) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage"); return GL_FALSE; } } /* Pull in any images not in the object's texture: */ for (face = 0; face < nr_faces; face++) { GLuint level; for (level = stObj->base.BaseLevel; level <= stObj->lastLevel; level++) { struct st_texture_image *stImage = st_texture_image(stObj->base.Image[face][level]); /* Need to import images in main memory or held in other textures. */ if (stImage && stObj->pt != stImage->pt) { if (level == 0 || (stImage->base.Width == u_minify(stObj->width0, level) && stImage->base.Height == u_minify(stObj->height0, level) && stImage->base.Depth == u_minify(stObj->depth0, level))) { /* src image fits expected dest mipmap level size */ copy_image_data_to_texture(st, stObj, level, stImage); } } } } return GL_TRUE; }
/** * glGetTexImage() helper: decompress a compressed texture by rendering * a textured quad. Store the results in the user's buffer. */ static void decompress_with_blit(struct gl_context * ctx, GLenum format, GLenum type, GLvoid *pixels, struct gl_texture_image *texImage) { struct st_context *st = st_context(ctx); struct pipe_context *pipe = st->pipe; struct st_texture_image *stImage = st_texture_image(texImage); struct st_texture_object *stObj = st_texture_object(texImage->TexObject); struct pipe_sampler_view *src_view; const GLuint width = texImage->Width; const GLuint height = texImage->Height; struct pipe_surface *dst_surface; struct pipe_resource *dst_texture; struct pipe_transfer *tex_xfer; unsigned bind = (PIPE_BIND_RENDER_TARGET | /* util_blit may choose to render */ PIPE_BIND_TRANSFER_READ); /* create temp / dest surface */ if (!util_create_rgba_surface(pipe, width, height, bind, &dst_texture, &dst_surface)) { _mesa_problem(ctx, "util_create_rgba_surface() failed " "in decompress_with_blit()"); return; } /* Disable conditional rendering. */ if (st->render_condition) { pipe->render_condition(pipe, NULL, 0); } /* Create sampler view that limits fetches to the source mipmap level */ { struct pipe_sampler_view sv_temp; u_sampler_view_default_template(&sv_temp, stObj->pt, stObj->pt->format); sv_temp.format = util_format_linear(sv_temp.format); sv_temp.u.tex.first_level = sv_temp.u.tex.last_level = texImage->Level; src_view = pipe->create_sampler_view(pipe, stObj->pt, &sv_temp); if (!src_view) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage"); return; } } /* blit/render/decompress */ util_blit_pixels_tex(st->blit, src_view, /* pipe_resource (src) */ 0, 0, /* src x0, y0 */ width, height, /* src x1, y1 */ dst_surface, /* pipe_surface (dst) */ 0, 0, /* dst x0, y0 */ width, height, /* dst x1, y1 */ 0.0, /* z */ PIPE_TEX_MIPFILTER_NEAREST); /* Restore conditional rendering state. */ if (st->render_condition) { pipe->render_condition(pipe, st->render_condition, st->condition_mode); } /* map the dst_surface so we can read from it */ tex_xfer = pipe_get_transfer(pipe, dst_texture, 0, 0, PIPE_TRANSFER_READ, 0, 0, width, height); pixels = _mesa_map_pbo_dest(ctx, &ctx->Pack, pixels); /* copy/pack data into user buffer */ if (_mesa_format_matches_format_and_type(stImage->base.TexFormat, format, type, ctx->Pack.SwapBytes)) { /* memcpy */ const uint bytesPerRow = width * util_format_get_blocksize(stImage->pt->format); ubyte *map = pipe_transfer_map(pipe, tex_xfer); GLuint row; for (row = 0; row < height; row++) { GLvoid *dest = _mesa_image_address2d(&ctx->Pack, pixels, width, height, format, type, row, 0); memcpy(dest, map, bytesPerRow); map += tex_xfer->stride; } pipe_transfer_unmap(pipe, tex_xfer); } else { /* format translation via floats */ GLuint row; enum pipe_format pformat = util_format_linear(dst_texture->format); GLfloat *rgba; rgba = (GLfloat *) malloc(width * 4 * sizeof(GLfloat)); if (!rgba) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage()"); goto end; } for (row = 0; row < height; row++) { const GLbitfield transferOps = 0x0; /* bypassed for glGetTexImage() */ GLvoid *dest = _mesa_image_address2d(&ctx->Pack, pixels, width, height, format, type, row, 0); if (ST_DEBUG & DEBUG_FALLBACK) debug_printf("%s: fallback format translation\n", __FUNCTION__); /* get float[4] rgba row from surface */ pipe_get_tile_rgba_format(pipe, tex_xfer, 0, row, width, 1, pformat, rgba); _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) rgba, format, type, dest, &ctx->Pack, transferOps); } free(rgba); } end: _mesa_unmap_pbo_dest(ctx, &ctx->Pack); pipe->transfer_destroy(pipe, tex_xfer); /* destroy the temp / dest surface */ util_destroy_rgba_surface(dst_texture, dst_surface); pipe_sampler_view_release(pipe, &src_view); }
/** * Define a vgpu10 sampler state. */ static void define_sampler_state_object(struct svga_context *svga, struct svga_sampler_state *ss, const struct pipe_sampler_state *ps) { uint8_t max_aniso = (uint8_t) 255; /* XXX fix me */ boolean anisotropic; uint8 compare_func; SVGA3dFilter filter; SVGA3dRGBAFloat bcolor; unsigned try; float min_lod, max_lod; assert(svga_have_vgpu10(svga)); anisotropic = ss->aniso_level > 1.0f; filter = translate_filter_mode(ps->min_mip_filter, ps->min_img_filter, ps->mag_img_filter, anisotropic, ss->compare_mode); compare_func = translate_comparison_func(ss->compare_func); COPY_4V(bcolor.value, ps->border_color.f); assert(ps->min_lod <= ps->max_lod); if (ps->min_mip_filter == PIPE_TEX_MIPFILTER_NONE) { /* just use the base level image */ min_lod = max_lod = 0.0f; } else { min_lod = ps->min_lod; max_lod = ps->max_lod; } /* If shadow comparisons are enabled, create two sampler states: one * with the given shadow compare mode, another with shadow comparison off. * We need the later because in some cases, we have to do the shadow * compare in the shader. So, we don't want to do it twice. */ STATIC_ASSERT(PIPE_TEX_COMPARE_NONE == 0); STATIC_ASSERT(PIPE_TEX_COMPARE_R_TO_TEXTURE == 1); ss->id[1] = SVGA3D_INVALID_ID; unsigned i; for (i = 0; i <= ss->compare_mode; i++) { ss->id[i] = util_bitmask_add(svga->sampler_object_id_bm); /* Loop in case command buffer is full and we need to flush and retry */ for (try = 0; try < 2; try++) { enum pipe_error ret = SVGA3D_vgpu10_DefineSamplerState(svga->swc, ss->id[i], filter, ss->addressu, ss->addressv, ss->addressw, ss->lod_bias, /* float */ max_aniso, compare_func, bcolor, min_lod, /* float */ max_lod); /* float */ if (ret == PIPE_OK) break; svga_context_flush(svga, NULL); } /* turn off the shadow compare option for second iteration */ filter &= ~SVGA3D_FILTER_COMPARE; } } static void * svga_create_sampler_state(struct pipe_context *pipe, const struct pipe_sampler_state *sampler) { struct svga_context *svga = svga_context(pipe); struct svga_sampler_state *cso = CALLOC_STRUCT( svga_sampler_state ); if (!cso) return NULL; cso->mipfilter = translate_mip_filter(sampler->min_mip_filter); cso->magfilter = translate_img_filter( sampler->mag_img_filter ); cso->minfilter = translate_img_filter( sampler->min_img_filter ); cso->aniso_level = MAX2( sampler->max_anisotropy, 1 ); if (sampler->max_anisotropy) cso->magfilter = cso->minfilter = SVGA3D_TEX_FILTER_ANISOTROPIC; cso->lod_bias = sampler->lod_bias; cso->addressu = translate_wrap_mode(sampler->wrap_s); cso->addressv = translate_wrap_mode(sampler->wrap_t); cso->addressw = translate_wrap_mode(sampler->wrap_r); cso->normalized_coords = sampler->normalized_coords; cso->compare_mode = sampler->compare_mode; cso->compare_func = sampler->compare_func; { uint32 r = float_to_ubyte(sampler->border_color.f[0]); uint32 g = float_to_ubyte(sampler->border_color.f[1]); uint32 b = float_to_ubyte(sampler->border_color.f[2]); uint32 a = float_to_ubyte(sampler->border_color.f[3]); cso->bordercolor = (a << 24) | (r << 16) | (g << 8) | b; } /* No SVGA3D support for: * - min/max LOD clamping */ cso->min_lod = 0; cso->view_min_lod = MAX2((int) (sampler->min_lod + 0.5), 0); cso->view_max_lod = MAX2((int) (sampler->max_lod + 0.5), 0); /* Use min_mipmap */ if (svga->debug.use_min_mipmap) { if (cso->view_min_lod == cso->view_max_lod) { cso->min_lod = cso->view_min_lod; cso->view_min_lod = 0; cso->view_max_lod = 1000; /* Just a high number */ cso->mipfilter = SVGA3D_TEX_FILTER_NONE; } } if (svga_have_vgpu10(svga)) { define_sampler_state_object(svga, cso, sampler); } SVGA_DBG(DEBUG_SAMPLERS, "New sampler: min %u, view(min %u, max %u) lod, mipfilter %s\n", cso->min_lod, cso->view_min_lod, cso->view_max_lod, cso->mipfilter == SVGA3D_TEX_FILTER_NONE ? "SVGA3D_TEX_FILTER_NONE" : "SOMETHING"); svga->hud.num_sampler_objects++; SVGA_STATS_COUNT_INC(svga_screen(svga->pipe.screen)->sws, SVGA_STATS_COUNT_SAMPLER); return cso; } static void svga_bind_sampler_states(struct pipe_context *pipe, enum pipe_shader_type shader, unsigned start, unsigned num, void **samplers) { struct svga_context *svga = svga_context(pipe); unsigned i; boolean any_change = FALSE; assert(shader < PIPE_SHADER_TYPES); assert(start + num <= PIPE_MAX_SAMPLERS); /* Pre-VGPU10 only supports FS textures */ if (!svga_have_vgpu10(svga) && shader != PIPE_SHADER_FRAGMENT) return; for (i = 0; i < num; i++) { if (svga->curr.sampler[shader][start + i] != samplers[i]) any_change = TRUE; svga->curr.sampler[shader][start + i] = samplers[i]; } if (!any_change) { return; } /* find highest non-null sampler[] entry */ { unsigned j = MAX2(svga->curr.num_samplers[shader], start + num); while (j > 0 && svga->curr.sampler[shader][j - 1] == NULL) j--; svga->curr.num_samplers[shader] = j; } svga->dirty |= SVGA_NEW_SAMPLER; } static void svga_delete_sampler_state(struct pipe_context *pipe, void *sampler) { struct svga_sampler_state *ss = (struct svga_sampler_state *) sampler; struct svga_context *svga = svga_context(pipe); if (svga_have_vgpu10(svga)) { unsigned i; for (i = 0; i < 2; i++) { enum pipe_error ret; if (ss->id[i] != SVGA3D_INVALID_ID) { svga_hwtnl_flush_retry(svga); ret = SVGA3D_vgpu10_DestroySamplerState(svga->swc, ss->id[i]); if (ret != PIPE_OK) { svga_context_flush(svga, NULL); ret = SVGA3D_vgpu10_DestroySamplerState(svga->swc, ss->id[i]); } util_bitmask_clear(svga->sampler_object_id_bm, ss->id[i]); } } } FREE(sampler); svga->hud.num_sampler_objects--; } static struct pipe_sampler_view * svga_create_sampler_view(struct pipe_context *pipe, struct pipe_resource *texture, const struct pipe_sampler_view *templ) { struct svga_context *svga = svga_context(pipe); struct svga_pipe_sampler_view *sv = CALLOC_STRUCT(svga_pipe_sampler_view); if (!sv) { return NULL; } sv->base = *templ; sv->base.reference.count = 1; sv->base.texture = NULL; pipe_resource_reference(&sv->base.texture, texture); sv->base.context = pipe; sv->id = SVGA3D_INVALID_ID; svga->hud.num_samplerview_objects++; SVGA_STATS_COUNT_INC(svga_screen(svga->pipe.screen)->sws, SVGA_STATS_COUNT_SAMPLERVIEW); return &sv->base; } static void svga_sampler_view_destroy(struct pipe_context *pipe, struct pipe_sampler_view *view) { struct svga_context *svga = svga_context(pipe); struct svga_pipe_sampler_view *sv = svga_pipe_sampler_view(view); if (svga_have_vgpu10(svga) && sv->id != SVGA3D_INVALID_ID) { if (view->context != pipe) { /* The SVGA3D device will generate an error (and on Linux, cause * us to abort) if we try to destroy a shader resource view from * a context other than the one it was created with. Skip the * SVGA3D_vgpu10_DestroyShaderResourceView() and leak the sampler * view for now. This should only sometimes happen when a shared * texture is deleted. */ _debug_printf("context mismatch in %s\n", __func__); } else { enum pipe_error ret; svga_hwtnl_flush_retry(svga); /* XXX is this needed? */ ret = SVGA3D_vgpu10_DestroyShaderResourceView(svga->swc, sv->id); if (ret != PIPE_OK) { svga_context_flush(svga, NULL); ret = SVGA3D_vgpu10_DestroyShaderResourceView(svga->swc, sv->id); } util_bitmask_clear(svga->sampler_view_id_bm, sv->id); } } pipe_resource_reference(&sv->base.texture, NULL); FREE(sv); svga->hud.num_samplerview_objects--; } static void svga_set_sampler_views(struct pipe_context *pipe, enum pipe_shader_type shader, unsigned start, unsigned num, struct pipe_sampler_view **views) { struct svga_context *svga = svga_context(pipe); unsigned flag_1d = 0; unsigned flag_srgb = 0; uint i; boolean any_change = FALSE; assert(shader < PIPE_SHADER_TYPES); assert(start + num <= ARRAY_SIZE(svga->curr.sampler_views[shader])); /* Pre-VGPU10 only supports FS textures */ if (!svga_have_vgpu10(svga) && shader != PIPE_SHADER_FRAGMENT) return; SVGA_STATS_TIME_PUSH(svga_sws(svga), SVGA_STATS_TIME_SETSAMPLERVIEWS); /* This bit of code works around a quirk in the CSO module. * If start=num=0 it means all sampler views should be released. * Note that the CSO module treats sampler views for fragment shaders * differently than other shader types. */ if (start == 0 && num == 0 && svga->curr.num_sampler_views[shader] > 0) { for (i = 0; i < svga->curr.num_sampler_views[shader]; i++) { pipe_sampler_view_release(pipe, &svga->curr.sampler_views[shader][i]); } any_change = TRUE; } for (i = 0; i < num; i++) { enum pipe_texture_target target; if (svga->curr.sampler_views[shader][start + i] != views[i]) { /* Note: we're using pipe_sampler_view_release() here to work around * a possible crash when the old view belongs to another context that * was already destroyed. */ pipe_sampler_view_release(pipe, &svga->curr.sampler_views[shader][start + i]); pipe_sampler_view_reference(&svga->curr.sampler_views[shader][start + i], views[i]); any_change = TRUE; } if (!views[i]) continue; if (util_format_is_srgb(views[i]->format)) flag_srgb |= 1 << (start + i); target = views[i]->target; if (target == PIPE_TEXTURE_1D) { flag_1d |= 1 << (start + i); } else if (target == PIPE_TEXTURE_RECT) { /* If the size of the bound texture changes, we need to emit new * const buffer values. */ svga->dirty |= SVGA_NEW_TEXTURE_CONSTS; } else if (target == PIPE_BUFFER) { /* If the size of the bound buffer changes, we need to emit new * const buffer values. */ svga->dirty |= SVGA_NEW_TEXTURE_CONSTS; } } if (!any_change) { goto done; } /* find highest non-null sampler_views[] entry */ { unsigned j = MAX2(svga->curr.num_sampler_views[shader], start + num); while (j > 0 && svga->curr.sampler_views[shader][j - 1] == NULL) j--; svga->curr.num_sampler_views[shader] = j; } svga->dirty |= SVGA_NEW_TEXTURE_BINDING; if (flag_srgb != svga->curr.tex_flags.flag_srgb || flag_1d != svga->curr.tex_flags.flag_1d) { svga->dirty |= SVGA_NEW_TEXTURE_FLAGS; svga->curr.tex_flags.flag_1d = flag_1d; svga->curr.tex_flags.flag_srgb = flag_srgb; } /* Check if any of the sampler view resources collide with the framebuffer * color buffers or depth stencil resource. If so, set the NEW_FRAME_BUFFER * dirty bit so that emit_framebuffer can be invoked to create backed view * for the conflicted surface view. */ if (svga_check_sampler_framebuffer_resource_collision(svga, shader)) { svga->dirty |= SVGA_NEW_FRAME_BUFFER; } done: SVGA_STATS_TIME_POP(svga_sws(svga)); } /** * Clean up sampler, sampler view state at context destruction time */ void svga_cleanup_sampler_state(struct svga_context *svga) { enum pipe_shader_type shader; for (shader = 0; shader <= PIPE_SHADER_GEOMETRY; shader++) { unsigned i; for (i = 0; i < svga->state.hw_draw.num_sampler_views[shader]; i++) { pipe_sampler_view_release(&svga->pipe, &svga->state.hw_draw.sampler_views[shader][i]); } } /* free polygon stipple state */ if (svga->polygon_stipple.sampler) { svga->pipe.delete_sampler_state(&svga->pipe, svga->polygon_stipple.sampler); } if (svga->polygon_stipple.sampler_view) { svga->pipe.sampler_view_destroy(&svga->pipe, &svga->polygon_stipple.sampler_view->base); } pipe_resource_reference(&svga->polygon_stipple.texture, NULL); } void svga_init_sampler_functions( struct svga_context *svga ) { svga->pipe.create_sampler_state = svga_create_sampler_state; svga->pipe.bind_sampler_states = svga_bind_sampler_states; svga->pipe.delete_sampler_state = svga_delete_sampler_state; svga->pipe.set_sampler_views = svga_set_sampler_views; svga->pipe.create_sampler_view = svga_create_sampler_view; svga->pipe.sampler_view_destroy = svga_sampler_view_destroy; }