[v7 2/7] d3dx9: Implement preshader parsing.
Paul Gofman
gofmanp at gmail.com
Mon Mar 28 02:20:22 CDT 2016
Signed-off-by: Paul Gofman <gofmanp at gmail.com>
---
Changes
- Used lowercase for enumeration type names
- Changed OFFSET2REG macro to get_reg_offset() function
- Use name size instead of sz in regstore_alloc_table
- Changed size /= 4 to size /= sizeof(*bytecode) in dump_bytecode
- Blocked bits set in regstore_set_values
- Changed opcode function to take double arguments and return double
- Modified ..._regset2table arrays to hold PRES_REGTAB_COUNT instead of PRES_REGTAB_NONE;
- Modified update_table_sizes_consts() to check for PRES_REGTAB_COUNT in regset2table
- Modified parse_pres_arg() to handle different numbering of register sets in opcode and
- Updated table_info[]
- Add {} to if when else has {}
dlls/d3dx9_36/d3dx9_private.h | 54 ++++-
dlls/d3dx9_36/preshader.c | 543 +++++++++++++++++++++++++++++++++++++++++-
2 files changed, 593 insertions(+), 4 deletions(-)
diff --git a/dlls/d3dx9_36/d3dx9_private.h b/dlls/d3dx9_36/d3dx9_private.h
index 5ba93ac..1afa0ea 100644
--- a/dlls/d3dx9_36/d3dx9_private.h
+++ b/dlls/d3dx9_36/d3dx9_private.h
@@ -108,7 +108,59 @@ const char *debug_d3dxparameter_registerset(D3DXREGISTER_SET r) DECLSPEC_HIDDEN;
void set_number(void *outdata, D3DXPARAMETER_TYPE outtype,
const void *indata, D3DXPARAMETER_TYPE intype) DECLSPEC_HIDDEN;
-struct d3dx_param_eval;
+struct d3dx_parameter;
+
+enum pres_reg_tables
+{
+ PRES_REGTAB_IMMED, /* immediate double constants from CLIT */
+ PRES_REGTAB_CONST,
+ PRES_REGTAB_OCONST,
+ PRES_REGTAB_OBCONST,
+ PRES_REGTAB_OICONST,
+ PRES_REGTAB_REG,
+ PRES_REGTAB_COUNT,
+ PRES_REGTAB_FIRST = PRES_REGTAB_IMMED,
+ PRES_REGTAB_LAST = PRES_REGTAB_REG,
+};
+
+struct d3dx_const_tab
+{
+ unsigned int input_count;
+ D3DXCONSTANT_DESC *inputs;
+ struct d3dx_parameter **inputs_param;
+ ID3DXConstantTable *ctab;
+ /* TODO: do not keep input constant structure
+ (use it only at the parse stage) */
+ const enum pres_reg_tables *regset2table;
+};
+
+struct d3dx_regstore
+{
+ void *tables[PRES_REGTAB_COUNT];
+ unsigned int table_sizes[PRES_REGTAB_COUNT]; /* registers count */
+ unsigned int *table_value_set[PRES_REGTAB_COUNT];
+};
+
+struct d3dx_pres_ins;
+
+struct d3dx_preshader
+{
+ struct d3dx_regstore regs;
+
+ unsigned int ins_count;
+ struct d3dx_pres_ins *ins;
+
+ struct d3dx_const_tab inputs;
+};
+
+
+struct d3dx_param_eval
+{
+ D3DXPARAMETER_TYPE param_type;
+
+ struct d3dx_preshader pres;
+ struct d3dx_const_tab shader_inputs;
+};
struct d3dx_parameter
{
diff --git a/dlls/d3dx9_36/preshader.c b/dlls/d3dx9_36/preshader.c
index d865fd0..1c2d7a7 100644
--- a/dlls/d3dx9_36/preshader.c
+++ b/dlls/d3dx9_36/preshader.c
@@ -25,17 +25,554 @@
WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
+enum pres_ops
+{
+ PRESHADER_OP_NOP,
+ PRESHADER_OP_MOV,
+ PRESHADER_OP_MAX_ENUM
+};
+
+typedef double (*pres_op_func)(double *args, int ncomp);
+
+static double pres_mov(double *args, int ncomp) {return args[0];}
+
+#define PRES_OPCODE_MASK 0x7ff00000
+#define PRES_OPCODE_SHIFT 20
+#define PRES_SCALAR_FLAG 0x80000000
+#define PRES_NCOMP_MASK 0x0000ffff
+
+#define FOURCC_PRES 0x53455250
+#define FOURCC_CLIT 0x54494c43
+#define FOURCC_FXLC 0x434c5846
+#define FOURCC_PRSI 0x49535250
+#define PRES_SIGN 0x46580000
+
+struct op_info
+{
+ unsigned int opcode;
+ char mnem[8];
+ unsigned int input_count;
+ BOOL func_all_comps;
+ pres_op_func func;
+};
+
+static struct op_info pres_op_info[] =
+{
+ {0x000, "nop", 0, 0, NULL }, /* PRESHADER_OP_NOP */
+ {0x100, "mov", 1, 0, pres_mov}, /* PRESHADER_OP_MOV */
+};
+
+enum pres_value_type
+{
+ PRES_VT_FLOAT,
+ PRES_VT_DOUBLE,
+ PRES_VT_INT,
+ PRES_VT_BOOL
+};
+
+static const struct
+{
+ unsigned int component_size;
+ unsigned int reg_component_count;
+ enum pres_value_type type;
+}
+table_info[] =
+{
+ {sizeof(double), 1, PRES_VT_DOUBLE}, /* PRES_REGTAB_IMMED */
+ {sizeof(float), 4, PRES_VT_FLOAT }, /* PRES_REGTAB_CONST */
+ {sizeof(float), 4, PRES_VT_FLOAT }, /* PRES_REGTAB_OCONST */
+ {sizeof(BOOL), 1, PRES_VT_BOOL }, /* PRES_REGTAB_OBCONST */
+ {sizeof(int), 4, PRES_VT_INT, }, /* PRES_REGTAB_OICONST */
+ /* TODO: use double precision for 64 bit */
+ {sizeof(float), 4, PRES_VT_FLOAT } /* PRES_REGTAB_REG */
+};
+
+static const enum pres_reg_tables pres_regset2table[] =
+{
+ PRES_REGTAB_OBCONST, /* D3DXRS_BOOL */
+ PRES_REGTAB_OICONST, /* D3DXRS_INT4 */
+ PRES_REGTAB_CONST, /* D3DXRS_FLOAT4 */
+ PRES_REGTAB_COUNT, /* D3DXRS_SAMPLER */
+};
+
+static const enum pres_reg_tables shad_regset2table[] =
+{
+ PRES_REGTAB_OBCONST, /* D3DXRS_BOOL */
+ PRES_REGTAB_OICONST, /* D3DXRS_INT4 */
+ PRES_REGTAB_OCONST, /* D3DXRS_FLOAT4 */
+ PRES_REGTAB_COUNT, /* D3DXRS_SAMPLER */
+};
+
+struct d3dx_pres_operand
+{
+ enum pres_reg_tables table;
+ /* offset is component index, not register index, e. g.
+ offset for component c3.y is 13 (3 * 4 + 1) */
+ unsigned int offset;
+};
+
+struct d3dx_pres_ins
+{
+ enum pres_ops op;
+ /* first input argument is scalar,
+ scalar component is propagated */
+ BOOL scalar_op;
+ unsigned int component_count;
+ struct d3dx_pres_operand inputs[3];
+ struct d3dx_pres_operand output;
+};
+
+static unsigned int get_reg_offset(unsigned int table, unsigned int offset)
+{
+ return offset / table_info[table].reg_component_count;
+}
+
+#define PRES_BITMASK_BLOCK_SIZE (sizeof(unsigned int) * 8)
+
+static HRESULT regstore_alloc_table(struct d3dx_regstore *rs, unsigned int table)
+{
+ unsigned int size;
+
+ size = rs->table_sizes[table] * table_info[table].reg_component_count * table_info[table].component_size;
+ if (size)
+ {
+ rs->tables[table] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
+ rs->table_value_set[table] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+ sizeof(*rs->table_value_set[table]) *
+ ((rs->table_sizes[table] + PRES_BITMASK_BLOCK_SIZE - 1) / PRES_BITMASK_BLOCK_SIZE));
+ if (!rs->tables[table] || !rs->table_value_set[table])
+ return E_OUTOFMEMORY;
+ }
+ return D3D_OK;
+}
+
+static void regstore_free_tables(struct d3dx_regstore *rs)
+{
+ unsigned int i;
+
+ for (i = PRES_REGTAB_FIRST; i <= PRES_REGTAB_LAST; ++i)
+ {
+ if (rs->tables[i])
+ HeapFree(GetProcessHeap(), 0, rs->tables[i]);
+ if (rs->table_value_set[i])
+ HeapFree(GetProcessHeap(), 0, rs->table_value_set[i]);
+ }
+}
+
+static void regstore_set_values(struct d3dx_regstore *rs, unsigned int table, void *data,
+ unsigned int start_offset, unsigned int count)
+{
+ unsigned int block_idx, start, end, start_block, end_block;
+
+ if (!count)
+ return;
+
+ memcpy((BYTE *)rs->tables[table] + start_offset * table_info[table].component_size,
+ data, count * table_info[table].component_size);
+
+ start = get_reg_offset(table, start_offset);
+ start_block = start / PRES_BITMASK_BLOCK_SIZE;
+ start -= start_block * PRES_BITMASK_BLOCK_SIZE;
+ end = get_reg_offset(table, start_offset + count - 1);
+ end_block = end / PRES_BITMASK_BLOCK_SIZE;
+ end = (end_block + 1) * PRES_BITMASK_BLOCK_SIZE - 1 - end;
+
+ if (start_block == end_block)
+ {
+ rs->table_value_set[table][start_block] |= (~0u << start) & (~0u >> end);
+ }
+ else
+ {
+ rs->table_value_set[table][start_block] |= ~0u << start;
+
+ for (block_idx = start_block + 1; block_idx < end_block; ++block_idx)
+ rs->table_value_set[table][block_idx] = ~0u;
+
+ rs->table_value_set[table][end_block] |= ~0u >> end;
+ }
+}
+
+static void dump_bytecode(void *data, unsigned int size)
+{
+ unsigned int *bytecode = (unsigned int *)data;
+ unsigned int i, j, n;
+
+ size /= sizeof(*bytecode);
+ i = 0;
+ while (i < size)
+ {
+ n = min(size - i, 8);
+ for (j = 0; j < n; ++j)
+ TRACE("0x%08x,", bytecode[i + j]);
+ i += n;
+ TRACE("\n");
+ }
+}
+
+static unsigned int *find_bytecode_comment(unsigned int *ptr, unsigned int fourcc)
+{
+ while ((*ptr & 0xffff) == 0xfffe)
+ {
+ if (*(ptr + 1) == fourcc)
+ return ptr + 2;
+ ptr += 1 + (*ptr >> 16);
+ }
+ return NULL;
+}
+
+static unsigned int *parse_pres_arg(unsigned int *ptr, struct d3dx_pres_operand *opr)
+{
+ static const enum pres_reg_tables reg_table[8] =
+ {
+ PRES_REGTAB_COUNT, PRES_REGTAB_IMMED, PRES_REGTAB_CONST, PRES_REGTAB_COUNT,
+ PRES_REGTAB_OCONST, PRES_REGTAB_OBCONST, PRES_REGTAB_OICONST, PRES_REGTAB_REG
+ };
+
+ if (*ptr)
+ {
+ FIXME("Relative addressing not supported yet, word %#x.\n", *ptr);
+ return NULL;
+ }
+ ptr++;
+
+ if (*ptr >= ARRAY_SIZE(reg_table) || reg_table[*ptr] == PRES_REGTAB_COUNT)
+ {
+ FIXME("Unsupported register table %#x.\n", *ptr);
+ return NULL;
+ }
+ opr->table = reg_table[*ptr];
+ ++ptr;
+ opr->offset = *ptr;
+ ++ptr;
+
+ if (opr->table == PRES_REGTAB_OBCONST)
+ opr->offset /= 4;
+ return ptr;
+}
+
+static unsigned int *parse_pres_ins(unsigned int *ptr, struct d3dx_pres_ins *ins)
+{
+ unsigned int ins_code, ins_raw;
+ unsigned int input_count;
+ unsigned int i;
+
+ ins_raw = *ptr;
+ ins_code = (ins_raw & PRES_OPCODE_MASK) >> PRES_OPCODE_SHIFT;
+ ins->component_count = ins_raw & PRES_NCOMP_MASK;
+ ins->scalar_op = !!(ins_raw & PRES_SCALAR_FLAG);
+
+ if (ins->component_count < 1 || ins->component_count > 4)
+ {
+ FIXME("Unsupported number of components %u.\n", ins->component_count);
+ return NULL;
+ }
+ ++ptr;
+ input_count = *ptr++;
+ for (i = 0; i < PRESHADER_OP_MAX_ENUM; ++i)
+ if (ins_code == pres_op_info[i].opcode)
+ break;
+ if (i == PRESHADER_OP_MAX_ENUM)
+ {
+ FIXME("Unknown opcode %#x, raw %#x.\n", ins_code, ins_raw);
+ return NULL;
+ }
+ ins->op = i;
+ if (input_count != pres_op_info[i].input_count)
+ {
+ FIXME("Actual input args %u, expected %u, instruction %s.\n", input_count,
+ pres_op_info[i].input_count, pres_op_info[i].mnem);
+ return NULL;
+ }
+ for (i = 0; i < input_count; ++i)
+ {
+ ptr = parse_pres_arg(ptr, &ins->inputs[i]);
+ if (!ptr)
+ return NULL;
+ }
+ ptr = parse_pres_arg(ptr, &ins->output);
+ return ptr;
+}
+
+static HRESULT get_constants_desc(unsigned int *byte_code, struct d3dx_const_tab *out, struct d3dx9_base_effect *base)
+{
+ ID3DXConstantTable *ctab;
+ D3DXCONSTANT_DESC *cdesc;
+ struct d3dx_parameter **inputs_param;
+ D3DXCONSTANTTABLE_DESC desc;
+ HRESULT hr;
+ D3DXHANDLE hc;
+ unsigned int i;
+ unsigned int count;
+
+ out->inputs = cdesc = NULL;
+ out->ctab = NULL;
+ out->inputs_param = NULL;
+ out->input_count = 0;
+ inputs_param = NULL;
+ hr = D3DXGetShaderConstantTable(byte_code, &ctab);
+ if (FAILED(hr) || !ctab)
+ {
+ TRACE("Could not get CTAB data, hr %#x.\n", hr);
+ /* returning OK, shaders and preshaders without CTAB are valid */
+ return D3D_OK;
+ }
+ hr = ID3DXConstantTable_GetDesc(ctab, &desc);
+ if (FAILED(hr))
+ {
+ FIXME("Could not get CTAB desc, hr %#x.\n", hr);
+ goto err_out;
+ }
+
+ cdesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*cdesc) * desc.Constants);
+ inputs_param = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*inputs_param) * desc.Constants);
+ for (i = 0; i < desc.Constants; ++i)
+ {
+ hc = ID3DXConstantTable_GetConstant(ctab, NULL, i);
+ if (!hc)
+ {
+ FIXME("Null constant handle.\n");
+ goto err_out;
+ }
+ count = 1;
+ hr = ID3DXConstantTable_GetConstantDesc(ctab, hc, &cdesc[i], &count);
+ if (FAILED(hr))
+ {
+ FIXME("Could not get constant desc, hr %#x.\n", hr);
+ goto err_out;
+ }
+ inputs_param[i] = get_parameter_by_name(base, NULL, cdesc[i].Name);
+ if (cdesc[i].Class == D3DXPC_OBJECT)
+ TRACE("Object %s, parameter %p.\n", cdesc[i].Name, inputs_param[i]);
+ else if (!inputs_param[i])
+ ERR("Could not find parameter %s in effect.\n", cdesc[i].Name);
+ }
+ out->input_count = desc.Constants;
+ out->inputs = cdesc;
+ out->inputs_param = inputs_param;
+ out->ctab = ctab;
+ return D3D_OK;
+
+err_out:
+ if (cdesc)
+ HeapFree(GetProcessHeap(), 0, cdesc);
+ if (inputs_param)
+ HeapFree(GetProcessHeap(), 0, inputs_param);
+ if (ctab)
+ ID3DXConstantTable_Release(ctab);
+ return hr;
+}
+
+static void update_table_sizes_consts(unsigned int *table_sizes, struct d3dx_const_tab *ctab)
+{
+ unsigned int i, table, max_offset;
+
+ for (i = 0; i < ctab->input_count; ++i)
+ {
+ max_offset = ctab->inputs[i].RegisterIndex + ctab->inputs[i].RegisterCount;
+ table = ctab->regset2table[ctab->inputs[i].RegisterSet];
+ if (table < PRES_REGTAB_COUNT)
+ table_sizes[table] = max(table_sizes[table], max_offset);
+ }
+}
+
+static HRESULT parse_preshader(struct d3dx_preshader *pres, unsigned int *ptr, struct d3dx9_base_effect *base)
+{
+ unsigned int *p;
+ unsigned int i, j, const_count, max_offset;
+ double *dconst;
+ HRESULT hr;
+ unsigned int saved_word;
+
+ TRACE("Preshader version %#x.\n", *ptr & 0xffff);
+
+ p = find_bytecode_comment(ptr + 1, FOURCC_CLIT);
+ if (p)
+ {
+ const_count = *p;
+ dconst = (double *)(p + 1);
+ }
+ else
+ {
+ const_count = 0;
+ dconst = NULL;
+ }
+ TRACE("%u double constants.\n", const_count);
+
+ p = find_bytecode_comment(ptr + 1, FOURCC_FXLC);
+ if (!p)
+ {
+ WARN("Could not find preshader code.\n");
+ return D3D_OK;
+ }
+
+ pres->ins_count = *p;
+ TRACE("%u instructions.\n", pres->ins_count);
+ ++p;
+ pres->ins = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pres->ins) * pres->ins_count);
+ for (i = 0; i < pres->ins_count; ++i)
+ {
+ p = parse_pres_ins(p, &pres->ins[i]);
+ if (!p)
+ return D3DXERR_INVALIDDATA;
+ }
+
+ saved_word = *ptr;
+ *ptr = 0xfffe0000;
+ hr = get_constants_desc(ptr, &pres->inputs, base);
+ *ptr = saved_word;
+ if (FAILED(hr))
+ return hr;
+
+ pres->inputs.regset2table = pres_regset2table;
+
+ pres->regs.table_sizes[PRES_REGTAB_IMMED] = const_count;
+
+ for (i = 0; i < pres->ins_count; ++i)
+ {
+ unsigned int table;
+
+ for (j = 0; j < pres_op_info[pres->ins[i].op].input_count; ++j)
+ {
+ table = pres->ins[i].inputs[j].table;
+ max_offset = get_reg_offset(table, pres->ins[i].inputs[j].offset + pres->ins[i].component_count - 1);
+ pres->regs.table_sizes[table] = max(pres->regs.table_sizes[table], max_offset + 1);
+ }
+ table = pres->ins[i].output.table;
+ max_offset = get_reg_offset(table, pres->ins[i].output.offset + pres->ins[i].component_count - 1);
+ pres->regs.table_sizes[table] = max(pres->regs.table_sizes[table], max_offset + 1);
+ }
+ update_table_sizes_consts(pres->regs.table_sizes, &pres->inputs);
+ if (FAILED(regstore_alloc_table(&pres->regs, PRES_REGTAB_IMMED)))
+ return E_OUTOFMEMORY;
+ regstore_set_values(&pres->regs, PRES_REGTAB_IMMED, dconst, 0, const_count);
+
+ return D3D_OK;
+}
+
HRESULT d3dx_create_param_eval(struct d3dx9_base_effect *base_effect, void *byte_code, unsigned int byte_code_size,
D3DXPARAMETER_TYPE type, struct d3dx_param_eval **peval_out)
{
- FIXME("stub, base_effect %p, byte_code %p, byte_code_size %u, type %u, peval_out %p.\n",
+ struct d3dx_param_eval *peval;
+ HRESULT hr;
+ unsigned int *ptr;
+ unsigned int i;
+ BOOL shader;
+
+ TRACE("base_effect %p, byte_code %p, byte_code_size %u, type %u, peval_out %p.\n",
base_effect, byte_code, byte_code_size, type, peval_out);
+ if (!byte_code)
+ {
+ *peval_out = NULL;
+ return D3DERR_INVALIDCALL;
+ }
+
+ peval = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*peval));
+ if (!peval)
+ {
+ hr = E_OUTOFMEMORY;
+ goto err_out;
+ }
+
+ peval->param_type = type;
+ switch (type)
+ {
+ case D3DXPT_VERTEXSHADER:
+ case D3DXPT_PIXELSHADER:
+ shader = TRUE;
+ break;
+ default:
+ shader = FALSE;
+ break;
+ }
+ peval->shader_inputs.regset2table = shad_regset2table;
+
+ ptr = (unsigned int *)byte_code;
+ if (shader)
+ {
+ if ((*ptr & 0xfffe0000) != 0xfffe0000)
+ {
+ FIXME("Invalid shader signature %#x.\n", *ptr);
+ hr = D3DXERR_INVALIDDATA;
+ goto err_out;
+ }
+ TRACE("Shader version %#x.\n", *ptr & 0xffff);
+
+ hr = get_constants_desc(ptr, &peval->shader_inputs, base_effect);
+ if (FAILED(hr))
+ {
+ FIXME("Could not get shader constant table, hr %#x.\n", hr);
+ goto err_out;
+ }
+ update_table_sizes_consts(peval->pres.regs.table_sizes, &peval->shader_inputs);
+ ptr++;
+ ptr = find_bytecode_comment(ptr, FOURCC_PRES);
+ if (!ptr)
+ TRACE("No preshader found.\n");
+ }
+ if (ptr)
+ {
+ hr = parse_preshader(&peval->pres, ptr, base_effect);
+ if (FAILED(hr))
+ {
+ FIXME("Failed parsing preshader, byte code for analysis follows.\n");
+ dump_bytecode(byte_code, byte_code_size);
+ goto err_out;
+ }
+ }
+
+ for (i = PRES_REGTAB_IMMED + 1; i <= PRES_REGTAB_LAST; ++i)
+ {
+ TRACE("table_sizes[%u] %u.\n", i, peval->pres.regs.table_sizes[i]);
+ if (FAILED(regstore_alloc_table(&peval->pres.regs, i)))
+ {
+ hr = E_OUTOFMEMORY;
+ goto err_out;
+ }
+ }
+
+ if (TRACE_ON(d3dx))
+ dump_bytecode(byte_code, byte_code_size);
+
+ *peval_out = peval;
+ TRACE("retval %u, *peval_out %p.\n", D3D_OK, *peval_out);
+ return D3D_OK;
+
+err_out:
+ FIXME("Error creating parameter evaluator.\n");
+ d3dx_free_param_eval(peval);
*peval_out = NULL;
- return E_NOTIMPL;
+ TRACE("retval %u, *peval_out %p.\n", hr, *peval_out);
+ return hr;
+}
+
+static void d3dx_free_const_tab(struct d3dx_const_tab *ctab)
+{
+ if (ctab->inputs)
+ HeapFree(GetProcessHeap(), 0, ctab->inputs);
+ if (ctab->inputs_param)
+ HeapFree(GetProcessHeap(), 0, ctab->inputs_param);
+ if (ctab->ctab)
+ ID3DXConstantTable_Release(ctab->ctab);
+}
+
+static void d3dx_free_preshader(struct d3dx_preshader *pres)
+{
+ if (pres->ins)
+ HeapFree(GetProcessHeap(), 0, pres->ins);
+
+ regstore_free_tables(&pres->regs);
+ d3dx_free_const_tab(&pres->inputs);
}
void d3dx_free_param_eval(struct d3dx_param_eval *peval)
{
- FIXME("stub, peval %p.\n", peval);
+ TRACE("peval %p.\n", peval);
+
+ if (!peval)
+ return;
+
+ d3dx_free_preshader(&peval->pres);
+ d3dx_free_const_tab(&peval->shader_inputs);
+ HeapFree(GetProcessHeap(), 0, peval);
}
--
2.5.5
More information about the wine-patches
mailing list