diff options
Diffstat (limited to 'src/VBox/Devices/Graphics/shaderlib/shader_sm4.c')
| -rw-r--r-- | src/VBox/Devices/Graphics/shaderlib/shader_sm4.c | 444 |
1 files changed, 444 insertions, 0 deletions
diff --git a/src/VBox/Devices/Graphics/shaderlib/shader_sm4.c b/src/VBox/Devices/Graphics/shaderlib/shader_sm4.c new file mode 100644 index 00000000..3e5a5cb6 --- /dev/null +++ b/src/VBox/Devices/Graphics/shaderlib/shader_sm4.c @@ -0,0 +1,444 @@ +/* + * Copyright 2009 Henri Verbeet for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +/* + * Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice + * other than GPL or LGPL is available it will apply instead, Oracle elects to use only + * the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where + * a choice of LGPL license versions is made available with the language indicating + * that LGPLv2 or any later version may be used, or where a choice of which version + * of the LGPL is applied is otherwise unspecified. + */ + +#include "config.h" +#include "wine/port.h" + +#include "wined3d_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader); + +#define WINED3D_SM4_INSTRUCTION_LENGTH_SHIFT 24 +#define WINED3D_SM4_INSTRUCTION_LENGTH_MASK (0xf << WINED3D_SM4_INSTRUCTION_LENGTH_SHIFT) + +#define WINED3D_SM4_OPCODE_MASK 0xff + +#define WINED3D_SM4_REGISTER_ORDER_SHIFT 20 +#define WINED3D_SM4_REGISTER_ORDER_MASK (0x3 << WINED3D_SM4_REGISTER_ORDER_SHIFT) + +#define WINED3D_SM4_REGISTER_TYPE_SHIFT 12 +#define WINED3D_SM4_REGISTER_TYPE_MASK (0xf << WINED3D_SM4_REGISTER_TYPE_SHIFT) + +#define WINED3D_SM4_IMMCONST_TYPE_SHIFT 0 +#define WINED3D_SM4_IMMCONST_TYPE_MASK (0x3 << WINED3D_SM4_IMMCONST_TYPE_SHIFT) + +#define WINED3D_SM4_WRITEMASK_SHIFT 4 +#define WINED3D_SM4_WRITEMASK_MASK (0xf << WINED3D_SM4_WRITEMASK_SHIFT) + +#define WINED3D_SM4_SWIZZLE_SHIFT 4 +#define WINED3D_SM4_SWIZZLE_MASK (0xff << WINED3D_SM4_SWIZZLE_SHIFT) + +#define WINED3D_SM4_VERSION_MAJOR(version) (((version) >> 4) & 0xf) +#define WINED3D_SM4_VERSION_MINOR(version) (((version) >> 0) & 0xf) + +enum wined3d_sm4_opcode +{ + WINED3D_SM4_OP_ADD = 0x00, + WINED3D_SM4_OP_BREAK = 0x02, + WINED3D_SM4_OP_BREAKC = 0x03, + WINED3D_SM4_OP_CUT = 0x09, + WINED3D_SM4_OP_DP3 = 0x10, + WINED3D_SM4_OP_DP4 = 0x11, + WINED3D_SM4_OP_EMIT = 0x13, + WINED3D_SM4_OP_ENDIF = 0x15, + WINED3D_SM4_OP_ENDLOOP = 0x16, + WINED3D_SM4_OP_EXP = 0x19, + WINED3D_SM4_OP_IADD = 0x1e, + WINED3D_SM4_OP_IF = 0x1f, + WINED3D_SM4_OP_IGE = 0x21, + WINED3D_SM4_OP_LOG = 0x2f, + WINED3D_SM4_OP_LT = 0x31, + WINED3D_SM4_OP_MIN = 0x33, + WINED3D_SM4_OP_MAX = 0x34, + WINED3D_SM4_OP_MOV = 0x36, + WINED3D_SM4_OP_MUL = 0x38, + WINED3D_SM4_OP_RET = 0x3e, + WINED3D_SM4_OP_RSQ = 0x44, + WINED3D_SM4_OP_SINCOS = 0x4d, +}; + +enum wined3d_sm4_register_type +{ + WINED3D_SM4_RT_TEMP = 0x0, + WINED3D_SM4_RT_INPUT = 0x1, + WINED3D_SM4_RT_OUTPUT = 0x2, + WINED3D_SM4_RT_IMMCONST = 0x4, + WINED3D_SM4_RT_CONSTBUFFER = 0x8, +}; + +enum wined3d_sm4_immconst_type +{ + WINED3D_SM4_IMMCONST_FLOAT = 0x1, + WINED3D_SM4_IMMCONST_FLOAT4 = 0x2, +}; + +struct wined3d_sm4_data +{ + struct wined3d_shader_version shader_version; + const DWORD *end; + DWORD tokens_num; + const struct wined3d_shader_signature *output_signature; +}; + +struct wined3d_sm4_opcode_info +{ + enum wined3d_sm4_opcode opcode; + enum WINED3D_SHADER_INSTRUCTION_HANDLER handler_idx; + UINT dst_count; + UINT src_count; +}; + +struct sysval_map +{ + enum wined3d_sysval_semantic sysval; + WINED3DSHADER_PARAM_REGISTER_TYPE register_type; + UINT register_idx; +}; + +static const struct wined3d_sm4_opcode_info opcode_table[] = +{ + {WINED3D_SM4_OP_ADD, WINED3DSIH_ADD, 1, 2}, + {WINED3D_SM4_OP_BREAK, WINED3DSIH_BREAK, 0, 0}, + {WINED3D_SM4_OP_BREAKC, WINED3DSIH_BREAKP, 0, 1}, + {WINED3D_SM4_OP_CUT, WINED3DSIH_CUT, 0, 0}, + {WINED3D_SM4_OP_DP3, WINED3DSIH_DP3, 1, 2}, + {WINED3D_SM4_OP_DP4, WINED3DSIH_DP4, 1, 2}, + {WINED3D_SM4_OP_EMIT, WINED3DSIH_EMIT, 0, 0}, + {WINED3D_SM4_OP_ENDIF, WINED3DSIH_ENDIF, 0, 0}, + {WINED3D_SM4_OP_ENDLOOP,WINED3DSIH_ENDLOOP, 0, 0}, + {WINED3D_SM4_OP_EXP, WINED3DSIH_EXP, 1, 1}, + {WINED3D_SM4_OP_IADD, WINED3DSIH_IADD, 1, 2}, + {WINED3D_SM4_OP_IF, WINED3DSIH_IF, 0, 1}, + {WINED3D_SM4_OP_IGE, WINED3DSIH_IGE, 1, 2}, + {WINED3D_SM4_OP_LOG, WINED3DSIH_LOG, 1, 1}, + {WINED3D_SM4_OP_LT, WINED3DSIH_LT, 1, 2}, + {WINED3D_SM4_OP_MIN, WINED3DSIH_MIN, 1, 2}, + {WINED3D_SM4_OP_MAX, WINED3DSIH_MAX, 1, 2}, + {WINED3D_SM4_OP_MOV, WINED3DSIH_MOV, 1, 1}, + {WINED3D_SM4_OP_MUL, WINED3DSIH_MUL, 1, 2}, + {WINED3D_SM4_OP_RET, WINED3DSIH_RET, 0, 0}, + {WINED3D_SM4_OP_RSQ, WINED3DSIH_RSQ, 1, 1}, + {WINED3D_SM4_OP_SINCOS, WINED3DSIH_SINCOS, 1, 2}, +}; + +static const WINED3DSHADER_PARAM_REGISTER_TYPE register_type_table[] = +{ + /* WINED3D_SM4_RT_TEMP */ WINED3DSPR_TEMP, + /* WINED3D_SM4_RT_INPUT */ WINED3DSPR_INPUT, + /* WINED3D_SM4_RT_OUTPUT */ WINED3DSPR_OUTPUT, + /* UNKNOWN */ 0, + /* WINED3D_SM4_RT_IMMCONST */ WINED3DSPR_IMMCONST, + /* UNKNOWN */ 0, + /* UNKNOWN */ 0, + /* UNKNOWN */ 0, + /* WINED3D_SM4_RT_CONSTBUFFER */ WINED3DSPR_CONSTBUFFER, +}; + +static const struct sysval_map sysval_map[] = +{ + {WINED3D_SV_DEPTH, WINED3DSPR_DEPTHOUT, 0}, + {WINED3D_SV_TARGET0, WINED3DSPR_COLOROUT, 0}, + {WINED3D_SV_TARGET1, WINED3DSPR_COLOROUT, 1}, + {WINED3D_SV_TARGET2, WINED3DSPR_COLOROUT, 2}, + {WINED3D_SV_TARGET3, WINED3DSPR_COLOROUT, 3}, + {WINED3D_SV_TARGET4, WINED3DSPR_COLOROUT, 4}, + {WINED3D_SV_TARGET5, WINED3DSPR_COLOROUT, 5}, + {WINED3D_SV_TARGET6, WINED3DSPR_COLOROUT, 6}, + {WINED3D_SV_TARGET7, WINED3DSPR_COLOROUT, 7}, +}; + +static const struct wined3d_sm4_opcode_info *get_opcode_info(enum wined3d_sm4_opcode opcode) +{ + unsigned int i; + + for (i = 0; i < sizeof(opcode_table) / sizeof(*opcode_table); ++i) + { + if (opcode == opcode_table[i].opcode) return &opcode_table[i]; + } + + return NULL; +} + +static void map_sysval(enum wined3d_sysval_semantic sysval, struct wined3d_shader_register *reg) +{ + unsigned int i; + + for (i = 0; i < sizeof(sysval_map) / sizeof(*sysval_map); ++i) + { + if (sysval == sysval_map[i].sysval) + { + reg->type = sysval_map[i].register_type; + reg->idx = sysval_map[i].register_idx; + } + } +} + +static void map_register(struct wined3d_sm4_data *priv, struct wined3d_shader_register *reg) +{ + switch (priv->shader_version.type) + { + case WINED3D_SHADER_TYPE_PIXEL: + if (reg->type == WINED3DSPR_OUTPUT) + { + unsigned int i; + const struct wined3d_shader_signature *s = priv->output_signature; + + if (!s) + { + ERR("Shader has no output signature, unable to map register.\n"); + break; + } + + for (i = 0; i < s->element_count; ++i) + { + if (s->elements[i].register_idx == reg->idx) + { + map_sysval(s->elements[i].sysval_semantic, reg); + break; + } + } + } + break; + + default: + break; + } +} + +static void *shader_sm4_init(const DWORD *byte_code, DWORD tokens_num, const struct wined3d_shader_signature *output_signature) +{ + struct wined3d_sm4_data *priv = HeapAlloc(GetProcessHeap(), 0, sizeof(*priv)); + if (!priv) + { + ERR("Failed to allocate private data\n"); + return NULL; + } + + priv->end = NULL; + priv->tokens_num = tokens_num; + priv->output_signature = output_signature; + + return priv; +} + +static void shader_sm4_free(void *data) +{ + HeapFree(GetProcessHeap(), 0, data); +} + +static void shader_sm4_read_header(void *data, const DWORD **ptr, struct wined3d_shader_version *shader_version) +{ + struct wined3d_sm4_data *priv = data; + DWORD version_token; + + priv->end = *ptr; + + version_token = *(*ptr)++; + TRACE("version: 0x%08x\n", version_token); + + TRACE("token count: %u\n", **ptr); + priv->end += *(*ptr)++; + + switch (version_token >> 16) + { + case WINED3D_SM4_PS: + priv->shader_version.type = WINED3D_SHADER_TYPE_PIXEL; + break; + + case WINED3D_SM4_VS: + priv->shader_version.type = WINED3D_SHADER_TYPE_VERTEX; + break; + + case WINED3D_SM4_GS: + priv->shader_version.type = WINED3D_SHADER_TYPE_GEOMETRY; + break; + + default: + FIXME("Unrecognized shader type %#x\n", version_token >> 16); + } + priv->shader_version.major = WINED3D_SM4_VERSION_MAJOR(version_token); + priv->shader_version.minor = WINED3D_SM4_VERSION_MINOR(version_token); + + *shader_version = priv->shader_version; +} + +static void shader_sm4_read_opcode(void *data, const DWORD **ptr, struct wined3d_shader_instruction *ins, + UINT *param_size) +{ + const struct wined3d_sm4_opcode_info *opcode_info; + DWORD token = *(*ptr)++; + DWORD opcode = token & WINED3D_SM4_OPCODE_MASK; + + *param_size = ((token & WINED3D_SM4_INSTRUCTION_LENGTH_MASK) >> WINED3D_SM4_INSTRUCTION_LENGTH_SHIFT) - 1; + + opcode_info = get_opcode_info(opcode); + if (!opcode_info) + { + FIXME("Unrecognized opcode %#x, token 0x%08x\n", opcode, token); + ins->handler_idx = WINED3DSIH_TABLE_SIZE; + return; + } + + ins->handler_idx = opcode_info->handler_idx; + ins->flags = 0; + ins->coissue = 0; + ins->predicate = 0; + ins->dst_count = opcode_info->dst_count; + ins->src_count = opcode_info->src_count; +} + +static void shader_sm4_read_src_param(void *data, const DWORD **ptr, struct wined3d_shader_src_param *src_param, + struct wined3d_shader_src_param *src_rel_addr) +{ + struct wined3d_sm4_data *priv = data; + DWORD token = *(*ptr)++; + enum wined3d_sm4_register_type register_type; + DWORD order; + + register_type = (token & WINED3D_SM4_REGISTER_TYPE_MASK) >> WINED3D_SM4_REGISTER_TYPE_SHIFT; + if (register_type >= sizeof(register_type_table) / sizeof(*register_type_table)) + { + FIXME("Unhandled register type %#x\n", register_type); + src_param->reg.type = WINED3DSPR_TEMP; + } + else + { + src_param->reg.type = register_type_table[register_type]; + } + + order = (token & WINED3D_SM4_REGISTER_ORDER_MASK) >> WINED3D_SM4_REGISTER_ORDER_SHIFT; + + if (order < 1) src_param->reg.idx = ~0U; + else src_param->reg.idx = *(*ptr)++; + + if (order < 2) src_param->reg.array_idx = ~0U; + else src_param->reg.array_idx = *(*ptr)++; + + if (order > 2) FIXME("Unhandled order %u.\n", order); + + if (register_type == WINED3D_SM4_RT_IMMCONST) + { + enum wined3d_sm4_immconst_type immconst_type = + (token & WINED3D_SM4_IMMCONST_TYPE_MASK) >> WINED3D_SM4_IMMCONST_TYPE_SHIFT; + src_param->swizzle = WINED3DSP_NOSWIZZLE; + + switch(immconst_type) + { + case WINED3D_SM4_IMMCONST_FLOAT: + src_param->reg.immconst_type = WINED3D_IMMCONST_FLOAT; + memcpy(src_param->reg.immconst_data, *ptr, 1 * sizeof(DWORD)); + *ptr += 1; + break; + + case WINED3D_SM4_IMMCONST_FLOAT4: + src_param->reg.immconst_type = WINED3D_IMMCONST_FLOAT4; + memcpy(src_param->reg.immconst_data, *ptr, 4 * sizeof(DWORD)); + *ptr += 4; + break; + + default: + FIXME("Unhandled immediate constant type %#x\n", immconst_type); + break; + } + } + else + { + src_param->swizzle = (token & WINED3D_SM4_SWIZZLE_MASK) >> WINED3D_SM4_SWIZZLE_SHIFT; + } + + src_param->modifiers = 0; + src_param->reg.rel_addr = NULL; + + map_register(priv, &src_param->reg); +} + +static void shader_sm4_read_dst_param(void *data, const DWORD **ptr, struct wined3d_shader_dst_param *dst_param, + struct wined3d_shader_src_param *dst_rel_addr) +{ + struct wined3d_sm4_data *priv = data; + DWORD token = *(*ptr)++; + enum wined3d_sm4_register_type register_type; + DWORD order; + + register_type = (token & WINED3D_SM4_REGISTER_TYPE_MASK) >> WINED3D_SM4_REGISTER_TYPE_SHIFT; + if (register_type >= sizeof(register_type_table) / sizeof(*register_type_table)) + { + FIXME("Unhandled register type %#x\n", register_type); + dst_param->reg.type = WINED3DSPR_TEMP; + } + else + { + dst_param->reg.type = register_type_table[register_type]; + } + + order = (token & WINED3D_SM4_REGISTER_ORDER_MASK) >> WINED3D_SM4_REGISTER_ORDER_SHIFT; + + if (order < 1) dst_param->reg.idx = ~0U; + else dst_param->reg.idx = *(*ptr)++; + + if (order < 2) dst_param->reg.array_idx = ~0U; + else dst_param->reg.array_idx = *(*ptr)++; + + if (order > 2) FIXME("Unhandled order %u.\n", order); + + dst_param->write_mask = (token & WINED3D_SM4_WRITEMASK_MASK) >> WINED3D_SM4_WRITEMASK_SHIFT; + dst_param->modifiers = 0; + dst_param->shift = 0; + dst_param->reg.rel_addr = NULL; + + map_register(priv, &dst_param->reg); +} + +static void shader_sm4_read_semantic(const DWORD **ptr, struct wined3d_shader_semantic *semantic) +{ + FIXME("ptr %p, semantic %p stub!\n", ptr, semantic); +} + +static void shader_sm4_read_comment(const DWORD **ptr, const char **comment, UINT *comment_size) +{ + FIXME("ptr %p, comment %p, comment_size %p stub!\n", ptr, comment, comment_size); + *comment = NULL; +} + +static BOOL shader_sm4_is_end(void *data, const DWORD **ptr) +{ + struct wined3d_sm4_data *priv = data; + return *ptr >= priv->end; +} + +const struct wined3d_shader_frontend sm4_shader_frontend = +{ + shader_sm4_init, + shader_sm4_free, + shader_sm4_read_header, + shader_sm4_read_opcode, + shader_sm4_read_src_param, + shader_sm4_read_dst_param, + shader_sm4_read_semantic, + shader_sm4_read_comment, + shader_sm4_is_end, +}; |