November 2021 - Wine-devel - list.winehq.org

[PATCH vkd3d v3 01/14] vkd3d-shader/hlsl: Define a symbolic constant to represent the D3D_SIF_TEXTURE_COMPONENTS shift.
by Matteo Bruni 09 Nov '21

09 Nov '21

From: Zebediah Figura <zfigura(a)codeweavers.com> Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> Signed-off-by: Matteo Bruni <mbruni(a)codeweavers.com> --- libs/vkd3d-shader/hlsl_sm4.c | 2 +- libs/vkd3d-shader/sm4.h | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/libs/vkd3d-shader/hlsl_sm4.c b/libs/vkd3d-shader/hlsl_sm4.c index 9d45e163..f8eb0a1e 100644 --- a/libs/vkd3d-shader/hlsl_sm4.c +++ b/libs/vkd3d-shader/hlsl_sm4.c @@ -561,7 +561,7 @@ static void write_sm4_rdef(struct hlsl_ctx *ctx, struct dxbc_writer *dxbc) put_u32(&buffer, sm4_resource_format(var->data_type)); put_u32(&buffer, sm4_rdef_resource_dimension(var->data_type)); put_u32(&buffer, ~0u); /* FIXME: multisample count */ - flags |= (var->data_type->e.resource_format->dimx - 1) << 2; + flags |= (var->data_type->e.resource_format->dimx - 1) << VKD3D_SM4_SIF_TEXTURE_COMPONENTS_SHIFT; } put_u32(&buffer, var->reg.id); put_u32(&buffer, 1); /* bind count */ diff --git a/libs/vkd3d-shader/sm4.h b/libs/vkd3d-shader/sm4.h index ddcb9a86..17a08ee2 100644 --- a/libs/vkd3d-shader/sm4.h +++ b/libs/vkd3d-shader/sm4.h @@ -526,4 +526,7 @@ enum vkd3d_sm4_shader_data_type VKD3D_SM4_SHADER_DATA_MESSAGE = 0x4, }; +/* The shift that corresponds to the D3D_SIF_TEXTURE_COMPONENTS mask. */ +#define VKD3D_SM4_SIF_TEXTURE_COMPONENTS_SHIFT 2 + #endif /* __VKD3D_SM4_H */ -- 2.26.3

5 35

[v3 PATCH] d3d10/effect: Add initial support for indexing expressions.
by Nikolay Sivov 09 Nov '21

