static void gs_setup_payload(struct gs_compile_context *gcc) { int grf, i; grf = 0; /* r0: payload header */ gcc->payload.header = tsrc_d(tsrc(TOY_FILE_GRF, grf, 0)); grf++; /* r1: SVBI */ if (gcc->write_so) { gcc->payload.svbi = tsrc_ud(tsrc(TOY_FILE_GRF, grf, 0)); grf++; } /* URB data */ gcc->shader->in.start_grf = grf; /* no pull constants */ /* VUEs */ for (i = 0; i < gcc->in_vue_count; i++) { gcc->payload.vues[i] = tsrc(TOY_FILE_GRF, grf, 0); grf += gcc->in_vue_size; } gcc->first_free_grf = grf; gcc->last_free_grf = 127; }
static void fs_lower_opcode_kil(struct toy_compiler *tc, struct toy_inst *inst) { struct toy_dst pixel_mask_dst; struct toy_src f0, pixel_mask; struct toy_inst *tmp; /* lower half of r1.7:ud */ pixel_mask_dst = tdst_uw(tdst(TOY_FILE_GRF, 1, 7 * 4)); pixel_mask = tsrc_rect(tsrc_from(pixel_mask_dst), TOY_RECT_010); f0 = tsrc_rect(tsrc_uw(tsrc(TOY_FILE_ARF, BRW_ARF_FLAG, 0)), TOY_RECT_010); /* KILP or KIL */ if (tsrc_is_null(inst->src[0])) { struct toy_src dummy = tsrc_uw(tsrc(TOY_FILE_GRF, 0, 0)); struct toy_dst f0_dst = tdst_uw(tdst(TOY_FILE_ARF, BRW_ARF_FLAG, 0)); /* create a mask that masks out all pixels */ tmp = tc_MOV(tc, f0_dst, tsrc_rect(tsrc_imm_uw(0xffff), TOY_RECT_010)); tmp->exec_size = BRW_EXECUTE_1; tmp->mask_ctrl = BRW_MASK_DISABLE; tc_CMP(tc, tdst_null(), dummy, dummy, BRW_CONDITIONAL_NEQ); /* swapping the two src operands breaks glBitmap()!? */ tmp = tc_AND(tc, pixel_mask_dst, f0, pixel_mask); tmp->exec_size = BRW_EXECUTE_1; tmp->mask_ctrl = BRW_MASK_DISABLE; } else { struct toy_src src[4]; int i; tsrc_transpose(inst->src[0], src); /* mask out killed pixels */ for (i = 0; i < 4; i++) { tc_CMP(tc, tdst_null(), src[i], tsrc_imm_f(0.0f), BRW_CONDITIONAL_GE); /* swapping the two src operands breaks glBitmap()!? */ tmp = tc_AND(tc, pixel_mask_dst, f0, pixel_mask); tmp->exec_size = BRW_EXECUTE_1; tmp->mask_ctrl = BRW_MASK_DISABLE; } } tc_discard_inst(tc, inst); }
static void vs_lower_opcode_tgsi_const_gen6(struct vs_compile_context *vcc, struct toy_dst dst, int dim, struct toy_src idx) { const struct toy_dst header = tdst_ud(tdst(TOY_FILE_MRF, vcc->first_free_mrf, 0)); const struct toy_dst block_offsets = tdst_ud(tdst(TOY_FILE_MRF, vcc->first_free_mrf + 1, 0)); const struct toy_src r0 = tsrc_ud(tsrc(TOY_FILE_GRF, 0, 0)); struct toy_compiler *tc = &vcc->tc; unsigned msg_type, msg_ctrl, msg_len; struct toy_inst *inst; struct toy_src desc; if (vs_lower_opcode_tgsi_const_pcb(vcc, dst, dim, idx)) return; /* set message header */ inst = tc_MOV(tc, header, r0); inst->mask_ctrl = GEN6_MASKCTRL_NOMASK; /* set block offsets */ tc_MOV(tc, block_offsets, idx); msg_type = GEN6_MSG_DP_OWORD_DUAL_BLOCK_READ; msg_ctrl = GEN6_MSG_DP_OWORD_DUAL_BLOCK_SIZE_1; msg_len = 2; desc = tsrc_imm_mdesc_data_port(tc, false, msg_len, 1, true, false, msg_type, msg_ctrl, vcc->shader->bt.const_base + dim); tc_SEND(tc, dst, tsrc_from(header), desc, vcc->const_cache); }
static void gs_setup_vars(struct gs_compile_context *gcc) { int grf = gcc->first_free_grf; int i; gcc->vars.urb_write_header = tdst_d(tdst(TOY_FILE_GRF, grf, 0)); grf++; gcc->vars.tmp = tdst(TOY_FILE_GRF, grf, 0); grf++; if (gcc->write_so) { gcc->vars.buffer_needed = gcc->out_vue_min_count - 1; for (i = 0; i < gcc->vars.buffer_needed; i++) { gcc->vars.buffers[i] = tdst(TOY_FILE_GRF, grf, 0); grf += gcc->shader->out.count; } gcc->vars.so_written = tdst_d(tdst(TOY_FILE_GRF, grf, 0)); grf++; gcc->vars.so_index = tdst_d(tdst(TOY_FILE_GRF, grf, 0)); grf++; } gcc->first_free_grf = grf; if (!gcc->tgsi.reg_mapping) { for (i = 0; i < gcc->shader->out.count; i++) gcc->vars.tgsi_outs[i] = tsrc(TOY_FILE_GRF, grf++, 0); gcc->first_free_grf = grf; return; } for (i = 0; i < gcc->shader->out.count; i++) { const int slot = gcc->output_map[i]; const int vrf = (slot >= 0) ? toy_tgsi_get_vrf(&gcc->tgsi, TGSI_FILE_OUTPUT, 0, gcc->tgsi.outputs[slot].index) : -1; if (vrf >= 0) gcc->vars.tgsi_outs[i] = tsrc(TOY_FILE_VRF, vrf, 0); else gcc->vars.tgsi_outs[i] = (i == 0) ? tsrc_imm_d(0) : tsrc_imm_f(0.0f); } }
NS_IMETHODIMP nsSpeechTask::SendAudio(JS::Handle<JS::Value> aData, JS::Handle<JS::Value> aLandmarks, JSContext* aCx) { MOZ_ASSERT(XRE_IsParentProcess()); if(NS_WARN_IF(!(mStream))) { return NS_ERROR_NOT_AVAILABLE; } if(NS_WARN_IF(mStream->IsDestroyed())) { return NS_ERROR_NOT_AVAILABLE; } if(NS_WARN_IF(!(mChannels))) { return NS_ERROR_FAILURE; } if(NS_WARN_IF(!(aData.isObject()))) { return NS_ERROR_INVALID_ARG; } if (mIndirectAudio) { NS_WARNING("Can't call SendAudio from an indirect audio speech service."); return NS_ERROR_FAILURE; } JS::Rooted<JSObject*> darray(aCx, &aData.toObject()); JSAutoCompartment ac(aCx, darray); JS::Rooted<JSObject*> tsrc(aCx, nullptr); // Allow either Int16Array or plain JS Array if (JS_IsInt16Array(darray)) { tsrc = darray; } else { bool isArray; if (!JS_IsArrayObject(aCx, darray, &isArray)) { return NS_ERROR_UNEXPECTED; } if (isArray) { tsrc = JS_NewInt16ArrayFromArray(aCx, darray); } } if (!tsrc) { return NS_ERROR_DOM_TYPE_MISMATCH_ERR; } uint32_t dataLen = JS_GetTypedArrayLength(tsrc); RefPtr<mozilla::SharedBuffer> samples; { JS::AutoCheckCannotGC nogc; samples = makeSamples(JS_GetInt16ArrayData(tsrc, nogc), dataLen); } SendAudioImpl(samples, dataLen); return NS_OK; }
static void fs_lower_opcode_tgsi_const_gen6(struct fs_compile_context *fcc, struct toy_dst dst, int dim, struct toy_src idx) { const struct toy_dst header = tdst_ud(tdst(TOY_FILE_MRF, fcc->first_free_mrf, 0)); const struct toy_dst global_offset = tdst_ud(tdst(TOY_FILE_MRF, fcc->first_free_mrf, 2 * 4)); const struct toy_src r0 = tsrc_ud(tsrc(TOY_FILE_GRF, 0, 0)); struct toy_compiler *tc = &fcc->tc; unsigned msg_type, msg_ctrl, msg_len; struct toy_inst *inst; struct toy_src desc; struct toy_dst tmp, real_dst[4]; int i; /* set message header */ inst = tc_MOV(tc, header, r0); inst->mask_ctrl = BRW_MASK_DISABLE; /* set global offset */ inst = tc_MOV(tc, global_offset, idx); inst->mask_ctrl = BRW_MASK_DISABLE; inst->exec_size = BRW_EXECUTE_1; inst->src[0].rect = TOY_RECT_010; msg_type = BRW_DATAPORT_READ_MESSAGE_OWORD_BLOCK_READ; msg_ctrl = BRW_DATAPORT_OWORD_BLOCK_1_OWORDLOW << 8; msg_len = 1; desc = tsrc_imm_mdesc_data_port(tc, false, msg_len, 1, true, false, msg_type, msg_ctrl, ILO_WM_CONST_SURFACE(dim)); tmp = tc_alloc_tmp(tc); tc_SEND(tc, tmp, tsrc_from(header), desc, fcc->const_cache); tdst_transpose(dst, real_dst); for (i = 0; i < 4; i++) { const struct toy_src src = tsrc_offset(tsrc_rect(tsrc_from(tmp), TOY_RECT_010), 0, i); /* cast to type D to make sure these are raw moves */ tc_MOV(tc, tdst_d(real_dst[i]), tsrc_d(src)); } }
static bool vs_lower_opcode_tgsi_const_pcb(struct vs_compile_context *vcc, struct toy_dst dst, int dim, struct toy_src idx) { const int i = idx.val32; const int grf = vcc->first_const_grf + i / 2; const int grf_subreg = (i & 1) * 16; struct toy_src src; if (!vcc->variant->use_pcb || dim != 0 || idx.file != TOY_FILE_IMM || grf >= vcc->first_ucp_grf) return false; src = tsrc_rect(tsrc(TOY_FILE_GRF, grf, grf_subreg), TOY_RECT_041); tc_MOV(&vcc->tc, dst, src); return true; }
static void vs_lower_opcode_tgsi_sv(struct vs_compile_context *vcc, struct toy_dst dst, int dim, int idx) { struct toy_compiler *tc = &vcc->tc; const struct toy_tgsi *tgsi = &vcc->tgsi; int slot; assert(!dim); slot = toy_tgsi_find_system_value(tgsi, idx); if (slot < 0) return; switch (tgsi->system_values[slot].semantic_name) { case TGSI_SEMANTIC_INSTANCEID: case TGSI_SEMANTIC_VERTEXID: /* * In 3DSTATE_VERTEX_ELEMENTS, we prepend an extra vertex element for * the generated IDs, with VID in the X channel and IID in the Y * channel. */ { const int grf = vcc->first_vue_grf; const struct toy_src src = tsrc(TOY_FILE_GRF, grf, 0); const enum toy_swizzle swizzle = (tgsi->system_values[slot].semantic_name == TGSI_SEMANTIC_INSTANCEID) ? TOY_SWIZZLE_Y : TOY_SWIZZLE_X; tc_MOV(tc, tdst_d(dst), tsrc_d(tsrc_swizzle1(src, swizzle))); } break; case TGSI_SEMANTIC_PRIMID: default: tc_fail(tc, "unhandled system value"); tc_MOV(tc, dst, tsrc_imm_d(0)); break; } }
static void cs_dummy(struct cs_compile_context *ccc) { struct toy_compiler *tc = &ccc->tc; struct toy_dst header; struct toy_src r0, desc; struct toy_inst *inst; header = tdst_ud(tdst(TOY_FILE_MRF, ccc->first_free_mrf, 0)); r0 = tsrc_ud(tsrc(TOY_FILE_GRF, 0, 0)); inst = tc_MOV(tc, header, r0); inst->exec_size = GEN6_EXECSIZE_8; inst->mask_ctrl = GEN6_MASKCTRL_NOMASK; desc = tsrc_imm_mdesc(tc, true, 1, 0, true, GEN6_MSG_TS_RESOURCE_SELECT_NO_DEREF | GEN6_MSG_TS_REQUESTER_TYPE_ROOT | GEN6_MSG_TS_OPCODE_DEREF); tc_SEND(tc, tdst_null(), tsrc_from(header), desc, GEN6_SFID_SPAWNER); }
static void vs_lower_opcode_tgsi_in(struct vs_compile_context *vcc, struct toy_dst dst, int dim, int idx) { struct toy_compiler *tc = &vcc->tc; int slot; assert(!dim); slot = toy_tgsi_find_input(&vcc->tgsi, idx); if (slot >= 0) { const int first_in_grf = vcc->first_vue_grf + (vcc->shader->in.count - vcc->tgsi.num_inputs); const int grf = first_in_grf + vcc->tgsi.inputs[slot].semantic_index; const struct toy_src src = tsrc(TOY_FILE_GRF, grf, 0); tc_MOV(tc, dst, src); } else { /* undeclared input */ tc_MOV(tc, dst, tsrc_imm_f(0.0f)); } }
NS_IMETHODIMP nsSpeechTask::SendAudio(JS::Handle<JS::Value> aData, JS::Handle<JS::Value> aLandmarks, JSContext* aCx) { MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default); NS_ENSURE_TRUE(mStream, NS_ERROR_NOT_AVAILABLE); NS_ENSURE_FALSE(mStream->IsDestroyed(), NS_ERROR_NOT_AVAILABLE); NS_ENSURE_TRUE(mChannels, NS_ERROR_FAILURE); NS_ENSURE_TRUE(aData.isObject(), NS_ERROR_INVALID_ARG); if (mIndirectAudio) { NS_WARNING("Can't call SendAudio from an indirect audio speech service."); return NS_ERROR_FAILURE; } JS::Rooted<JSObject*> darray(aCx, &aData.toObject()); JSAutoCompartment ac(aCx, darray); JS::Rooted<JSObject*> tsrc(aCx, nullptr); // Allow either Int16Array or plain JS Array if (JS_IsInt16Array(darray)) { tsrc = darray; } else if (JS_IsArrayObject(aCx, darray)) { tsrc = JS_NewInt16ArrayFromArray(aCx, darray); } if (!tsrc) { return NS_ERROR_DOM_TYPE_MISMATCH_ERR; } SendAudioImpl(JS_GetInt16ArrayData(tsrc), JS_GetTypedArrayLength(tsrc)); return NS_OK; }
static void fetch_face(struct fs_compile_context *fcc, struct toy_dst dst) { struct toy_compiler *tc = &fcc->tc; const struct toy_src r0 = tsrc_d(tsrc(TOY_FILE_GRF, 0, 0)); struct toy_dst tmp_f, tmp; struct toy_dst real_dst[4]; tdst_transpose(dst, real_dst); tmp_f = tc_alloc_tmp(tc); tmp = tdst_d(tmp_f); tc_SHR(tc, tmp, tsrc_rect(r0, TOY_RECT_010), tsrc_imm_d(15)); tc_AND(tc, tmp, tsrc_from(tmp), tsrc_imm_d(1)); tc_MOV(tc, tmp_f, tsrc_from(tmp)); /* convert to 1.0 and -1.0 */ tc_MUL(tc, tmp_f, tsrc_from(tmp_f), tsrc_imm_f(-2.0f)); tc_ADD(tc, real_dst[0], tsrc_from(tmp_f), tsrc_imm_f(1.0f)); tc_MOV(tc, real_dst[1], tsrc_imm_f(0.0f)); tc_MOV(tc, real_dst[2], tsrc_imm_f(0.0f)); tc_MOV(tc, real_dst[3], tsrc_imm_f(1.0f)); }
/** * Emit instructions to write the VUE. */ static void vs_write_vue(struct vs_compile_context *vcc) { struct toy_compiler *tc = &vcc->tc; struct toy_src outs[PIPE_MAX_SHADER_OUTPUTS]; struct toy_dst header; struct toy_src r0; struct toy_inst *inst; int sent_attrs, total_attrs; header = tdst_ud(tdst(TOY_FILE_MRF, vcc->first_free_mrf, 0)); r0 = tsrc_ud(tsrc(TOY_FILE_GRF, 0, 0)); inst = tc_MOV(tc, header, r0); inst->mask_ctrl = GEN6_MASKCTRL_NOMASK; if (ilo_dev_gen(tc->dev) >= ILO_GEN(7)) { inst = tc_OR(tc, tdst_offset(header, 0, 5), tsrc_rect(tsrc_offset(r0, 0, 5), TOY_RECT_010), tsrc_rect(tsrc_imm_ud(0xff00), TOY_RECT_010)); inst->exec_size = GEN6_EXECSIZE_1; inst->access_mode = GEN6_ALIGN_1; inst->mask_ctrl = GEN6_MASKCTRL_NOMASK; } total_attrs = vs_collect_outputs(vcc, outs); sent_attrs = 0; while (sent_attrs < total_attrs) { struct toy_src desc; int mrf = vcc->first_free_mrf + 1, avail_mrf_for_attrs; int num_attrs, msg_len, i; bool eot; num_attrs = total_attrs - sent_attrs; eot = true; /* see if we need another message */ avail_mrf_for_attrs = vcc->last_free_mrf - mrf + 1; if (num_attrs > avail_mrf_for_attrs) { /* * From the Sandy Bridge PRM, volume 4 part 2, page 22: * * "Offset. This field specifies a destination offset (in 256-bit * units) from the start of the URB entry(s), as referenced by * URB Return Handle n, at which the data (if any) will be * written." * * As we need to offset the following messages, we must make sure * this one writes an even number of attributes. */ num_attrs = avail_mrf_for_attrs & ~1; eot = false; } if (ilo_dev_gen(tc->dev) >= ILO_GEN(7)) { /* do not forget about the header */ msg_len = 1 + num_attrs; } else { /* * From the Sandy Bridge PRM, volume 4 part 2, page 26: * * "At least 256 bits per vertex (512 bits total, M1 & M2) must * be written. Writing only 128 bits per vertex (256 bits * total, M1 only) results in UNDEFINED operation." * * "[DevSNB] Interleave writes must be in multiples of 256 per * vertex." * * That is, we must write or appear to write an even number of * attributes, starting from two. */ if (num_attrs % 2 && num_attrs == avail_mrf_for_attrs) { num_attrs--; eot = false; } msg_len = 1 + align(num_attrs, 2); } for (i = 0; i < num_attrs; i++) tc_MOV(tc, tdst(TOY_FILE_MRF, mrf++, 0), outs[sent_attrs + i]); assert(sent_attrs % 2 == 0); desc = tsrc_imm_mdesc_urb(tc, eot, msg_len, 0, eot, true, false, true, sent_attrs / 2, 0); tc_add2(tc, TOY_OPCODE_URB_WRITE, tdst_null(), tsrc_from(header), desc); sent_attrs += num_attrs; } }
/** * Collect the toy registers to be written to the VUE. */ static int vs_collect_outputs(struct vs_compile_context *vcc, struct toy_src *outs) { const struct toy_tgsi *tgsi = &vcc->tgsi; unsigned i; for (i = 0; i < vcc->shader->out.count; i++) { const int slot = vcc->output_map[i]; const int vrf = (slot >= 0) ? toy_tgsi_get_vrf(tgsi, TGSI_FILE_OUTPUT, 0, tgsi->outputs[slot].index) : -1; struct toy_src src; if (vrf >= 0) { struct toy_dst dst; dst = tdst(TOY_FILE_VRF, vrf, 0); src = tsrc_from(dst); if (i == 0) { /* PSIZE is at channel W */ tc_MOV(&vcc->tc, tdst_writemask(dst, TOY_WRITEMASK_W), tsrc_swizzle1(src, TOY_SWIZZLE_X)); /* the other channels are for the header */ dst = tdst_d(dst); tc_MOV(&vcc->tc, tdst_writemask(dst, TOY_WRITEMASK_XYZ), tsrc_imm_d(0)); } else { /* initialize unused channels to 0.0f */ if (tgsi->outputs[slot].undefined_mask) { dst = tdst_writemask(dst, tgsi->outputs[slot].undefined_mask); tc_MOV(&vcc->tc, dst, tsrc_imm_f(0.0f)); } } } else { /* XXX this is too ugly */ if (vcc->shader->out.semantic_names[i] == TGSI_SEMANTIC_CLIPDIST && slot < 0) { /* ok, we need to compute clip distance */ int clipvert_slot = -1, clipvert_vrf, j; for (j = 0; j < tgsi->num_outputs; j++) { if (tgsi->outputs[j].semantic_name == TGSI_SEMANTIC_CLIPVERTEX) { clipvert_slot = j; break; } else if (tgsi->outputs[j].semantic_name == TGSI_SEMANTIC_POSITION) { /* remember pos, but keep looking */ clipvert_slot = j; } } clipvert_vrf = (clipvert_slot >= 0) ? toy_tgsi_get_vrf(tgsi, TGSI_FILE_OUTPUT, 0, tgsi->outputs[clipvert_slot].index) : -1; if (clipvert_vrf >= 0) { struct toy_dst tmp = tc_alloc_tmp(&vcc->tc); struct toy_src clipvert = tsrc(TOY_FILE_VRF, clipvert_vrf, 0); int first_ucp, last_ucp; if (vcc->shader->out.semantic_indices[i]) { first_ucp = 4; last_ucp = MIN2(7, vcc->variant->u.vs.num_ucps - 1); } else { first_ucp = 0; last_ucp = MIN2(3, vcc->variant->u.vs.num_ucps - 1); } for (j = first_ucp; j <= last_ucp; j++) { const int plane_grf = vcc->first_ucp_grf + j / 2; const int plane_subreg = (j & 1) * 16; const struct toy_src plane = tsrc_rect(tsrc(TOY_FILE_GRF, plane_grf, plane_subreg), TOY_RECT_041); const unsigned writemask = 1 << ((j >= 4) ? j - 4 : j); tc_DP4(&vcc->tc, tdst_writemask(tmp, writemask), clipvert, plane); } src = tsrc_from(tmp); } else { src = tsrc_imm_f(0.0f); } } else { src = (i == 0) ? tsrc_imm_d(0) : tsrc_imm_f(0.0f); } } outs[i] = src; } return i; }
static void vs_lower_opcode_tgsi_sampling(struct vs_compile_context *vcc, struct toy_inst *inst) { struct toy_compiler *tc = &vcc->tc; struct toy_src desc; struct toy_dst dst, tmp; unsigned sampler_index; int swizzles[4], i; unsigned swizzle_zero_mask, swizzle_one_mask, swizzle_normal_mask; bool need_filter; desc = vs_prepare_tgsi_sampling(vcc, inst, vcc->first_free_mrf, &sampler_index); switch (inst->opcode) { case TOY_OPCODE_TGSI_TXF: case TOY_OPCODE_TGSI_TXQ: case TOY_OPCODE_TGSI_TXQ_LZ: need_filter = false; break; default: need_filter = true; break; } toy_compiler_lower_to_send(tc, inst, false, GEN6_SFID_SAMPLER); inst->src[0] = tsrc(TOY_FILE_MRF, vcc->first_free_mrf, 0); inst->src[1] = desc; /* write to a temp first */ tmp = tc_alloc_tmp(tc); tmp.type = inst->dst.type; dst = inst->dst; inst->dst = tmp; tc_move_inst(tc, inst); if (need_filter) { assert(sampler_index < vcc->variant->num_sampler_views); swizzles[0] = vcc->variant->sampler_view_swizzles[sampler_index].r; swizzles[1] = vcc->variant->sampler_view_swizzles[sampler_index].g; swizzles[2] = vcc->variant->sampler_view_swizzles[sampler_index].b; swizzles[3] = vcc->variant->sampler_view_swizzles[sampler_index].a; } else { swizzles[0] = PIPE_SWIZZLE_RED; swizzles[1] = PIPE_SWIZZLE_GREEN; swizzles[2] = PIPE_SWIZZLE_BLUE; swizzles[3] = PIPE_SWIZZLE_ALPHA; } swizzle_zero_mask = 0; swizzle_one_mask = 0; swizzle_normal_mask = 0; for (i = 0; i < 4; i++) { switch (swizzles[i]) { case PIPE_SWIZZLE_ZERO: swizzle_zero_mask |= 1 << i; swizzles[i] = i; break; case PIPE_SWIZZLE_ONE: swizzle_one_mask |= 1 << i; swizzles[i] = i; break; default: swizzle_normal_mask |= 1 << i; break; } } /* swizzle the results */ if (swizzle_normal_mask) { tc_MOV(tc, tdst_writemask(dst, swizzle_normal_mask), tsrc_swizzle(tsrc_from(tmp), swizzles[0], swizzles[1], swizzles[2], swizzles[3])); } if (swizzle_zero_mask) tc_MOV(tc, tdst_writemask(dst, swizzle_zero_mask), tsrc_imm_f(0.0f)); if (swizzle_one_mask) tc_MOV(tc, tdst_writemask(dst, swizzle_one_mask), tsrc_imm_f(1.0f)); }
static void fs_lower_opcode_tgsi_sampling(struct fs_compile_context *fcc, struct toy_inst *inst) { struct toy_compiler *tc = &fcc->tc; struct toy_dst dst[4], tmp[4]; struct toy_src desc; unsigned sampler_index; int swizzles[4], i; bool need_filter; desc = fs_prepare_tgsi_sampling(tc, inst, fcc->first_free_mrf, fcc->variant->saturate_tex_coords, &sampler_index); switch (inst->opcode) { case TOY_OPCODE_TGSI_TXF: case TOY_OPCODE_TGSI_TXQ: case TOY_OPCODE_TGSI_TXQ_LZ: need_filter = false; break; default: need_filter = true; break; } toy_compiler_lower_to_send(tc, inst, false, BRW_SFID_SAMPLER); inst->src[0] = tsrc(TOY_FILE_MRF, fcc->first_free_mrf, 0); inst->src[1] = desc; for (i = 2; i < Elements(inst->src); i++) inst->src[i] = tsrc_null(); /* write to temps first */ tc_alloc_tmp4(tc, tmp); tdst_transpose(inst->dst, dst); inst->dst = tmp[0]; tc_move_inst(tc, inst); if (need_filter) { assert(sampler_index < fcc->variant->num_sampler_views); swizzles[0] = fcc->variant->sampler_view_swizzles[sampler_index].r; swizzles[1] = fcc->variant->sampler_view_swizzles[sampler_index].g; swizzles[2] = fcc->variant->sampler_view_swizzles[sampler_index].b; swizzles[3] = fcc->variant->sampler_view_swizzles[sampler_index].a; } else { swizzles[0] = PIPE_SWIZZLE_RED; swizzles[1] = PIPE_SWIZZLE_GREEN; swizzles[2] = PIPE_SWIZZLE_BLUE; swizzles[3] = PIPE_SWIZZLE_ALPHA; } /* swizzle the results */ for (i = 0; i < 4; i++) { switch (swizzles[i]) { case PIPE_SWIZZLE_ZERO: tc_MOV(tc, dst[i], tsrc_imm_f(0.0f)); break; case PIPE_SWIZZLE_ONE: tc_MOV(tc, dst[i], tsrc_imm_f(1.0f)); break; default: tc_MOV(tc, dst[i], tsrc_from(tmp[swizzles[i]])); break; } } }
static void fetch_position(struct fs_compile_context *fcc, struct toy_dst dst) { struct toy_compiler *tc = &fcc->tc; const struct toy_src src_z = tsrc(TOY_FILE_GRF, fcc->payloads[0].source_depth, 0); const struct toy_src src_w = tsrc(TOY_FILE_GRF, fcc->payloads[0].source_w, 0); const int fb_height = (fcc->variant->u.fs.fb_height) ? fcc->variant->u.fs.fb_height : 1; const bool origin_upper_left = (fcc->tgsi.props.fs_coord_origin == TGSI_FS_COORD_ORIGIN_UPPER_LEFT); const bool pixel_center_integer = (fcc->tgsi.props.fs_coord_pixel_center == TGSI_FS_COORD_PIXEL_CENTER_INTEGER); struct toy_src subspan_x, subspan_y; struct toy_dst tmp, tmp_uw; struct toy_dst real_dst[4]; tdst_transpose(dst, real_dst); subspan_x = tsrc_uw(tsrc(TOY_FILE_GRF, 1, 2 * 4)); subspan_x = tsrc_rect(subspan_x, TOY_RECT_240); subspan_y = tsrc_offset(subspan_x, 0, 1); tmp_uw = tdst_uw(tc_alloc_tmp(tc)); tmp = tc_alloc_tmp(tc); /* X */ tc_ADD(tc, tmp_uw, subspan_x, tsrc_imm_v(0x10101010)); tc_MOV(tc, tmp, tsrc_from(tmp_uw)); if (pixel_center_integer) tc_MOV(tc, real_dst[0], tsrc_from(tmp)); else tc_ADD(tc, real_dst[0], tsrc_from(tmp), tsrc_imm_f(0.5f)); /* Y */ tc_ADD(tc, tmp_uw, subspan_y, tsrc_imm_v(0x11001100)); tc_MOV(tc, tmp, tsrc_from(tmp_uw)); if (origin_upper_left && pixel_center_integer) { tc_MOV(tc, real_dst[1], tsrc_from(tmp)); } else { struct toy_src y = tsrc_from(tmp); float offset = 0.0f; if (!pixel_center_integer) offset += 0.5f; if (!origin_upper_left) { offset += (float) (fb_height - 1); y = tsrc_negate(y); } tc_ADD(tc, real_dst[1], y, tsrc_imm_f(offset)); } /* Z and W */ tc_MOV(tc, real_dst[2], src_z); tc_INV(tc, real_dst[3], src_w); }
static void fetch_attr(struct fs_compile_context *fcc, struct toy_dst dst, int slot) { struct toy_compiler *tc = &fcc->tc; struct toy_dst real_dst[4]; bool is_const = false; int grf, mode, ch; tdst_transpose(dst, real_dst); grf = fcc->first_attr_grf + slot * 2; switch (fcc->tgsi.inputs[slot].interp) { case TGSI_INTERPOLATE_CONSTANT: is_const = true; break; case TGSI_INTERPOLATE_LINEAR: if (fcc->tgsi.inputs[slot].centroid) mode = BRW_WM_NONPERSPECTIVE_CENTROID_BARYCENTRIC; else mode = BRW_WM_NONPERSPECTIVE_PIXEL_BARYCENTRIC; break; case TGSI_INTERPOLATE_COLOR: if (fcc->variant->u.fs.flatshade) { is_const = true; break; } /* fall through */ case TGSI_INTERPOLATE_PERSPECTIVE: if (fcc->tgsi.inputs[slot].centroid) mode = BRW_WM_PERSPECTIVE_CENTROID_BARYCENTRIC; else mode = BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC; break; default: assert(!"unexpected FS interpolation"); mode = BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC; break; } if (is_const) { struct toy_src a0[4]; a0[0] = tsrc(TOY_FILE_GRF, grf + 0, 3 * 4); a0[1] = tsrc(TOY_FILE_GRF, grf + 0, 7 * 4); a0[2] = tsrc(TOY_FILE_GRF, grf + 1, 3 * 4); a0[3] = tsrc(TOY_FILE_GRF, grf + 1, 7 * 4); for (ch = 0; ch < 4; ch++) tc_MOV(tc, real_dst[ch], tsrc_rect(a0[ch], TOY_RECT_010)); } else { struct toy_src attr[4], uv; attr[0] = tsrc(TOY_FILE_GRF, grf + 0, 0); attr[1] = tsrc(TOY_FILE_GRF, grf + 0, 4 * 4); attr[2] = tsrc(TOY_FILE_GRF, grf + 1, 0); attr[3] = tsrc(TOY_FILE_GRF, grf + 1, 4 * 4); uv = tsrc(TOY_FILE_GRF, fcc->payloads[0].barycentric_interps[mode], 0); for (ch = 0; ch < 4; ch++) { tc_add2(tc, BRW_OPCODE_PLN, real_dst[ch], tsrc_rect(attr[ch], TOY_RECT_010), uv); } } if (fcc->tgsi.inputs[slot].semantic_name == TGSI_SEMANTIC_FOG) { tc_MOV(tc, real_dst[1], tsrc_imm_f(0.0f)); tc_MOV(tc, real_dst[2], tsrc_imm_f(0.0f)); tc_MOV(tc, real_dst[3], tsrc_imm_f(1.0f)); } }
/** * Emit instructions to write the color buffers (and the depth buffer). */ static void fs_write_fb(struct fs_compile_context *fcc) { struct toy_compiler *tc = &fcc->tc; int base_mrf = fcc->first_free_mrf; const struct toy_dst header = tdst_ud(tdst(TOY_FILE_MRF, base_mrf, 0)); bool header_present = false; struct toy_src desc; unsigned msg_type, ctrl; int color_slots[ILO_MAX_DRAW_BUFFERS], num_cbufs; int pos_slot = -1, cbuf, i; for (i = 0; i < Elements(color_slots); i++) color_slots[i] = -1; for (i = 0; i < fcc->tgsi.num_outputs; i++) { if (fcc->tgsi.outputs[i].semantic_name == TGSI_SEMANTIC_COLOR) { assert(fcc->tgsi.outputs[i].semantic_index < Elements(color_slots)); color_slots[fcc->tgsi.outputs[i].semantic_index] = i; } else if (fcc->tgsi.outputs[i].semantic_name == TGSI_SEMANTIC_POSITION) { pos_slot = i; } } num_cbufs = fcc->variant->u.fs.num_cbufs; /* still need to send EOT (and probably depth) */ if (!num_cbufs) num_cbufs = 1; /* we need the header to specify the pixel mask or render target */ if (fcc->tgsi.uses_kill || num_cbufs > 1) { const struct toy_src r0 = tsrc_ud(tsrc(TOY_FILE_GRF, 0, 0)); struct toy_inst *inst; inst = tc_MOV(tc, header, r0); inst->mask_ctrl = BRW_MASK_DISABLE; base_mrf += fcc->num_grf_per_vrf; /* this is a two-register header */ if (fcc->dispatch_mode == GEN6_WM_8_DISPATCH_ENABLE) { inst = tc_MOV(tc, tdst_offset(header, 1, 0), tsrc_offset(r0, 1, 0)); inst->mask_ctrl = BRW_MASK_DISABLE; base_mrf += fcc->num_grf_per_vrf; } header_present = true; } for (cbuf = 0; cbuf < num_cbufs; cbuf++) { const int slot = color_slots[(fcc->tgsi.props.fs_color0_writes_all_cbufs) ? 0 : cbuf]; int mrf = base_mrf, vrf; struct toy_src src[4]; if (slot >= 0) { const unsigned undefined_mask = fcc->tgsi.outputs[slot].undefined_mask; const int index = fcc->tgsi.outputs[slot].index; vrf = toy_tgsi_get_vrf(&fcc->tgsi, TGSI_FILE_OUTPUT, 0, index); if (vrf >= 0) { const struct toy_src tmp = tsrc(TOY_FILE_VRF, vrf, 0); tsrc_transpose(tmp, src); } else { /* use (0, 0, 0, 0) */ tsrc_transpose(tsrc_imm_f(0.0f), src); } for (i = 0; i < 4; i++) { const struct toy_dst dst = tdst(TOY_FILE_MRF, mrf, 0); if (undefined_mask & (1 << i)) src[i] = tsrc_imm_f(0.0f); tc_MOV(tc, dst, src[i]); mrf += fcc->num_grf_per_vrf; } } else { /* use (0, 0, 0, 0) */ for (i = 0; i < 4; i++) { const struct toy_dst dst = tdst(TOY_FILE_MRF, mrf, 0); tc_MOV(tc, dst, tsrc_imm_f(0.0f)); mrf += fcc->num_grf_per_vrf; } } /* select BLEND_STATE[rt] */ if (cbuf > 0) { struct toy_inst *inst; inst = tc_MOV(tc, tdst_offset(header, 0, 2), tsrc_imm_ud(cbuf)); inst->mask_ctrl = BRW_MASK_DISABLE; inst->exec_size = BRW_EXECUTE_1; inst->src[0].rect = TOY_RECT_010; } if (cbuf == 0 && pos_slot >= 0) { const int index = fcc->tgsi.outputs[pos_slot].index; const struct toy_dst dst = tdst(TOY_FILE_MRF, mrf, 0); struct toy_src src[4]; int vrf; vrf = toy_tgsi_get_vrf(&fcc->tgsi, TGSI_FILE_OUTPUT, 0, index); if (vrf >= 0) { const struct toy_src tmp = tsrc(TOY_FILE_VRF, vrf, 0); tsrc_transpose(tmp, src); } else { /* use (0, 0, 0, 0) */ tsrc_transpose(tsrc_imm_f(0.0f), src); } /* only Z */ tc_MOV(tc, dst, src[2]); mrf += fcc->num_grf_per_vrf; } msg_type = (fcc->dispatch_mode == GEN6_WM_16_DISPATCH_ENABLE) ? BRW_DATAPORT_RENDER_TARGET_WRITE_SIMD16_SINGLE_SOURCE : BRW_DATAPORT_RENDER_TARGET_WRITE_SIMD8_SINGLE_SOURCE_SUBSPAN01; ctrl = (cbuf == num_cbufs - 1) << 12 | msg_type << 8; desc = tsrc_imm_mdesc_data_port(tc, cbuf == num_cbufs - 1, mrf - fcc->first_free_mrf, 0, header_present, false, GEN6_DATAPORT_WRITE_MESSAGE_RENDER_TARGET_WRITE, ctrl, ILO_WM_DRAW_SURFACE(cbuf)); tc_add2(tc, TOY_OPCODE_FB_WRITE, tdst_null(), tsrc(TOY_FILE_MRF, fcc->first_free_mrf, 0), desc); } }