fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-01-21 13:00:22 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

egl,gallium,gbm,mesa: replace get_param with pipe_caps access

Browse source 
Use command:
  find . -path "./.git" -prune -o -type f -exec sed -i ':a;N;$!ba;s/->get_param([^,]*,[[:space:]]*PIPE_CAP_\([^)]*\))/->caps.\L\1/g' {} +

And some manual adjustment.

Reviewed-by: Marek Olšák <marek.olsak@amd.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/32955>
This commit is contained in:
Qiang Yu 2025-01-08 11:34:28 +08:00 • committed by Marge Bot
parent b2caa48ec9
commit ef0b6f8262
76 changed files with 397 additions and 455 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
src/egl/drivers/haiku/egl_haiku.cpp
View file

@ -359,8 +359,7 @@ haiku_initialize_impl(_EGLDisplay *disp, void *platformDisplay)
/* Report back to EGL the bitmask of priorities supported */
disp->Extensions.IMG_context_priority =
hgl_dpy->disp->fscreen->screen->get_param(hgl_dpy->disp->fscreen->screen,
PIPE_CAP_CONTEXT_PRIORITY_MASK);
hgl_dpy->disp->fscreen->screen->caps.context_priority_mask;
disp->Extensions.NV_context_priority_realtime =
disp->Extensions.IMG_context_priority &
(1 << __EGL_CONTEXT_PRIORITY_REALTIME_BIT);

3
src/egl/drivers/wgl/egl_wgl.c
View file

@ -269,8 +269,7 @@ wgl_initialize_impl(_EGLDisplay *disp, HDC hdc)
disp->Extensions.MESA_query_driver = EGL_TRUE;
/* Report back to EGL the bitmask of priorities supported */
disp->Extensions.IMG_context_priority = wgl_dpy->screen->get_param(
wgl_dpy->screen, PIPE_CAP_CONTEXT_PRIORITY_MASK);
disp->Extensions.IMG_context_priority = wgl_dpy->screen->caps.context_priority_mask;
disp->Extensions.NV_context_priority_realtime =
disp->Extensions.IMG_context_priority &
(1 << __EGL_CONTEXT_PRIORITY_REALTIME_BIT);

6
src/gallium/auxiliary/cso_cache/cso_context.c
View file