09 Nov '21

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- v3: some rework based on received feedback For now for simplicity I removed destination index from property update, with additional test for property type when parsing. dlls/d3d10/effect.c | 577 +++++++++++++++++++++++++++++++++++++- dlls/d3d10/tests/effect.c | 114 ++++++++ 2 files changed, 683 insertions(+), 8 deletions(-) diff --git a/dlls/d3d10/effect.c b/dlls/d3d10/effect.c index 78a3d0c386a..1be16771921 100644 --- a/dlls/d3d10/effect.c +++ b/dlls/d3d10/effect.c @@ -30,6 +30,9 @@ WINE_DEFAULT_DEBUG_CHANNEL(d3d10); ((DWORD)(ch2) << 16) | ((DWORD)(ch3) << 24 )) #define TAG_DXBC MAKE_TAG('D', 'X', 'B', 'C') #define TAG_FX10 MAKE_TAG('F', 'X', '1', '0') +#define TAG_FXLC MAKE_TAG('F', 'X', 'L', 'C') +#define TAG_CLI4 MAKE_TAG('C', 'L', 'I', '4') +#define TAG_CTAB MAKE_TAG('C', 'T', 'A', 'B') #define D3D10_FX10_TYPE_COLUMN_SHIFT 11 #define D3D10_FX10_TYPE_COLUMN_MASK (0x7 << D3D10_FX10_TYPE_COLUMN_SHIFT) @@ -180,6 +183,96 @@ static enum d3d10_effect_container_type get_var_container_type(const struct d3d1 } } +struct preshader_instr +{ + unsigned int comp_count : 16; + unsigned int reserved : 4; + unsigned int opcode : 11; + unsigned int scalar : 1; +}; + +typedef float (*pres_op_func)(float **args, unsigned int n); + +static float pres_ftou(float **args, unsigned int n) +{ + unsigned int u = *args[0]; + return *(float *)&u; +} + +static float pres_add(float **args, unsigned int n) +{ + return *args[0] + *args[1]; +} + +struct preshader_op_info +{ + int opcode; + char name[8]; + pres_op_func func; +}; + +static const struct preshader_op_info preshader_ops[] = +{ + { 0x133, "ftou", pres_ftou }, + { 0x204, "add", pres_add }, +}; + +static int __cdecl preshader_op_compare(const void *a, const void *b) +{ + int opcode = *(int *)a; + const struct preshader_op_info *op_info = b; + return opcode - op_info->opcode; +} + +static const struct preshader_op_info * d3d10_effect_get_op_info(int opcode) +{ + return bsearch(&opcode, preshader_ops, ARRAY_SIZE(preshader_ops), sizeof(*preshader_ops), + preshader_op_compare); +} + +struct d3d10_ctab_var +{ + struct d3d10_effect_variable *v; + unsigned int offset; + unsigned int length; +}; + +struct d3d10_reg_table +{ + union + { + float *f; + DWORD *dword; + }; + unsigned int count; +}; + +enum d3d10_reg_table_type +{ + D3D10_REG_TABLE_CONSTANTS = 1, + D3D10_REG_TABLE_CB = 2, + D3D10_REG_TABLE_RESULT = 4, + D3D10_REG_TABLE_TEMP = 7, + D3D10_REG_TABLE_COUNT, +}; + +struct d3d10_effect_preshader +{ + struct d3d10_reg_table reg_tables[D3D10_REG_TABLE_COUNT]; + ID3D10Blob *code; + + struct d3d10_ctab_var *vars; + unsigned int vars_count; +}; + +struct d3d10_preshader_parse_context +{ + struct d3d10_effect_preshader *preshader; + struct d3d10_effect *effect; + unsigned int result_count; + unsigned int temp_count; +}; + struct d3d10_effect_prop_dependency { unsigned int id; @@ -192,11 +285,115 @@ struct d3d10_effect_prop_dependency struct d3d10_effect_variable *v; unsigned int offset; } var; - } u; + struct + { + struct d3d10_effect_variable *v; + struct d3d10_effect_preshader index; + } index_expr; + }; }; +static HRESULT d3d10_reg_table_allocate(struct d3d10_reg_table *table, unsigned int count) +{ + if (!(table->f = heap_calloc(count, sizeof(*table->f)))) + return E_OUTOFMEMORY; + table->count = count; + return S_OK; +} + +static void d3d10_effect_preshader_clear(struct d3d10_effect_preshader *p) +{ + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(p->reg_tables); ++i) + heap_free(&p->reg_tables[i].f); + if (p->code) + ID3D10Blob_Release(p->code); + heap_free(p->vars); + memset(p, 0, sizeof(*p)); +} + +static float * d3d10_effect_preshader_get_reg_ptr(const struct d3d10_effect_preshader *p, + enum d3d10_reg_table_type regt, unsigned int offset) +{ + switch (regt) + { + case D3D10_REG_TABLE_CONSTANTS: + case D3D10_REG_TABLE_CB: + case D3D10_REG_TABLE_RESULT: + case D3D10_REG_TABLE_TEMP: + return p->reg_tables[regt].f + offset; + default: + return NULL; + } +} + +static HRESULT d3d10_effect_preshader_eval(struct d3d10_effect_preshader *p) +{ + unsigned int i, j, regt, offset, instr_count, input_count; + const DWORD *ip = ID3D10Blob_GetBufferPointer(p->code); + float *dst, *args[4], *retval; + struct preshader_instr ins; + + dst = d3d10_effect_preshader_get_reg_ptr(p, D3D10_REG_TABLE_RESULT, 0); + memset(dst, 0, sizeof(float) * p->reg_tables[D3D10_REG_TABLE_RESULT].count); + + /* Update constant buffer */ + dst = d3d10_effect_preshader_get_reg_ptr(p, D3D10_REG_TABLE_CB, 0); + for (i = 0; i < p->vars_count; ++i) + { + struct d3d10_ctab_var *v = &p->vars[i]; + memcpy(dst + v->offset, v->v->buffer->u.buffer.local_buffer, v->length * sizeof(*dst)); + } + + instr_count = *ip++; + + for (i = 0; i < instr_count; ++i) + { + *(DWORD *)&ins = *ip++; + input_count = *ip++; + + if (input_count > ARRAY_SIZE(args)) + { + FIXME("Unexpected argument count %u.\n", input_count); + return E_FAIL; + } + + /* Arguments */ + for (j = 0; j < input_count; ++j) + { + ip++; /* TODO: argument register flags are currently ignored */ + regt = *ip++; + offset = *ip++; + + args[j] = d3d10_effect_preshader_get_reg_ptr(p, regt, offset); + } + + ip++; /* TODO: result register flags are currently ignored */ + regt = *ip++; + offset = *ip++; + retval = d3d10_effect_preshader_get_reg_ptr(p, regt, offset); + + *retval = d3d10_effect_get_op_info(ins.opcode)->func(args, input_count); + } + + return S_OK; +} + static void d3d10_effect_clear_prop_dependencies(struct d3d10_effect_prop_dependencies *d) { + unsigned int i; + + for (i = 0; i < d->count; ++i) + { + struct d3d10_effect_prop_dependency *dep = &d->entries[i]; + switch (dep->operation) + { + case D3D10_EOO_INDEX_EXPRESSION: + d3d10_effect_preshader_clear(&dep->index_expr.index); + break; + } + } heap_free(d->entries); memset(d, 0, sizeof(*d)); } @@ -516,9 +713,11 @@ static void d3d10_effect_update_dependent_props(struct d3d10_effect_prop_depende { const struct d3d10_effect_state_property_info *property_info; struct d3d10_effect_prop_dependency *d; + unsigned int i, j, count, variable_idx; struct d3d10_effect_variable *v; - unsigned int i, j, count; + unsigned int *dst_index; uint32_t value; + HRESULT hr; void *dst; for (i = 0; i < deps->count; ++i) @@ -528,24 +727,58 @@ static void d3d10_effect_update_dependent_props(struct d3d10_effect_prop_depende property_info = &property_infos[d->id]; dst = (char *)container + property_info->offset; + dst_index = (unsigned int *)((char *)container + property_info->index_offset); switch (d->operation) { case D3D10_EOO_VAR: case D3D10_EOO_CONST_INDEX: - v = d->u.var.v; + v = d->var.v; count = v->type->type_class == D3D10_SVC_VECTOR ? 4 : 1; for (j = 0; j < count; ++j) { - d3d10_effect_variable_get_raw_value(v, &value, d->u.var.offset + j * sizeof(value), sizeof(value)); + d3d10_effect_variable_get_raw_value(v, &value, d->var.offset + j * sizeof(value), sizeof(value)); d3d10_effect_read_numeric_value(value, v->type->basetype, property_info->type, dst, j); } break; + case D3D10_EOO_INDEX_EXPRESSION: + + v = d->index_expr.v; + + if (FAILED(hr = d3d10_effect_preshader_eval(&d->index_expr.index))) + { + WARN("Failed to evaluate index expression, hr %#x.\n", hr); + return; + } + + variable_idx = *d->index_expr.index.reg_tables[D3D10_REG_TABLE_RESULT].dword; + + if (variable_idx >= v->type->element_count) + { + WARN("Expression evaluated to invalid index value %u, array %s of size %u.\n", + variable_idx, debugstr_a(v->name), v->type->element_count); + return; + } + + /* Ignoring destination index here, there are no object typed array properties. */ + switch (property_info->type) + { + case D3D10_SVT_VERTEXSHADER: + case D3D10_SVT_PIXELSHADER: + case D3D10_SVT_GEOMETRYSHADER: + *(void **)dst = v; + *dst_index = variable_idx; + break; + default: + *(void **)dst = &v->elements[variable_idx]; + } + break; + default: FIXME("Unsupported property update for %u.\n", d->operation); } @@ -1856,6 +2089,266 @@ static BOOL is_object_property_type_matching(const struct d3d10_effect_state_pro } } +static HRESULT parse_fx10_preshader_instr(struct d3d10_preshader_parse_context *context, + unsigned int *offset, const char **ptr, unsigned int data_size) +{ + const struct preshader_op_info *op_info; + unsigned int i, param_count; + struct preshader_instr ins; + uint32_t input_count; + + if (!require_space(*offset, 2, sizeof(uint32_t), data_size)) + { + WARN("Malformed FXLC table, size %u.\n", data_size); + return E_FAIL; + } + + read_dword(ptr, (uint32_t *)&ins); + read_dword(ptr, &input_count); + *offset += 2 * sizeof(uint32_t); + + if (!(op_info = d3d10_effect_get_op_info(ins.opcode))) + { + FIXME("Unrecognized opcode %#x.\n", ins.opcode); + return E_FAIL; + } + + TRACE("Opcode %#x (%s), input count %u.\n", ins.opcode, op_info->name, input_count); + + /* Inputs + one output */ + param_count = input_count + 1; + + if (!require_space(*offset, 3 * param_count, sizeof(uint32_t), data_size)) + { + WARN("Malformed FXLC table, opcode %#x.\n", ins.opcode); + return E_FAIL; + } + *offset += 3 * param_count * sizeof(uint32_t); + + for (i = 0; i < param_count; ++i) + { + uint32_t flags, regt, param_offset; + + read_dword(ptr, &flags); + if (flags) + { + FIXME("Arguments flags are not supported %#x.\n", flags); + return E_UNEXPECTED; + } + + read_dword(ptr, &regt); + read_dword(ptr, &param_offset); + + switch (regt) + { + case D3D10_REG_TABLE_RESULT: + context->result_count = max(context->result_count, param_offset + 1); + break; + case D3D10_REG_TABLE_TEMP: + context->temp_count = max(context->temp_count, param_offset + 1); + break; + default: + break; + } + } + + return S_OK; +} + +static HRESULT parse_fx10_fxlc(void *ctx, const char *data, unsigned int data_size) +{ + struct d3d10_preshader_parse_context *context = ctx; + struct d3d10_effect_preshader *p = context->preshader; + unsigned int i, offset = 4; + uint32_t ins_count; + const char *ptr; + HRESULT hr; + + if (data_size % sizeof(uint32_t)) + { + WARN("FXLC size misaligned %u.\n", data_size); + return E_FAIL; + } + + /* Parse through bytecode copy, so we can patch opcodes. */ + if (FAILED(hr = D3DCreateBlob(data_size, &p->code))) + return hr; + memcpy(ID3D10Blob_GetBufferPointer(p->code), data, data_size); + + ptr = data; + read_dword(&ptr, &ins_count); + TRACE("%u instructions.\n", ins_count); + + for (i = 0; i < ins_count; ++i) + { + if (FAILED(hr = parse_fx10_preshader_instr(context, &offset, &ptr, data_size))) + { + WARN("Failed to parse instruction %u.\n", i); + return hr; + } + } + + if (FAILED(hr = d3d10_reg_table_allocate(&p->reg_tables[D3D10_REG_TABLE_RESULT], + context->result_count))) return hr; + if (FAILED(hr = d3d10_reg_table_allocate(&p->reg_tables[D3D10_REG_TABLE_TEMP], + context->temp_count))) return hr; + + return S_OK; +} + +static HRESULT parse_fx10_cli4(void *ctx, const char *data, unsigned int data_size) +{ + struct d3d10_preshader_parse_context *context = ctx; + struct d3d10_effect_preshader *p = context->preshader; + struct d3d10_reg_table *table = &p->reg_tables[D3D10_REG_TABLE_CONSTANTS]; + const char *ptr = data; + uint32_t count; + HRESULT hr; + + if (data_size < sizeof(DWORD)) + { + WARN("Invalid CLI4 chunk size %u.\n", data_size); + return E_FAIL; + } + + read_dword(&ptr, &count); + + TRACE("%u literal constants.\n", count); + + if (!require_space(4, count, sizeof(float), data_size)) + { + WARN("Invalid constant table size %u.\n", data_size); + return E_FAIL; + } + + if (FAILED(hr = d3d10_reg_table_allocate(table, count))) + return hr; + + memcpy(table->f, ptr, table->count * sizeof(*table->f)); + + return S_OK; +} + +static HRESULT parse_fx10_ctab(void *ctx, const char *data, unsigned int data_size) +{ + struct d3d10_preshader_parse_context *context = ctx; + struct d3d10_effect_preshader *p = context->preshader; + struct ctab_header + { + DWORD size; + DWORD creator; + DWORD version; + DWORD constants; + DWORD constantinfo; + DWORD flags; + DWORD target; + } header; + struct ctab_const_info + { + DWORD name; + WORD register_set; + WORD register_index; + WORD register_count; + WORD reserved; + DWORD typeinfo; + DWORD default_value; + } *info; + unsigned int i, cb_reg_count = 0; + const char *ptr = data; + const char *name; + size_t name_len; + HRESULT hr; + + if (data_size < sizeof(header)) + { + WARN("Invalid constant table size %u.\n", data_size); + return E_FAIL; + } + + read_dword(&ptr, &header.size); + read_dword(&ptr, &header.creator); + read_dword(&ptr, &header.version); + read_dword(&ptr, &header.constants); + read_dword(&ptr, &header.constantinfo); + read_dword(&ptr, &header.flags); + read_dword(&ptr, &header.target); + + if (!require_space(header.constantinfo, header.constants, sizeof(*info), data_size)) + { + WARN("Invalid constant info section offset %#x.\n", header.constantinfo); + return E_FAIL; + } + + p->vars_count = header.constants; + + TRACE("Variable count %u.\n", p->vars_count); + + if (!(p->vars = heap_calloc(p->vars_count, sizeof(*p->vars)))) + return E_OUTOFMEMORY; + + /* Collect variables used in expression. */ + info = (struct ctab_const_info *)(data + header.constantinfo); + for (i = 0; i < p->vars_count; ++i, ++info) + { + if (!fx10_get_string(data, data_size, info->name, &name, &name_len)) + return E_FAIL; + + if (!(p->vars[i].v = d3d10_effect_get_variable_by_name(context->effect, name))) + { + WARN("Couldn't find variable %s.\n", debugstr_a(name)); + return E_FAIL; + } + + /* 4 components per register */ + p->vars[i].offset = info->register_index * 4; + p->vars[i].length = info->register_count * 4; + + cb_reg_count = max(cb_reg_count, info->register_index + info->register_count); + } + + /* Allocate contiguous "constant buffer" for all referenced variables. */ + if (FAILED(hr = d3d10_reg_table_allocate(&p->reg_tables[D3D10_REG_TABLE_CB], cb_reg_count * 4))) + { + WARN("Failed to allocate variables buffer.\n"); + return hr; + } + + return S_OK; +} + +static HRESULT fxlvm_chunk_handler(const char *data, DWORD data_size, DWORD tag, void *ctx) +{ + TRACE("Chunk tag: %s, size: %u.\n", debugstr_an((const char *)&tag, 4), data_size); + + switch (tag) + { + case TAG_FXLC: + return parse_fx10_fxlc(ctx, data, data_size); + + case TAG_CLI4: + return parse_fx10_cli4(ctx, data, data_size); + + case TAG_CTAB: + return parse_fx10_ctab(ctx, data, data_size); + + default: + FIXME("Unhandled chunk %s.\n", debugstr_an((const char *)&tag, 4)); + return S_OK; + } +} + +static HRESULT parse_fx10_preshader(const char *data, size_t data_size, + struct d3d10_effect *effect, struct d3d10_effect_preshader *preshader) +{ + struct d3d10_preshader_parse_context context; + + memset(preshader, 0, sizeof(*preshader)); + context.preshader = preshader; + context.effect = effect; + + return parse_dxbc(data, data_size, fxlvm_chunk_handler, &context); +} + static HRESULT d3d10_effect_add_prop_dependency(struct d3d10_effect_prop_dependencies *d, const struct d3d10_effect_prop_dependency *dep) { @@ -1875,6 +2368,7 @@ static HRESULT parse_fx10_property_assignment(const char *data, size_t data_size const struct d3d10_effect_state_property_info *property_info; struct d3d10_effect_prop_dependency dep; struct d3d10_effect_variable *variable; + uint32_t code_offset, blob_size; const char *data_ptr, *name; unsigned int *dst_index; size_t name_len; @@ -1974,8 +2468,8 @@ static HRESULT parse_fx10_property_assignment(const char *data, size_t data_size dep.id = id; dep.idx = idx; dep.operation = operation; - dep.u.var.v = variable; - dep.u.var.offset = 0; + dep.var.v = variable; + dep.var.offset = 0; return d3d10_effect_add_prop_dependency(d, &dep); } @@ -2051,14 +2545,75 @@ static HRESULT parse_fx10_property_assignment(const char *data, size_t data_size dep.id = id; dep.idx = idx; dep.operation = operation; - dep.u.var.v = variable; - dep.u.var.offset = offset; + dep.var.v = variable; + dep.var.offset = offset; return d3d10_effect_add_prop_dependency(d, &dep); } break; + case D3D10_EOO_INDEX_EXPRESSION: + + /* Variable, and an expression for its index. */ + if (value_offset >= data_size || !require_space(value_offset, 2, sizeof(DWORD), data_size)) + { + WARN("Invalid offset %#x (data size %#lx).\n", value_offset, (long)data_size); + return E_FAIL; + } + + data_ptr = data + value_offset; + read_dword(&data_ptr, &value_offset); + read_dword(&data_ptr, &code_offset); + + if (!fx10_get_string(data, data_size, value_offset, &name, &name_len)) + { + WARN("Failed to get variable name.\n"); + return E_FAIL; + } + + TRACE("Variable name %s[<expr>].\n", debugstr_a(name)); + + if (!(variable = d3d10_effect_get_variable_by_name(effect, name))) + { + WARN("Couldn't find variable %s.\n", debugstr_a(name)); + return E_FAIL; + } + + /* Has to be an array */ + if (!variable->type->element_count) + { + WARN("Expected array variable.\n"); + return E_FAIL; + } + + if (!is_object_property(property_info)) + { + WARN("Expected object type property used with indexed expression.\n"); + return E_FAIL; + } + + if (code_offset >= data_size || !require_space(code_offset, 1, sizeof(DWORD), data_size)) + { + WARN("Invalid offset %#x (data size %#lx).\n", value_offset, (long)data_size); + return E_FAIL; + } + + data_ptr = data + code_offset; + read_dword(&data_ptr, &blob_size); + + dep.id = id; + dep.idx = idx; + dep.operation = operation; + dep.index_expr.v = variable; + if (FAILED(hr = parse_fx10_preshader(data_ptr, blob_size, effect, &dep.index_expr.index))) + { + WARN("Failed to parse preshader, hr %#x.\n", hr); + return hr; + } + + return d3d10_effect_add_prop_dependency(d, &dep); + case D3D10_EOO_ANONYMOUS_SHADER: /* Anonymous shader */ @@ -4004,6 +4559,8 @@ static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetVertexShaderDesc(ID3D10Eff return E_INVALIDARG; } + d3d10_effect_update_dependent_props(&pass->dependencies, pass); + desc->pShaderVariable = (ID3D10EffectShaderVariable *)&pass->vs.shader->ID3D10EffectVariable_iface; desc->ShaderIndex = pass->vs.index; @@ -4029,6 +4586,8 @@ static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetGeometryShaderDesc(ID3D10E return E_INVALIDARG; } + d3d10_effect_update_dependent_props(&pass->dependencies, pass); + desc->pShaderVariable = (ID3D10EffectShaderVariable *)&pass->gs.shader->ID3D10EffectVariable_iface; desc->ShaderIndex = pass->gs.index; @@ -4054,6 +4613,8 @@ static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetPixelShaderDesc(ID3D10Effe return E_INVALIDARG; } + d3d10_effect_update_dependent_props(&pass->dependencies, pass); + desc->pShaderVariable = (ID3D10EffectShaderVariable *)&pass->ps.shader->ID3D10EffectVariable_iface; desc->ShaderIndex = pass->ps.index; diff --git a/dlls/d3d10/tests/effect.c b/dlls/d3d10/tests/effect.c index da644d8d9db..f3e93fe34f4 100644 --- a/dlls/d3d10/tests/effect.c +++ b/dlls/d3d10/tests/effect.c @@ -7801,6 +7801,119 @@ static void test_effect_dynamic_numeric_field(void) ok(!refcount, "Device has %u references left.\n", refcount); } +#if 0 +float4 g_var; +PixelShader ps_array[2]; +VertexShader vs_array[2]; +technique10 tech +{ + pass p0 + { + SetPixelShader( ps_array[g_var.z] ); + SetVertexShader( vs_array[g_var.x + 0.1f] ); + } +} +#endif +static DWORD fx_test_index_expression[] = +{ + 0x43425844, 0x83787296, 0xf866b7a9, 0x7b56930c, 0xdc9d061a, 0x00000001, 0x000003e9, 0x00000001, + 0x00000024, 0x30315846, 0x000003bd, 0xfeff1001, 0x00000001, 0x00000001, 0x00000002, 0x00000000, + 0x00000000, 0x00000000, 0x00000001, 0x000002cd, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000004, 0x00000000, 0x00000000, 0x6f6c4724, + 0x736c6162, 0x6f6c6600, 0x00347461, 0x0000000d, 0x00000001, 0x00000000, 0x00000010, 0x00000010, + 0x00000010, 0x0000210a, 0x61765f67, 0x69500072, 0x536c6578, 0x65646168, 0x00360072, 0x00020000, + 0x00020000, 0x00000000, 0x00000000, 0x00000000, 0x00050000, 0x73700000, 0x7272615f, 0x56007961, + 0x65747265, 0x61685378, 0x00726564, 0x00000067, 0x00000002, 0x00000002, 0x00000000, 0x00000000, + 0x00000000, 0x00000006, 0x615f7376, 0x79617272, 0x63657400, 0x30700068, 0x0000ec00, 0x42584400, + 0x990a9743, 0xd17834e6, 0x40de477e, 0xf476a79f, 0x00000101, 0x0000ec00, 0x00000300, 0x00002c00, + 0x0000a800, 0x0000b400, 0x41544300, 0x00007442, 0x00001c00, 0x00004b00, 0x58040000, 0x00000146, + 0x00001c00, 0x00010000, 0x00004800, 0x00003000, 0x00000200, 0x00000100, 0x00003800, 0x00000000, + 0x765f6700, 0xab007261, 0x030001ab, 0x04000100, 0x00000100, 0x00000000, 0x00787400, 0x7263694d, + 0x666f736f, 0x52282074, 0x4c482029, 0x53204c53, 0x65646168, 0x6f432072, 0x6c69706d, 0x31207265, + 0x00312e30, 0x494c43ab, 0x00000434, 0x00000000, 0x4c584600, 0x00003043, 0x00000100, 0x30000100, + 0x00000113, 0x00000000, 0x00000200, 0x00000200, 0x00000000, 0x00000400, 0x00000000, 0xf0f0f000, + 0x0f0f0ff0, 0x00ffff0f, 0x00005e00, 0x0000a100, 0x00012800, 0x42584400, 0x78de2e43, 0x31414e7a, + 0xf69158cd, 0x416c97b6, 0x00000192, 0x00012800, 0x00000300, 0x00002c00, 0x0000a800, 0x0000c400, + 0x41544300, 0x00007442, 0x00001c00, 0x00004b00, 0x58040000, 0x00000146, 0x00001c00, 0x00010000, + 0x00004800, 0x00003000, 0x00000200, 0x00000100, 0x00003800, 0x00000000, 0x765f6700, 0xab007261, + 0x030001ab, 0x04000100, 0x00000100, 0x00000000, 0x00787400, 0x7263694d, 0x666f736f, 0x52282074, + 0x4c482029, 0x53204c53, 0x65646168, 0x6f432072, 0x6c69706d, 0x31207265, 0x00312e30, 0x494c43ab, + 0x00001434, 0x00000400, 0xcccccd00, 0x0000003d, 0x00000000, 0x00000000, 0x4c584600, 0x00005c43, + 0x00000200, 0x40000100, 0x00000220, 0x00000000, 0x00000200, 0x00000000, 0x00000000, 0x00000100, + 0x00000000, 0x00000000, 0x00000700, 0x00000000, 0x30000100, 0x00000113, 0x00000000, 0x00000700, + 0x00000000, 0x00000000, 0x00000400, 0x00000000, 0xf0f0f000, 0x0f0f0ff0, 0x00ffff0f, 0x00009000, + 0x00019900, 0x00000400, 0x00001000, 0x00000000, 0x00000100, 0xffffff00, 0x000000ff, 0x00003000, + 0x00001400, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00005e00, 0x00004200, + 0x00000000, 0xffffff00, 0x000000ff, 0x00000000, 0x00000000, 0x00009000, 0x00007400, 0x00000000, + 0xffffff00, 0x000000ff, 0x00000000, 0x00000000, 0x00009900, 0x00000100, 0x00000000, 0x00009e00, + 0x00000200, 0x00000000, 0x00000700, 0x00000000, 0x00000500, 0x00019100, 0x00000600, 0x00000000, + 0x00000500, 0x0002c500, 0x00000000, +}; + +static void test_effect_index_expression(void) +{ + D3D10_PASS_SHADER_DESC shader_desc; + ID3D10EffectVectorVariable *vector; + ID3D10EffectTechnique *tech; + ID3D10EffectVariable *v; + ID3D10EffectPass *pass; + ID3D10Effect *effect; + ID3D10Device *device; + ULONG refcount; + float val[4]; + HRESULT hr; + + if (!(device = create_device())) + { + skip("Failed to create device, skipping tests.\n"); + return; + } + + hr = create_effect(fx_test_index_expression, 0, device, NULL, &effect); + ok(SUCCEEDED(hr), "Failed to create an effect, hr %#x.\n", hr); + + /* Initial index */ + tech = effect->lpVtbl->GetTechniqueByIndex(effect, 0); + pass = tech->lpVtbl->GetPassByIndex(tech, 0); + hr = pass->lpVtbl->GetPixelShaderDesc(pass, &shader_desc); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ok(!shader_desc.ShaderIndex, "Unexpected shader index.\n"); + + v = effect->lpVtbl->GetVariableByName(effect, "g_var"); + vector = v->lpVtbl->AsVector(v); + + val[0] = 0.0f; + val[1] = 0.0f; + val[2] = 1.0f; + val[3] = 0.0f; + hr = vector->lpVtbl->SetFloatVector(vector, val); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + hr = pass->lpVtbl->GetPixelShaderDesc(pass, &shader_desc); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ok(shader_desc.ShaderIndex == 1, "Unexpected shader index %#x.\n", shader_desc.ShaderIndex); + + hr = pass->lpVtbl->GetVertexShaderDesc(pass, &shader_desc); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ok(!shader_desc.ShaderIndex, "Unexpected shader index %#x.\n", shader_desc.ShaderIndex); + + val[0] = 0.9f; + val[1] = 0.0f; + val[2] = 1.0f; + val[3] = 0.0f; + hr = vector->lpVtbl->SetFloatVector(vector, val); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + hr = pass->lpVtbl->GetVertexShaderDesc(pass, &shader_desc); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ok(shader_desc.ShaderIndex == 1, "Unexpected shader index %#x.\n", shader_desc.ShaderIndex); + + effect->lpVtbl->Release(effect); + + refcount = ID3D10Device_Release(device); + ok(!refcount, "Device has %u references left.\n", refcount); +} + START_TEST(effect) { test_effect_constant_buffer_type(); @@ -7825,4 +7938,5 @@ START_TEST(effect) test_effect_default_variable_value(); test_effect_raw_value(); test_effect_dynamic_numeric_field(); + test_effect_index_expression(); } -- 2.33.0

