/** * This helper function returns TRUE if the specified resource collides with * any of the resources bound to any of the currently bound sampler views. */ boolean svga_check_sampler_view_resource_collision(const struct svga_context *svga, const struct svga_winsys_surface *res, enum pipe_shader_type shader) { struct pipe_screen *screen = svga->pipe.screen; unsigned i; if (svga_screen(screen)->debug.no_surface_view) { return FALSE; } for (i = 0; i < svga->curr.num_sampler_views[shader]; i++) { struct svga_pipe_sampler_view *sv = svga_pipe_sampler_view(svga->curr.sampler_views[shader][i]); if (sv && res == svga_resource_handle(sv->base.texture)) { return TRUE; } } return FALSE; }
static enum pipe_error validate_sampler_resources(struct svga_context *svga) { unsigned shader; assert(svga_have_vgpu10(svga)); for (shader = PIPE_SHADER_VERTEX; shader <= PIPE_SHADER_GEOMETRY; shader++) { unsigned count = svga->curr.num_sampler_views[shader]; unsigned i; struct svga_winsys_surface *surfaces[PIPE_MAX_SAMPLERS]; enum pipe_error ret; /* * Reference bound sampler resources to ensure pending updates are * noticed by the device. */ for (i = 0; i < count; i++) { struct svga_pipe_sampler_view *sv = svga_pipe_sampler_view(svga->curr.sampler_views[shader][i]); if (sv) { if (sv->base.texture->target == PIPE_BUFFER) { surfaces[i] = svga_buffer_handle(svga, sv->base.texture); } else { surfaces[i] = svga_texture(sv->base.texture)->handle; } } else { surfaces[i] = NULL; } } if (shader == PIPE_SHADER_FRAGMENT && svga->curr.rast->templ.poly_stipple_enable) { const unsigned unit = svga->state.hw_draw.fs->pstipple_sampler_unit; struct svga_pipe_sampler_view *sv = svga->polygon_stipple.sampler_view; assert(sv); surfaces[unit] = svga_texture(sv->base.texture)->handle; count = MAX2(count, unit+1); } /* rebind the shader resources if needed */ if (svga->rebind.flags.texture_samplers) { for (i = 0; i < count; i++) { if (surfaces[i]) { ret = svga->swc->resource_rebind(svga->swc, surfaces[i], NULL, SVGA_RELOC_READ); if (ret != PIPE_OK) return ret; } } } } svga->rebind.flags.texture_samplers = FALSE; return PIPE_OK; }
static enum pipe_error update_sampler_resources(struct svga_context *svga, unsigned dirty) { enum pipe_error ret = PIPE_OK; enum pipe_shader_type shader; if (!svga_have_vgpu10(svga)) return PIPE_OK; for (shader = PIPE_SHADER_VERTEX; shader <= PIPE_SHADER_GEOMETRY; shader++) { SVGA3dShaderResourceViewId ids[PIPE_MAX_SAMPLERS]; struct svga_winsys_surface *surfaces[PIPE_MAX_SAMPLERS]; struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS]; unsigned count; unsigned nviews; unsigned i; count = svga->curr.num_sampler_views[shader]; for (i = 0; i < count; i++) { struct svga_pipe_sampler_view *sv = svga_pipe_sampler_view(svga->curr.sampler_views[shader][i]); if (sv) { surfaces[i] = svga_resource_handle(sv->base.texture); ret = svga_validate_pipe_sampler_view(svga, sv); if (ret != PIPE_OK) return ret; assert(sv->id != SVGA3D_INVALID_ID); ids[i] = sv->id; sampler_views[i] = &sv->base; } else { surfaces[i] = NULL; ids[i] = SVGA3D_INVALID_ID; sampler_views[i] = NULL; } } for (; i < svga->state.hw_draw.num_sampler_views[shader]; i++) { ids[i] = SVGA3D_INVALID_ID; surfaces[i] = NULL; sampler_views[i] = NULL; } /* Number of ShaderResources that need to be modified. This includes * the one that need to be unbound. */ nviews = MAX2(svga->state.hw_draw.num_sampler_views[shader], count); if (nviews > 0) { if (count != svga->state.hw_draw.num_sampler_views[shader] || memcmp(sampler_views, svga->state.hw_draw.sampler_views[shader], count * sizeof(sampler_views[0])) != 0) { SVGA3dShaderResourceViewId *pIds = ids; struct svga_winsys_surface **pSurf = surfaces; unsigned numSR = 0; /* Loop through the sampler view list to only emit * the sampler views that are not already in the * corresponding entries in the device's * shader resource list. */ for (i = 0; i < nviews; i++) { boolean emit; emit = sampler_views[i] == svga->state.hw_draw.sampler_views[shader][i]; if (!emit && i == nviews-1) { /* Include the last sampler view in the next emit * if it is different. */ emit = TRUE; numSR++; i++; } if (emit) { /* numSR can only be 0 if the first entry of the list * is the same as the one in the device list. * In this case, * there is nothing to send yet. */ if (numSR) { ret = SVGA3D_vgpu10_SetShaderResources( svga->swc, svga_shader_type(shader), i - numSR, /* startView */ numSR, pIds, pSurf); if (ret != PIPE_OK) return ret; } pIds += (numSR + 1); pSurf += (numSR + 1); numSR = 0; } else numSR++; } /* Save referenced sampler views in the hw draw state. */ svga->state.hw_draw.num_sampler_views[shader] = count; for (i = 0; i < nviews; i++) { pipe_sampler_view_reference( &svga->state.hw_draw.sampler_views[shader][i], sampler_views[i]); } } } } /* Handle polygon stipple sampler view */ if (svga->curr.rast->templ.poly_stipple_enable) { const unsigned unit = svga->state.hw_draw.fs->pstipple_sampler_unit; struct svga_pipe_sampler_view *sv = svga->polygon_stipple.sampler_view; struct svga_winsys_surface *surface; assert(sv); if (!sv) { return PIPE_OK; /* probably out of memory */ } ret = svga_validate_pipe_sampler_view(svga, sv); if (ret != PIPE_OK) return ret; surface = svga_resource_handle(sv->base.texture); ret = SVGA3D_vgpu10_SetShaderResources( svga->swc, svga_shader_type(PIPE_SHADER_FRAGMENT), unit, /* startView */ 1, &sv->id, &surface); } return ret; }
/** * 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; }