@ -334,13 +334,11 @@ cso_create_context(struct pipe_context *pipe, unsigned flags)
PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0) {
ctx->has_task_mesh_shader = true;
}
if (pipe->screen->get_param(pipe->screen,
PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS) != 0) {
if (pipe->screen->caps.max_stream_output_buffers != 0) {
ctx->has_streamout = true;
}
if (pipe->screen->get_param(pipe->screen,
PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK) &
if (pipe->screen->caps.texture_border_color_quirk &
PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_FREEDRENO)
ctx->sampler_format = true;

4
src/gallium/auxiliary/draw/draw_context.c
View file

@ -163,8 +163,8 @@ draw_init(struct draw_context *draw)
if (!draw_gs_init(draw))
return false;
draw->quads_always_flatshade_last = !draw->pipe->screen->get_param(
draw->pipe->screen, PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION);
draw->quads_always_flatshade_last =
!draw->pipe->screen->caps.quads_follow_provoking_vertex_convention;
draw->floating_point_depth = false;

2
src/gallium/auxiliary/draw/draw_pipe_pstipple.c
View file

@ -133,7 +133,7 @@ generate_pstip_fs(struct pstip_stage *pstip)
struct pipe_shader_state pstip_fs;
enum tgsi_file_type wincoord_file;
wincoord_file = screen->get_param(screen, PIPE_CAP_FS_POSITION_IS_SYSVAL) ?
wincoord_file = screen->caps.fs_position_is_sysval ?
TGSI_FILE_SYSTEM_VALUE : TGSI_FILE_INPUT;
pstip_fs = *orig_fs; /* copy to init */

2
src/gallium/auxiliary/draw/draw_pipe_wide_point.c
View file

@ -328,7 +328,7 @@ struct draw_stage *draw_wide_point_stage(struct draw_context *draw)
goto fail;
wide->sprite_coord_semantic =
draw->pipe->screen->get_param(draw->pipe->screen, PIPE_CAP_TGSI_TEXCOORD)
draw->pipe->screen->caps.tgsi_texcoord
?
TGSI_SEMANTIC_TEXCOORD : TGSI_SEMANTIC_GENERIC;

6
src/gallium/auxiliary/hud/hud_context.c
View file

@ -1208,19 +1208,19 @@ read_pane_settings(char *str, unsigned * const x, unsigned * const y,
static bool
has_occlusion_query(struct pipe_screen *screen)
{
return screen->get_param(screen, PIPE_CAP_OCCLUSION_QUERY) != 0;
return screen->caps.occlusion_query != 0;
}
static bool
has_streamout(struct pipe_screen *screen)
{
return screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS) != 0;
return screen->caps.max_stream_output_buffers != 0;
}
static bool
has_pipeline_stats_query(struct pipe_screen *screen)
{
return screen->get_param(screen, PIPE_CAP_QUERY_PIPELINE_STATISTICS) != 0;
return screen->caps.query_pipeline_statistics != 0;
}
static void

15
src/gallium/auxiliary/nir/nir_to_tgsi.c
View file

@ -2839,8 +2839,7 @@ ntt_emit_texture(struct ntt_compile *c, nir_tex_instr *instr)
}
if (instr->op == nir_texop_tg4 && target != TGSI_TEXTURE_SHADOWCUBE_ARRAY) {
if (c->screen->get_param(c->screen,
PIPE_CAP_TGSI_TG4_COMPONENT_IN_SWIZZLE)) {
if (c->screen->caps.tgsi_tg4_component_in_swizzle) {
sampler = ureg_scalar(sampler, instr->component);
s.srcs[s.i++] = ureg_src_undef();
} else {
@ -3684,7 +3683,7 @@ ntt_fix_nir_options(struct pipe_screen *screen, struct nir_shader *s,
PIPE_SHADER_CAP_TGSI_SQRT_SUPPORTED);
bool force_indirect_unrolling_sampler =
screen->get_param(screen, PIPE_CAP_GLSL_FEATURE_LEVEL) < 400;
screen->caps.glsl_feature_level < 400;
nir_variable_mode no_indirects_mask = ntt_no_indirects_mask(s, screen);
@ -3931,7 +3930,7 @@ const void *nir_to_tgsi_options(struct nir_shader *s,
if (!original_options->lower_uniforms_to_ubo) {
NIR_PASS_V(s, nir_lower_uniforms_to_ubo,
screen->get_param(screen, PIPE_CAP_PACKED_UNIFORMS),
screen->caps.packed_uniforms,
!native_integers);
}
@ -3942,7 +3941,7 @@ const void *nir_to_tgsi_options(struct nir_shader *s,
NIR_PASS_V(s, nir_lower_alu_to_scalar, scalarize_64bit, NULL);
NIR_PASS_V(s, nir_to_tgsi_lower_64bit_to_vec2);
if (!screen->get_param(screen, PIPE_CAP_LOAD_CONSTBUF))
if (!screen->caps.load_constbuf)
NIR_PASS_V(s, nir_lower_ubo_vec4);
ntt_optimize_nir(s, screen, options);
@ -4007,15 +4006,15 @@ const void *nir_to_tgsi_options(struct nir_shader *s,
c->options = options;
c->needs_texcoord_semantic =
screen->get_param(screen, PIPE_CAP_TGSI_TEXCOORD);
screen->caps.tgsi_texcoord;
c->has_txf_lz =
screen->get_param(screen, PIPE_CAP_TGSI_TEX_TXF_LZ);
screen->caps.tgsi_tex_txf_lz;
c->s = s;
c->native_integers = native_integers;
c->ureg = ureg_create(pipe_shader_type_from_mesa(s->info.stage));
ureg_setup_shader_info(c->ureg, &s->info);
if (s->info.use_legacy_math_rules && screen->get_param(screen, PIPE_CAP_LEGACY_MATH_RULES))
if (s->info.use_legacy_math_rules && screen->caps.legacy_math_rules)
ureg_property(c->ureg, TGSI_PROPERTY_LEGACY_MATH_RULES, 1);
if (s->info.stage == MESA_SHADER_FRAGMENT) {

12
src/gallium/auxiliary/nir/tgsi_to_nir.c
View file

@ -2211,13 +2211,13 @@ static void
ttn_read_pipe_caps(struct ttn_compile *c,
struct pipe_screen *screen)
{
c->cap_samplers_as_deref = screen->get_param(screen, PIPE_CAP_NIR_SAMPLERS_AS_DEREF);
c->cap_face_is_sysval = screen->get_param(screen, PIPE_CAP_FS_FACE_IS_INTEGER_SYSVAL);
c->cap_position_is_sysval = screen->get_param(screen, PIPE_CAP_FS_POSITION_IS_SYSVAL);
c->cap_point_is_sysval = screen->get_param(screen, PIPE_CAP_FS_POINT_IS_SYSVAL);
c->cap_samplers_as_deref = screen->caps.nir_samplers_as_deref;
c->cap_face_is_sysval = screen->caps.fs_face_is_integer_sysval;
c->cap_position_is_sysval = screen->caps.fs_position_is_sysval;
c->cap_point_is_sysval = screen->caps.fs_point_is_sysval;
c->cap_integers = screen->get_shader_param(screen, c->scan->processor, PIPE_SHADER_CAP_INTEGERS);
c->cap_tg4_component_in_swizzle =
screen->get_param(screen, PIPE_CAP_TGSI_TG4_COMPONENT_IN_SWIZZLE);
screen->caps.tgsi_tg4_component_in_swizzle;
}
#define BITSET_SET32(bitset, u32_mask) do { \
@ -2532,7 +2532,7 @@ ttn_finalize_nir(struct ttn_compile *c, struct pipe_screen *screen)
NIR_PASS_V(nir, nir_lower_system_values);
NIR_PASS_V(nir, nir_lower_compute_system_values, NULL);
if (!screen->get_param(screen, PIPE_CAP_TEXRECT)) {
if (!screen->caps.texrect) {
const struct nir_lower_tex_options opts = { .lower_rect = true, };
NIR_PASS_V(nir, nir_lower_tex, &opts);
}

34
src/gallium/auxiliary/util/u_blitter.c
View file

@ -201,26 +201,18 @@ struct blitter_context *util_blitter_create(struct pipe_context *pipe)
pipe->screen->get_shader_param(pipe->screen, PIPE_SHADER_TESS_CTRL,
PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0;
ctx->has_stream_out =
pipe->screen->get_param(pipe->screen,
PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS) != 0;
ctx->has_stream_out = pipe->screen->caps.max_stream_output_buffers != 0;
ctx->has_stencil_export =
pipe->screen->get_param(pipe->screen,
PIPE_CAP_SHADER_STENCIL_EXPORT);
ctx->has_stencil_export = pipe->screen->caps.shader_stencil_export;
ctx->has_texture_multisample =
pipe->screen->get_param(pipe->screen, PIPE_CAP_TEXTURE_MULTISAMPLE);
pipe->screen->caps.texture_multisample;
ctx->has_tex_lz = pipe->screen->get_param(pipe->screen,
PIPE_CAP_TGSI_TEX_TXF_LZ);
ctx->has_txf_txq = pipe->screen->get_param(pipe->screen,
PIPE_CAP_GLSL_FEATURE_LEVEL) >= 130;
ctx->has_sample_shading = pipe->screen->get_param(pipe->screen,
PIPE_CAP_SAMPLE_SHADING);
ctx->cube_as_2darray = pipe->screen->get_param(pipe->screen,
PIPE_CAP_SAMPLER_VIEW_TARGET);
ctx->has_texrect = pipe->screen->get_param(pipe->screen, PIPE_CAP_TEXRECT);
ctx->has_tex_lz = pipe->screen->caps.tgsi_tex_txf_lz;
ctx->has_txf_txq = pipe->screen->caps.glsl_feature_level >= 130;
ctx->has_sample_shading = pipe->screen->caps.sample_shading;
ctx->cube_as_2darray = pipe->screen->caps.sampler_view_target;
ctx->has_texrect = pipe->screen->caps.texrect;
/* blend state objects */
memset(&blend, 0, sizeof(blend));
@ -344,8 +336,8 @@ struct blitter_context *util_blitter_create(struct pipe_context *pipe)
}
ctx->has_layered =
pipe->screen->get_param(pipe->screen, PIPE_CAP_VS_INSTANCEID) &&
pipe->screen->get_param(pipe->screen, PIPE_CAP_VS_LAYER_VIEWPORT);
pipe->screen->caps.vs_instanceid &&
pipe->screen->caps.vs_layer_viewport;
/* set invariant vertex coordinates */
for (i = 0; i < 4; i++) {
@ -1273,10 +1265,8 @@ void util_blitter_cache_all_shaders(struct blitter_context *blitter)
bool has_arraytex, has_cubearraytex;
max_samples = ctx->has_texture_multisample ? 2 : 1;
has_arraytex = screen->get_param(screen,
PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS) != 0;
has_cubearraytex = screen->get_param(screen,
PIPE_CAP_CUBE_MAP_ARRAY) != 0;
has_arraytex = screen->caps.max_texture_array_layers != 0;
has_cubearraytex = screen->caps.cube_map_array;
/* It only matters if i <= 1 or > 1. */
for (samples = 1; samples <= max_samples; samples++) {

7
src/gallium/auxiliary/util/u_inlines.h
View file

@ -363,7 +363,7 @@ pipe_buffer_create_const0(struct pipe_screen *screen,
buffer.format = PIPE_FORMAT_R8_UNORM;
buffer.bind = bind;
buffer.usage = usage;
buffer.flags = screen->get_param(screen, PIPE_CAP_CONSTBUF0_FLAGS);
buffer.flags = screen->caps.constbuf0_flags;
buffer.width0 = size;
buffer.height0 = 1;
buffer.depth0 = 1;
@ -907,10 +907,9 @@ pipe_create_multimedia_context(struct pipe_screen *screen, bool compute_only)
{
unsigned flags = 0;
if (!screen->get_param(screen, PIPE_CAP_GRAPHICS) &&
!screen->get_param(screen, PIPE_CAP_COMPUTE))
if (!screen->caps.graphics && !screen->caps.compute)
flags |= PIPE_CONTEXT_MEDIA_ONLY;
else if (compute_only || !screen->get_param(screen, PIPE_CAP_GRAPHICS))
else if (compute_only || !screen->caps.graphics)
flags |= PIPE_CONTEXT_COMPUTE_ONLY;
return screen->context_create(screen, NULL, flags);

2
src/gallium/auxiliary/util/u_screen.c
View file

@ -531,7 +531,7 @@ u_pipe_screen_get_param_defaults(struct pipe_screen *pscreen,
* >0: on GPU, enable by default, user can disable it manually
* <0: unknown, disable by default, user can enable it manually
*/
int accel = pscreen->get_param(pscreen, PIPE_CAP_ACCELERATED);
int accel = pscreen->caps.accelerated;
return !!accel && debug_get_bool_option("MESA_HW_ACCEL_SELECT", accel > 0) &&
/* internal geometry shader need indirect array access */

4
src/gallium/auxiliary/util/u_surface.c
View file

@ -700,8 +700,8 @@ u_default_clear_texture(struct pipe_context *pipe,
bool cleared = false;
assert(data != NULL);
bool has_layers = screen->get_param(screen, PIPE_CAP_VS_INSTANCEID) &&
screen->get_param(screen, PIPE_CAP_VS_LAYER_VIEWPORT);
bool has_layers = screen->caps.vs_instanceid &&
screen->caps.vs_layer_viewport;
if (has_layers) {
cleared = util_clear_texture_as_surface(pipe, tex, level,

11
src/gallium/auxiliary/util/u_tests.c
View file

@ -324,8 +324,7 @@ tgsi_vs_window_space_position(struct pipe_context *ctx)
bool pass = true;
static const float red[] = {1, 0, 0, 1};
if (!ctx->screen->get_param(ctx->screen,
PIPE_CAP_VS_WINDOW_SPACE_POSITION)) {
if (!ctx->screen->caps.vs_window_space_position) {
util_report_result(SKIP);
return;
}
@ -385,7 +384,7 @@ null_sampler_view(struct pipe_context *ctx, unsigned tgsi_tex_target)
unsigned num_expected = tgsi_tex_target == TGSI_TEXTURE_BUFFER ? 1 : 2;
if (tgsi_tex_target == TGSI_TEXTURE_BUFFER &&
!ctx->screen->get_param(ctx->screen, PIPE_CAP_TEXTURE_BUFFER_OBJECTS)) {
!ctx->screen->caps.texture_buffer_objects) {
util_report_result_helper(SKIP, "%s: %s", __func__,
tgsi_texture_names[tgsi_tex_target]);
return;
@ -534,7 +533,7 @@ test_sync_file_fences(struct pipe_context *ctx)
bool pass = true;
enum pipe_fd_type fd_type = PIPE_FD_TYPE_NATIVE_SYNC;
if (!screen->get_param(screen, PIPE_CAP_NATIVE_FENCE_FD))
if (!screen->caps.native_fence_fd)
return;
struct cso_context *cso = cso_create_context(ctx, 0);
@ -638,12 +637,12 @@ test_texture_barrier(struct pipe_context *ctx, bool use_fbfetch,
snprintf(name, sizeof(name), "%s: %s, %u samples", __func__,
use_fbfetch ? "FBFETCH" : "sampler", MAX2(num_samples, 1));
if (!ctx->screen->get_param(ctx->screen, PIPE_CAP_TEXTURE_BARRIER)) {
if (!ctx->screen->caps.texture_barrier) {
util_report_result_helper(SKIP, name);
return;
}
if (use_fbfetch &&
!ctx->screen->get_param(ctx->screen, PIPE_CAP_FBFETCH)) {
!ctx->screen->caps.fbfetch) {
util_report_result_helper(SKIP, name);
return;
}

4
src/gallium/auxiliary/util/u_threaded_context.c
View file

@ -5228,9 +5228,9 @@ threaded_context_create(struct pipe_context *pipe,
tc->pipe = pipe;
tc->replace_buffer_storage = replace_buffer;
tc->map_buffer_alignment =
pipe->screen->get_param(pipe->screen, PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT);
pipe->screen->caps.min_map_buffer_alignment;
tc->ubo_alignment =
MAX2(pipe->screen->get_param(pipe->screen, PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT), 64);
MAX2(pipe->screen->caps.constant_buffer_offset_alignment, 64);
tc->base.priv = pipe; /* priv points to the wrapped driver context */
tc->base.screen = pipe->screen;
tc->base.destroy = tc_destroy;

3
src/gallium/auxiliary/util/u_upload_mgr.c
View file

@ -73,8 +73,7 @@ u_upload_create(struct pipe_context *pipe, unsigned default_size,
upload->flags = flags;
upload->map_persistent =
pipe->screen->get_param(pipe->screen,
PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT);
pipe->screen->caps.buffer_map_persistent_coherent;
if (upload->map_persistent) {
upload->map_flags = PIPE_MAP_WRITE |

19
src/gallium/auxiliary/util/u_vbuf.c
View file

@ -310,7 +310,7 @@ void u_vbuf_get_caps(struct pipe_screen *screen, struct u_vbuf_caps *caps,
caps->attrib_element_unaligned = 1;
/* pipe cap removes capabilities */
switch (screen->get_param(screen, PIPE_CAP_VERTEX_INPUT_ALIGNMENT)) {
switch (screen->caps.vertex_input_alignment) {
case PIPE_VERTEX_INPUT_ALIGNMENT_4BYTE:
caps->attrib_4byte_unaligned = 0;
break;
@ -322,20 +322,20 @@ void u_vbuf_get_caps(struct pipe_screen *screen, struct u_vbuf_caps *caps,
}
caps->user_vertex_buffers =
screen->get_param(screen, PIPE_CAP_USER_VERTEX_BUFFERS);
screen->caps.user_vertex_buffers;
caps->max_vertex_buffers =
screen->get_param(screen, PIPE_CAP_MAX_VERTEX_BUFFERS);
screen->caps.max_vertex_buffers;
if (screen->get_param(screen, PIPE_CAP_PRIMITIVE_RESTART) ||
screen->get_param(screen, PIPE_CAP_PRIMITIVE_RESTART_FIXED_INDEX)) {
caps->rewrite_restart_index = screen->get_param(screen, PIPE_CAP_EMULATE_NONFIXED_PRIMITIVE_RESTART);
caps->supported_restart_modes = screen->get_param(screen, PIPE_CAP_SUPPORTED_PRIM_MODES_WITH_RESTART);
if (screen->caps.primitive_restart ||
screen->caps.primitive_restart_fixed_index) {
caps->rewrite_restart_index = screen->caps.emulate_nonfixed_primitive_restart;
caps->supported_restart_modes = screen->caps.supported_prim_modes_with_restart;
caps->supported_restart_modes |= BITFIELD_BIT(MESA_PRIM_PATCHES);
if (caps->supported_restart_modes != BITFIELD_MASK(MESA_PRIM_COUNT))
caps->fallback_always = true;
caps->fallback_always |= caps->rewrite_restart_index;
}
caps->supported_prim_modes = screen->get_param(screen, PIPE_CAP_SUPPORTED_PRIM_MODES);
caps->supported_prim_modes = screen->caps.supported_prim_modes;
if (caps->supported_prim_modes != BITFIELD_MASK(MESA_PRIM_COUNT))
caps->fallback_always = true;
@ -375,8 +375,7 @@ u_vbuf_create(struct pipe_context *pipe, struct u_vbuf_caps *caps)
mgr->allowed_vb_mask = u_bit_consecutive(0, mgr->caps.max_vertex_buffers);
mgr->has_signed_vb_offset =
pipe->screen->get_param(pipe->screen,
PIPE_CAP_SIGNED_VERTEX_BUFFER_OFFSET);
pipe->screen->caps.signed_vertex_buffer_offset;
cso_cache_init(&mgr->cso_cache, pipe);
cso_cache_set_delete_cso_callback(&mgr->cso_cache,

4
src/gallium/auxiliary/vl/vl_compositor.c
View file

@ -825,8 +825,8 @@ vl_compositor_init(struct vl_compositor *c, struct pipe_context *pipe, bool comp
memset(c, 0, sizeof(*c));
c->pipe_cs_composit_supported = compute_only || pipe->screen->get_param(pipe->screen, PIPE_CAP_PREFER_COMPUTE_FOR_MULTIMEDIA);
c->pipe_gfx_supported = !compute_only && pipe->screen->get_param(pipe->screen, PIPE_CAP_GRAPHICS);
c->pipe_cs_composit_supported = compute_only || pipe->screen->caps.prefer_compute_for_multimedia;
c->pipe_gfx_supported = !compute_only && pipe->screen->caps.graphics;
c->pipe = pipe;
c->deinterlace = VL_COMPOSITOR_NONE;

2
src/gallium/auxiliary/vl/vl_mc.c
View file

@ -86,7 +86,7 @@ calc_line(struct pipe_screen *screen, struct ureg_program *shader)
tmp = ureg_DECL_temporary(shader);
if (screen->get_param(screen, PIPE_CAP_FS_POSITION_IS_SYSVAL))
if (screen->caps.fs_position_is_sysval)
pos = ureg_DECL_system_value(shader, TGSI_SEMANTIC_POSITION, 0);
else
pos = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_POSITION, VS_O_VPOS,

7
src/gallium/auxiliary/vl/vl_mpeg12_decoder.c
View file

@ -966,11 +966,8 @@ init_idct(struct vl_mpeg12_decoder *dec, const struct format_config* format_conf
struct pipe_sampler_view *matrix = NULL;
nr_of_idct_render_targets = dec->context->screen->get_param
(
dec->context->screen, PIPE_CAP_MAX_RENDER_TARGETS
);
nr_of_idct_render_targets = dec->context->screen->caps.max_render_targets;
max_inst = dec->context->screen->get_shader_param
(
dec->context->screen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_MAX_INSTRUCTIONS

2
src/gallium/auxiliary/vl/vl_video_buffer.c
View file

@ -149,7 +149,7 @@ vl_video_buffer_is_format_supported(struct pipe_screen *screen,
unsigned
vl_video_buffer_max_size(struct pipe_screen *screen)
{
return screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_SIZE);
return screen->caps.max_texture_2d_size;
}
void

2
src/gallium/drivers/freedreno/freedreno_blitter.c
View file

@ -33,7 +33,7 @@ default_src_texture(struct pipe_sampler_view *src_templ,
struct pipe_resource *src, unsigned srclevel)
{
bool cube_as_2darray =
src->screen->get_param(src->screen, PIPE_CAP_SAMPLER_VIEW_TARGET);
src->screen->caps.sampler_view_target;
memset(src_templ, 0, sizeof(*src_templ));

2
src/gallium/drivers/freedreno/freedreno_program.c
View file

@ -148,7 +148,7 @@ texcoord_semantic(struct pipe_context *pctx)
{
struct pipe_screen *pscreen = pctx->screen;
if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_TEXCOORD)) {
if (pscreen->caps.tgsi_texcoord) {
return TGSI_SEMANTIC_TEXCOORD;
} else {
return TGSI_SEMANTIC_GENERIC;

4
src/gallium/drivers/r300/compiler/nir_to_rc.c
View file

@ -1703,7 +1703,7 @@ ntr_emit_texture(struct ntr_compile *c, nir_tex_instr *instr)
}
if (instr->op == nir_texop_tg4 && target != TGSI_TEXTURE_SHADOWCUBE_ARRAY) {
if (c->screen->get_param(c->screen, PIPE_CAP_TGSI_TG4_COMPONENT_IN_SWIZZLE)) {
if (c->screen->caps.tgsi_tg4_component_in_swizzle) {
sampler = ureg_scalar(sampler, instr->component);
s.srcs[s.i++] = ureg_src_undef();
} else {
@ -2364,7 +2364,7 @@ nir_to_rc(struct nir_shader *s, struct pipe_screen *screen)
c->s = s;
c->ureg = ureg_create(pipe_shader_type_from_mesa(s->info.stage));
ureg_setup_shader_info(c->ureg, &s->info);
if (s->info.use_legacy_math_rules && screen->get_param(screen, PIPE_CAP_LEGACY_MATH_RULES))
if (s->info.use_legacy_math_rules && screen->caps.legacy_math_rules)
ureg_property(c->ureg, TGSI_PROPERTY_LEGACY_MATH_RULES, 1);
if (s->info.stage == MESA_SHADER_FRAGMENT) {

2
src/gallium/drivers/r600/r600_test_dma.c
View file

@ -161,7 +161,7 @@ void r600_test_dma(struct r600_common_screen *rscreen)
unsigned i, iterations, num_partial_copies, max_tex_side;
unsigned num_pass = 0, num_fail = 0;
max_tex_side = screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_SIZE);
max_tex_side = screen->caps.max_texture_2d_size;
/* Max 128 MB allowed for both textures. */
max_alloc_size = 128 * 1024 * 1024;

4
src/gallium/drivers/radeonsi/si_state.c
View file

@ -2291,7 +2291,7 @@ static bool si_is_format_supported(struct pipe_screen *screen, enum pipe_format
return false;
if (sample_count > 1) {
if (!screen->get_param(screen, PIPE_CAP_TEXTURE_MULTISAMPLE))
if (!screen->caps.texture_multisample)
return false;
/* Only power-of-two sample counts are supported. */
@ -2361,7 +2361,7 @@ static bool si_is_format_supported(struct pipe_screen *screen, enum pipe_format
retval |= PIPE_BIND_LINEAR;
if ((usage & PIPE_BIND_SAMPLER_REDUCTION_MINMAX) &&
screen->get_param(screen, PIPE_CAP_SAMPLER_REDUCTION_MINMAX) &&
screen->caps.sampler_reduction_minmax &&
si_is_reduction_mode_supported(screen, format))
retval |= PIPE_BIND_SAMPLER_REDUCTION_MINMAX;

3
src/gallium/drivers/softpipe/sp_tile_cache.c
View file

@ -94,8 +94,7 @@ sp_create_tile_cache( struct pipe_context *pipe )
uint pos;
/* sanity checking: max sure MAX_WIDTH/HEIGHT >= largest texture image */
assert(MAX_WIDTH >= pipe->screen->get_param(pipe->screen,
PIPE_CAP_MAX_TEXTURE_2D_SIZE));
assert(MAX_WIDTH >= pipe->screen->caps.max_texture_2d_size);
STATIC_ASSERT(sizeof(union tile_address) == 4);

2
src/gallium/drivers/svga/svga_state_tgsi_transform.c
View file

@ -223,7 +223,7 @@ emulate_point_sprite(struct svga_context *svga,
int aa_point_coord_index = -1;
struct pipe_screen *screen = svga->pipe.screen;
bool has_texcoord_semantic =
screen->get_param(screen, PIPE_CAP_TGSI_TEXCOORD);
screen->caps.tgsi_texcoord;
assert(tokens != NULL);

2
src/gallium/drivers/svga/svga_tgsi_vgpu10.c
View file

@ -12798,7 +12798,7 @@ transform_fs_aapoint(struct svga_context *svga,
int aa_coord_index)
{
bool need_texcoord_semantic =
svga->pipe.screen->get_param(svga->pipe.screen, PIPE_CAP_TGSI_TEXCOORD);
svga->pipe.screen->caps.tgsi_texcoord;
if (0) {
debug_printf("Before tgsi_add_aa_point ------------------\n");

6
src/gallium/drivers/virgl/virgl_context.c
View file

@ -362,8 +362,7 @@ static struct pipe_surface *virgl_create_surface(struct pipe_context *ctx,
if (!surf)
return NULL;
assert(ctx->screen->get_param(ctx->screen,
PIPE_CAP_DEST_SURFACE_SRGB_CONTROL) ||
assert(ctx->screen->caps.dest_surface_srgb_control ||
(util_format_is_srgb(templ->format) ==
util_format_is_srgb(resource->format)));
@ -1331,8 +1330,7 @@ static void virgl_blit(struct pipe_context *ctx,
struct virgl_resource *dres = virgl_resource(blit->dst.resource);
struct virgl_resource *sres = virgl_resource(blit->src.resource);
assert(ctx->screen->get_param(ctx->screen,
PIPE_CAP_DEST_SURFACE_SRGB_CONTROL) ||
assert(ctx->screen->caps.dest_surface_srgb_control ||
(util_format_is_srgb(blit->dst.resource->format) ==
util_format_is_srgb(blit->dst.format)));

22
src/gallium/frontends/clover/core/device.cpp
View file

@ -159,7 +159,7 @@ namespace {
device::device(clover::platform &platform, pipe_loader_device *ldev) :
platform(platform), clc_cache(NULL), ldev(ldev) {
pipe = pipe_loader_create_screen(ldev, false);
if (pipe && pipe->get_param(pipe, PIPE_CAP_COMPUTE)) {
if (pipe && pipe->caps.compute) {
const bool has_supported_ir = supports_ir(PIPE_SHADER_IR_NATIVE);
if (has_supported_ir) {
unsigned major = 1, minor = 1;
@ -243,22 +243,22 @@ device::max_images_write() const {
size_t
device::max_image_buffer_size() const {
return pipe->get_param(pipe, PIPE_CAP_MAX_TEXEL_BUFFER_ELEMENTS_UINT);
return pipe->caps.max_texel_buffer_elements_uint;
}
cl_uint
device::max_image_size() const {
return pipe->get_param(pipe, PIPE_CAP_MAX_TEXTURE_2D_SIZE);
return pipe->caps.max_texture_2d_size;
}
cl_uint
device::max_image_size_3d() const {
return 1 << (pipe->get_param(pipe, PIPE_CAP_MAX_TEXTURE_3D_LEVELS) - 1);
return 1 << (pipe->caps.max_texture_3d_levels - 1);
}
size_t
device::max_image_array_number() const {
return pipe->get_param(pipe, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS);
return pipe->caps.max_texture_array_layers;
}
cl_uint
@ -353,7 +353,7 @@ device::has_doubles() const {
(nir_shader_compiler_options *)pipe->get_compiler_options(pipe,
PIPE_SHADER_IR_NIR,
PIPE_SHADER_COMPUTE);
return pipe->get_param(pipe, PIPE_CAP_DOUBLES) &&
return pipe->caps.doubles &&
!(options->lower_doubles_options & nir_lower_fp64_full_software);
}
@ -371,7 +371,7 @@ device::has_int64_atomics() const {
bool
device::has_unified_memory() const {
return pipe->get_param(pipe, PIPE_CAP_UMA);
return pipe->caps.uma;
}
size_t
@ -398,7 +398,7 @@ device::svm_support() const {
//
// Another unsolvable scenario is a cl_mem object passed by cl_mem reference
// and SVM pointer into the same kernel at the same time.
if (allows_user_pointers() && pipe->get_param(pipe, PIPE_CAP_SYSTEM_SVM))
if (allows_user_pointers() && pipe->caps.system_svm)
// we can emulate all lower levels if we support fine grain system
return CL_DEVICE_SVM_FINE_GRAIN_SYSTEM |
CL_DEVICE_SVM_COARSE_GRAIN_BUFFER |
@ -408,8 +408,8 @@ device::svm_support() const {
bool
device::allows_user_pointers() const {
return pipe->get_param(pipe, PIPE_CAP_RESOURCE_FROM_USER_MEMORY) ||
pipe->get_param(pipe, PIPE_CAP_RESOURCE_FROM_USER_MEMORY_COMPUTE_ONLY);
return pipe->caps.resource_from_user_memory ||
pipe->caps.resource_from_user_memory_compute_only;
}
std::vector<size_t>
@ -459,7 +459,7 @@ device::ir_target() const {
enum pipe_endian
device::endianness() const {
return (enum pipe_endian)pipe->get_param(pipe, PIPE_CAP_ENDIANNESS);
return pipe->caps.endianness;
}
std::string

2
src/gallium/frontends/d3d10umd/Device.cpp
View file

@ -141,7 +141,7 @@ CreateDevice(D3D10DDI_HADAPTER hAdapter, // IN
pipe->bind_fs_state(pipe, pDevice->empty_fs);
pDevice->max_dual_source_render_targets =
screen->get_param(screen, PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS);
screen->caps.max_dual_source_render_targets;
pDevice->hRTCoreLayer = pCreateData->hRTCoreLayer;
pDevice->hDevice = (HANDLE)pCreateData->hRTDevice.handle;

2
src/gallium/frontends/dri/dri_helpers.c
View file

@ -83,7 +83,7 @@ dri_fence_get_caps(struct dri_screen *driscreen)
struct pipe_screen *screen = driscreen->base.screen;
unsigned caps = 0;
if (screen->get_param(screen, PIPE_CAP_NATIVE_FENCE_FD))
if (screen->caps.native_fence_fd)
caps |= __DRI_FENCE_CAP_NATIVE_FD;
return caps;

18
src/gallium/frontends/dri/dri_query_renderer.c
View file

@ -82,25 +82,21 @@ dri_query_renderer_integer(struct dri_screen *screen, int param,
switch (param) {
case __DRI2_RENDERER_VENDOR_ID:
value[0] =
(unsigned int)screen->base.screen->get_param(screen->base.screen,
PIPE_CAP_VENDOR_ID);
(unsigned int)screen->base.screen->caps.vendor_id;
return 0;
case __DRI2_RENDERER_DEVICE_ID:
value[0] =
(unsigned int)screen->base.screen->get_param(screen->base.screen,
PIPE_CAP_DEVICE_ID);
(unsigned int)screen->base.screen->caps.device_id;
return 0;
case __DRI2_RENDERER_ACCELERATED:
value[0] =
(unsigned int)!!screen->base.screen->get_param(screen->base.screen,
PIPE_CAP_ACCELERATED);
(unsigned int)!!screen->base.screen->caps.accelerated;
return 0;
case __DRI2_RENDERER_VIDEO_MEMORY: {
int ov = driQueryOptioni(&screen->dev->option_cache, "override_vram_size");
value[0] =
(unsigned int)screen->base.screen->get_param(screen->base.screen,
PIPE_CAP_VIDEO_MEMORY);
(unsigned int)screen->base.screen->caps.video_memory;
if (ov >= 0)
value[0] = MIN2(ov, value[0]);
return 0;
@ -108,14 +104,12 @@ dri_query_renderer_integer(struct dri_screen *screen, int param,
case __DRI2_RENDERER_UNIFIED_MEMORY_ARCHITECTURE:
value[0] =
(unsigned int)screen->base.screen->get_param(screen->base.screen,
PIPE_CAP_UMA);
(unsigned int)screen->base.screen->caps.uma;
return 0;
case __DRI2_RENDERER_PREFER_BACK_BUFFER_REUSE:
value[0] =
screen->base.screen->get_param(screen->base.screen,
PIPE_CAP_PREFER_BACK_BUFFER_REUSE);
screen->base.screen->caps.prefer_back_buffer_reuse;
return 0;
default:
return driQueryRendererIntegerCommon(screen, param, value);

12
src/gallium/frontends/dri/dri_screen.c
View file

@ -381,7 +381,7 @@ dri_fill_in_modes(struct dri_screen *screen)
#undef HAS_ZS
mixed_color_depth =
p_screen->get_param(p_screen, PIPE_CAP_MIXED_COLOR_DEPTH_BITS);
p_screen->caps.mixed_color_depth_bits;
/* Add configs. */
for (unsigned f = 0; f < ARRAY_SIZE(pipe_formats); f++) {
@ -627,7 +627,7 @@ dri_init_screen(struct dri_screen *screen,
screen->base.set_background_context = dri_set_background_context;
screen->base.validate_egl_image = dri_validate_egl_image;
if (pscreen->get_param(pscreen, PIPE_CAP_NPOT_TEXTURES))
if (pscreen->caps.npot_textures)
screen->target = PIPE_TEXTURE_2D;
else
screen->target = PIPE_TEXTURE_RECT;
@ -642,15 +642,15 @@ dri_init_screen(struct dri_screen *screen,
&screen->max_gl_es1_version,
&screen->max_gl_es2_version);
screen->throttle = pscreen->get_param(pscreen, PIPE_CAP_THROTTLE);
if (pscreen->get_param(pscreen, PIPE_CAP_DEVICE_PROTECTED_CONTEXT))
screen->throttle = pscreen->caps.throttle;
if (pscreen->caps.device_protected_context)
screen->has_protected_context = true;
screen->has_reset_status_query = pscreen->get_param(pscreen, PIPE_CAP_DEVICE_RESET_STATUS_QUERY);
screen->has_reset_status_query = pscreen->caps.device_reset_status_query;
#ifdef HAVE_LIBDRM
if (has_multibuffer) {
int dmabuf_caps = pscreen->get_param(pscreen, PIPE_CAP_DMABUF);
int dmabuf_caps = pscreen->caps.dmabuf;
if (dmabuf_caps & DRM_PRIME_CAP_IMPORT)
screen->dmabuf_import = true;
if (screen->dmabuf_import && dmabuf_caps & DRM_PRIME_CAP_EXPORT)

2
src/gallium/frontends/dri/kopper.c
View file

@ -86,7 +86,7 @@ kopper_init_screen(struct dri_screen *screen, bool driver_name_is_inferred)
if (!pscreen)
return NULL;
assert(pscreen->get_param(pscreen, PIPE_CAP_DEVICE_RESET_STATUS_QUERY));
assert(pscreen->caps.device_reset_status_query);
screen->is_sw = zink_kopper_is_cpu(pscreen);
return pscreen;

2
src/gallium/frontends/glx/xlib/xm_st.c
View file

@ -310,7 +310,7 @@ xmesa_create_st_framebuffer(XMesaDisplay xmdpy, XMesaBuffer b)
xstfb->buffer = b;
xstfb->screen = xmdpy->screen;
xstfb->stvis = b->xm_visual->stvis;
if (xstfb->screen->get_param(xstfb->screen, PIPE_CAP_NPOT_TEXTURES))
if (xstfb->screen->caps.npot_textures)
xstfb->target = PIPE_TEXTURE_2D;
else
xstfb->target = PIPE_TEXTURE_RECT;

2
src/gallium/frontends/hgl/hgl.c
View file

@ -230,7 +230,7 @@ hgl_create_st_framebuffer(struct hgl_display *display, struct st_visual* visual,
buffer->screen = display->fscreen->screen;
buffer->winsysContext = winsysContext;
if (buffer->screen->get_param(buffer->screen, PIPE_CAP_NPOT_TEXTURES))
if (buffer->screen->caps.npot_textures)
buffer->target = PIPE_TEXTURE_2D;
else
buffer->target = PIPE_TEXTURE_RECT;

94
src/gallium/frontends/lavapipe/lvp_device.c
View file

@ -320,25 +320,25 @@ static void
lvp_get_features(const struct lvp_physical_device *pdevice,
struct vk_features *features)
{
bool instance_divisor = pdevice->pscreen->get_param(pdevice->pscreen, PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR) != 0;
bool instance_divisor = pdevice->pscreen->caps.vertex_element_instance_divisor != 0;
*features = (struct vk_features){
/* Vulkan 1.0 */
.robustBufferAccess = true,
.fullDrawIndexUint32 = true,
.imageCubeArray = (pdevice->pscreen->get_param(pdevice->pscreen, PIPE_CAP_CUBE_MAP_ARRAY) != 0),
.imageCubeArray = (pdevice->pscreen->caps.cube_map_array != 0),
.independentBlend = true,
.geometryShader = (pdevice->pscreen->get_shader_param(pdevice->pscreen, MESA_SHADER_GEOMETRY, PIPE_SHADER_CAP_MAX_INSTRUCTIONS) != 0),
.tessellationShader = (pdevice->pscreen->get_shader_param(pdevice->pscreen, MESA_SHADER_TESS_EVAL, PIPE_SHADER_CAP_MAX_INSTRUCTIONS) != 0),
.sampleRateShading = (pdevice->pscreen->get_param(pdevice->pscreen, PIPE_CAP_SAMPLE_SHADING) != 0),
.dualSrcBlend = (pdevice->pscreen->get_param(pdevice->pscreen, PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS) != 0),
.sampleRateShading = (pdevice->pscreen->caps.sample_shading != 0),
.dualSrcBlend = (pdevice->pscreen->caps.max_dual_source_render_targets != 0),
.logicOp = true,
.multiDrawIndirect = (pdevice->pscreen->get_param(pdevice->pscreen, PIPE_CAP_MULTI_DRAW_INDIRECT) != 0),
.multiDrawIndirect = (pdevice->pscreen->caps.multi_draw_indirect != 0),
.drawIndirectFirstInstance = true,
.depthClamp = (pdevice->pscreen->get_param(pdevice->pscreen, PIPE_CAP_DEPTH_CLIP_DISABLE) != 0),
.depthClamp = (pdevice->pscreen->caps.depth_clip_disable != 0),
.depthBiasClamp = true,
.fillModeNonSolid = true,
.depthBounds = (pdevice->pscreen->get_param(pdevice->pscreen, PIPE_CAP_DEPTH_BOUNDS_TEST) != 0),
.depthBounds = (pdevice->pscreen->caps.depth_bounds_test != 0),
.wideLines = true,
.largePoints = true,
.alphaToOne = true,
@ -354,7 +354,7 @@ lvp_get_features(const struct lvp_physical_device *pdevice,
.shaderTessellationAndGeometryPointSize = true,
.shaderImageGatherExtended = true,
.shaderStorageImageExtendedFormats = (min_shader_param(pdevice->pscreen, PIPE_SHADER_CAP_MAX_SHADER_IMAGES) != 0),
.shaderStorageImageMultisample = (pdevice->pscreen->get_param(pdevice->pscreen, PIPE_CAP_TEXTURE_MULTISAMPLE) != 0),
.shaderStorageImageMultisample = (pdevice->pscreen->caps.texture_multisample != 0),
.shaderUniformBufferArrayDynamicIndexing = true,
.shaderSampledImageArrayDynamicIndexing = true,
.shaderStorageBufferArrayDynamicIndexing = true,
@ -362,9 +362,9 @@ lvp_get_features(const struct lvp_physical_device *pdevice,
.shaderStorageImageReadWithoutFormat = true,
.shaderStorageImageWriteWithoutFormat = true,
.shaderClipDistance = true,
.shaderCullDistance = (pdevice->pscreen->get_param(pdevice->pscreen, PIPE_CAP_CULL_DISTANCE) == 1),
.shaderFloat64 = (pdevice->pscreen->get_param(pdevice->pscreen, PIPE_CAP_DOUBLES) == 1),
.shaderInt64 = (pdevice->pscreen->get_param(pdevice->pscreen, PIPE_CAP_INT64) == 1),
.shaderCullDistance = (pdevice->pscreen->caps.cull_distance == 1),
.shaderFloat64 = (pdevice->pscreen->caps.doubles == 1),
.shaderInt64 = (pdevice->pscreen->caps.int64 == 1),
.shaderInt16 = (min_shader_param(pdevice->pscreen, PIPE_SHADER_CAP_INT16) == 1),
.variableMultisampleRate = false,
.inheritedQueries = false,
@ -600,7 +600,7 @@ lvp_get_features(const struct lvp_physical_device *pdevice,
.multiDraw = true,
/* VK_EXT_depth_clip_enable */
.depthClipEnable = (pdevice->pscreen->get_param(pdevice->pscreen, PIPE_CAP_DEPTH_CLAMP_ENABLE) != 0),
.depthClipEnable = (pdevice->pscreen->caps.depth_clamp_enable != 0),
/* VK_EXT_extended_dynamic_state2 */
.extendedDynamicState2 = true,
@ -790,9 +790,9 @@ lvp_get_properties(const struct lvp_physical_device *device, struct vk_propertie
PIPE_COMPUTE_CAP_MAX_LOCAL_SIZE,
&max_local_size);
const uint64_t max_render_targets = device->pscreen->get_param(device->pscreen, PIPE_CAP_MAX_RENDER_TARGETS);
const uint64_t max_render_targets = device->pscreen->caps.max_render_targets;
int texel_buffer_alignment = device->pscreen->get_param(device->pscreen, PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT);
int texel_buffer_alignment = device->pscreen->caps.texture_buffer_offset_alignment;
STATIC_ASSERT(sizeof(struct lp_descriptor) <= 256);
*p = (struct vk_properties) {
@ -802,14 +802,14 @@ lvp_get_properties(const struct lvp_physical_device *device, struct vk_propertie
.vendorID = VK_VENDOR_ID_MESA,
.deviceID = 0,
.deviceType = VK_PHYSICAL_DEVICE_TYPE_CPU,
.maxImageDimension1D = device->pscreen->get_param(device->pscreen, PIPE_CAP_MAX_TEXTURE_2D_SIZE),
.maxImageDimension2D = device->pscreen->get_param(device->pscreen, PIPE_CAP_MAX_TEXTURE_2D_SIZE),
.maxImageDimension3D = (1 << device->pscreen->get_param(device->pscreen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS)),
.maxImageDimensionCube = (1 << device->pscreen->get_param(device->pscreen, PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS)),
.maxImageArrayLayers = device->pscreen->get_param(device->pscreen, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS),
.maxTexelBufferElements = device->pscreen->get_param(device->pscreen, PIPE_CAP_MAX_TEXEL_BUFFER_ELEMENTS_UINT),
.maxImageDimension1D = device->pscreen->caps.max_texture_2d_size,
.maxImageDimension2D = device->pscreen->caps.max_texture_2d_size,
.maxImageDimension3D = (1 << device->pscreen->caps.max_texture_3d_levels),
.maxImageDimensionCube = (1 << device->pscreen->caps.max_texture_cube_levels),
.maxImageArrayLayers = device->pscreen->caps.max_texture_array_layers,
.maxTexelBufferElements = device->pscreen->caps.max_texel_buffer_elements_uint,
.maxUniformBufferRange = min_shader_param(device->pscreen, PIPE_SHADER_CAP_MAX_CONST_BUFFER0_SIZE),
.maxStorageBufferRange = device->pscreen->get_param(device->pscreen, PIPE_CAP_MAX_SHADER_BUFFER_SIZE_UINT),
.maxStorageBufferRange = device->pscreen->caps.max_shader_buffer_size_uint,
.maxPushConstantsSize = MAX_PUSH_CONSTANTS_SIZE,
.maxMemoryAllocationCount = UINT32_MAX,
.maxSamplerAllocationCount = 32 * 1024,
@ -844,11 +844,11 @@ lvp_get_properties(const struct lvp_physical_device *device, struct vk_propertie
.maxTessellationControlTotalOutputComponents = 4096,
.maxTessellationEvaluationInputComponents = 128,
.maxTessellationEvaluationOutputComponents = 128,
.maxGeometryShaderInvocations = device->pscreen->get_param(device->pscreen, PIPE_CAP_MAX_GS_INVOCATIONS),
.maxGeometryShaderInvocations = device->pscreen->caps.max_gs_invocations,
.maxGeometryInputComponents = 64,
.maxGeometryOutputComponents = 128,
.maxGeometryOutputVertices = device->pscreen->get_param(device->pscreen, PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES),
.maxGeometryTotalOutputComponents = device->pscreen->get_param(device->pscreen, PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS),
.maxGeometryOutputVertices = device->pscreen->caps.max_geometry_output_vertices,
.maxGeometryTotalOutputComponents = device->pscreen->caps.max_geometry_total_output_components,
.maxFragmentInputComponents = 128,
.maxFragmentOutputAttachments = 8,
.maxFragmentDualSrcAttachments = 2,
@ -861,31 +861,31 @@ lvp_get_properties(const struct lvp_physical_device *device, struct vk_propertie
.maxComputeWorkGroupCount = { grid_size[0], grid_size[1], grid_size[2] },
.maxComputeWorkGroupInvocations = max_threads_per_block,
.maxComputeWorkGroupSize = { block_size[0], block_size[1], block_size[2] },
.subPixelPrecisionBits = device->pscreen->get_param(device->pscreen, PIPE_CAP_RASTERIZER_SUBPIXEL_BITS),
.subPixelPrecisionBits = device->pscreen->caps.rasterizer_subpixel_bits,
.subTexelPrecisionBits = 8,
.mipmapPrecisionBits = 6,
.maxDrawIndexedIndexValue = UINT32_MAX,
.maxDrawIndirectCount = UINT32_MAX,
.maxSamplerLodBias = 16,
.maxSamplerAnisotropy = 16,
.maxViewports = device->pscreen->get_param(device->pscreen, PIPE_CAP_MAX_VIEWPORTS),
.maxViewports = device->pscreen->caps.max_viewports,
.maxViewportDimensions = { (1 << 14), (1 << 14) },
.viewportBoundsRange = { -32768.0, 32768.0 },
.viewportSubPixelBits = device->pscreen->get_param(device->pscreen, PIPE_CAP_VIEWPORT_SUBPIXEL_BITS),
.minMemoryMapAlignment = device->pscreen->get_param(device->pscreen, PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT),
.minTexelBufferOffsetAlignment = device->pscreen->get_param(device->pscreen, PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT),
.minUniformBufferOffsetAlignment = device->pscreen->get_param(device->pscreen, PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT),
.minStorageBufferOffsetAlignment = device->pscreen->get_param(device->pscreen, PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT),
.minTexelOffset = device->pscreen->get_param(device->pscreen, PIPE_CAP_MIN_TEXEL_OFFSET),
.maxTexelOffset = device->pscreen->get_param(device->pscreen, PIPE_CAP_MAX_TEXEL_OFFSET),
.minTexelGatherOffset = device->pscreen->get_param(device->pscreen, PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET),
.maxTexelGatherOffset = device->pscreen->get_param(device->pscreen, PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET),
.viewportSubPixelBits = device->pscreen->caps.viewport_subpixel_bits,
.minMemoryMapAlignment = device->pscreen->caps.min_map_buffer_alignment,
.minTexelBufferOffsetAlignment = device->pscreen->caps.texture_buffer_offset_alignment,
.minUniformBufferOffsetAlignment = device->pscreen->caps.constant_buffer_offset_alignment,
.minStorageBufferOffsetAlignment = device->pscreen->caps.shader_buffer_offset_alignment,
.minTexelOffset = device->pscreen->caps.min_texel_offset,
.maxTexelOffset = device->pscreen->caps.max_texel_offset,
.minTexelGatherOffset = device->pscreen->caps.min_texture_gather_offset,
.maxTexelGatherOffset = device->pscreen->caps.max_texture_gather_offset,
.minInterpolationOffset = -2, /* FIXME */
.maxInterpolationOffset = 2, /* FIXME */
.subPixelInterpolationOffsetBits = 8, /* FIXME */
.maxFramebufferWidth = device->pscreen->get_param(device->pscreen, PIPE_CAP_MAX_TEXTURE_2D_SIZE),
.maxFramebufferHeight = device->pscreen->get_param(device->pscreen, PIPE_CAP_MAX_TEXTURE_2D_SIZE),
.maxFramebufferLayers = device->pscreen->get_param(device->pscreen, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS),
.maxFramebufferWidth = device->pscreen->caps.max_texture_2d_size,
.maxFramebufferHeight = device->pscreen->caps.max_texture_2d_size,
.maxFramebufferLayers = device->pscreen->caps.max_texture_array_layers,
.framebufferColorSampleCounts = sample_counts,
.framebufferDepthSampleCounts = sample_counts,
.framebufferStencilSampleCounts = sample_counts,
@ -1016,7 +1016,7 @@ lvp_get_properties(const struct lvp_physical_device *device, struct vk_propertie
.maxBufferSize = UINT32_MAX,
/* Vulkan 1.4 */
.lineSubPixelPrecisionBits = device->pscreen->get_param(device->pscreen, PIPE_CAP_RASTERIZER_SUBPIXEL_BITS),
.lineSubPixelPrecisionBits = device->pscreen->caps.rasterizer_subpixel_bits,
.maxPushDescriptors = MAX_PUSH_DESCRIPTORS,
/* FIXME No idea about most of these ones. */
.earlyFragmentMultisampleCoverageAfterSampleCounting = true,
@ -1038,8 +1038,8 @@ lvp_get_properties(const struct lvp_physical_device *device, struct vk_propertie
.identicalMemoryTypeRequirements = VK_FALSE,
/* VK_EXT_transform_feedback */
.maxTransformFeedbackStreams = device->pscreen->get_param(device->pscreen, PIPE_CAP_MAX_VERTEX_STREAMS),
.maxTransformFeedbackBuffers = device->pscreen->get_param(device->pscreen, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS),
.maxTransformFeedbackStreams = device->pscreen->caps.max_vertex_streams,
.maxTransformFeedbackBuffers = device->pscreen->caps.max_stream_output_buffers,
.maxTransformFeedbackBufferSize = UINT32_MAX,
.maxTransformFeedbackStreamDataSize = 512,
.maxTransformFeedbackBufferDataSize = 512,
@ -1218,7 +1218,7 @@ lvp_get_properties(const struct lvp_physical_device *device, struct vk_propertie
);
/* Vulkan 1.4 */
if (device->pscreen->get_param(device->pscreen, PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR) != 0)
if (device->pscreen->caps.vertex_element_instance_divisor)
p->maxVertexAttribDivisor = UINT32_MAX;
else
p->maxVertexAttribDivisor = 1;
@ -1285,13 +1285,13 @@ lvp_physical_device_init(struct lvp_physical_device *device,
device->vk.supported_extensions = lvp_device_extensions_supported;
#ifdef HAVE_LIBDRM
int dmabuf_bits = DRM_PRIME_CAP_EXPORT | DRM_PRIME_CAP_IMPORT;
int supported_dmabuf_bits = device->pscreen->get_param(device->pscreen, PIPE_CAP_DMABUF);
int supported_dmabuf_bits = device->pscreen->caps.dmabuf;
/* if import or export is supported then EXT_external_memory_dma_buf is supported */
if (supported_dmabuf_bits)
device->vk.supported_extensions.EXT_external_memory_dma_buf = true;
if ((supported_dmabuf_bits & dmabuf_bits) == dmabuf_bits)
device->vk.supported_extensions.EXT_image_drm_format_modifier = true;
if (device->pscreen->get_param(device->pscreen, PIPE_CAP_NATIVE_FENCE_FD)) {
if (device->pscreen->caps.native_fence_fd) {
device->vk.supported_extensions.KHR_external_semaphore_fd = true;
device->vk.supported_extensions.KHR_external_fence_fd = true;
}
@ -2606,8 +2606,7 @@ VKAPI_ATTR void VKAPI_CALL lvp_GetPhysicalDeviceExternalFenceProperties(
const VkExternalFenceHandleTypeFlagBits handle_type = pExternalFenceInfo->handleType;
if (handle_type == VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT &&
physical_device->pscreen->get_param(
physical_device->pscreen, PIPE_CAP_NATIVE_FENCE_FD)) {
physical_device->pscreen->caps.native_fence_fd) {
pExternalFenceProperties->exportFromImportedHandleTypes =
VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT;
pExternalFenceProperties->compatibleHandleTypes =
@ -2635,8 +2634,7 @@ VKAPI_ATTR void VKAPI_CALL lvp_GetPhysicalDeviceExternalSemaphoreProperties(
if (type == VK_SEMAPHORE_TYPE_BINARY &&
handle_type == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT &&
physical_device->pscreen->get_param(
physical_device->pscreen, PIPE_CAP_NATIVE_FENCE_FD)) {
physical_device->pscreen->caps.native_fence_fd) {
pExternalSemaphoreProperties->exportFromImportedHandleTypes =
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
pExternalSemaphoreProperties->compatibleHandleTypes =

10
src/gallium/frontends/lavapipe/lvp_formats.c
View file

@ -312,8 +312,8 @@ static VkResult lvp_get_image_format_properties(struct lvp_physical_device *phys
if (format_feature_flags == 0)
goto unsupported;
uint32_t max_2d_ext = physical_device->pscreen->get_param(physical_device->pscreen, PIPE_CAP_MAX_TEXTURE_2D_SIZE);
uint32_t max_layers = physical_device->pscreen->get_param(physical_device->pscreen, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS);
uint32_t max_2d_ext = physical_device->pscreen->caps.max_texture_2d_size;
uint32_t max_layers = physical_device->pscreen->caps.max_texture_array_layers;
switch (info->type) {
default:
unreachable("bad vkimage type\n");
@ -342,7 +342,7 @@ static VkResult lvp_get_image_format_properties(struct lvp_physical_device *phys
case VK_IMAGE_TYPE_3D:
maxExtent.width = max_2d_ext;
maxExtent.height = max_2d_ext;
maxExtent.depth = (1 << physical_device->pscreen->get_param(physical_device->pscreen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS));
maxExtent.depth = (1 << physical_device->pscreen->caps.max_texture_3d_levels);
maxMipLevels = util_logbase2(max_2d_ext) + 1;
maxArraySize = 1;
break;
@ -472,7 +472,7 @@ VKAPI_ATTR VkResult VKAPI_CALL lvp_GetPhysicalDeviceImageFormatProperties2(
switch (external_info->handleType) {
#ifdef HAVE_LIBDRM
case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT: {
int params = physical_device->pscreen->get_param(physical_device->pscreen, PIPE_CAP_DMABUF);
int params = physical_device->pscreen->caps.dmabuf;
flags = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
if (params & DRM_PRIME_CAP_EXPORT)
flags |= VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
@ -633,7 +633,7 @@ VKAPI_ATTR void VKAPI_CALL lvp_GetPhysicalDeviceExternalBufferProperties(
#ifdef HAVE_LIBDRM
case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT: {
LVP_FROM_HANDLE(lvp_physical_device, physical_device, physicalDevice);
int params = physical_device->pscreen->get_param(physical_device->pscreen, PIPE_CAP_DMABUF);
int params = physical_device->pscreen->caps.dmabuf;
flags = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
if (params & DRM_PRIME_CAP_EXPORT)
flags |= VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;

22
src/gallium/frontends/nine/adapter9.c
View file

@ -21,8 +21,8 @@
static bool
has_sm3(struct pipe_screen *hal)
{
return hal->get_param(hal, PIPE_CAP_FRAGMENT_SHADER_TEXTURE_LOD) &&
hal->get_param(hal, PIPE_CAP_FRAGMENT_SHADER_DERIVATIVES);
return hal->caps.fragment_shader_texture_lod &&
hal->caps.fragment_shader_derivatives;
}
HRESULT
@ -38,7 +38,7 @@ NineAdapter9_ctor( struct NineAdapter9 *This,
nine_dump_D3DADAPTER_IDENTIFIER9(DBG_CHANNEL, &pCTX->identifier);
This->ctx = pCTX;
if (!hal->get_param(hal, PIPE_CAP_CLIP_HALFZ)) {
if (!hal->caps.clip_halfz) {
WARN_ONCE("Driver doesn't natively support d3d9 coordinates\n");
const nir_shader_compiler_options *options = hal->get_compiler_options(hal, PIPE_SHADER_IR_NIR, PIPE_SHADER_VERTEX);
if(!options->compact_arrays){
@ -335,7 +335,7 @@ NineAdapter9_CheckDeviceFormat( struct NineAdapter9 *This,
/* RESZ hack */
if (CheckFormat == D3DFMT_RESZ && bind == PIPE_BIND_RENDER_TARGET &&
RType == D3DRTYPE_SURFACE)
return screen->get_param(screen, PIPE_CAP_MULTISAMPLE_Z_RESOLVE) ?
return screen->caps.multisample_z_resolve ?
D3D_OK : D3DERR_NOTAVAILABLE;
/* ATOC hack */
@ -633,8 +633,8 @@ NineAdapter9_GetDeviceCaps( struct NineAdapter9 *This,
D3DPIPECAP(mixed_colorbuffer_formats, D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS) |
D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING |
D3DPMISCCAPS_FOGVERTEXCLAMPED;
if (!screen->get_param(screen, PIPE_CAP_VS_WINDOW_SPACE_POSITION) &&
!screen->get_param(screen, PIPE_CAP_DEPTH_CLIP_DISABLE))
if (!screen->caps.vs_window_space_position &&
!screen->caps.depth_clip_disable)
pCaps->PrimitiveMiscCaps |= D3DPMISCCAPS_CLIPTLVERTS;
pCaps->RasterCaps =
@ -752,11 +752,10 @@ NineAdapter9_GetDeviceCaps( struct NineAdapter9 *This,
pCaps->LineCaps |= D3DLINECAPS_ANTIALIAS;
}
pCaps->MaxTextureWidth =screen->get_param(screen,
PIPE_CAP_MAX_TEXTURE_2D_SIZE);
pCaps->MaxTextureWidth =screen->caps.max_texture_2d_size;
pCaps->MaxTextureHeight = pCaps->MaxTextureWidth;
pCaps->MaxVolumeExtent =
1 << (screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS) - 1);
1 << (screen->caps.max_texture_3d_levels - 1);
/* XXX values from wine */
pCaps->MaxTextureRepeat = 32768;
pCaps->MaxTextureAspectRatio = pCaps->MaxTextureWidth;
@ -841,8 +840,7 @@ NineAdapter9_GetDeviceCaps( struct NineAdapter9 *This,
PIPE_SHADER_VERTEX, PIPE_SHADER_CAP_MAX_INPUTS),
16);
pCaps->MaxStreamStride = screen->get_param(screen,
PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE);
pCaps->MaxStreamStride = screen->caps.max_vertex_attrib_stride;
pCaps->VertexShaderVersion = D3DVS_VERSION(3,0);
@ -886,7 +884,7 @@ NineAdapter9_GetDeviceCaps( struct NineAdapter9 *This,
D3DDTCAPS_FLOAT16_4;
pCaps->NumSimultaneousRTs =
screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS);
screen->caps.max_render_targets;
if (pCaps->NumSimultaneousRTs > NINE_MAX_SIMULTANEOUS_RENDERTARGETS)
pCaps->NumSimultaneousRTs = NINE_MAX_SIMULTANEOUS_RENDERTARGETS;

6
src/gallium/frontends/nine/device9.c
View file

@ -259,7 +259,7 @@ NineDevice9_ctor( struct NineDevice9 *This,
/* Available memory counter. Updated only for allocations with this device
* instance. This is the Win 7 behavior.
* Win XP shares this counter across multiple devices. */
This->available_texture_mem = This->screen->get_param(This->screen, PIPE_CAP_VIDEO_MEMORY);
This->available_texture_mem = This->screen->caps.video_memory;
This->available_texture_mem = (pCTX->override_vram_size >= 0) ?
(long long)pCTX->override_vram_size : This->available_texture_mem;
This->available_texture_mem <<= 20;
@ -555,7 +555,7 @@ NineDevice9_ctor( struct NineDevice9 *This,
/* Allocate upload helper for drivers that suck (from st pov ;). */
This->driver_caps.user_sw_vbufs = This->screen_sw->get_param(This->screen_sw, PIPE_CAP_USER_VERTEX_BUFFERS);
This->driver_caps.user_sw_vbufs = This->screen_sw->caps.user_vertex_buffers;
This->vertex_uploader = This->csmt_active ? This->pipe_secondary->stream_uploader : This->context.pipe->stream_uploader;
This->driver_caps.window_space_position_support = GET_PCAP(vs_window_space_position);
This->driver_caps.disabling_depth_clipping_support = GET_PCAP(depth_clip_disable);
@ -3261,7 +3261,7 @@ NineDevice9_ProcessVertices( struct NineDevice9 *This,
user_assert(pDestBuffer && pVertexDecl, D3DERR_INVALIDCALL);
if (!screen_sw->get_param(screen_sw, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS)) {
if (!screen_sw->caps.max_stream_output_buffers) {
DBG("ProcessVertices not supported\n");
return D3DERR_INVALIDCALL;
}

3
src/gallium/frontends/nine/nine_buffer_upload.c
View file

@ -120,8 +120,7 @@ nine_upload_create(struct pipe_context *pipe, unsigned buffers_size,
DBG("\n");
if (!pipe->screen->get_param(pipe->screen,
PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT))
if (!pipe->screen->caps.buffer_map_persistent_coherent)
return NULL;
upload = CALLOC_STRUCT(nine_buffer_upload);

5
src/gallium/frontends/nine/nine_ff.c
View file

@ -304,7 +304,7 @@ struct vs_build_ctx
static inline unsigned
get_texcoord_sn(struct pipe_screen *screen)
{
if (screen->get_param(screen, PIPE_CAP_TGSI_TEXCOORD))
if (screen->caps.tgsi_texcoord)
return TGSI_SEMANTIC_TEXCOORD;
return TGSI_SEMANTIC_GENERIC;
}
@ -1552,8 +1552,7 @@ nine_ff_build_ps(struct NineDevice9 *device, struct nine_ff_ps_key *key)
if (key->fog_mode) {
struct ureg_dst rFog = ureg_writemask(ps.rTmp, TGSI_WRITEMASK_X);
struct ureg_src vPos;
if (device->screen->get_param(device->screen,
PIPE_CAP_FS_POSITION_IS_SYSVAL)) {
if (device->screen->caps.fs_position_is_sysval) {
vPos = ureg_DECL_system_value(ureg, TGSI_SEMANTIC_POSITION, 0);
} else {
vPos = ureg_DECL_fs_input(ureg, TGSI_SEMANTIC_POSITION, 0,

9
src/gallium/frontends/nine/query9.c
View file

@ -21,18 +21,17 @@ d3dquerytype_to_pipe_query(struct pipe_screen *screen, D3DQUERYTYPE type)
case D3DQUERYTYPE_EVENT:
return PIPE_QUERY_GPU_FINISHED;
case D3DQUERYTYPE_OCCLUSION:
return screen->get_param(screen, PIPE_CAP_OCCLUSION_QUERY) ?
return screen->caps.occlusion_query ?
PIPE_QUERY_OCCLUSION_COUNTER : PIPE_QUERY_TYPES;
case D3DQUERYTYPE_TIMESTAMP:
return screen->get_param(screen, PIPE_CAP_QUERY_TIMESTAMP) ?
return screen->caps.query_timestamp ?
PIPE_QUERY_TIMESTAMP : PIPE_QUERY_TYPES;
case D3DQUERYTYPE_TIMESTAMPDISJOINT:
case D3DQUERYTYPE_TIMESTAMPFREQ:
return screen->get_param(screen, PIPE_CAP_QUERY_TIMESTAMP) ?
return screen->caps.query_timestamp ?
PIPE_QUERY_TIMESTAMP_DISJOINT : PIPE_QUERY_TYPES;
case D3DQUERYTYPE_VERTEXSTATS:
return screen->get_param(screen,
PIPE_CAP_QUERY_PIPELINE_STATISTICS) ?
return screen->caps.query_pipeline_statistics ?
PIPE_QUERY_PIPELINE_STATISTICS : PIPE_QUERY_TYPES;
default:
return PIPE_QUERY_TYPES; /* Query not supported */

2
src/gallium/frontends/osmesa/osmesa.c
View file

@ -876,7 +876,7 @@ OSMesaGetIntegerv(GLint pname, GLint *value)
case OSMESA_MAX_HEIGHT:
{
struct pipe_screen *screen = get_st_manager()->screen;
*value = screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_SIZE);
*value = screen->caps.max_texture_2d_size;
}
return;
default:

6
src/gallium/frontends/va/context.c
View file

@ -208,7 +208,7 @@ VA_DRIVER_INIT_FUNC(VADriverContextP ctx)
if (!drv->vscreen->pscreen->get_video_param || !drv->vscreen->pscreen->is_video_format_supported)
goto error_pipe;
bool compute_only = drv->vscreen->pscreen->get_param(drv->vscreen->pscreen, PIPE_CAP_PREFER_COMPUTE_FOR_MULTIMEDIA);
bool compute_only = drv->vscreen->pscreen->caps.prefer_compute_for_multimedia;
drv->pipe = pipe_create_multimedia_context(drv->vscreen->pscreen, compute_only);
if (!drv->pipe)
goto error_pipe;
@ -217,8 +217,8 @@ VA_DRIVER_INIT_FUNC(VADriverContextP ctx)
if (!drv->htab)
goto error_htab;
bool can_init_compositor = (drv->vscreen->pscreen->get_param(drv->vscreen->pscreen, PIPE_CAP_GRAPHICS) ||
drv->vscreen->pscreen->get_param(drv->vscreen->pscreen, PIPE_CAP_COMPUTE));
bool can_init_compositor = drv->vscreen->pscreen->caps.graphics ||
drv->vscreen->pscreen->caps.compute;
if (can_init_compositor) {
if (!vl_compositor_init(&drv->compositor, drv->pipe, compute_only))

4
src/gallium/frontends/va/display.c
View file

@ -74,8 +74,8 @@ vlVaGetDisplayAttributes(VADriverContextP ctx, VADisplayAttribute *attr_list, in
switch (attr_list->type) {
#if VA_CHECK_VERSION(1, 15, 0)
case VADisplayPCIID: {
uint32_t vendor_id = pscreen->get_param(pscreen, PIPE_CAP_VENDOR_ID);
uint32_t device_id = pscreen->get_param(pscreen, PIPE_CAP_DEVICE_ID);
uint32_t vendor_id = pscreen->caps.vendor_id;
uint32_t device_id = pscreen->caps.device_id;
attr_list->min_value = attr_list->max_value = attr_list->value = (vendor_id << 16) | (device_id & 0xFFFF);
attr_list->flags = VA_DISPLAY_ATTRIB_GETTABLE;
break;

6
src/gallium/frontends/va/postproc.c
View file

@ -463,8 +463,7 @@ static VAStatus vlVaPostProcBlit(vlVaDriver *drv, vlVaContext *context,
blit.mask = PIPE_MASK_RGBA;
blit.filter = PIPE_TEX_MIPFILTER_LINEAR;
if (drv->pipe->screen->get_param(drv->pipe->screen,
PIPE_CAP_PREFER_COMPUTE_FOR_MULTIMEDIA))
if (drv->pipe->screen->caps.prefer_compute_for_multimedia)
util_compute_blit(drv->pipe, &blit, &context->blit_cs);
else
drv->pipe->blit(drv->pipe, &blit);
@ -674,8 +673,7 @@ vlVaHandleVAProcPipelineParameterBufferType(vlVaDriver *drv, vlVaContext *contex
/* Some devices may be media only (PIPE_VIDEO_ENTRYPOINT_PROCESSING with video engine)
* and won't have shader support
*/
if (!drv->vscreen->pscreen->get_param(drv->vscreen->pscreen, PIPE_CAP_GRAPHICS) &&
!drv->vscreen->pscreen->get_param(drv->vscreen->pscreen, PIPE_CAP_COMPUTE))
if (!drv->vscreen->pscreen->caps.graphics && !drv->vscreen->pscreen->caps.compute)
return VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
/* Subsampled formats not supported */

2
src/gallium/frontends/vdpau/device.c
View file

@ -88,7 +88,7 @@ vdp_imp_device_create_x11(Display *display, int screen, VdpDevice *device,
goto no_context;
}
if (!pscreen->get_param(pscreen, PIPE_CAP_NPOT_TEXTURES)) {
if (!pscreen->caps.npot_textures) {
ret = VDP_STATUS_NO_IMPLEMENTATION;
goto no_context;
}

2
src/gallium/frontends/vdpau/mixer.c
View file

@ -147,7 +147,7 @@ vlVdpVideoMixerCreate(VdpDevice device,
goto no_params;
}
max_size = screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_SIZE);
max_size = screen->caps.max_texture_2d_size;
if (vmixer->video_width < 48 || vmixer->video_width > max_size) {
VDPAU_MSG(VDPAU_WARN, "[VDPAU] 48 < %u < %u not valid for width\n",
vmixer->video_width, max_size);

8
src/gallium/frontends/vdpau/query.c
View file

@ -88,7 +88,7 @@ vlVdpVideoSurfaceQueryCapabilities(VdpDevice device, VdpChromaType surface_chrom
/* XXX: Current limits */
*is_supported = true;
max_2d_texture_size = pscreen->get_param(pscreen, PIPE_CAP_MAX_TEXTURE_2D_SIZE);
max_2d_texture_size = pscreen->caps.max_texture_2d_size;
mtx_unlock(&dev->mutex);
if (!max_2d_texture_size)
return VDP_STATUS_RESOURCES;
@ -260,8 +260,7 @@ vlVdpOutputSurfaceQueryCapabilities(VdpDevice device, VdpRGBAFormat surface_rgba
PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET
);
if (*is_supported) {
uint32_t max_2d_texture_size = pscreen->get_param(
pscreen, PIPE_CAP_MAX_TEXTURE_2D_SIZE);
uint32_t max_2d_texture_size = pscreen->caps.max_texture_2d_size;
if (!max_2d_texture_size) {
mtx_unlock(&dev->mutex);
@ -460,8 +459,7 @@ vlVdpBitmapSurfaceQueryCapabilities(VdpDevice device, VdpRGBAFormat surface_rgba
PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET
);
if (*is_supported) {
uint32_t max_2d_texture_size = pscreen->get_param(
pscreen, PIPE_CAP_MAX_TEXTURE_2D_SIZE);
uint32_t max_2d_texture_size = pscreen->caps.max_texture_2d_size;
if (!max_2d_texture_size) {
mtx_unlock(&dev->mutex);

3
src/gallium/frontends/wgl/stw_device.c
View file

@ -103,8 +103,7 @@ init_screen(const struct stw_winsys *stw_winsys, HDC hdc)
stw_dev->screen = screen;
stw_dev->zink = !memcmp(screen->get_name(screen), "zink", 4);
stw_dev->max_2d_length = screen->get_param(screen,
PIPE_CAP_MAX_TEXTURE_2D_SIZE);
stw_dev->max_2d_length = screen->caps.max_texture_2d_size;
return true;
}

2
src/gallium/targets/d3dadapter9/drm.c
View file

@ -232,7 +232,7 @@ drm_create_adapter( int fd,
return D3DERR_DRIVERINTERNALERROR;
}
if (!ctx->base.hal->get_param(ctx->base.hal, PIPE_CAP_DMABUF)) {
if (!ctx->base.hal->caps.dmabuf) {
ERR("The driver is not capable of dma-buf sharing."
"Abandon to load nine state tracker\n");
drm_destroy(&ctx->base);

2
src/gallium/winsys/sw/wrapper/wrapper_sw_winsys.c
View file

@ -306,7 +306,7 @@ wrapper_sw_winsys_wrap_pipe_screen(struct pipe_screen *screen)
if (!wsw->pipe)
goto err_free;
if(screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES))
if(screen->caps.npot_textures)
wsw->target = PIPE_TEXTURE_2D;
else
wsw->target = PIPE_TEXTURE_RECT;

4
src/gbm/backends/dri/gbm_dri.c
View file

@ -1209,9 +1209,9 @@ dri_device_create(int fd, uint32_t gbm_backend_version)
struct dri_screen *screen = dri->screen;
struct pipe_screen *pscreen = screen->base.screen;
#ifdef HAVE_LIBDRM
if (pscreen->get_param(pscreen, PIPE_CAP_DMABUF) & DRM_PRIME_CAP_IMPORT)
if (pscreen->caps.dmabuf & DRM_PRIME_CAP_IMPORT)
dri->has_dmabuf_import = true;
if (pscreen->get_param(pscreen, PIPE_CAP_DMABUF) & DRM_PRIME_CAP_EXPORT)
if (pscreen->caps.dmabuf & DRM_PRIME_CAP_EXPORT)
dri->has_dmabuf_export = true;
#endif
dri->has_compression_modifiers = pscreen->query_compression_rates &&

2
src/mesa/main/bufferobj.c
View file

@ -302,7 +302,7 @@ bufferobj_data(struct gl_context *ctx,
return GL_TRUE;
} else if (is_mapped) {
return GL_TRUE; /* can't reallocate, nothing to do */
} else if (screen->get_param(screen, PIPE_CAP_INVALIDATE_BUFFER)) {
} else if (screen->caps.invalidate_buffer) {
pipe->invalidate_resource(pipe, obj->buffer);
return GL_TRUE;
}

4
src/mesa/main/externalobjects.c
View file

@ -1189,7 +1189,7 @@ _mesa_ImportSemaphoreWin32HandleEXT(GLuint semaphore,
}
if (handleType == GL_HANDLE_TYPE_D3D12_FENCE_EXT &&
!ctx->screen->get_param(ctx->screen, PIPE_CAP_TIMELINE_SEMAPHORE_IMPORT)) {
!ctx->screen->caps.timeline_semaphore_import) {
_mesa_error(ctx, GL_INVALID_ENUM, "%s(handleType=%u)", func, handleType);
}
@ -1233,7 +1233,7 @@ _mesa_ImportSemaphoreWin32NameEXT(GLuint semaphore,
}
if (handleType == GL_HANDLE_TYPE_D3D12_FENCE_EXT &&
!ctx->screen->get_param(ctx->screen, PIPE_CAP_TIMELINE_SEMAPHORE_IMPORT)) {
!ctx->screen->caps.timeline_semaphore_import) {
_mesa_error(ctx, GL_INVALID_ENUM, "%s(handleType=%u)", func, handleType);
}

2
src/mesa/main/fbobject.c
View file

@ -1190,7 +1190,7 @@ do_validate_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb)
GLuint i;
enum pipe_format first_format = PIPE_FORMAT_NONE;
bool mixed_formats =
screen->get_param(screen, PIPE_CAP_MIXED_COLORBUFFER_FORMATS) != 0;
screen->caps.mixed_colorbuffer_formats != 0;
if (depth->Type && stencil->Type && depth->Type != stencil->Type) {
fbo_invalid("Different Depth/Stencil buffer formats");

4
src/mesa/main/glthread.c
View file

@ -214,8 +214,8 @@ _mesa_glthread_init(struct gl_context *ctx)
struct glthread_state *glthread = &ctx->GLThread;
assert(!glthread->enabled);
if (!screen->get_param(screen, PIPE_CAP_MAP_UNSYNCHRONIZED_THREAD_SAFE) ||
!screen->get_param(screen, PIPE_CAP_ALLOW_MAPPED_BUFFERS_DURING_EXECUTION))
if (!screen->caps.map_unsynchronized_thread_safe ||
!screen->caps.allow_mapped_buffers_during_execution)
return;
if (!util_queue_init(&glthread->queue, "gl", MARSHAL_MAX_BATCHES - 2,

6
src/mesa/main/queryobj.c
View file

@ -1345,7 +1345,7 @@ _mesa_init_queryobj(struct gl_context *ctx)
_mesa_InitHashTable(&ctx->Query.QueryObjects, ctx->Shared->ReuseGLNames);
ctx->Query.CurrentOcclusionObject = NULL;
if (screen->get_param(screen, PIPE_CAP_OCCLUSION_QUERY))
if (screen->caps.occlusion_query)
ctx->Const.QueryCounterBits.SamplesPassed = 64;
else
ctx->Const.QueryCounterBits.SamplesPassed = 0;
@ -1355,8 +1355,8 @@ _mesa_init_queryobj(struct gl_context *ctx)
ctx->Const.QueryCounterBits.PrimitivesGenerated = 64;
ctx->Const.QueryCounterBits.PrimitivesWritten = 64;
if (screen->get_param(screen, PIPE_CAP_QUERY_PIPELINE_STATISTICS) ||
screen->get_param(screen, PIPE_CAP_QUERY_PIPELINE_STATISTICS_SINGLE)) {
if (screen->caps.query_pipeline_statistics ||
screen->caps.query_pipeline_statistics_single) {
ctx->Const.QueryCounterBits.VerticesSubmitted = 64;
ctx->Const.QueryCounterBits.PrimitivesSubmitted = 64;
ctx->Const.QueryCounterBits.VsInvocations = 64;

2
src/mesa/state_tracker/st_cb_bitmap.c
View file

@ -319,7 +319,7 @@ draw_bitmap_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
* it up into chunks.
*/
ASSERTED GLuint maxSize =
st->screen->get_param(st->screen, PIPE_CAP_MAX_TEXTURE_2D_SIZE);
st->screen->caps.max_texture_2d_size;
assert(width <= (GLsizei) maxSize);
assert(height <= (GLsizei) maxSize);
}

4
src/mesa/state_tracker/st_cb_clear.c
View file

@ -162,7 +162,7 @@ set_vertex_shader_layered(struct st_context *st)
{
struct pipe_context *pipe = st->pipe;
if (!st->screen->get_param(st->screen, PIPE_CAP_VS_INSTANCEID)) {
if (!st->screen->caps.vs_instanceid) {
assert(!"Got layered clear, but VS instancing is unsupported");
set_vertex_shader(st);
return;
@ -170,7 +170,7 @@ set_vertex_shader_layered(struct st_context *st)
if (!st->clear.vs_layered) {
bool vs_layer =
st->screen->get_param(st->screen, PIPE_CAP_VS_LAYER_VIEWPORT);
st->screen->caps.vs_layer_viewport;
if (vs_layer) {
st->clear.vs_layered = make_nir_clear_vertex_shader(st, true);
} else {

6
src/mesa/state_tracker/st_cb_drawpixels.c
View file

@ -730,8 +730,7 @@ draw_textured_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
/* XXX if DrawPixels image is larger than max texture size, break
* it up into chunks.
*/
maxSize = st->screen->get_param(st->screen,
PIPE_CAP_MAX_TEXTURE_2D_SIZE);
maxSize = st->screen->caps.max_texture_2d_size;
assert(width <= maxSize);
assert(height <= maxSize);
@ -1165,8 +1164,7 @@ static void
clamp_size(struct st_context *st, GLsizei *width, GLsizei *height,
struct gl_pixelstore_attrib *unpack)
{
const int maxSize = st->screen->get_param(st->screen,
PIPE_CAP_MAX_TEXTURE_2D_SIZE);
const int maxSize = st->screen->caps.max_texture_2d_size;
if (*width > maxSize) {
if (unpack->RowLength == 0)

2
src/mesa/state_tracker/st_cb_flush.c
View file

@ -183,6 +183,6 @@ void
st_init_flush_functions(struct pipe_screen *screen,
struct dd_function_table *functions)
{
if (screen->get_param(screen, PIPE_CAP_DEVICE_RESET_STATUS_QUERY))
if (screen->caps.device_reset_status_query)
functions->GetGraphicsResetStatus = st_get_graphics_reset_status;
}

2
src/mesa/state_tracker/st_cb_readpixels.c
View file

@ -285,7 +285,7 @@ blit_to_staging(struct st_context *st, struct gl_renderbuffer *rb,
/* We are creating a texture of the size of the region being read back.
* Need to check for NPOT texture support. */
if (!screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES) &&
if (!screen->caps.npot_textures &&
(!util_is_power_of_two_or_zero(width) ||
!util_is_power_of_two_or_zero(height)))
return NULL;

4
src/mesa/state_tracker/st_cb_texture.c
View file

@ -2283,7 +2283,7 @@ st_TexSubImage(struct gl_context *ctx, GLuint dims,
&src_templ.depth0, &src_templ.array_size);
/* Check for NPOT texture support. */
if (!screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES) &&
if (!screen->caps.npot_textures &&
(!util_is_power_of_two_or_zero(src_templ.width0) ||
!util_is_power_of_two_or_zero(src_templ.height0) ||
!util_is_power_of_two_or_zero(src_templ.depth0))) {
@ -2490,7 +2490,7 @@ st_CompressedTexSubImage(struct gl_context *ctx, GLuint dims,
}
if (!st->pbo.upload_enabled ||
!screen->get_param(screen, PIPE_CAP_SURFACE_REINTERPRET_BLOCKS)) {
!screen->caps.surface_reinterpret_blocks) {
goto fallback;
}

93
src/mesa/state_tracker/st_context.c
View file

@ -447,7 +447,7 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
st->pipe = pipe;
st->can_bind_const_buffer_as_vertex =
screen->get_param(screen, PIPE_CAP_CAN_BIND_CONST_BUFFER_AS_VERTEX);
screen->caps.can_bind_const_buffer_as_vertex;
/* st/mesa always uploads zero-stride vertex attribs, and other user
* vertex buffers are only possible with a compatibility profile.
@ -480,14 +480,14 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
st_init_clear(st);
{
enum pipe_texture_transfer_mode val = screen->get_param(screen, PIPE_CAP_TEXTURE_TRANSFER_MODES);
enum pipe_texture_transfer_mode val = screen->caps.texture_transfer_modes;
st->prefer_blit_based_texture_transfer = (val & PIPE_TEXTURE_TRANSFER_BLIT) != 0;
st->allow_compute_based_texture_transfer = (val & PIPE_TEXTURE_TRANSFER_COMPUTE) != 0;
}
st_init_pbo_helpers(st);
/* Choose texture target for glDrawPixels, glBitmap, renderbuffers */
if (screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES))
if (screen->caps.npot_textures)
st->internal_target = PIPE_TEXTURE_2D;
else
st->internal_target = PIPE_TEXTURE_RECT;
@ -513,7 +513,7 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
}
ctx->Const.PackedDriverUniformStorage =
screen->get_param(screen, PIPE_CAP_PACKED_UNIFORMS);
screen->caps.packed_uniforms;
ctx->Const.BitmapUsesRed =
screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM,
@ -521,10 +521,10 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
PIPE_BIND_SAMPLER_VIEW);
ctx->Const.QueryCounterBits.Timestamp =
screen->get_param(screen, PIPE_CAP_QUERY_TIMESTAMP_BITS);
screen->caps.query_timestamp_bits;
st->has_stencil_export =
screen->get_param(screen, PIPE_CAP_SHADER_STENCIL_EXPORT);
screen->caps.shader_stencil_export;
st->has_etc1 = screen->is_format_supported(screen, PIPE_FORMAT_ETC1_RGB8,
PIPE_TEXTURE_2D, 0, 0,
PIPE_BIND_SAMPLER_VIEW);
@ -549,7 +549,7 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
screen->is_format_supported(screen, PIPE_FORMAT_ASTC_5x5_SRGB,
PIPE_TEXTURE_2D, 0, 0, PIPE_BIND_SAMPLER_VIEW);
st->astc_void_extents_need_denorm_flush =
screen->get_param(screen, PIPE_CAP_ASTC_VOID_EXTENTS_NEED_DENORM_FLUSH);
screen->caps.astc_void_extents_need_denorm_flush;
st->has_s3tc = screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA,
PIPE_TEXTURE_2D, 0, 0,
@ -564,49 +564,48 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
PIPE_TEXTURE_2D, 0, 0,
PIPE_BIND_SAMPLER_VIEW);
st->force_persample_in_shader =
screen->get_param(screen, PIPE_CAP_SAMPLE_SHADING) &&
!screen->get_param(screen, PIPE_CAP_FORCE_PERSAMPLE_INTERP);
st->has_shareable_shaders = screen->get_param(screen,
PIPE_CAP_SHAREABLE_SHADERS);
screen->caps.sample_shading &&
!screen->caps.force_persample_interp;
st->has_shareable_shaders = screen->caps.shareable_shaders;
st->needs_texcoord_semantic =
screen->get_param(screen, PIPE_CAP_TGSI_TEXCOORD);
screen->caps.tgsi_texcoord;
st->apply_texture_swizzle_to_border_color =
!!(screen->get_param(screen, PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK) &
!!(screen->caps.texture_border_color_quirk &
(PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_NV50 |
PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_R600));
st->use_format_with_border_color =
!!(screen->get_param(screen, PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK) &
!!(screen->caps.texture_border_color_quirk &
PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_FREEDRENO);
st->alpha_border_color_is_not_w =
!!(screen->get_param(screen, PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK) &
!!(screen->caps.texture_border_color_quirk &
PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_ALPHA_NOT_W);
st->emulate_gl_clamp =
!screen->get_param(screen, PIPE_CAP_GL_CLAMP);
!screen->caps.gl_clamp;
st->has_time_elapsed =
screen->get_param(screen, PIPE_CAP_QUERY_TIME_ELAPSED);
screen->caps.query_time_elapsed;
ctx->Const.GLSLHasHalfFloatPacking =
screen->get_param(screen, PIPE_CAP_SHADER_PACK_HALF_FLOAT);
screen->caps.shader_pack_half_float;
st->has_multi_draw_indirect =
screen->get_param(screen, PIPE_CAP_MULTI_DRAW_INDIRECT);
screen->caps.multi_draw_indirect;
st->has_indirect_partial_stride =
screen->get_param(screen, PIPE_CAP_MULTI_DRAW_INDIRECT_PARTIAL_STRIDE);
screen->caps.multi_draw_indirect_partial_stride;
st->has_occlusion_query =
screen->get_param(screen, PIPE_CAP_OCCLUSION_QUERY);
screen->caps.occlusion_query;
st->has_single_pipe_stat =
screen->get_param(screen, PIPE_CAP_QUERY_PIPELINE_STATISTICS_SINGLE);
screen->caps.query_pipeline_statistics_single;
st->has_pipeline_stat =
screen->get_param(screen, PIPE_CAP_QUERY_PIPELINE_STATISTICS);
screen->caps.query_pipeline_statistics;
st->has_indep_blend_enable =
screen->get_param(screen, PIPE_CAP_INDEP_BLEND_ENABLE);
screen->caps.indep_blend_enable;
st->has_indep_blend_func =
screen->get_param(screen, PIPE_CAP_INDEP_BLEND_FUNC);
screen->caps.indep_blend_func;
st->can_dither =
screen->get_param(screen, PIPE_CAP_DITHERING);
screen->caps.dithering;
st->lower_flatshade =
!screen->get_param(screen, PIPE_CAP_FLATSHADE);
!screen->caps.flatshade;
st->lower_alpha_test =
!screen->get_param(screen, PIPE_CAP_ALPHA_TEST);
switch (screen->get_param(screen, PIPE_CAP_POINT_SIZE_FIXED)) {
!screen->caps.alpha_test;
switch (screen->caps.point_size_fixed) {
case PIPE_POINT_SIZE_LOWER_ALWAYS:
st->lower_point_size = true;
st->add_point_size = true;
@ -617,17 +616,17 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
default: break;
}
st->lower_two_sided_color =
!screen->get_param(screen, PIPE_CAP_TWO_SIDED_COLOR);
!screen->caps.two_sided_color;
st->lower_ucp =
!screen->get_param(screen, PIPE_CAP_CLIP_PLANES);
!screen->caps.clip_planes;
st->prefer_real_buffer_in_constbuf0 =
screen->get_param(screen, PIPE_CAP_PREFER_REAL_BUFFER_IN_CONSTBUF0);
screen->caps.prefer_real_buffer_in_constbuf0;
st->has_conditional_render =
screen->get_param(screen, PIPE_CAP_CONDITIONAL_RENDER);
screen->caps.conditional_render;
st->lower_rect_tex =
!screen->get_param(screen, PIPE_CAP_TEXRECT);
!screen->caps.texrect;
st->allow_st_finalize_nir_twice =
screen->get_param(screen, PIPE_CAP_CALL_FINALIZE_NIR_IN_LINKER);
screen->caps.call_finalize_nir_in_linker;
st->has_hw_atomics =
screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
@ -635,15 +634,14 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
? true : false;
st->validate_all_dirty_states =
screen->get_param(screen, PIPE_CAP_VALIDATE_ALL_DIRTY_STATES)
screen->caps.validate_all_dirty_states
? true : false;
st->can_null_texture =
screen->get_param(screen, PIPE_CAP_NULL_TEXTURES)
screen->caps.null_textures
? true : false;
util_throttle_init(&st->throttle,
screen->get_param(screen,
PIPE_CAP_MAX_TEXTURE_UPLOAD_MEMORY_BUDGET));
screen->caps.max_texture_upload_memory_budget);
/* GL limits and extensions */
st_init_limits(screen, &ctx->Const, &ctx->Extensions, ctx->API);
@ -655,12 +653,12 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
}
/* Enable shader-based fallbacks for ARB_color_buffer_float if needed. */
if (screen->get_param(screen, PIPE_CAP_VERTEX_COLOR_UNCLAMPED)) {
if (!screen->get_param(screen, PIPE_CAP_VERTEX_COLOR_CLAMPED)) {
if (screen->caps.vertex_color_unclamped) {
if (!screen->caps.vertex_color_clamped) {
st->clamp_vert_color_in_shader = GL_TRUE;
}
if (!screen->get_param(screen, PIPE_CAP_FRAGMENT_COLOR_CLAMPED)) {
if (!screen->caps.fragment_color_clamped) {
st->clamp_frag_color_in_shader = GL_TRUE;
}
@ -681,11 +679,10 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
ctx->Point.MaxSize = MAX2(ctx->Const.MaxPointSize,
ctx->Const.MaxPointSizeAA);
ctx->Const.NoClippingOnCopyTex = screen->get_param(screen,
PIPE_CAP_NO_CLIP_ON_COPY_TEX);
ctx->Const.NoClippingOnCopyTex = screen->caps.no_clip_on_copy_tex;
ctx->Const.ForceFloat32TexNearest =
!screen->get_param(screen, PIPE_CAP_TEXTURE_FLOAT_LINEAR);
!screen->caps.texture_float_linear;
ctx->Const.ShaderCompilerOptions[MESA_SHADER_VERTEX].PositionAlwaysInvariant = options->vs_position_always_invariant;
@ -764,7 +761,7 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
list_inithead(&st->zombie_shaders.list.node);
simple_mtx_init(&st->zombie_shaders.mutex, mtx_plain);
ctx->Const.DriverSupportedPrimMask = screen->get_param(screen, PIPE_CAP_SUPPORTED_PRIM_MODES) |
ctx->Const.DriverSupportedPrimMask = screen->caps.supported_prim_modes |
/* patches is always supported */
BITFIELD_BIT(MESA_PRIM_PATCHES);
st->active_states = _mesa_get_active_states(ctx);
@ -843,10 +840,10 @@ st_create_context(gl_api api, struct pipe_context *pipe,
if (debug_get_option_mesa_mvp_dp4())
ctx->Const.ShaderCompilerOptions[MESA_SHADER_VERTEX].OptimizeForAOS = GL_TRUE;
if (pipe->screen->get_param(pipe->screen, PIPE_CAP_INVALIDATE_BUFFER))
if (pipe->screen->caps.invalidate_buffer)
ctx->has_invalidate_buffer = true;
if (pipe->screen->get_param(pipe->screen, PIPE_CAP_STRING_MARKER))
if (pipe->screen->caps.string_marker)
ctx->has_string_marker = true;
st = st_create_context_priv(ctx, pipe, options);

223
src/mesa/state_tracker/st_extensions.c
View file

@ -115,24 +115,24 @@ void st_init_limits(struct pipe_screen *screen,
bool can_ubo = true;
int temp;
c->MaxTextureSize = screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_SIZE);
c->MaxTextureSize = screen->caps.max_texture_2d_size;
c->MaxTextureSize = MIN2(c->MaxTextureSize, 1 << (MAX_TEXTURE_LEVELS - 1));
c->MaxTextureMbytes = MAX2(c->MaxTextureMbytes,
screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_MB));
screen->caps.max_texture_mb);
c->Max3DTextureLevels
= _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS),
= _min(screen->caps.max_texture_3d_levels,
MAX_TEXTURE_LEVELS);
extensions->OES_texture_3D = c->Max3DTextureLevels != 0;
c->MaxCubeTextureLevels
= _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS),
= _min(screen->caps.max_texture_cube_levels,
MAX_TEXTURE_LEVELS);
c->MaxTextureRectSize = _min(c->MaxTextureSize, MAX_TEXTURE_RECT_SIZE);
c->MaxArrayTextureLayers
= screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS);
= screen->caps.max_texture_array_layers;
/* Define max viewport size and max renderbuffer size in terms of
* max texture size (note: max tex RECT size = max tex 2D size).
@ -143,17 +143,16 @@ void st_init_limits(struct pipe_screen *screen,
c->MaxRenderbufferSize = c->MaxTextureRectSize;
c->SubPixelBits =
screen->get_param(screen, PIPE_CAP_RASTERIZER_SUBPIXEL_BITS);
screen->caps.rasterizer_subpixel_bits;
c->ViewportSubpixelBits =
screen->get_param(screen, PIPE_CAP_VIEWPORT_SUBPIXEL_BITS);
screen->caps.viewport_subpixel_bits;
c->MaxDrawBuffers = c->MaxColorAttachments =
_clamp(screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS),
_clamp(screen->caps.max_render_targets,
1, MAX_DRAW_BUFFERS);
c->MaxDualSourceDrawBuffers =
_clamp(screen->get_param(screen,
PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS),
_clamp(screen->caps.max_dual_source_render_targets,
0, MAX_DRAW_BUFFERS);
c->MaxLineWidth =
@ -182,11 +181,10 @@ void st_init_limits(struct pipe_screen *screen,
_minf(31.0f, screen->get_paramf(screen, PIPE_CAPF_MAX_TEXTURE_LOD_BIAS));
c->QuadsFollowProvokingVertexConvention =
screen->get_param(screen,
PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION);
screen->caps.quads_follow_provoking_vertex_convention;
c->MaxUniformBlockSize =
screen->get_param(screen, PIPE_CAP_MAX_CONSTANT_BUFFER_SIZE_UINT);
screen->caps.max_constant_buffer_size_uint;
if (c->MaxUniformBlockSize < 16384) {
can_ubo = false;
@ -197,9 +195,9 @@ void st_init_limits(struct pipe_screen *screen,
*/
c->MaxUniformBlockSize &= ~3;
c->HasFBFetch = screen->get_param(screen, PIPE_CAP_FBFETCH);
c->HasFBFetch = screen->caps.fbfetch;
c->PointSizeFixed = screen->get_param(screen, PIPE_CAP_POINT_SIZE_FIXED) != PIPE_POINT_SIZE_LOWER_ALWAYS;
c->PointSizeFixed = screen->caps.point_size_fixed != PIPE_POINT_SIZE_LOWER_ALWAYS;
for (sh = 0; sh < PIPE_SHADER_TYPES; ++sh) {
const gl_shader_stage stage = tgsi_processor_to_shader_stage(sh);
@ -216,7 +214,7 @@ void st_init_limits(struct pipe_screen *screen,
}
if (sh == PIPE_SHADER_COMPUTE) {
if (!screen->get_param(screen, PIPE_CAP_COMPUTE))
if (!screen->caps.compute)
continue;
}
@ -250,13 +248,13 @@ void st_init_limits(struct pipe_screen *screen,
sh == PIPE_SHADER_TESS_EVAL ||
sh == PIPE_SHADER_GEOMETRY) {
if (!screen->get_param(screen, PIPE_CAP_CLIP_PLANES))
if (!screen->caps.clip_planes)
pc->MaxUniformComponents -= 4 * MAX_CLIP_PLANES;
if (!screen->get_param(screen, PIPE_CAP_POINT_SIZE_FIXED))
if (!screen->caps.point_size_fixed)
pc->MaxUniformComponents -= 4;
} else if (sh == PIPE_SHADER_FRAGMENT) {
if (!screen->get_param(screen, PIPE_CAP_ALPHA_TEST))
if (!screen->caps.alpha_test)
pc->MaxUniformComponents -= 4;
}
@ -364,9 +362,9 @@ void st_init_limits(struct pipe_screen *screen,
}
if (sh == PIPE_SHADER_VERTEX || sh == PIPE_SHADER_GEOMETRY) {
if (screen->get_param(screen, PIPE_CAP_VIEWPORT_TRANSFORM_LOWERED))
if (screen->caps.viewport_transform_lowered)
options->LowerBuiltinVariablesXfb |= VARYING_BIT_POS;
if (screen->get_param(screen, PIPE_CAP_PSIZ_CLAMPED))
if (screen->caps.psiz_clamped)
options->LowerBuiltinVariablesXfb |= VARYING_BIT_PSIZ;
}
@ -390,9 +388,9 @@ void st_init_limits(struct pipe_screen *screen,
c->Program[MESA_SHADER_FRAGMENT].MaxUniformComponents;
c->GLSLLowerConstArrays =
screen->get_param(screen, PIPE_CAP_PREFER_IMM_ARRAYS_AS_CONSTBUF);
screen->caps.prefer_imm_arrays_as_constbuf;
c->GLSLTessLevelsAsInputs =
screen->get_param(screen, PIPE_CAP_GLSL_TESS_LEVELS_AS_INPUTS);
screen->caps.glsl_tess_levels_as_inputs;
c->PrimitiveRestartForPatches = false;
c->MaxCombinedTextureImageUnits =
@ -416,59 +414,58 @@ void st_init_limits(struct pipe_screen *screen,
c->Program[MESA_SHADER_VERTEX].MaxAttribs =
MIN2(c->Program[MESA_SHADER_VERTEX].MaxAttribs, 16);
c->MaxVarying = screen->get_param(screen, PIPE_CAP_MAX_VARYINGS);
c->MaxVarying = screen->caps.max_varyings;
c->MaxVarying = MIN2(c->MaxVarying, MAX_VARYING);
c->MaxGeometryOutputVertices =
screen->get_param(screen, PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES);
screen->caps.max_geometry_output_vertices;
c->MaxGeometryTotalOutputComponents =
screen->get_param(screen, PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS);
screen->caps.max_geometry_total_output_components;
c->MaxGeometryShaderInvocations =
screen->get_param(screen, PIPE_CAP_MAX_GS_INVOCATIONS);
screen->caps.max_gs_invocations;
c->MaxTessPatchComponents =
MIN2(screen->get_param(screen, PIPE_CAP_MAX_SHADER_PATCH_VARYINGS),
MIN2(screen->caps.max_shader_patch_varyings,
MAX_VARYING) * 4;
c->MinProgramTexelOffset =
screen->get_param(screen, PIPE_CAP_MIN_TEXEL_OFFSET);
screen->caps.min_texel_offset;
c->MaxProgramTexelOffset =
screen->get_param(screen, PIPE_CAP_MAX_TEXEL_OFFSET);
screen->caps.max_texel_offset;
c->MaxProgramTextureGatherComponents =
screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS);
screen->caps.max_texture_gather_components;
c->MinProgramTextureGatherOffset =
screen->get_param(screen, PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET);
screen->caps.min_texture_gather_offset;
c->MaxProgramTextureGatherOffset =
screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET);
screen->caps.max_texture_gather_offset;
c->MaxTransformFeedbackBuffers =
screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS);
screen->caps.max_stream_output_buffers;
c->MaxTransformFeedbackBuffers = MIN2(c->MaxTransformFeedbackBuffers,
MAX_FEEDBACK_BUFFERS);
c->MaxTransformFeedbackSeparateComponents =
screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS);
screen->caps.max_stream_output_separate_components;
c->MaxTransformFeedbackInterleavedComponents =
screen->get_param(screen,
PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS);
screen->caps.max_stream_output_interleaved_components;
c->MaxVertexStreams =
MAX2(1, screen->get_param(screen, PIPE_CAP_MAX_VERTEX_STREAMS));
MAX2(1, screen->caps.max_vertex_streams);
/* The vertex stream must fit into pipe_stream_output_info::stream */
assert(c->MaxVertexStreams <= 4);
c->MaxVertexAttribStride
= screen->get_param(screen, PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE);
= screen->caps.max_vertex_attrib_stride;
/* The value cannot be larger than that since pipe_vertex_buffer::src_offset
* is only 16 bits.
*/
temp = screen->get_param(screen, PIPE_CAP_MAX_VERTEX_ELEMENT_SRC_OFFSET);
temp = screen->caps.max_vertex_element_src_offset;
c->MaxVertexAttribRelativeOffset = MIN2(0xffff, temp);
c->GLSLSkipStrictMaxUniformLimitCheck =
screen->get_param(screen, PIPE_CAP_TGSI_CAN_COMPACT_CONSTANTS);
screen->caps.tgsi_can_compact_constants;
c->UniformBufferOffsetAlignment =
screen->get_param(screen, PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT);
screen->caps.constant_buffer_offset_alignment;
if (can_ubo) {
extensions->ARB_uniform_buffer_object = GL_TRUE;
@ -483,17 +480,17 @@ void st_init_limits(struct pipe_screen *screen,
}
c->GLSLFragCoordIsSysVal =
screen->get_param(screen, PIPE_CAP_FS_POSITION_IS_SYSVAL);
screen->caps.fs_position_is_sysval;
c->GLSLPointCoordIsSysVal =
screen->get_param(screen, PIPE_CAP_FS_POINT_IS_SYSVAL);
screen->caps.fs_point_is_sysval;
c->GLSLFrontFacingIsSysVal =
screen->get_param(screen, PIPE_CAP_FS_FACE_IS_INTEGER_SYSVAL);
screen->caps.fs_face_is_integer_sysval;
/* GL_ARB_get_program_binary */
if (screen->get_disk_shader_cache && screen->get_disk_shader_cache(screen))
c->NumProgramBinaryFormats = 1;
/* GL_ARB_gl_spirv */
if (screen->get_param(screen, PIPE_CAP_GL_SPIRV) &&
if (screen->caps.gl_spirv &&
(api == API_OPENGL_CORE || api == API_OPENGL_COMPAT))
c->NumShaderBinaryFormats = 1;
@ -505,8 +502,7 @@ void st_init_limits(struct pipe_screen *screen,
c->Program[MESA_SHADER_COMPUTE].MaxAtomicCounters);
c->MaxCombinedAtomicBuffers =
MIN2(screen->get_param(screen,
PIPE_CAP_MAX_COMBINED_HW_ATOMIC_COUNTER_BUFFERS),
MIN2(screen->caps.max_combined_hw_atomic_counter_buffers,
MAX_COMBINED_ATOMIC_BUFFERS);
if (!c->MaxCombinedAtomicBuffers) {
c->MaxCombinedAtomicBuffers = MAX2(
@ -520,7 +516,7 @@ void st_init_limits(struct pipe_screen *screen,
}
c->MaxCombinedAtomicCounters =
screen->get_param(screen, PIPE_CAP_MAX_COMBINED_HW_ATOMIC_COUNTERS);
screen->caps.max_combined_hw_atomic_counters;
if (!c->MaxCombinedAtomicCounters)
c->MaxCombinedAtomicCounters = MAX_ATOMIC_COUNTERS;
@ -531,10 +527,10 @@ void st_init_limits(struct pipe_screen *screen,
c->MaxCombinedShaderOutputResources = c->MaxDrawBuffers;
c->ShaderStorageBufferOffsetAlignment =
screen->get_param(screen, PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT);
screen->caps.shader_buffer_offset_alignment;
if (c->ShaderStorageBufferOffsetAlignment) {
c->MaxCombinedShaderStorageBlocks =
MIN2(screen->get_param(screen, PIPE_CAP_MAX_COMBINED_SHADER_BUFFERS),
MIN2(screen->caps.max_combined_shader_buffers,
MAX_COMBINED_SHADER_STORAGE_BUFFERS);
if (!c->MaxCombinedShaderStorageBlocks) {
c->MaxCombinedShaderStorageBlocks = MAX2(
@ -551,7 +547,7 @@ void st_init_limits(struct pipe_screen *screen,
c->MaxCombinedShaderOutputResources +=
c->MaxCombinedShaderStorageBlocks;
c->MaxShaderStorageBlockSize =
screen->get_param(screen, PIPE_CAP_MAX_SHADER_BUFFER_SIZE_UINT);
screen->caps.max_shader_buffer_size_uint;
if (c->Program[MESA_SHADER_FRAGMENT].MaxShaderStorageBlocks)
extensions->ARB_shader_storage_buffer_object = GL_TRUE;
}
@ -566,7 +562,7 @@ void st_init_limits(struct pipe_screen *screen,
c->MaxCombinedShaderOutputResources += c->MaxCombinedImageUniforms;
c->MaxImageUnits = MAX_IMAGE_UNITS;
if (c->Program[MESA_SHADER_FRAGMENT].MaxImageUniforms &&
screen->get_param(screen, PIPE_CAP_IMAGE_STORE_FORMATTED)) {
screen->caps.image_store_formatted) {
extensions->ARB_shader_image_load_store = GL_TRUE;
extensions->ARB_shader_image_size = GL_TRUE;
}
@ -581,22 +577,22 @@ void st_init_limits(struct pipe_screen *screen,
* in practicality.
*/
c->MaxFramebufferLayers =
screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS);
screen->caps.max_texture_array_layers;
c->MaxWindowRectangles =
screen->get_param(screen, PIPE_CAP_MAX_WINDOW_RECTANGLES);
screen->caps.max_window_rectangles;
c->SparseBufferPageSize =
screen->get_param(screen, PIPE_CAP_SPARSE_BUFFER_PAGE_SIZE);
screen->caps.sparse_buffer_page_size;
c->AllowMappedBuffersDuringExecution =
screen->get_param(screen, PIPE_CAP_ALLOW_MAPPED_BUFFERS_DURING_EXECUTION);
screen->caps.allow_mapped_buffers_during_execution;
c->UseSTD430AsDefaultPacking =
screen->get_param(screen, PIPE_CAP_LOAD_CONSTBUF);
screen->caps.load_constbuf;
c->MaxSubpixelPrecisionBiasBits =
screen->get_param(screen, PIPE_CAP_MAX_CONSERVATIVE_RASTER_SUBPIXEL_PRECISION_BIAS);
screen->caps.max_conservative_raster_subpixel_precision_bias;
c->ConservativeRasterDilateRange[0] =
screen->get_paramf(screen, PIPE_CAPF_MIN_CONSERVATIVE_RASTER_DILATE);
@ -606,45 +602,45 @@ void st_init_limits(struct pipe_screen *screen,
screen->get_paramf(screen, PIPE_CAPF_CONSERVATIVE_RASTER_DILATE_GRANULARITY);
/* limit the max combined shader output resources to a driver limit */
temp = screen->get_param(screen, PIPE_CAP_MAX_COMBINED_SHADER_OUTPUT_RESOURCES);
temp = screen->caps.max_combined_shader_output_resources;
if (temp > 0 && c->MaxCombinedShaderOutputResources > temp)
c->MaxCombinedShaderOutputResources = temp;
c->VertexBufferOffsetIsInt32 =
screen->get_param(screen, PIPE_CAP_SIGNED_VERTEX_BUFFER_OFFSET);
screen->caps.signed_vertex_buffer_offset;
c->UseVAOFastPath =
screen->get_param(screen, PIPE_CAP_ALLOW_DYNAMIC_VAO_FASTPATH);
screen->caps.allow_dynamic_vao_fastpath;
c->glBeginEndBufferSize =
screen->get_param(screen, PIPE_CAP_GL_BEGIN_END_BUFFER_SIZE);
screen->caps.gl_begin_end_buffer_size;
c->MaxSparseTextureSize =
screen->get_param(screen, PIPE_CAP_MAX_SPARSE_TEXTURE_SIZE);
screen->caps.max_sparse_texture_size;
c->MaxSparse3DTextureSize =
screen->get_param(screen, PIPE_CAP_MAX_SPARSE_3D_TEXTURE_SIZE);
screen->caps.max_sparse_3d_texture_size;
c->MaxSparseArrayTextureLayers =
screen->get_param(screen, PIPE_CAP_MAX_SPARSE_ARRAY_TEXTURE_LAYERS);
screen->caps.max_sparse_array_texture_layers;
c->SparseTextureFullArrayCubeMipmaps =
screen->get_param(screen, PIPE_CAP_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS);
screen->caps.sparse_texture_full_array_cube_mipmaps;
c->HardwareAcceleratedSelect =
screen->get_param(screen, PIPE_CAP_HARDWARE_GL_SELECT);
screen->caps.hardware_gl_select;
c->AllowGLThreadBufferSubDataOpt =
screen->get_param(screen, PIPE_CAP_ALLOW_GLTHREAD_BUFFER_SUBDATA_OPT);
screen->caps.allow_glthread_buffer_subdata_opt;
c->HasDrawVertexState =
screen->get_param(screen, PIPE_CAP_DRAW_VERTEX_STATE);
screen->caps.draw_vertex_state;
c->ShaderSubgroupSize =
screen->get_param(screen, PIPE_CAP_SHADER_SUBGROUP_SIZE);
screen->caps.shader_subgroup_size;
c->ShaderSubgroupSupportedStages =
mesa_to_gl_stages(screen->get_param(screen, PIPE_CAP_SHADER_SUBGROUP_SUPPORTED_STAGES));
mesa_to_gl_stages(screen->caps.shader_subgroup_supported_stages);
c->ShaderSubgroupSupportedFeatures =
screen->get_param(screen, PIPE_CAP_SHADER_SUBGROUP_SUPPORTED_FEATURES);
screen->caps.shader_subgroup_supported_features;
c->ShaderSubgroupQuadAllStages =
screen->get_param(screen, PIPE_CAP_SHADER_SUBGROUP_QUAD_ALL_STAGES);
screen->caps.shader_subgroup_quad_all_stages;
}
@ -1174,12 +1170,12 @@ void st_init_extensions(struct pipe_screen *screen,
PIPE_BIND_VERTEX_BUFFER);
/* Figure out GLSL support and set GLSLVersion to it. */
consts->GLSLVersion = screen->get_param(screen, PIPE_CAP_GLSL_FEATURE_LEVEL);
consts->GLSLVersion = screen->caps.glsl_feature_level;
consts->GLSLVersionCompat =
screen->get_param(screen, PIPE_CAP_GLSL_FEATURE_LEVEL_COMPATIBILITY);
screen->caps.glsl_feature_level_compatibility;
const unsigned ESSLVersion =
screen->get_param(screen, PIPE_CAP_ESSL_FEATURE_LEVEL);
screen->caps.essl_feature_level;
const unsigned GLSLVersion =
api == API_OPENGL_COMPAT ? consts->GLSLVersionCompat :
consts->GLSLVersion;
@ -1213,7 +1209,7 @@ void st_init_extensions(struct pipe_screen *screen,
consts->ForceMapBufferSynchronized = options->force_gl_map_buffer_synchronized;
consts->PrimitiveRestartFixedIndex =
screen->get_param(screen, PIPE_CAP_PRIMITIVE_RESTART_FIXED_INDEX);
screen->caps.primitive_restart_fixed_index;
/* Technically we are turning on the EXT_gpu_shader5 extension,
* ARB_gpu_shader5 does not exist in GLES, but this flag is what
@ -1230,7 +1226,7 @@ void st_init_extensions(struct pipe_screen *screen,
/* This extension needs full OpenGL 3.2, but we don't know if that's
* supported at this point. Only check the GLSL version. */
if (GLSLVersion >= 150 &&
screen->get_param(screen, PIPE_CAP_VS_LAYER_VIEWPORT)) {
screen->caps.vs_layer_viewport) {
extensions->AMD_vertex_shader_layer = GL_TRUE;
}
@ -1244,7 +1240,7 @@ void st_init_extensions(struct pipe_screen *screen,
extensions->EXT_texture_buffer_object = GL_TRUE;
if (consts->MaxTransformFeedbackBuffers &&
screen->get_param(screen, PIPE_CAP_SHADER_ARRAY_COMPONENTS))
screen->caps.shader_array_components)
extensions->ARB_enhanced_layouts = GL_TRUE;
}
@ -1252,7 +1248,7 @@ void st_init_extensions(struct pipe_screen *screen,
consts->NativeIntegers = GL_TRUE;
consts->MaxClipPlanes = 8;
uint32_t drv_clip_planes = screen->get_param(screen, PIPE_CAP_CLIP_PLANES);
uint32_t drv_clip_planes = screen->caps.clip_planes;
/* only override for > 1 - 0 if none, 1 is MAX, >2 overrides MAX */
if (drv_clip_planes > 1)
consts->MaxClipPlanes = drv_clip_planes;
@ -1270,7 +1266,7 @@ void st_init_extensions(struct pipe_screen *screen,
extensions->ARB_arrays_of_arrays = GL_TRUE;
extensions->MESA_shader_integer_functions = GL_TRUE;
switch (screen->get_param(screen, PIPE_CAP_MULTIVIEW)) {
switch (screen->caps.multiview) {
case 1:
extensions->OVR_multiview = GL_TRUE;
break;
@ -1283,8 +1279,8 @@ void st_init_extensions(struct pipe_screen *screen,
extensions->OVR_multiview_multisampled_render_to_texture = extensions->EXT_multisampled_render_to_texture &&
extensions->OVR_multiview;
if (screen->get_param(screen, PIPE_CAP_OPENCL_INTEGER_FUNCTIONS) &&
screen->get_param(screen, PIPE_CAP_INTEGER_MULTIPLY_32X16)) {
if (screen->caps.opencl_integer_functions &&
screen->caps.integer_multiply_32x16) {
extensions->INTEL_shader_integer_functions2 = GL_TRUE;
}
} else {
@ -1306,7 +1302,7 @@ void st_init_extensions(struct pipe_screen *screen,
if (options->glsl_zero_init) {
consts->GLSLZeroInit = 1;
} else {
consts->GLSLZeroInit = screen->get_param(screen, PIPE_CAP_GLSL_ZERO_INIT);
consts->GLSLZeroInit = screen->caps.glsl_zero_init;
}
consts->ForceIntegerTexNearest = options->force_integer_tex_nearest;
@ -1476,7 +1472,7 @@ void st_init_extensions(struct pipe_screen *screen,
extensions->EXT_framebuffer_multisample_blit_scaled = GL_TRUE;
}
else if (consts->MaxSamples > 0 &&
screen->get_param(screen, PIPE_CAP_FAKE_SW_MSAA)) {
screen->caps.fake_sw_msaa) {
/* fake MSAA support */
consts->FakeSWMSAA = GL_TRUE;
extensions->EXT_framebuffer_multisample = GL_TRUE;
@ -1488,7 +1484,7 @@ void st_init_extensions(struct pipe_screen *screen,
!options->disable_blend_func_extended)
extensions->ARB_blend_func_extended = GL_TRUE;
if (screen->get_param(screen, PIPE_CAP_QUERY_TIME_ELAPSED) ||
if (screen->caps.query_time_elapsed ||
extensions->ARB_timer_query) {
extensions->EXT_timer_query = GL_TRUE;
}
@ -1524,18 +1520,18 @@ void st_init_extensions(struct pipe_screen *screen,
consts->AllowGLSLRelaxedES = GL_TRUE;
consts->MinMapBufferAlignment =
screen->get_param(screen, PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT);
screen->caps.min_map_buffer_alignment;
/* The OpenGL Compatibility profile requires arbitrary buffer swizzling. */
if (api == API_OPENGL_COMPAT &&
screen->get_param(screen, PIPE_CAP_BUFFER_SAMPLER_VIEW_RGBA_ONLY))
screen->caps.buffer_sampler_view_rgba_only)
extensions->ARB_texture_buffer_object = GL_FALSE;
if (extensions->ARB_texture_buffer_object) {
consts->MaxTextureBufferSize =
screen->get_param(screen, PIPE_CAP_MAX_TEXEL_BUFFER_ELEMENTS_UINT);
screen->caps.max_texel_buffer_elements_uint;
consts->TextureBufferOffsetAlignment =
screen->get_param(screen, PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT);
screen->caps.texture_buffer_offset_alignment;
if (consts->TextureBufferOffsetAlignment)
extensions->ARB_texture_buffer_range = GL_TRUE;
@ -1552,7 +1548,7 @@ void st_init_extensions(struct pipe_screen *screen,
extensions->ARB_texture_buffer_object_rgb32;
extensions->EXT_framebuffer_sRGB =
screen->get_param(screen, PIPE_CAP_DEST_SURFACE_SRGB_CONTROL) &&
screen->caps.dest_surface_srgb_control &&
extensions->EXT_sRGB;
/* Unpacking a varying in the fragment shader costs 1 texture indirection.
@ -1569,17 +1565,16 @@ void st_init_extensions(struct pipe_screen *screen,
consts->DisableVaryingPacking = GL_TRUE;
}
if (!screen->get_param(screen, PIPE_CAP_PACKED_STREAM_OUTPUT))
if (!screen->caps.packed_stream_output)
consts->DisableTransformFeedbackPacking = GL_TRUE;
if (screen->get_param(screen, PIPE_CAP_PREFER_POT_ALIGNED_VARYINGS))
if (screen->caps.prefer_pot_aligned_varyings)
consts->PreferPOTAlignedVaryings = GL_TRUE;
unsigned max_fb_fetch_rts = screen->get_param(screen, PIPE_CAP_FBFETCH);
bool coherent_fb_fetch =
screen->get_param(screen, PIPE_CAP_FBFETCH_COHERENT);
unsigned max_fb_fetch_rts = screen->caps.fbfetch;
bool coherent_fb_fetch = screen->caps.fbfetch_coherent;
if (screen->get_param(screen, PIPE_CAP_BLEND_EQUATION_ADVANCED))
if (screen->caps.blend_equation_advanced)
extensions->KHR_blend_equation_advanced = true;
if (max_fb_fetch_rts > 0) {
@ -1587,13 +1582,13 @@ void st_init_extensions(struct pipe_screen *screen,
extensions->KHR_blend_equation_advanced_coherent = coherent_fb_fetch;
if (max_fb_fetch_rts >=
screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS)) {
screen->caps.max_render_targets) {
extensions->EXT_shader_framebuffer_fetch_non_coherent = true;
extensions->EXT_shader_framebuffer_fetch = coherent_fb_fetch;
}
}
consts->MaxViewports = screen->get_param(screen, PIPE_CAP_MAX_VIEWPORTS);
consts->MaxViewports = screen->caps.max_viewports;
if (consts->MaxViewports >= 16) {
if (GLSLVersion >= 400) {
consts->ViewportBounds.Min = -32768.0;
@ -1610,11 +1605,11 @@ void st_init_extensions(struct pipe_screen *screen,
if (extensions->AMD_vertex_shader_layer &&
extensions->AMD_vertex_shader_viewport_index &&
screen->get_param(screen, PIPE_CAP_TES_LAYER_VIEWPORT))
screen->caps.tes_layer_viewport)
extensions->ARB_shader_viewport_layer_array = GL_TRUE;
/* ARB_framebuffer_no_attachments */
if (screen->get_param(screen, PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT) &&
if (screen->caps.framebuffer_no_attachment &&
((consts->MaxSamples >= 4 && consts->MaxFramebufferLayers >= 2048) ||
(consts->MaxFramebufferSamples >= consts->MaxSamples &&
consts->MaxFramebufferLayers >= consts->MaxArrayTextureLayers)))
@ -1660,16 +1655,16 @@ void st_init_extensions(struct pipe_screen *screen,
}
#endif
if (screen->get_param(screen, PIPE_CAP_DOUBLES)) {
if (screen->caps.doubles) {
extensions->ARB_gpu_shader_fp64 = GL_TRUE;
extensions->ARB_vertex_attrib_64bit = GL_TRUE;
}
if ((ST_DEBUG & DEBUG_GREMEDY) &&
screen->get_param(screen, PIPE_CAP_STRING_MARKER))
screen->caps.string_marker)
extensions->GREMEDY_string_marker = GL_TRUE;
if (screen->get_param(screen, PIPE_CAP_COMPUTE)) {
if (screen->caps.compute) {
uint64_t grid_size[3], block_size[3];
uint64_t max_local_size, max_threads_per_block;
@ -1810,21 +1805,21 @@ void st_init_extensions(struct pipe_screen *screen,
extensions->ARB_texture_stencil8 &&
extensions->ARB_texture_multisample;
if (screen->get_param(screen, PIPE_CAP_CONSERVATIVE_RASTER_POST_SNAP_TRIANGLES) &&
screen->get_param(screen, PIPE_CAP_CONSERVATIVE_RASTER_POST_SNAP_POINTS_LINES) &&
screen->get_param(screen, PIPE_CAP_CONSERVATIVE_RASTER_POST_DEPTH_COVERAGE)) {
if (screen->caps.conservative_raster_post_snap_triangles &&
screen->caps.conservative_raster_post_snap_points_lines &&
screen->caps.conservative_raster_post_depth_coverage) {
float max_dilate;
bool pre_snap_triangles, pre_snap_points_lines;
max_dilate = screen->get_paramf(screen, PIPE_CAPF_MAX_CONSERVATIVE_RASTER_DILATE);
pre_snap_triangles =
screen->get_param(screen, PIPE_CAP_CONSERVATIVE_RASTER_PRE_SNAP_TRIANGLES);
screen->caps.conservative_raster_pre_snap_triangles;
pre_snap_points_lines =
screen->get_param(screen, PIPE_CAP_CONSERVATIVE_RASTER_PRE_SNAP_POINTS_LINES);
screen->caps.conservative_raster_pre_snap_points_lines;
extensions->NV_conservative_raster =
screen->get_param(screen, PIPE_CAP_MAX_CONSERVATIVE_RASTER_SUBPIXEL_PRECISION_BIAS) > 1;
screen->caps.max_conservative_raster_subpixel_precision_bias > 1;
if (extensions->NV_conservative_raster) {
extensions->NV_conservative_raster_dilate = max_dilate >= 0.75;
@ -1840,7 +1835,7 @@ void st_init_extensions(struct pipe_screen *screen,
extensions->ARB_shader_draw_parameters;
consts->SpirVExtensions->supported[SPV_KHR_storage_buffer_storage_class] = true;
consts->SpirVExtensions->supported[SPV_KHR_variable_pointers] =
screen->get_param(screen, PIPE_CAP_GL_SPIRV_VARIABLE_POINTERS);
screen->caps.gl_spirv_variable_pointers;
consts->SpirVExtensions->supported[SPV_KHR_shader_ballot] =
extensions->ARB_shader_ballot;
consts->SpirVExtensions->supported[SPV_KHR_subgroup_vote] =
@ -1850,7 +1845,7 @@ void st_init_extensions(struct pipe_screen *screen,
consts->AllowDrawOutOfOrder =
api == API_OPENGL_COMPAT &&
options->allow_draw_out_of_order &&
screen->get_param(screen, PIPE_CAP_ALLOW_DRAW_OUT_OF_ORDER);
screen->caps.allow_draw_out_of_order;
consts->GLThreadNopCheckFramebufferStatus = options->glthread_nop_check_framebuffer_status;
const struct nir_shader_compiler_options *nir_options =
@ -1858,7 +1853,7 @@ void st_init_extensions(struct pipe_screen *screen,
if (screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_INTEGERS) &&
extensions->ARB_stencil_texturing &&
screen->get_param(screen, PIPE_CAP_DOUBLES) &&
screen->caps.doubles &&
!(nir_options->lower_doubles_options & nir_lower_fp64_full_software))
extensions->NV_copy_depth_to_color = true;
}

3
src/mesa/state_tracker/st_gen_mipmap.c
View file

@ -141,8 +141,7 @@ st_generate_mipmap(struct gl_context *ctx, GLenum target,
* if not then generate the mipmap by rendering/texturing.
* If that fails, use the software fallback.
*/
if (!st->screen->get_param(st->screen,
PIPE_CAP_GENERATE_MIPMAP) ||
if (!st->screen->caps.generate_mipmap ||
!st->pipe->generate_mipmap(st->pipe, pt, format, baseLevel,
lastLevel, first_layer, last_layer)) {

22
src/mesa/state_tracker/st_glsl_to_nir.cpp
View file

@ -323,7 +323,7 @@ st_glsl_to_nir_post_opts(struct st_context *st, struct gl_program *prog,
!st->ctx->Const.PackedDriverUniformStorage)
NIR_PASS(_, nir, st_nir_lower_builtin);
if (!screen->get_param(screen, PIPE_CAP_NIR_ATOMICS_AS_DEREF))
if (!screen->caps.nir_atomics_as_deref)
NIR_PASS(_, nir, gl_nir_lower_atomics, shader_program, true);
NIR_PASS(_, nir, nir_opt_intrinsics);
@ -367,7 +367,7 @@ st_glsl_to_nir_post_opts(struct st_context *st, struct gl_program *prog,
nir_var_shader_in | nir_var_shader_out | nir_var_function_temp;
nir_remove_dead_variables(nir, mask, NULL);
if (!st->has_hw_atomics && !screen->get_param(screen, PIPE_CAP_NIR_ATOMICS_AS_DEREF)) {
if (!st->has_hw_atomics && !screen->caps.nir_atomics_as_deref) {
unsigned align_offset_state = 0;
if (st->ctx->Const.ShaderStorageBufferOffsetAlignment > 4) {
struct gl_program_parameter_list *params = prog->Parameters;
@ -466,17 +466,13 @@ st_nir_lower_wpos_ytransform(struct nir_shader *nir,
memcpy(wpos_options.state_tokens, wposTransformState,
sizeof(wpos_options.state_tokens));
wpos_options.fs_coord_origin_upper_left =
pscreen->get_param(pscreen,
PIPE_CAP_FS_COORD_ORIGIN_UPPER_LEFT);
pscreen->caps.fs_coord_origin_upper_left;
wpos_options.fs_coord_origin_lower_left =
pscreen->get_param(pscreen,
PIPE_CAP_FS_COORD_ORIGIN_LOWER_LEFT);
pscreen->caps.fs_coord_origin_lower_left;
wpos_options.fs_coord_pixel_center_integer =
pscreen->get_param(pscreen,
PIPE_CAP_FS_COORD_PIXEL_CENTER_INTEGER);
pscreen->caps.fs_coord_pixel_center_integer;
wpos_options.fs_coord_pixel_center_half_integer =
pscreen->get_param(pscreen,
PIPE_CAP_FS_COORD_PIXEL_CENTER_HALF_INTEGER);
pscreen->caps.fs_coord_pixel_center_half_integer;
if (nir_lower_wpos_ytransform(nir, &wpos_options)) {
_mesa_add_state_reference(prog->Parameters, wposTransformState);
@ -831,7 +827,7 @@ st_nir_lower_samplers(struct pipe_screen *screen, nir_shader *nir,
struct gl_shader_program *shader_program,
struct gl_program *prog)
{
if (screen->get_param(screen, PIPE_CAP_NIR_SAMPLERS_AS_DEREF))
if (screen->caps.nir_samplers_as_deref)
NIR_PASS(_, nir, gl_nir_lower_samplers_as_deref, shader_program);
else
NIR_PASS(_, nir, gl_nir_lower_samplers, shader_program);
@ -893,7 +889,7 @@ st_finalize_nir(struct st_context *st, struct gl_program *prog,
NIR_PASS(_, nir, nir_lower_var_copies);
const bool lower_tg4_offsets =
!is_draw_shader && !st->screen->get_param(screen, PIPE_CAP_TEXTURE_GATHER_OFFSETS);
!is_draw_shader && !st->screen->caps.texture_gather_offsets;
if (!is_draw_shader && (st->lower_rect_tex || lower_tg4_offsets)) {
struct nir_lower_tex_options opts = {0};
@ -920,7 +916,7 @@ st_finalize_nir(struct st_context *st, struct gl_program *prog,
}
st_nir_lower_samplers(screen, nir, shader_program, prog);
if (!is_draw_shader && !screen->get_param(screen, PIPE_CAP_NIR_IMAGES_AS_DEREF))
if (!is_draw_shader && !screen->caps.nir_images_as_deref)
NIR_PASS(_, nir, gl_nir_lower_images, false);
}

12
src/mesa/state_tracker/st_interop.c
View file

@ -48,14 +48,14 @@ st_interop_query_device_info(struct st_context *st,
/* PCI values are obsolete on version >= 4 of the interface */
if (out->version < 4) {
out->pci_segment_group = screen->get_param(screen, PIPE_CAP_PCI_GROUP);
out->pci_bus = screen->get_param(screen, PIPE_CAP_PCI_BUS);
out->pci_device = screen->get_param(screen, PIPE_CAP_PCI_DEVICE);
out->pci_function = screen->get_param(screen, PIPE_CAP_PCI_FUNCTION);
out->pci_segment_group = screen->caps.pci_group;
out->pci_bus = screen->caps.pci_bus;
out->pci_device = screen->caps.pci_device;
out->pci_function = screen->caps.pci_function;
}
out->vendor_id = screen->get_param(screen, PIPE_CAP_VENDOR_ID);
out->device_id = screen->get_param(screen, PIPE_CAP_DEVICE_ID);
out->vendor_id = screen->caps.vendor_id;
out->device_id = screen->caps.device_id;
if (out->version > 1 && screen->interop_query_device_info)
out->driver_data_size = screen->interop_query_device_info(screen,

4
src/mesa/state_tracker/st_manager.c
View file

@ -1037,7 +1037,7 @@ st_api_create_context(struct pipe_frontend_screen *fscreen,
}
}
st->can_scissor_clear = !!st->screen->get_param(st->screen, PIPE_CAP_CLEAR_SCISSORED);
st->can_scissor_clear = !!st->screen->caps.clear_scissored;
st->ctx->invalidate_on_gl_viewport =
fscreen->get_param(fscreen, ST_MANAGER_BROKEN_INVALIDATE);
@ -1045,7 +1045,7 @@ st_api_create_context(struct pipe_frontend_screen *fscreen,
st->frontend_screen = fscreen;
if (st->ctx->IntelBlackholeRender &&
st->screen->get_param(st->screen, PIPE_CAP_FRONTEND_NOOP))
st->screen->caps.frontend_noop)
st->pipe->set_frontend_noop(st->pipe, st->ctx->IntelBlackholeRender);
*error = ST_CONTEXT_SUCCESS;

2
src/mesa/state_tracker/st_nir_builtins.c
View file

@ -71,7 +71,7 @@ st_nir_finish_builtin_nir(struct st_context *st, nir_shader *nir)
st_nir_lower_samplers(screen, nir, NULL, NULL);
st_nir_lower_uniforms(st, nir);
if (!screen->get_param(screen, PIPE_CAP_NIR_IMAGES_AS_DEREF))
if (!screen->caps.nir_images_as_deref)
NIR_PASS(_, nir, gl_nir_lower_images, false);
if (nir->info.io_lowered &&

20
src/mesa/state_tracker/st_pbo.c
View file

@ -614,7 +614,7 @@ st_pbo_get_download_fs(struct st_context *st, enum pipe_texture_target target,
struct pipe_screen *screen = st->screen;
enum st_pbo_conversion conversion = get_pbo_conversion(src_format, dst_format);
bool formatless_store = screen->get_param(screen, PIPE_CAP_IMAGE_STORE_FORMATTED);
bool formatless_store = screen->caps.image_store_formatted;
/* For drivers not supporting formatless storing, download FS is stored in an
* indirect dynamically allocated array of storing formats.
@ -640,26 +640,26 @@ st_init_pbo_helpers(struct st_context *st)
struct pipe_screen *screen = st->screen;
st->pbo.upload_enabled =
screen->get_param(screen, PIPE_CAP_TEXTURE_BUFFER_OBJECTS) &&
screen->get_param(screen, PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT) >= 1 &&
screen->caps.texture_buffer_objects &&
screen->caps.texture_buffer_offset_alignment >= 1 &&
screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_INTEGERS);
if (!st->pbo.upload_enabled)
return;
st->pbo.download_enabled =
st->pbo.upload_enabled &&
screen->get_param(screen, PIPE_CAP_SAMPLER_VIEW_TARGET) &&
screen->get_param(screen, PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT) &&
screen->caps.sampler_view_target &&
screen->caps.framebuffer_no_attachment &&
screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
PIPE_SHADER_CAP_MAX_SHADER_IMAGES) >= 1;
st->pbo.rgba_only =
screen->get_param(screen, PIPE_CAP_BUFFER_SAMPLER_VIEW_RGBA_ONLY);
screen->caps.buffer_sampler_view_rgba_only;
if (screen->get_param(screen, PIPE_CAP_VS_INSTANCEID)) {
if (screen->get_param(screen, PIPE_CAP_VS_LAYER_VIEWPORT)) {
if (screen->caps.vs_instanceid) {
if (screen->caps.vs_layer_viewport) {
st->pbo.layers = true;
} else if (screen->get_param(screen, PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES) >= 3) {
} else if (screen->caps.max_geometry_output_vertices >= 3) {
st->pbo.layers = true;
st->pbo.use_gs = true;
}
@ -687,7 +687,7 @@ void
st_destroy_pbo_helpers(struct st_context *st)
{
struct pipe_screen *screen = st->screen;
bool formatless_store = screen->get_param(screen, PIPE_CAP_IMAGE_STORE_FORMATTED);
bool formatless_store = screen->caps.image_store_formatted;
unsigned i;
for (i = 0; i < ARRAY_SIZE(st->pbo.upload_fs); ++i) {

4
src/mesa/state_tracker/st_vdpau.c
View file

@ -216,8 +216,8 @@ st_vdpau_map_surface(struct gl_context *ctx, GLenum target, GLenum access,
struct winsys_handle whandle = { .type = WINSYS_HANDLE_TYPE_FD };
unsigned usage = PIPE_HANDLE_USAGE_FRAMEBUFFER_WRITE;
if (screen->get_param(screen, PIPE_CAP_DMABUF) &&
res->screen->get_param(res->screen, PIPE_CAP_DMABUF) &&
if (screen->caps.dmabuf &&
res->screen->caps.dmabuf &&
res->screen->resource_get_handle(res->screen, NULL, res, &whandle,
usage)) {
whandle.modifier = DRM_FORMAT_MOD_INVALID;