2 2

[PATCH] ipconfig: Print primary DNS suffix.
by Hans Leidekker 09 Nov '21

09 Nov '21

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- programs/ipconfig/ipconfig.c | 4 +++- programs/ipconfig/ipconfig.h | 1 + programs/ipconfig/ipconfig.rc | 1 + 3 files changed, 5 insertions(+), 1 deletion(-) diff --git a/programs/ipconfig/ipconfig.c b/programs/ipconfig/ipconfig.c index 29f86521b07..f985d337265 100644 --- a/programs/ipconfig/ipconfig.c +++ b/programs/ipconfig/ipconfig.c @@ -277,11 +277,13 @@ static void print_full_information(void) if (GetNetworkParams(info, &out) == ERROR_SUCCESS) { WCHAR hostnameW[MAX_HOSTNAME_LEN + 4]; + WCHAR dnssuffixW[MAX_DOMAIN_NAME_LEN + 4]; MultiByteToWideChar(CP_ACP, 0, info->HostName, -1, hostnameW, ARRAY_SIZE(hostnameW)); print_field(STRING_HOSTNAME, hostnameW); - /* FIXME: Output primary DNS suffix. */ + MultiByteToWideChar(CP_ACP, 0, info->DomainName, -1, dnssuffixW, ARRAY_SIZE(dnssuffixW)); + print_field(STRING_PRIMARY_DNS_SUFFIX, dnssuffixW); print_field(STRING_NODE_TYPE, nodetype_to_string(info->NodeType)); print_field(STRING_IP_ROUTING, boolean_to_string(info->EnableRouting)); diff --git a/programs/ipconfig/ipconfig.h b/programs/ipconfig/ipconfig.h index 579ba70954a..63e9ef45a8c 100644 --- a/programs/ipconfig/ipconfig.h +++ b/programs/ipconfig/ipconfig.h @@ -42,3 +42,4 @@ #define STRING_NO 119 #define STRING_DEFAULT_GATEWAY 120 #define STRING_IP6_ADDRESS 121 +#define STRING_PRIMARY_DNS_SUFFIX 122 diff --git a/programs/ipconfig/ipconfig.rc b/programs/ipconfig/ipconfig.rc index b7cf14b6e50..4ea0a633c7d 100644 --- a/programs/ipconfig/ipconfig.rc +++ b/programs/ipconfig/ipconfig.rc @@ -34,6 +34,7 @@ STRINGTABLE STRING_CONN_DNS_SUFFIX, "Connection-specific DNS suffix" STRING_IP_ADDRESS, "IPv4 address" STRING_HOSTNAME, "Hostname" + STRING_PRIMARY_DNS_SUFFIX, "Primary DNS suffix" STRING_NODE_TYPE, "Node type" STRING_BROADCAST, "Broadcast" STRING_PEER_TO_PEER, "Peer-to-peer" -- 2.30.2

1 0

[PATCH v4 1/2] ntdll: Allow loading system DLLs from a path specified at configure time.
by Zebediah Figura 09 Nov '21

09 Nov '21

Many distributions provide MinGW-compiled system DLLs which are currently bundled with Wine. Unfortunately, while MinGW pkg-config can be used to detect the linking path, there is no standardized runtime path, and many distributions in fact use different paths. Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- Makefile.in | 1 + configure.ac | 3 +++ dlls/ntdll/Makefile.in | 1 + dlls/ntdll/loader.c | 10 ++++++++-- dlls/ntdll/unix/env.c | 1 + dlls/ntdll/unix/loader.c | 3 +++ dlls/ntdll/unix/unix_private.h | 1 + 7 files changed, 18 insertions(+), 2 deletions(-) diff --git a/Makefile.in b/Makefile.in index 42f161e3af9..c4b0fbda616 100644 --- a/Makefile.in +++ b/Makefile.in @@ -32,6 +32,7 @@ nlsdir = ${datadir}/wine/nls dlldir = ${libdir}/wine srcdir = @srcdir@ host_cpu = @host_cpu@ +system_dlldir = @system_dlldir@ SHELL = /bin/sh CC = @CC@ CXX = @CXX@ diff --git a/configure.ac b/configure.ac index 57383fb2e31..77765db0490 100644 --- a/configure.ac +++ b/configure.ac @@ -103,6 +103,7 @@ AC_ARG_WITH(xshm, AS_HELP_STRING([--without-xshm],[do not use XShm (shared AC_ARG_WITH(xxf86vm, AS_HELP_STRING([--without-xxf86vm],[do not use XFree video mode extension]), [if test "x$withval" = "xno"; then ac_cv_header_X11_extensions_xf86vmode_h=no; ac_cv_header_X11_extensions_xf86vmproto_h=no; fi]) +AC_ARG_WITH(system-dlldir, AS_HELP_STRING([--with-system-dlldir=DIR],[load external PE dependencies from directory DIR])) AC_ARG_WITH(wine-tools,AS_HELP_STRING([--with-wine-tools=DIR],[use Wine tools from directory DIR])) AC_ARG_WITH(wine64, AS_HELP_STRING([--with-wine64=DIR],[use the 64-bit Wine in DIR for a Wow64 build])) @@ -256,6 +257,8 @@ then TARGETFLAGS="-b $host_alias $TARGETFLAGS" fi +AC_SUBST(system_dlldir,"$with_system_dlldir") + dnl Check for flex AC_CHECK_PROGS(FLEX,flex,none) if test "$FLEX" = "none" diff --git a/dlls/ntdll/Makefile.in b/dlls/ntdll/Makefile.in index fa2ac1623ea..5b15ab5108f 100644 --- a/dlls/ntdll/Makefile.in +++ b/dlls/ntdll/Makefile.in @@ -73,5 +73,6 @@ EXTRA_OBJS = unix/version.o unix_loader_EXTRADEFS = \ -DBINDIR=\"${bindir}\" \ + -DSYSTEMDLLDIR=\"${system_dlldir}\" \ -DDLL_TO_BINDIR=\"`${MAKEDEP} -R ${dlldir} ${bindir}`\" \ -DBIN_TO_DATADIR=\"`${MAKEDEP} -R ${bindir} ${datadir}/wine`\" diff --git a/dlls/ntdll/loader.c b/dlls/ntdll/loader.c index 255d5afef79..a9578ae86bf 100644 --- a/dlls/ntdll/loader.c +++ b/dlls/ntdll/loader.c @@ -95,6 +95,7 @@ static int free_lib_count; /* recursion depth of LdrUnloadDll calls */ static ULONG path_safe_mode; /* path mode set by RtlSetSearchPathMode */ static ULONG dll_safe_mode = 1; /* dll search mode */ static UNICODE_STRING dll_directory; /* extra path for LdrSetDllDirectory */ +static UNICODE_STRING system_dll_path; /* path to search for system dependency dlls */ static DWORD default_search_flags; /* default flags set by LdrSetDefaultDllDirectories */ static WCHAR *default_load_path; /* default dll search path */ @@ -2981,12 +2982,15 @@ static NTSTATUS load_dll( const WCHAR *load_path, const WCHAR *libname, const WC struct file_id id; HANDLE mapping = 0; SECTION_IMAGE_INFORMATION image_info; - NTSTATUS nts; + NTSTATUS nts = STATUS_DLL_NOT_FOUND; ULONG64 prev; TRACE( "looking for %s in %s\n", debugstr_w(libname), debugstr_w(load_path) ); - nts = find_dll_file( load_path, libname, default_ext, &nt_name, pwm, &mapping, &image_info, &id ); + if (system_dll_path.Buffer) + nts = find_dll_file( system_dll_path.Buffer, libname, default_ext, &nt_name, pwm, &mapping, &image_info, &id ); + if (nts) + nts = find_dll_file( load_path, libname, default_ext, &nt_name, pwm, &mapping, &image_info, &id ); if (*pwm) /* found already loaded module */ { @@ -3997,6 +4001,8 @@ void WINAPI LdrInitializeThunk( CONTEXT *context, ULONG_PTR unknown2, ULONG_PTR load_global_options(); version_init(); + get_env_var( L"WINESYSTEMDLLDIR", 0, &system_dll_path ); + wm = build_main_module(); wm->ldr.LoadCount = -1; diff --git a/dlls/ntdll/unix/env.c b/dlls/ntdll/unix/env.c index 43a34bf831b..1647603efa5 100644 --- a/dlls/ntdll/unix/env.c +++ b/dlls/ntdll/unix/env.c @@ -1296,6 +1296,7 @@ static void add_dynamic_environment( WCHAR **env, SIZE_T *pos, SIZE_T *size ) add_path_var( env, pos, size, "WINEHOMEDIR", home_dir ); add_path_var( env, pos, size, "WINEBUILDDIR", build_dir ); add_path_var( env, pos, size, "WINECONFIGDIR", config_dir ); + add_path_var( env, pos, size, "WINESYSTEMDLLDIR", system_dll_path ); for (i = 0; dll_paths[i]; i++) { sprintf( str, "WINEDLLDIR%u", i ); diff --git a/dlls/ntdll/unix/loader.c b/dlls/ntdll/unix/loader.c index 0ca4b1ea6dd..9fdcc236fb1 100644 --- a/dlls/ntdll/unix/loader.c +++ b/dlls/ntdll/unix/loader.c @@ -388,6 +388,7 @@ const char *data_dir = NULL; const char *build_dir = NULL; const char *config_dir = NULL; const char **dll_paths = NULL; +const char *system_dll_path = NULL; const char *user_name = NULL; SECTION_IMAGE_INFORMATION main_image_info = { NULL }; static HMODULE ntdll_module; @@ -619,6 +620,8 @@ static void init_paths( char *argv[] ) data_dir = build_path( bin_dir, BIN_TO_DATADIR ); } + if (strlen(SYSTEMDLLDIR)) system_dll_path = SYSTEMDLLDIR; + set_dll_path(); set_home_dir(); set_config_dir(); diff --git a/dlls/ntdll/unix/unix_private.h b/dlls/ntdll/unix/unix_private.h index 792cb33710d..01c7cc1c103 100644 --- a/dlls/ntdll/unix/unix_private.h +++ b/dlls/ntdll/unix/unix_private.h @@ -125,6 +125,7 @@ extern const char *build_dir DECLSPEC_HIDDEN; extern const char *config_dir DECLSPEC_HIDDEN; extern const char *user_name DECLSPEC_HIDDEN; extern const char **dll_paths DECLSPEC_HIDDEN; +extern const char *system_dll_path DECLSPEC_HIDDEN; extern PEB *peb DECLSPEC_HIDDEN; extern USHORT *uctable DECLSPEC_HIDDEN; extern USHORT *lctable DECLSPEC_HIDDEN; -- 2.33.0

2 2

[PATCH] msvcrt: Better handle multiple width specifiers
by Andrew Eikum 09 Nov '21

09 Nov '21

Includes feedback from David Gow <david(a)davidgow.net> and Piotr Caban. Signed-off-by: Andrew Eikum <aeikum(a)codeweavers.com> --- dlls/msvcrt/printf.h | 9 ++++++++- dlls/msvcrt/tests/printf.c | 12 ++++++++++++ dlls/ucrtbase/tests/printf.c | 19 +++++++++++++++++++ 3 files changed, 39 insertions(+), 1 deletion(-) diff --git a/dlls/msvcrt/printf.h b/dlls/msvcrt/printf.h index aeb1290f48f..c34479c5688 100644 --- a/dlls/msvcrt/printf.h +++ b/dlls/msvcrt/printf.h @@ -1050,7 +1050,14 @@ int FUNC_NAME(pf_printf)(FUNC_NAME(puts_clbk) pf_puts, void *puts_ctx, const API flags.LeftAlign = TRUE; flags.FieldLength = -flags.FieldLength; } - } else while (*p >= '0' && *p <= '9') { + } + +#if _MSVCR_VER >= 140 + if (*p >= '0' && *p <= '9') + flags.FieldLength = 0; +#endif + + while (*p >= '0' && *p <= '9') { flags.FieldLength *= 10; flags.FieldLength += *p++ - '0'; } diff --git a/dlls/msvcrt/tests/printf.c b/dlls/msvcrt/tests/printf.c index 06acf4c8450..010cad0ab8f 100644 --- a/dlls/msvcrt/tests/printf.c +++ b/dlls/msvcrt/tests/printf.c @@ -396,6 +396,18 @@ static void test_sprintf( void ) ok(!strcmp(buffer, "string to copy"), "failed: \"%s\"\n", buffer); setlocale(LC_ALL, "C"); + + r = p_sprintf(buffer, "%*1d", 1, 3); + ok(r==11, "r = %d\n", r); + ok(!strcmp(buffer, " 3"), "failed: \"%s\"\n", buffer); + + r = p_sprintf(buffer, "%0*0d", 1, 2); + ok(r==10, "r = %d\n", r); + ok(!strcmp(buffer, "0000000002"), "failed: \"%s\"\n", buffer); + + r = p_sprintf(buffer, "% *2d", 0, 7); + ok(r==2, "r = %d\n", r); + ok(!strcmp(buffer, " 7"), "failed: \"%s\"\n", buffer); } static void test_swprintf( void ) diff --git a/dlls/ucrtbase/tests/printf.c b/dlls/ucrtbase/tests/printf.c index 4f20ccff9a4..51a54426bc4 100644 --- a/dlls/ucrtbase/tests/printf.c +++ b/dlls/ucrtbase/tests/printf.c @@ -845,6 +845,24 @@ static void test_printf_fp(void) } } +static void test_printf_width_specification(void) +{ + int r; + char buffer[20]; + + r = vsprintf_wrapper(0, buffer, sizeof(buffer), "%0*2d", 1, 3); + ok(r == 2, "r = %d\n", r); + ok(!strcmp(buffer, "03"), "buffer wrong, got=%s\n", buffer); + + r = vsprintf_wrapper(0, buffer, sizeof(buffer), "%*0d", 1, 2); + ok(r == 1, "r = %d\n", r); + ok(!strcmp(buffer, "2"), "buffer wrong, got=%s\n", buffer); + + r = vsprintf_wrapper(0, buffer, sizeof(buffer), "% *2d", 0, 7); + ok(r == 2, "r = %d\n", r); + ok(!strcmp(buffer, " 7"), "buffer wrong, got=%s\n", buffer); +} + START_TEST(printf) { ok(_set_invalid_parameter_handler(test_invalid_parameter_handler) == NULL, @@ -862,4 +880,5 @@ START_TEST(printf) test_printf_c99(); test_printf_natural_string(); test_printf_fp(); + test_printf_width_specification(); } -- 2.33.1

3 2

[PATCH 1/2] d3dx10: Implement D3DX10CreateTextureFromFile{A,W}.
by Ziqing Hui 09 Nov '21

09 Nov '21

Signed-off-by: Ziqing Hui <zhui(a)codeweavers.com> --- dlls/d3dx10_43/tests/d3dx10.c | 7 ++---- dlls/d3dx10_43/texture.c | 42 +++++++++++++++++++++++++++++++---- 2 files changed, 40 insertions(+), 9 deletions(-) diff --git a/dlls/d3dx10_43/tests/d3dx10.c b/dlls/d3dx10_43/tests/d3dx10.c index 13f70f34f96..50128260b3e 100644 --- a/dlls/d3dx10_43/tests/d3dx10.c +++ b/dlls/d3dx10_43/tests/d3dx10.c @@ -2034,8 +2034,6 @@ static void test_create_texture(void) /* D3DX10CreateTextureFromFile tests */ - todo_wine - { hr = D3DX10CreateTextureFromFileW(device, NULL, NULL, NULL, &resource, NULL); ok(hr == E_FAIL, "Got unexpected hr %#x.\n", hr); hr = D3DX10CreateTextureFromFileW(device, L"deadbeef", NULL, NULL, &resource, NULL); @@ -2044,7 +2042,6 @@ static void test_create_texture(void) ok(hr == E_FAIL, "Got unexpected hr %#x.\n", hr); hr = D3DX10CreateTextureFromFileA(device, "deadbeef", NULL, NULL, &resource, NULL); ok(hr == D3D10_ERROR_FILE_NOT_FOUND, "Got unexpected hr %#x.\n", hr); - } for (i = 0; i < ARRAY_SIZE(test_image); ++i) { @@ -2052,7 +2049,7 @@ static void test_create_texture(void) create_file(test_filename, test_image[i].data, test_image[i].size, path); hr = D3DX10CreateTextureFromFileW(device, path, NULL, NULL, &resource, NULL); - todo_wine + todo_wine_if(test_image[i].expected_info.MiscFlags & D3D10_RESOURCE_MISC_TEXTURECUBE) ok(hr == S_OK || broken(hr == E_FAIL && test_image[i].expected_info.ImageFileFormat == D3DX10_IFF_WMP), "Got unexpected hr %#x.\n", hr); if (hr == S_OK) @@ -2063,7 +2060,7 @@ static void test_create_texture(void) } hr = D3DX10CreateTextureFromFileA(device, get_str_a(path), NULL, NULL, &resource, NULL); - todo_wine + todo_wine_if(test_image[i].expected_info.MiscFlags & D3D10_RESOURCE_MISC_TEXTURECUBE) ok(hr == S_OK || broken(hr == E_FAIL && test_image[i].expected_info.ImageFileFormat == D3DX10_IFF_WMP), "Got unexpected hr %#x.\n", hr); if (hr == S_OK) diff --git a/dlls/d3dx10_43/texture.c b/dlls/d3dx10_43/texture.c index 0568bc2316c..62baed0ca23 100644 --- a/dlls/d3dx10_43/texture.c +++ b/dlls/d3dx10_43/texture.c @@ -576,17 +576,51 @@ end: HRESULT WINAPI D3DX10CreateTextureFromFileA(ID3D10Device *device, const char *src_file, D3DX10_IMAGE_LOAD_INFO *load_info, ID3DX10ThreadPump *pump, ID3D10Resource **texture, HRESULT *hresult) { - FIXME("device %p, src_file %s, load_info %p, pump %p, texture %p, hresult %p stub!\n", + WCHAR *buffer; + int str_len; + HRESULT hr; + + TRACE("device %p, src_file %s, load_info %p, pump %p, texture %p, hresult %p.\n", device, debugstr_a(src_file), load_info, pump, texture, hresult); - return E_NOTIMPL; + + if (!src_file || !texture) + return E_FAIL; + + if (!(str_len = MultiByteToWideChar(CP_ACP, 0, src_file, -1, NULL, 0))) + return HRESULT_FROM_WIN32(GetLastError()); + + if (!(buffer = heap_alloc(str_len * sizeof(*buffer)))) + return E_OUTOFMEMORY; + + MultiByteToWideChar(CP_ACP, 0, src_file, -1, buffer, str_len); + hr = D3DX10CreateTextureFromFileW(device, buffer, load_info, pump, texture, hresult); + + heap_free(buffer); + + return hr; } HRESULT WINAPI D3DX10CreateTextureFromFileW(ID3D10Device *device, const WCHAR *src_file, D3DX10_IMAGE_LOAD_INFO *load_info, ID3DX10ThreadPump *pump, ID3D10Resource **texture, HRESULT *hresult) { - FIXME("device %p, src_file %s, load_info %p, pump %p, texture %p, hresult %p stub!\n", + void *buffer = NULL; + DWORD size = 0; + HRESULT hr; + + TRACE("device %p, src_file %s, load_info %p, pump %p, texture %p, hresult %p.\n", device, debugstr_w(src_file), load_info, pump, texture, hresult); - return E_NOTIMPL; + + if (!src_file || !texture) + return E_FAIL; + + if (FAILED(load_file(src_file, &buffer, &size))) + return D3D10_ERROR_FILE_NOT_FOUND; + + hr = D3DX10CreateTextureFromMemory(device, buffer, size, load_info, pump, texture, hresult); + + heap_free(buffer); + + return hr; } HRESULT WINAPI D3DX10CreateTextureFromResourceA(ID3D10Device *device, HMODULE module, const char *resource, -- 2.25.1

2 3

[PATCH 1/3] wined3d: Test if an offset is needed to get the correct filling convention (v3).
by Stefan Dösinger 09 Nov '21

09 Nov '21

This fixes stray lines in GameFace GUIs, e.g. in World of Tanks. Signed-off-by: Stefan Dösinger <stefan(a)codeweavers.com> --- Version 3: *) Fix "convetion" for real this time *) nudge -> offset *) good, bad -> upper, lower Version 2: *) Use a binary search for the fixup value. *) Change how an unexpected test result is detected. *) Add a comment about this to the Vulkan backend. *) Small wording changes. Re Vulkan: If you can refer me to the place in the spec that mandates a top-left filling convention I am more than happy to add it in the comment. I really don't want to add this detection mess to the Vulkan backend. I am also more than happy to just drop this nudge thingy unconditionally. I am not aware of a card + game combination that is fixed by this. Spore doesn't need it on my gf9600. I didn't bother to download Everquest, I expect it to have changed a lot in the past 10 years. I don't have access to a dx9 level card right now, so I can't entirely rule out that Spore needs this nudge on those cards. The ddraw tests started succeeding in the todo block for a few of the tested pixels. I looked at the output results and I don't think it happened because the Z values are more precise now. I think a few bits flipped (in the random readback we get) and now a few of those tests were inside the expected diff. --- dlls/d3d11/tests/d3d11.c | 1 - dlls/ddraw/tests/ddraw4.c | 6 +- dlls/ddraw/tests/ddraw7.c | 6 +- dlls/wined3d/adapter_gl.c | 50 ++++++++++++++ dlls/wined3d/adapter_vk.c | 8 +++ dlls/wined3d/state.c | 3 +- dlls/wined3d/utils.c | 118 ++++++++++++++++++++++++++++++--- dlls/wined3d/wined3d_private.h | 13 +++- 8 files changed, 187 insertions(+), 18 deletions(-) diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c index 2ed9aed490e..561a38ec5aa 100644 --- a/dlls/d3d11/tests/d3d11.c +++ b/dlls/d3d11/tests/d3d11.c @@ -28185,7 +28185,6 @@ static void test_fractional_viewports(void) ok(compare_float(v->x, expected.x, 0) && compare_float(v->y, expected.y, 0), "Got fragcoord {%.8e, %.8e}, expected {%.8e, %.8e} at (%u, %u), offset %.8e.\n", v->x, v->y, expected.x, expected.y, x, y, viewport_offsets[i]); - todo_wine ok(compare_float(v->z, expected.z, 2) && compare_float(v->w, expected.w, 2), "Got texcoord {%.8e, %.8e}, expected {%.8e, %.8e} at (%u, %u), offset %.8e.\n", v->z, v->w, expected.z, expected.w, x, y, viewport_offsets[i]); diff --git a/dlls/ddraw/tests/ddraw4.c b/dlls/ddraw/tests/ddraw4.c index 6b514b15e25..4f052256882 100644 --- a/dlls/ddraw/tests/ddraw4.c +++ b/dlls/ddraw/tests/ddraw4.c @@ -16118,8 +16118,10 @@ static void test_depth_readback(void) /* The ddraw4 version of this test behaves similarly to the ddraw7 version on Nvidia GPUs, * except that Geforce 7 also returns garbage data in D24S8, whereas the ddraw7 version * returns 0 for that format. Give up on pre-filtering formats, accept Nvidia as generally - * broken here, but still expect at least one format (D16 or D24X8 in practise) to pass. */ - todo_wine_if(tests[i].todo) + * broken here, but still expect at least one format (D16 or D24X8 in practise) to pass. + * + * Some of the tested places pass on some GPUs on Wine by accident. */ + todo_wine_if(tests[i].todo && !compare_uint(expected_depth, depth, max_diff)) ok(compare_uint(expected_depth, depth, max_diff) || ddraw_is_nvidia(ddraw), "Test %u: Got depth 0x%08x (diff %d), expected 0x%08x+/-%u, at %u, %u.\n", i, depth, expected_depth - depth, expected_depth, max_diff, x, y); diff --git a/dlls/ddraw/tests/ddraw7.c b/dlls/ddraw/tests/ddraw7.c index 4c42d6f4b64..4402f2d93b5 100644 --- a/dlls/ddraw/tests/ddraw7.c +++ b/dlls/ddraw/tests/ddraw7.c @@ -15597,8 +15597,10 @@ static void test_depth_readback(void) * Geforce GTX 650 has working D16 and D24, but D24S8 returns 0. * * Arx Fatalis is broken on the Geforce 9 in the same way it was broken in Wine (bug 43654). - * The !tests[i].s_depth is supposed to rule out D16 on GF9 and D24X8 on GF7. */ - todo_wine_if(tests[i].todo) + * The !tests[i].s_depth is supposed to rule out D16 on GF9 and D24X8 on GF7. + * + * Some of the tested places pass on some GPUs on Wine by accident. */ + todo_wine_if(tests[i].todo && !compare_uint(expected_depth, depth, max_diff)) ok(compare_uint(expected_depth, depth, max_diff) || (ddraw_is_nvidia(ddraw) && (all_zero || all_one || !tests[i].s_depth)), "Test %u: Got depth 0x%08x (diff %d), expected 0x%08x+/-%u, at %u, %u.\n", diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c index f1cdbffe718..2a91418b0d0 100644 --- a/dlls/wined3d/adapter_gl.c +++ b/dlls/wined3d/adapter_gl.c @@ -5142,6 +5142,7 @@ static void wined3d_adapter_gl_init_d3d_info(struct wined3d_adapter_gl *adapter_ d3d_info->scaled_resolve = !!gl_info->supported[EXT_FRAMEBUFFER_MULTISAMPLE_BLIT_SCALED]; d3d_info->pbo = !!gl_info->supported[ARB_PIXEL_BUFFER_OBJECT]; d3d_info->feature_level = feature_level_from_caps(gl_info, &shader_caps, &fragment_caps); + d3d_info->filling_convention_offset = gl_info->filling_convention_offset; if (gl_info->supported[ARB_TEXTURE_MULTISAMPLE]) d3d_info->multisample_draw_location = WINED3D_LOCATION_TEXTURE_RGB; @@ -5149,6 +5150,53 @@ static void wined3d_adapter_gl_init_d3d_info(struct wined3d_adapter_gl *adapter_ d3d_info->multisample_draw_location = WINED3D_LOCATION_RB_MULTISAMPLE; } +static float wined3d_adapter_find_fill_offset(struct wined3d_caps_gl_ctx *ctx) +{ + static const float test_array[] = + { + 0.0f, + -1.0f / 1024.0f, + -1.0f / 512.0f, + -1.0f / 256.0f, + -1.0f / 128.0f, + -1.0f / 64.0f + }; + unsigned int upper = ARRAY_SIZE(test_array), lower = 0, test; + float value; + + if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) + goto end; + + while (upper != lower) + { + test = (upper + lower) / 2; + value = test_array[test]; + TRACE("Good %u lower %u, test %u.\n", upper, lower, test); + if (wined3d_caps_gl_ctx_test_filling_convention(ctx, value)) + upper = test; + else + lower = test + 1; + } + + if (upper < ARRAY_SIZE(test_array)) + { + value = test_array[upper]; + if (value) + WARN("Using a filling convention fixup offset of -1/%f.\n", -1.0f / value); + else + TRACE("No need for a filling convention offset.\n"); + + return value; + } + + FIXME("Did not find a way to get the filling convention we want.\n"); + +end: + /* This value was used unconditionally before the dynamic test function was + * introduced. */ + return -1.0f / 64.0f; +} + static BOOL wined3d_adapter_gl_init(struct wined3d_adapter_gl *adapter_gl, unsigned int ordinal, unsigned int wined3d_creation_flags) { @@ -5234,6 +5282,8 @@ static BOOL wined3d_adapter_gl_init(struct wined3d_adapter_gl *adapter_gl, return FALSE; } + gl_info->filling_convention_offset = wined3d_adapter_find_fill_offset(&caps_gl_ctx); + wined3d_adapter_gl_init_d3d_info(adapter_gl, wined3d_creation_flags); if (!adapter_gl->a.d3d_info.shader_color_key) diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index 02a359c4f07..d82b5221d3c 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -2224,6 +2224,14 @@ static void wined3d_adapter_vk_init_d3d_info(struct wined3d_adapter_vk *adapter_ d3d_info->pbo = true; d3d_info->feature_level = feature_level_from_caps(&shader_caps); + /* Like GL, Vulkan doesn't explicitly specify a filling convention and only mandates that a + * shared edge of two adjacent triangles generate a fragment for exactly one of the triangles. + * + * However, every Vulkan implementation we have seen so far uses a top-left rule. Hardware + * that differs either predates Vulkan (d3d9 class HW, GeForce 9xxx) or behaves the way we + * want in Vulkan (MacOS Radeon driver through MoltenVK). */ + d3d_info->filling_convention_offset = 0.0f; + d3d_info->multisample_draw_location = WINED3D_LOCATION_TEXTURE_RGB; } diff --git a/dlls/wined3d/state.c b/dlls/wined3d/state.c index fd2ade572c8..901771fdcc1 100644 --- a/dlls/wined3d/state.c +++ b/dlls/wined3d/state.c @@ -4239,13 +4239,14 @@ static void viewport_miscpart_cc(struct wined3d_context *context, const struct wined3d_gl_info *gl_info = wined3d_context_gl(context)->gl_info; /* See get_projection_matrix() in utils.c for a discussion about those values. */ float pixel_center_offset = context->d3d_info->wined3d_creation_flags - & WINED3D_PIXEL_CENTER_INTEGER ? 63.0f / 128.0f : -1.0f / 128.0f; + & WINED3D_PIXEL_CENTER_INTEGER ? 0.5f : 0.0f; struct wined3d_viewport vp[WINED3D_MAX_VIEWPORTS]; GLdouble depth_ranges[2 * WINED3D_MAX_VIEWPORTS]; GLfloat viewports[4 * WINED3D_MAX_VIEWPORTS]; unsigned int i, reset_count = 0; float min_z, max_z; + pixel_center_offset += context->d3d_info->filling_convention_offset / 2.0f; get_viewports(context, state, state->viewport_count, vp); GL_EXTCALL(glClipControl(context->render_offscreen ? GL_UPPER_LEFT : GL_LOWER_LEFT, GL_ZERO_TO_ONE)); diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index 29326668e07..26001775300 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -3914,6 +3914,100 @@ BOOL wined3d_caps_gl_ctx_test_viewport_subpixel_bits(struct wined3d_caps_gl_ctx return TRUE; } +bool wined3d_caps_gl_ctx_test_filling_convention(struct wined3d_caps_gl_ctx *ctx, float offset) +{ + static const struct wined3d_color red = {1.0f, 0.0f, 0.0f, 1.0f}; + const struct wined3d_gl_info *gl_info = ctx->gl_info; + unsigned int x, y, clear = 0, draw = 0; + GLuint texture, fbo; + DWORD readback[8][8]; + + /* This is a very simple test to find out how GL handles polygon edges: + * Draw a 1x1 quad exactly through 4 adjacent pixel centers in an 8x8 + * viewport and see which pixel it ends up in. So far we've seen top left + * and bottom left conventions. This test may produce unexpected results + * if the driver forces multisampling on us. + * + * If we find a bottom-left filling behavior we also move the x-axis + * by the same amount. This is necessary to keep diagonals that go + * through the pixel center intact. + * + * Note that we are ignoring some settings that might influence the + * driver: How we switch GL to an upper-left coordinate system, + * shaders vs fixed function GL. Testing these isn't possible with + * the current draw_test_quad() infrastructure. Also the test is + * skipped if we are not using FBOs. Drawing into the onscreen + * frame buffer may also yield different driver behavior. + * + * The minimum offset also depends on the viewport size, although + * the relation between those two is GPU dependent and not exactly + * sensible. E.g. a 8192x8192 viewport on a GeForce 9 needs at + * least an offset of 1/240.9, whereas a 8x8 one needs 1/255.982; + * 32x32 needs 1/255.935. 4x4 and lower are happy with something + * below 1/256. The 8x8 size below has been arbitrarily chosen to + * get a useful result out of that card and avoid allocating a + * gigantic texture during library init. + * + * Newer cards usually do the right thing anyway. In cases where + * they do not (e.g. Radeon GPUs in a macbookpro14,3 running MacOS) + * an offset of 1/2^20 is enough. */ + const struct wined3d_vec3 edge_geometry[] = + { + {(-1.0f + offset) / 8.0f, (-1.0f + offset) / 8.0f, 0.0f}, + {( 1.0f + offset) / 8.0f, (-1.0f + offset) / 8.0f, 0.0f}, + {(-1.0f + offset) / 8.0f, ( 1.0f + offset) / 8.0f, 0.0f}, + {( 1.0f + offset) / 8.0f, ( 1.0f + offset) / 8.0f, 0.0f}, + }; + + gl_info->gl_ops.gl.p_glGenTextures(1, &texture); + gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, texture); + gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); + gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 8, 8, 0, + GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL); + gl_info->fbo_ops.glGenFramebuffers(1, &fbo); + gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo); + gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, + GL_TEXTURE_2D, texture, 0); + checkGLcall("create resources"); + + gl_info->gl_ops.gl.p_glViewport(0, 0, 8, 8); + gl_info->gl_ops.gl.p_glClearColor(0.0f, 0.0f, 1.0f, 1.0f); + gl_info->gl_ops.gl.p_glClear(GL_COLOR_BUFFER_BIT); + + draw_test_quad(ctx, edge_geometry, &red); + checkGLcall("draw"); + + gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, texture); + gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_2D, 0, + GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, readback); + checkGLcall("readback"); + + gl_info->gl_ops.gl.p_glDeleteTextures(1, &texture); + gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo); + gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0); + checkGLcall("delete resources"); + + /* We expect that exactly one fragment is generated. */ + for (y = 0; y < ARRAY_SIZE(readback); ++y) + { + for (x = 0; x < ARRAY_SIZE(readback[0]); ++x) + { + if (readback[y][x] == 0xff0000ff) + clear++; + else if (readback[y][x] == 0xffff0000) + draw++; + } + } + + if (clear != 63 || draw != 1) + { + FIXME("Unexpected filling convention test result.\n"); + return FALSE; + } + + /* One pixel was drawn, check if it is the expected one */ + return readback[3][3] == 0xffff0000; +} static float wined3d_adapter_find_polyoffset_scale(struct wined3d_caps_gl_ctx *ctx, GLenum format) { const struct wined3d_gl_info *gl_info = ctx->gl_info; @@ -5542,15 +5636,19 @@ void get_projection_matrix(const struct wined3d_context *context, const struct w * - We need to flip along the y-axis in case of offscreen rendering. * - OpenGL Z range is {-Wc,...,Wc} while D3D Z range is {0,...,Wc}. * - <= D3D9 coordinates refer to pixel centers while GL coordinates - * refer to pixel corners. - * - D3D has a top-left filling convention. We need to maintain this - * even after the y-flip mentioned above. - * In order to handle the last two points, we translate by - * (63.0 / 128.0) / VPw and (63.0 / 128.0) / VPh. This is equivalent to - * translating slightly less than half a pixel. We want the difference to - * be large enough that it doesn't get lost due to rounding inside the - * driver, but small enough to prevent it from interfering with any - * anti-aliasing. */ + * refer to pixel corners. D3D10 fixed this particular oddity. + * - D3D has a top-left filling convention while GL does not specify + * a particular behavior, other than that that the GL implementation + * needs to be consistent. + * + * In order to handle the pixel center, we translate by 0.5 / VPw and + * 0.5 / VPh. We test the filling convention during adapter init and + * add a small offset to correct it if necessary. See + * wined3d_caps_gl_ctx_test_filling_convention() for more details on how + * we test GL and considerations regarding the added offset value. + * + * If we have GL_ARB_clip_control we take care of all this through + * viewport properties and don't have to translate geometry. */ /* Projection matrices are <= d3d9, which all have integer pixel centers. */ if (!(d3d_info->wined3d_creation_flags & WINED3D_PIXEL_CENTER_INTEGER)) @@ -5559,7 +5657,7 @@ void get_projection_matrix(const struct wined3d_context *context, const struct w clip_control = d3d_info->clip_control; flip = !clip_control && context->render_offscreen; if (!clip_control) - center_offset = 63.0f / 64.0f; + center_offset = 1.0f + d3d_info->filling_convention_offset; else center_offset = 0.0f; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index aa8974366a6..6e122ce31dc 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -243,6 +243,8 @@ struct wined3d_d3d_info enum wined3d_feature_level feature_level; DWORD multisample_draw_location; + + float filling_convention_offset; }; static const struct color_fixup_desc COLOR_FIXUP_IDENTITY = @@ -3265,6 +3267,7 @@ struct wined3d_gl_info DWORD quirks; BOOL supported[WINED3D_GL_EXT_COUNT]; GLint wrap_lookup[WINED3D_TADDRESS_MIRROR_ONCE - WINED3D_TADDRESS_WRAP + 1]; + float filling_convention_offset; HGLRC (WINAPI *p_wglCreateContextAttribsARB)(HDC dc, HGLRC share, const GLint *attribs); struct opengl_funcs gl_ops; @@ -3525,6 +3528,7 @@ BOOL wined3d_adapter_vk_init_format_info(struct wined3d_adapter_vk *adapter_vk, UINT64 adapter_adjust_memory(struct wined3d_adapter *adapter, INT64 amount) DECLSPEC_HIDDEN; BOOL wined3d_caps_gl_ctx_test_viewport_subpixel_bits(struct wined3d_caps_gl_ctx *ctx) DECLSPEC_HIDDEN; +bool wined3d_caps_gl_ctx_test_filling_convention(struct wined3d_caps_gl_ctx *ctx, float offset) DECLSPEC_HIDDEN; void install_gl_compat_wrapper(struct wined3d_gl_info *gl_info, enum wined3d_gl_extension ext) DECLSPEC_HIDDEN; @@ -5759,10 +5763,15 @@ static inline void shader_get_position_fixup(const struct wined3d_context *conte float center_offset; unsigned int i; + /* See get_projection_matrix() in utils.c for a discussion of the position fixup. + * This function here also applies to d3d10+ which does not need adjustment for + * integer pixel centers, but it may need the filling convention offset. */ if (context->d3d_info->wined3d_creation_flags & WINED3D_PIXEL_CENTER_INTEGER) - center_offset = 63.0f / 64.0f; + center_offset = 1.0f; else - center_offset = -1.0f / 64.0f; + center_offset = 0.0f; + + center_offset += context->d3d_info->filling_convention_offset; for (i = 0; i < fixup_count; ++i) { -- 2.32.0

4 8

[PATCH 1/4] winebus.sys: Use +hid debug channel.
by Rémi Bernon 09 Nov '21

09 Nov '21

Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- This may be a bit verbose but then all HID backend code will be on the same "+hid" debug channel, and frontend APIs on "+xinput" / "+dinput" respectively, simplifying the capture of relevant logs. dlls/winebus.sys/bus_iohid.c | 2 +- dlls/winebus.sys/bus_sdl.c | 2 +- dlls/winebus.sys/bus_udev.c | 2 +- dlls/winebus.sys/hid.c | 2 +- dlls/winebus.sys/main.c | 12 ++++++------ 5 files changed, 10 insertions(+), 10 deletions(-) diff --git a/dlls/winebus.sys/bus_iohid.c b/dlls/winebus.sys/bus_iohid.c index eef882b52e8..735fd8c54cc 100644 --- a/dlls/winebus.sys/bus_iohid.c +++ b/dlls/winebus.sys/bus_iohid.c @@ -97,7 +97,7 @@ #include "unix_private.h" -WINE_DEFAULT_DEBUG_CHANNEL(plugplay); +WINE_DEFAULT_DEBUG_CHANNEL(hid); #ifdef HAVE_IOHIDMANAGERCREATE static pthread_mutex_t iohid_cs = PTHREAD_MUTEX_INITIALIZER; diff --git a/dlls/winebus.sys/bus_sdl.c b/dlls/winebus.sys/bus_sdl.c index c01648ce67e..49afcbaf67c 100644 --- a/dlls/winebus.sys/bus_sdl.c +++ b/dlls/winebus.sys/bus_sdl.c @@ -55,7 +55,7 @@ #include "unix_private.h" -WINE_DEFAULT_DEBUG_CHANNEL(plugplay); +WINE_DEFAULT_DEBUG_CHANNEL(hid); #ifdef SONAME_LIBSDL2 diff --git a/dlls/winebus.sys/bus_udev.c b/dlls/winebus.sys/bus_udev.c index 1591f00eedf..dad5344a54c 100644 --- a/dlls/winebus.sys/bus_udev.c +++ b/dlls/winebus.sys/bus_udev.c @@ -92,7 +92,7 @@ #include "unix_private.h" -WINE_DEFAULT_DEBUG_CHANNEL(plugplay); +WINE_DEFAULT_DEBUG_CHANNEL(hid); #ifdef HAVE_UDEV diff --git a/dlls/winebus.sys/hid.c b/dlls/winebus.sys/hid.c index a0f07f66392..893bf1cd7f6 100644 --- a/dlls/winebus.sys/hid.c +++ b/dlls/winebus.sys/hid.c @@ -39,7 +39,7 @@ #include "unix_private.h" -WINE_DEFAULT_DEBUG_CHANNEL(plugplay); +WINE_DEFAULT_DEBUG_CHANNEL(hid); static BOOL hid_report_descriptor_append(struct hid_report_descriptor *desc, const BYTE *buffer, SIZE_T size) { diff --git a/dlls/winebus.sys/main.c b/dlls/winebus.sys/main.c index 169b64a2c83..06925395ea8 100644 --- a/dlls/winebus.sys/main.c +++ b/dlls/winebus.sys/main.c @@ -40,7 +40,7 @@ #include "unixlib.h" -WINE_DEFAULT_DEBUG_CHANNEL(plugplay); +WINE_DEFAULT_DEBUG_CHANNEL(hid); static DRIVER_OBJECT *driver_obj; @@ -413,7 +413,7 @@ static BOOL deliver_next_report(struct device_extension *ext, IRP *irp) irp->IoStatus.Information = report->length; irp->IoStatus.Status = STATUS_SUCCESS; - if (TRACE_ON(plugplay)) + if (TRACE_ON(hid)) { TRACE("read input report length %u:\n", report->length); for (i = 0; i < report->length;) @@ -1042,7 +1042,7 @@ static NTSTATUS WINAPI hid_internal_dispatch(DEVICE_OBJECT *device, IRP *irp) memcpy(packet->reportBuffer, ext->last_reports[packet->reportId], packet->reportBufferLen); irp->IoStatus.Information = packet->reportBufferLen; irp->IoStatus.Status = STATUS_SUCCESS; - if (TRACE_ON(plugplay)) + if (TRACE_ON(hid)) { TRACE("read input report id %u length %u:\n", packet->reportId, packet->reportBufferLen); for (i = 0; i < packet->reportBufferLen;) @@ -1072,7 +1072,7 @@ static NTSTATUS WINAPI hid_internal_dispatch(DEVICE_OBJECT *device, IRP *irp) case IOCTL_HID_WRITE_REPORT: { HID_XFER_PACKET *packet = (HID_XFER_PACKET *)irp->UserBuffer; - if (TRACE_ON(plugplay)) + if (TRACE_ON(hid)) { TRACE("write output report id %u length %u:\n", packet->reportId, packet->reportBufferLen); for (i = 0; i < packet->reportBufferLen;) @@ -1091,7 +1091,7 @@ static NTSTATUS WINAPI hid_internal_dispatch(DEVICE_OBJECT *device, IRP *irp) { HID_XFER_PACKET *packet = (HID_XFER_PACKET *)irp->UserBuffer; unix_device_get_feature_report(device, packet, &irp->IoStatus); - if (!irp->IoStatus.Status && TRACE_ON(plugplay)) + if (!irp->IoStatus.Status && TRACE_ON(hid)) { TRACE("read feature report id %u length %u:\n", packet->reportId, packet->reportBufferLen); for (i = 0; i < packet->reportBufferLen;) @@ -1108,7 +1108,7 @@ static NTSTATUS WINAPI hid_internal_dispatch(DEVICE_OBJECT *device, IRP *irp) case IOCTL_HID_SET_FEATURE: { HID_XFER_PACKET *packet = (HID_XFER_PACKET *)irp->UserBuffer; - if (TRACE_ON(plugplay)) + if (TRACE_ON(hid)) { TRACE("write feature report id %u length %u:\n", packet->reportId, packet->reportBufferLen); for (i = 0; i < packet->reportBufferLen;) -- 2.33.1

1 3

[PATCH] Subject: [PATCH] wbemprox: add empty DNSDomain to Win32_NetworkAdapterConfiguration
by Louis Lenders 09 Nov '21

09 Nov '21

https://bugs.winehq.org/show_bug.cgi?id=51938 Signed-off-by: Louis Lenders <xerox.xerox2000x(a)gmail.com> --- dlls/wbemprox/builtin.c | 3 +++ dlls/wbemprox/tests/query.c | 12 ++++++++++++ 2 files changed, 15 insertions(+) diff --git a/dlls/wbemprox/builtin.c b/dlls/wbemprox/builtin.c index 346ba365b74..3fccd3fb600 100644 --- a/dlls/wbemprox/builtin.c +++ b/dlls/wbemprox/builtin.c @@ -215,6 +215,7 @@ static const struct column col_networkadapterconfig[] = { L"DefaultIPGateway", CIM_STRING|CIM_FLAG_ARRAY|COL_FLAG_DYNAMIC }, { L"Description", CIM_STRING|COL_FLAG_DYNAMIC }, { L"DHCPEnabled", CIM_BOOLEAN }, + { L"DNSDomain", CIM_STRING }, { L"DNSHostName", CIM_STRING|COL_FLAG_DYNAMIC }, { L"DNSServerSearchOrder", CIM_STRING|CIM_FLAG_ARRAY|COL_FLAG_DYNAMIC }, { L"Index", CIM_UINT32|COL_FLAG_KEY }, @@ -632,6 +633,7 @@ struct record_networkadapterconfig const struct array *defaultipgateway; const WCHAR *description; int dhcpenabled; + const WCHAR *dnsdomain; const WCHAR *dnshostname; const struct array *dnsserversearchorder; UINT32 index; @@ -2989,6 +2991,7 @@ static enum fill_status fill_networkadapterconfig( struct table *table, const st rec->defaultipgateway = get_defaultipgateway( aa->FirstGatewayAddress ); rec->description = heap_strdupW( aa->Description ); rec->dhcpenabled = -1; + rec->dnsdomain = L""; rec->dnshostname = get_dnshostname( aa->FirstUnicastAddress ); rec->dnsserversearchorder = get_dnsserversearchorder( aa->FirstDnsServerAddress ); rec->index = aa->u.s.IfIndex; diff --git a/dlls/wbemprox/tests/query.c b/dlls/wbemprox/tests/query.c index b3a0e3c4534..577a352c26f 100644 --- a/dlls/wbemprox/tests/query.c +++ b/dlls/wbemprox/tests/query.c @@ -1331,8 +1331,10 @@ static void test_Win32_NetworkAdapterConfiguration( IWbemServices *services ) BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_NetworkAdapterConfiguration" ); IEnumWbemClassObject *result; IWbemClassObject *obj; + CIMTYPE type; HRESULT hr; DWORD count; + VARIANT val; hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result ); ok( hr == S_OK, "got %08x\n", hr ); @@ -1345,6 +1347,16 @@ static void test_Win32_NetworkAdapterConfiguration( IWbemServices *services ) check_property( obj, L"Description", VT_BSTR, CIM_STRING ); check_property( obj, L"Index", VT_I4, CIM_UINT32 ); check_property( obj, L"IPEnabled", VT_BOOL, CIM_BOOLEAN ); + + type = 0xdeadbeef; + VariantInit( &val ); + hr = IWbemClassObject_Get( obj, L"DNSDomain", 0, &val, &type, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + ok( V_VT( &val ) == VT_BSTR || V_VT( &val ) == VT_NULL, "unexpected variant type 0x%x\n", V_VT( &val ) ); + ok( type == CIM_STRING, "unexpected type 0x%x\n", type ); + trace( "DNSDomain %s\n", wine_dbgstr_w(V_BSTR( &val )) ); + VariantClear( &val ); + IWbemClassObject_Release( obj ); } -- 2.33.1

2 1

[PATCH] propsys/tests: Add a VT_UI4 test for PropVariantCompareEx().
by Nikolay Sivov 09 Nov '21

09 Nov '21

A test for 58eeb1a86433db1104d3a9ccf9ad7435ec81443a. Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/propsys/tests/propsys.c | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/dlls/propsys/tests/propsys.c b/dlls/propsys/tests/propsys.c index 9ffa048a8b7..6370c01dc80 100644 --- a/dlls/propsys/tests/propsys.c +++ b/dlls/propsys/tests/propsys.c @@ -670,6 +670,7 @@ static void test_PropVariantCompareEx(void) { PROPVARIANT empty, null, emptyarray, i2_0, i2_2, i4_large, i4_largeneg, i4_2, str_2, str_02, str_b; PROPVARIANT clsid_null, clsid, clsid2, r4_0, r4_2, r8_0, r8_2; + PROPVARIANT ui4, ui4_large; PROPVARIANT var1, var2; INT res; static const WCHAR str_2W[] = {'2', 0}; @@ -711,6 +712,10 @@ static void test_PropVariantCompareEx(void) i4_largeneg.lVal = -65536; i4_2.vt = VT_I4; i4_2.lVal = 2; + ui4.vt = VT_UI4; + ui4.ulVal = 2; + ui4_large.vt = VT_UI4; + ui4_large.ulVal = 65536; str_2.vt = VT_BSTR; str_2.bstrVal = SysAllocString(str_2W); str_02.vt = VT_BSTR; @@ -759,6 +764,12 @@ static void test_PropVariantCompareEx(void) res = PropVariantCompareEx(&i2_0, &i2_2, 0, 0); ok(res == -1, "res=%i\n", res); + res = PropVariantCompareEx(&ui4, &ui4_large, 0, 0); + ok(res == -1, "res=%i\n", res); + + res = PropVariantCompareEx(&ui4_large, &ui4, 0, 0); + ok(res == 1, "res=%i\n", res); + /* Always return -1 if second value cannot be converted to first type */ res = PropVariantCompareEx(&i2_0, &i4_large, 0, 0); ok(res == -1, "res=%i\n", res); -- 2.33.0

2 1