static void swr_resource_copy(struct pipe_context *pipe, struct pipe_resource *dst, unsigned dst_level, unsigned dstx, unsigned dsty, unsigned dstz, struct pipe_resource *src, unsigned src_level, const struct pipe_box *src_box) { struct swr_screen *screen = swr_screen(pipe->screen); /* If either the src or dst is a renderTarget, store tiles before copy */ swr_store_dirty_resource(pipe, src, SWR_TILE_RESOLVED); swr_store_dirty_resource(pipe, dst, SWR_TILE_RESOLVED); swr_fence_finish(pipe->screen, NULL, screen->flush_fence, 0); swr_resource_unused(src); swr_resource_unused(dst); if ((dst->target == PIPE_BUFFER && src->target == PIPE_BUFFER) || (dst->target != PIPE_BUFFER && src->target != PIPE_BUFFER)) { util_resource_copy_region( pipe, dst, dst_level, dstx, dsty, dstz, src, src_level, src_box); return; } debug_printf("unhandled swr_resource_copy\n"); }
void swr_store_dirty_resource(struct pipe_context *pipe, struct pipe_resource *resource, enum SWR_TILE_STATE post_tile_state) { /* Only store resource if it has been written to */ if (swr_resource(resource)->status & SWR_RESOURCE_WRITE) { struct swr_context *ctx = swr_context(pipe); struct swr_screen *screen = swr_screen(pipe->screen); struct swr_resource *spr = swr_resource(resource); swr_draw_context *pDC = &ctx->swrDC; SWR_SURFACE_STATE *renderTargets = pDC->renderTargets; for (uint32_t i = 0; i < SWR_NUM_ATTACHMENTS; i++) if (renderTargets[i].pBaseAddress == spr->swr.pBaseAddress) { swr_store_render_target(pipe, i, post_tile_state); /* Mesa thinks depth/stencil are fused, so we'll never get an * explicit resource for stencil. So, if checking depth, then * also check for stencil. */ if (spr->has_stencil && (i == SWR_ATTACHMENT_DEPTH)) { swr_store_render_target( pipe, SWR_ATTACHMENT_STENCIL, post_tile_state); } /* This fence signals StoreTiles completion */ swr_fence_submit(ctx, screen->flush_fence); break; } } }
static void swr_resource_destroy(struct pipe_screen *p_screen, struct pipe_resource *pt) { struct swr_screen *screen = swr_screen(p_screen); struct swr_resource *spr = swr_resource(pt); struct pipe_context *pipe = screen->pipe; /* Only wait on fence if the resource is being used */ if (pipe && spr->status) { /* But, if there's no fence pending, submit one. * XXX: Remove once draw timestamps are implmented. */ if (!swr_is_fence_pending(screen->flush_fence)) swr_fence_submit(swr_context(pipe), screen->flush_fence); swr_fence_finish(p_screen, screen->flush_fence, 0); swr_resource_unused(pt); } /* * Free resource primary surface. If resource is display target, winsys * manages the buffer and will free it on displaytarget_destroy. */ if (spr->display_target) { /* display target */ struct sw_winsys *winsys = screen->winsys; winsys->displaytarget_destroy(winsys, spr->display_target); } else AlignedFree(spr->swr.pBaseAddress); AlignedFree(spr->secondary.pBaseAddress); FREE(spr); }
static void swr_resource_destroy(struct pipe_screen *p_screen, struct pipe_resource *pt) { struct swr_screen *screen = swr_screen(p_screen); struct swr_resource *spr = swr_resource(pt); struct pipe_context *pipe = screen->pipe; if (spr->display_target) { /* If resource is display target, winsys manages the buffer and will * free it on displaytarget_destroy. */ swr_fence_finish(p_screen, NULL, screen->flush_fence, 0); struct sw_winsys *winsys = screen->winsys; winsys->displaytarget_destroy(winsys, spr->display_target); } else { /* For regular resources, if the resource is being used, defer deletion * (use aligned-free) */ if (pipe && spr->status) { swr_resource_unused(pt); swr_fence_work_free(screen->flush_fence, spr->swr.pBaseAddress, true); swr_fence_work_free(screen->flush_fence, spr->secondary.pBaseAddress, true); } else { AlignedFree(spr->swr.pBaseAddress); AlignedFree(spr->secondary.pBaseAddress); } } FREE(spr); }
static boolean swr_is_format_supported(struct pipe_screen *screen, enum pipe_format format, enum pipe_texture_target target, unsigned sample_count, unsigned bind) { struct sw_winsys *winsys = swr_screen(screen)->winsys; const struct util_format_description *format_desc; assert(target == PIPE_BUFFER || target == PIPE_TEXTURE_1D || target == PIPE_TEXTURE_1D_ARRAY || target == PIPE_TEXTURE_2D || target == PIPE_TEXTURE_2D_ARRAY || target == PIPE_TEXTURE_RECT || target == PIPE_TEXTURE_3D || target == PIPE_TEXTURE_CUBE || target == PIPE_TEXTURE_CUBE_ARRAY); format_desc = util_format_description(format); if (!format_desc) return FALSE; if (sample_count > 1) return FALSE; if (bind & (PIPE_BIND_DISPLAY_TARGET | PIPE_BIND_SCANOUT | PIPE_BIND_SHARED)) { if (!winsys->is_displaytarget_format_supported(winsys, bind, format)) return FALSE; } if (bind & PIPE_BIND_RENDER_TARGET) { if (format_desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS) return FALSE; if (mesa_to_swr_format(format) == (SWR_FORMAT)-1) return FALSE; /* * Although possible, it is unnatural to render into compressed or YUV * surfaces. So disable these here to avoid going into weird paths * inside the state trackers. */ if (format_desc->block.width != 1 || format_desc->block.height != 1) return FALSE; } if (bind & PIPE_BIND_DEPTH_STENCIL) { if (format_desc->colorspace != UTIL_FORMAT_COLORSPACE_ZS) return FALSE; if (mesa_to_swr_format(format) == (SWR_FORMAT)-1) return FALSE; } return TRUE; }
static boolean swr_can_create_resource(struct pipe_screen *screen, const struct pipe_resource *templat) { struct swr_resource res; memset(&res, 0, sizeof(res)); res.base = *templat; return swr_texture_layout(swr_screen(screen), &res, false); }
static void swr_destroy(struct pipe_context *pipe) { struct swr_context *ctx = swr_context(pipe); struct swr_screen *screen = swr_screen(pipe->screen); if (ctx->blitter) util_blitter_destroy(ctx->blitter); for (unsigned i = 0; i < PIPE_MAX_COLOR_BUFS; i++) { if (ctx->framebuffer.cbufs[i]) { struct swr_resource *res = swr_resource(ctx->framebuffer.cbufs[i]->texture); /* NULL curr_pipe, so we don't have a reference to a deleted pipe */ res->curr_pipe = NULL; pipe_surface_reference(&ctx->framebuffer.cbufs[i], NULL); } } if (ctx->framebuffer.zsbuf) { struct swr_resource *res = swr_resource(ctx->framebuffer.zsbuf->texture); /* NULL curr_pipe, so we don't have a reference to a deleted pipe */ res->curr_pipe = NULL; pipe_surface_reference(&ctx->framebuffer.zsbuf, NULL); } for (unsigned i = 0; i < ARRAY_SIZE(ctx->sampler_views[0]); i++) { pipe_sampler_view_reference(&ctx->sampler_views[PIPE_SHADER_FRAGMENT][i], NULL); } for (unsigned i = 0; i < ARRAY_SIZE(ctx->sampler_views[0]); i++) { pipe_sampler_view_reference(&ctx->sampler_views[PIPE_SHADER_VERTEX][i], NULL); } if (ctx->pipe.stream_uploader) u_upload_destroy(ctx->pipe.stream_uploader); /* Idle core after destroying buffer resources, but before deleting * context. Destroying resources has potentially called StoreTiles.*/ ctx->api.pfnSwrWaitForIdle(ctx->swrContext); if (ctx->swrContext) ctx->api.pfnSwrDestroyContext(ctx->swrContext); delete ctx->blendJIT; swr_destroy_scratch_buffers(ctx); /* Only update screen->pipe if current context is being destroyed */ assert(screen); if (screen->pipe == pipe) screen->pipe = NULL; AlignedFree(ctx); }
static struct pipe_resource * swr_resource_create(struct pipe_screen *_screen, const struct pipe_resource *templat) { struct swr_screen *screen = swr_screen(_screen); struct swr_resource *res = CALLOC_STRUCT(swr_resource); if (!res) return NULL; res->base = *templat; pipe_reference_init(&res->base.reference, 1); res->base.screen = &screen->base; if (swr_resource_is_texture(&res->base)) { if (res->base.bind & (PIPE_BIND_DISPLAY_TARGET | PIPE_BIND_SCANOUT | PIPE_BIND_SHARED)) { /* displayable surface * first call swr_texture_layout without allocating to finish * filling out the SWR_SURFAE_STATE in res */ swr_texture_layout(screen, res, false); if (!swr_displaytarget_layout(screen, res)) goto fail; } else { /* texture map */ if (!swr_texture_layout(screen, res, true)) goto fail; } } else { /* other data (vertex buffer, const buffer, etc) */ assert(util_format_get_blocksize(templat->format) == 1); assert(templat->height0 == 1); assert(templat->depth0 == 1); assert(templat->last_level == 0); /* Easiest to just call swr_texture_layout, as it sets up * SWR_SURFAE_STATE in res */ if (!swr_texture_layout(screen, res, true)) goto fail; } return &res->base; fail: FREE(res); return NULL; }
static void swr_destroy_screen(struct pipe_screen *p_screen) { struct swr_screen *screen = swr_screen(p_screen); struct sw_winsys *winsys = screen->winsys; fprintf(stderr, "SWR destroy screen!\n"); swr_fence_finish(p_screen, screen->flush_fence, 0); swr_fence_reference(p_screen, &screen->flush_fence, NULL); JitDestroyContext(screen->hJitMgr); if (winsys->destroy) winsys->destroy(winsys); FREE(screen); }
static void swr_flush(struct pipe_context *pipe, struct pipe_fence_handle **fence, unsigned flags) { struct swr_context *ctx = swr_context(pipe); struct swr_screen *screen = swr_screen(pipe->screen); struct pipe_surface *cb = ctx->framebuffer.cbufs[0]; /* If the current renderTarget is the display surface, store tiles back to * the surface, in preparation for present (swr_flush_frontbuffer). * Other renderTargets get stored back when attachment changes or * swr_surface_destroy */ if (cb && swr_resource(cb->texture)->display_target) swr_store_dirty_resource(pipe, cb->texture, SWR_TILE_RESOLVED); if (fence) swr_fence_reference(pipe->screen, fence, screen->flush_fence); }
static void swr_destroy(struct pipe_context *pipe) { struct swr_context *ctx = swr_context(pipe); struct swr_screen *screen = swr_screen(pipe->screen); if (ctx->blitter) util_blitter_destroy(ctx->blitter); /* Idle core before deleting context */ SwrWaitForIdle(ctx->swrContext); for (unsigned i = 0; i < PIPE_MAX_COLOR_BUFS; i++) { pipe_surface_reference(&ctx->framebuffer.cbufs[i], NULL); } pipe_surface_reference(&ctx->framebuffer.zsbuf, NULL); for (unsigned i = 0; i < ARRAY_SIZE(ctx->sampler_views[0]); i++) { pipe_sampler_view_reference(&ctx->sampler_views[PIPE_SHADER_FRAGMENT][i], NULL); } for (unsigned i = 0; i < ARRAY_SIZE(ctx->sampler_views[0]); i++) { pipe_sampler_view_reference(&ctx->sampler_views[PIPE_SHADER_VERTEX][i], NULL); } if (ctx->swrContext) SwrDestroyContext(ctx->swrContext); delete ctx->blendJIT; swr_destroy_scratch_buffers(ctx); /* Only update screen->pipe if current context is being destroyed */ assert(screen); if (screen->pipe == pipe) screen->pipe = NULL; FREE(ctx); }
static void swr_flush(struct pipe_context *pipe, struct pipe_fence_handle **fence, unsigned flags) { struct swr_context *ctx = swr_context(pipe); struct swr_screen *screen = swr_screen(pipe->screen); for (int i=0; i < ctx->framebuffer.nr_cbufs; i++) { struct pipe_surface *cb = ctx->framebuffer.cbufs[i]; if (cb) { swr_store_dirty_resource(pipe, cb->texture, SWR_TILE_RESOLVED); } } if (ctx->framebuffer.zsbuf) { swr_store_dirty_resource(pipe, ctx->framebuffer.zsbuf->texture, SWR_TILE_RESOLVED); } if (fence) swr_fence_reference(pipe->screen, fence, screen->flush_fence); }
static void swr_flush_frontbuffer(struct pipe_screen *p_screen, struct pipe_resource *resource, unsigned level, unsigned layer, void *context_private, struct pipe_box *sub_box) { struct swr_screen *screen = swr_screen(p_screen); struct sw_winsys *winsys = screen->winsys; struct swr_resource *spr = swr_resource(resource); struct pipe_context *pipe = screen->pipe; if (pipe) { swr_fence_finish(p_screen, screen->flush_fence, 0); swr_resource_unused(resource); SwrEndFrame(swr_context(pipe)->swrContext); } debug_assert(spr->display_target); if (spr->display_target) winsys->displaytarget_display( winsys, spr->display_target, context_private, sub_box); }
struct pipe_context * swr_create_context(struct pipe_screen *p_screen, void *priv, unsigned flags) { struct swr_context *ctx = (struct swr_context *) AlignedMalloc(sizeof(struct swr_context), KNOB_SIMD_BYTES); memset(ctx, 0, sizeof(struct swr_context)); swr_screen(p_screen)->pfnSwrGetInterface(ctx->api); ctx->swrDC.pAPI = &ctx->api; ctx->blendJIT = new std::unordered_map<BLEND_COMPILE_STATE, PFN_BLEND_JIT_FUNC>; ctx->max_draws_in_flight = KNOB_MAX_DRAWS_IN_FLIGHT; SWR_CREATECONTEXT_INFO createInfo; memset(&createInfo, 0, sizeof(createInfo)); createInfo.privateStateSize = sizeof(swr_draw_context); createInfo.pfnLoadTile = swr_LoadHotTile; createInfo.pfnStoreTile = swr_StoreHotTile; createInfo.pfnClearTile = swr_StoreHotTileClear; createInfo.pfnUpdateStats = swr_UpdateStats; createInfo.pfnUpdateStatsFE = swr_UpdateStatsFE; SWR_THREADING_INFO threadingInfo {0}; threadingInfo.MAX_WORKER_THREADS = KNOB_MAX_WORKER_THREADS; threadingInfo.MAX_NUMA_NODES = KNOB_MAX_NUMA_NODES; threadingInfo.MAX_CORES_PER_NUMA_NODE = KNOB_MAX_CORES_PER_NUMA_NODE; threadingInfo.MAX_THREADS_PER_CORE = KNOB_MAX_THREADS_PER_CORE; threadingInfo.SINGLE_THREADED = KNOB_SINGLE_THREADED; // Use non-standard settings for KNL if (swr_screen(p_screen)->is_knl) { if (nullptr == getenv("KNOB_MAX_THREADS_PER_CORE")) threadingInfo.MAX_THREADS_PER_CORE = 2; if (nullptr == getenv("KNOB_MAX_DRAWS_IN_FLIGHT")) { ctx->max_draws_in_flight = 2048; createInfo.MAX_DRAWS_IN_FLIGHT = ctx->max_draws_in_flight; } } createInfo.pThreadInfo = &threadingInfo; ctx->swrContext = ctx->api.pfnSwrCreateContext(&createInfo); ctx->api.pfnSwrInit(); if (ctx->swrContext == NULL) goto fail; ctx->pipe.screen = p_screen; ctx->pipe.destroy = swr_destroy; ctx->pipe.priv = priv; ctx->pipe.create_surface = swr_create_surface; ctx->pipe.surface_destroy = swr_surface_destroy; ctx->pipe.transfer_map = swr_transfer_map; ctx->pipe.transfer_unmap = swr_transfer_unmap; ctx->pipe.transfer_flush_region = swr_transfer_flush_region; ctx->pipe.buffer_subdata = u_default_buffer_subdata; ctx->pipe.texture_subdata = u_default_texture_subdata; ctx->pipe.clear_texture = util_clear_texture; ctx->pipe.resource_copy_region = swr_resource_copy; ctx->pipe.render_condition = swr_render_condition; swr_state_init(&ctx->pipe); swr_clear_init(&ctx->pipe); swr_draw_init(&ctx->pipe); swr_query_init(&ctx->pipe); ctx->pipe.stream_uploader = u_upload_create_default(&ctx->pipe); if (!ctx->pipe.stream_uploader) goto fail; ctx->pipe.const_uploader = ctx->pipe.stream_uploader; ctx->pipe.blit = swr_blit; ctx->blitter = util_blitter_create(&ctx->pipe); if (!ctx->blitter) goto fail; swr_init_scratch_buffers(ctx); return &ctx->pipe; fail: /* Should really validate the init steps and fail gracefully */ swr_destroy(&ctx->pipe); return NULL; }
static void * swr_transfer_map(struct pipe_context *pipe, struct pipe_resource *resource, unsigned level, unsigned usage, const struct pipe_box *box, struct pipe_transfer **transfer) { struct swr_screen *screen = swr_screen(pipe->screen); struct swr_resource *spr = swr_resource(resource); struct pipe_transfer *pt; enum pipe_format format = resource->format; assert(resource); assert(level <= resource->last_level); /* If mapping an attached rendertarget, store tiles to surface and set * postStoreTileState to SWR_TILE_INVALID so tiles get reloaded on next use * and nothing needs to be done at unmap. */ swr_store_dirty_resource(pipe, resource, SWR_TILE_INVALID); if (!(usage & PIPE_TRANSFER_UNSYNCHRONIZED)) { /* If resource is in use, finish fence before mapping. * Unless requested not to block, then if not done return NULL map */ if (usage & PIPE_TRANSFER_DONTBLOCK) { if (swr_is_fence_pending(screen->flush_fence)) return NULL; } else { if (spr->status) { /* But, if there's no fence pending, submit one. * XXX: Remove once draw timestamps are finished. */ if (!swr_is_fence_pending(screen->flush_fence)) swr_fence_submit(swr_context(pipe), screen->flush_fence); swr_fence_finish(pipe->screen, screen->flush_fence, 0); swr_resource_unused(resource); } } } pt = CALLOC_STRUCT(pipe_transfer); if (!pt) return NULL; pipe_resource_reference(&pt->resource, resource); pt->level = level; pt->box = *box; pt->stride = spr->row_stride[level]; pt->layer_stride = spr->img_stride[level]; /* if we're mapping the depth/stencil, copy in stencil */ if (spr->base.format == PIPE_FORMAT_Z24_UNORM_S8_UINT && spr->has_stencil) { for (unsigned i = 0; i < spr->alignedWidth * spr->alignedHeight; i++) { spr->swr.pBaseAddress[4 * i + 3] = spr->secondary.pBaseAddress[i]; } } else if (spr->base.format == PIPE_FORMAT_Z32_FLOAT_S8X24_UINT && spr->has_stencil) { for (unsigned i = 0; i < spr->alignedWidth * spr->alignedHeight; i++) { spr->swr.pBaseAddress[8 * i + 4] = spr->secondary.pBaseAddress[i]; } } unsigned offset = box->z * pt->layer_stride + box->y * pt->stride + box->x * util_format_get_blocksize(format); *transfer = pt; return spr->swr.pBaseAddress + offset + spr->mip_offsets[level]; }
/* * Draw vertex arrays, with optional indexing, optional instancing. */ static void swr_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *info) { struct swr_context *ctx = swr_context(pipe); if (!info->count_from_stream_output && !info->indirect && !info->primitive_restart && !u_trim_pipe_prim(info->mode, (unsigned*)&info->count)) return; if (!swr_check_render_cond(pipe)) return; if (info->indirect) { util_draw_indirect(pipe, info); return; } /* If indexed draw, force vertex validation since index buffer comes * from draw info. */ if (info->index_size) ctx->dirty |= SWR_NEW_VERTEX; /* Update derived state, pass draw info to update function. */ swr_update_derived(pipe, info); swr_update_draw_context(ctx); if (ctx->vs->pipe.stream_output.num_outputs) { if (!ctx->vs->soFunc[info->mode]) { STREAMOUT_COMPILE_STATE state = {0}; struct pipe_stream_output_info *so = &ctx->vs->pipe.stream_output; state.numVertsPerPrim = u_vertices_per_prim(info->mode); uint32_t offsets[MAX_SO_STREAMS] = {0}; uint32_t num = 0; for (uint32_t i = 0; i < so->num_outputs; i++) { assert(so->output[i].stream == 0); // @todo uint32_t output_buffer = so->output[i].output_buffer; if (so->output[i].dst_offset != offsets[output_buffer]) { // hole - need to fill state.stream.decl[num].bufferIndex = output_buffer; state.stream.decl[num].hole = true; state.stream.decl[num].componentMask = (1 << (so->output[i].dst_offset - offsets[output_buffer])) - 1; num++; offsets[output_buffer] = so->output[i].dst_offset; } unsigned attrib_slot = so->output[i].register_index; attrib_slot = swr_so_adjust_attrib(attrib_slot, ctx->vs); state.stream.decl[num].bufferIndex = output_buffer; state.stream.decl[num].attribSlot = attrib_slot; state.stream.decl[num].componentMask = ((1 << so->output[i].num_components) - 1) << so->output[i].start_component; state.stream.decl[num].hole = false; num++; offsets[output_buffer] += so->output[i].num_components; } state.stream.numDecls = num; HANDLE hJitMgr = swr_screen(pipe->screen)->hJitMgr; ctx->vs->soFunc[info->mode] = JitCompileStreamout(hJitMgr, state); debug_printf("so shader %p\n", ctx->vs->soFunc[info->mode]); assert(ctx->vs->soFunc[info->mode] && "Error: SoShader = NULL"); } ctx->api.pfnSwrSetSoFunc(ctx->swrContext, ctx->vs->soFunc[info->mode], 0); } struct swr_vertex_element_state *velems = ctx->velems; if (info->primitive_restart) velems->fsState.cutIndex = info->restart_index; else velems->fsState.cutIndex = 0; velems->fsState.bEnableCutIndex = info->primitive_restart; velems->fsState.bPartialVertexBuffer = (info->min_index > 0); swr_jit_fetch_key key; swr_generate_fetch_key(key, velems); auto search = velems->map.find(key); if (search != velems->map.end()) { velems->fsFunc = search->second; } else { HANDLE hJitMgr = swr_screen(ctx->pipe.screen)->hJitMgr; velems->fsFunc = JitCompileFetch(hJitMgr, velems->fsState); debug_printf("fetch shader %p\n", velems->fsFunc); assert(velems->fsFunc && "Error: FetchShader = NULL"); velems->map.insert(std::make_pair(key, velems->fsFunc)); } ctx->api.pfnSwrSetFetchFunc(ctx->swrContext, velems->fsFunc); /* Set up frontend state * XXX setup provokingVertex & topologyProvokingVertex */ SWR_FRONTEND_STATE feState = {0}; // feState.vsVertexSize seeds the PA size that is used as an interface // between all the shader stages, so it has to be large enough to // incorporate all interfaces between stages // max of gs and vs num_outputs feState.vsVertexSize = ctx->vs->info.base.num_outputs; if (ctx->gs && ctx->gs->info.base.num_outputs > feState.vsVertexSize) { feState.vsVertexSize = ctx->gs->info.base.num_outputs; } if (ctx->vs->info.base.num_outputs) { // gs does not adjust for position in SGV slot at input from vs if (!ctx->gs) feState.vsVertexSize--; } // other (non-SGV) slots start at VERTEX_ATTRIB_START_SLOT feState.vsVertexSize += VERTEX_ATTRIB_START_SLOT; // The PA in the clipper does not handle BE vertex sizes // different from FE. Increase vertexsize only for the cases that needed it // primid needs a slot if (ctx->fs->info.base.uses_primid) feState.vsVertexSize++; // sprite coord enable if (ctx->rasterizer->sprite_coord_enable) feState.vsVertexSize++; if (ctx->rasterizer->flatshade_first) { feState.provokingVertex = {1, 0, 0}; } else { feState.provokingVertex = {2, 1, 2}; } enum pipe_prim_type topology; if (ctx->gs) topology = (pipe_prim_type)ctx->gs->info.base.properties[TGSI_PROPERTY_GS_OUTPUT_PRIM]; else topology = info->mode; switch (topology) { case PIPE_PRIM_TRIANGLE_FAN: feState.topologyProvokingVertex = feState.provokingVertex.triFan; break; case PIPE_PRIM_TRIANGLE_STRIP: case PIPE_PRIM_TRIANGLES: feState.topologyProvokingVertex = feState.provokingVertex.triStripList; break; case PIPE_PRIM_QUAD_STRIP: case PIPE_PRIM_QUADS: if (ctx->rasterizer->flatshade_first) feState.topologyProvokingVertex = 0; else feState.topologyProvokingVertex = 3; break; case PIPE_PRIM_LINES: case PIPE_PRIM_LINE_LOOP: case PIPE_PRIM_LINE_STRIP: feState.topologyProvokingVertex = feState.provokingVertex.lineStripList; break; default: feState.topologyProvokingVertex = 0; } feState.bEnableCutIndex = info->primitive_restart; ctx->api.pfnSwrSetFrontendState(ctx->swrContext, &feState); if (info->index_size) ctx->api.pfnSwrDrawIndexedInstanced(ctx->swrContext, swr_convert_prim_topology(info->mode), info->count, info->instance_count, info->start, info->index_bias, info->start_instance); else ctx->api.pfnSwrDrawInstanced(ctx->swrContext, swr_convert_prim_topology(info->mode), info->count, info->instance_count, info->start, info->start_instance); /* On large client-buffer draw, we used client buffer directly, without * copy. Block until draw is finished. * VMD is an example application that benefits from this. */ if (ctx->dirty & SWR_LARGE_CLIENT_DRAW) { struct swr_screen *screen = swr_screen(pipe->screen); swr_fence_submit(ctx, screen->flush_fence); swr_fence_finish(pipe->screen, NULL, screen->flush_fence, 0); } }
static void * swr_transfer_map(struct pipe_context *pipe, struct pipe_resource *resource, unsigned level, unsigned usage, const struct pipe_box *box, struct pipe_transfer **transfer) { struct swr_screen *screen = swr_screen(pipe->screen); struct swr_resource *spr = swr_resource(resource); struct pipe_transfer *pt; enum pipe_format format = resource->format; assert(resource); assert(level <= resource->last_level); /* If mapping an attached rendertarget, store tiles to surface and set * postStoreTileState to SWR_TILE_INVALID so tiles get reloaded on next use * and nothing needs to be done at unmap. */ swr_store_dirty_resource(pipe, resource, SWR_TILE_INVALID); if (!(usage & PIPE_TRANSFER_UNSYNCHRONIZED)) { /* If resource is in use, finish fence before mapping. * Unless requested not to block, then if not done return NULL map */ if (usage & PIPE_TRANSFER_DONTBLOCK) { if (swr_is_fence_pending(screen->flush_fence)) return NULL; } else { if (spr->status) { /* But, if there's no fence pending, submit one. * XXX: Remove once draw timestamps are finished. */ if (!swr_is_fence_pending(screen->flush_fence)) swr_fence_submit(swr_context(pipe), screen->flush_fence); swr_fence_finish(pipe->screen, NULL, screen->flush_fence, 0); swr_resource_unused(resource); } } } pt = CALLOC_STRUCT(pipe_transfer); if (!pt) return NULL; pipe_resource_reference(&pt->resource, resource); pt->usage = (pipe_transfer_usage)usage; pt->level = level; pt->box = *box; pt->stride = spr->swr.pitch; pt->layer_stride = spr->swr.qpitch * spr->swr.pitch; /* if we're mapping the depth/stencil, copy in stencil for the section * being read in */ if (usage & PIPE_TRANSFER_READ && spr->has_depth && spr->has_stencil) { size_t zbase, sbase; for (int z = box->z; z < box->z + box->depth; z++) { zbase = (z * spr->swr.qpitch + box->y) * spr->swr.pitch + spr->mip_offsets[level]; sbase = (z * spr->secondary.qpitch + box->y) * spr->secondary.pitch + spr->secondary_mip_offsets[level]; for (int y = box->y; y < box->y + box->height; y++) { if (spr->base.format == PIPE_FORMAT_Z24_UNORM_S8_UINT) { for (int x = box->x; x < box->x + box->width; x++) ((uint8_t*)(spr->swr.xpBaseAddress))[zbase + 4 * x + 3] = ((uint8_t*)(spr->secondary.xpBaseAddress))[sbase + x]; } else if (spr->base.format == PIPE_FORMAT_Z32_FLOAT_S8X24_UINT) { for (int x = box->x; x < box->x + box->width; x++) ((uint8_t*)(spr->swr.xpBaseAddress))[zbase + 8 * x + 4] = ((uint8_t*)(spr->secondary.xpBaseAddress))[sbase + x]; } zbase += spr->swr.pitch; sbase += spr->secondary.pitch; } } } unsigned offset = box->z * pt->layer_stride + util_format_get_nblocksy(format, box->y) * pt->stride + util_format_get_stride(format, box->x); *transfer = pt; return (void*)(spr->swr.xpBaseAddress + offset + spr->mip_offsets[level]); }
/* * Draw vertex arrays, with optional indexing, optional instancing. */ static void swr_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *info) { struct swr_context *ctx = swr_context(pipe); if (!swr_check_render_cond(pipe)) return; if (info->indirect) { util_draw_indirect(pipe, info); return; } /* Update derived state, pass draw info to update function */ if (ctx->dirty) swr_update_derived(pipe, info); swr_update_draw_context(ctx); if (ctx->vs->pipe.stream_output.num_outputs) { if (!ctx->vs->soFunc[info->mode]) { STREAMOUT_COMPILE_STATE state = {0}; struct pipe_stream_output_info *so = &ctx->vs->pipe.stream_output; state.numVertsPerPrim = u_vertices_per_prim(info->mode); uint32_t offsets[MAX_SO_STREAMS] = {0}; uint32_t num = 0; for (uint32_t i = 0; i < so->num_outputs; i++) { assert(so->output[i].stream == 0); // @todo uint32_t output_buffer = so->output[i].output_buffer; if (so->output[i].dst_offset != offsets[output_buffer]) { // hole - need to fill state.stream.decl[num].bufferIndex = output_buffer; state.stream.decl[num].hole = true; state.stream.decl[num].componentMask = (1 << (so->output[i].dst_offset - offsets[output_buffer])) - 1; num++; offsets[output_buffer] = so->output[i].dst_offset; } state.stream.decl[num].bufferIndex = output_buffer; state.stream.decl[num].attribSlot = so->output[i].register_index - 1; state.stream.decl[num].componentMask = ((1 << so->output[i].num_components) - 1) << so->output[i].start_component; state.stream.decl[num].hole = false; num++; offsets[output_buffer] += so->output[i].num_components; } state.stream.numDecls = num; HANDLE hJitMgr = swr_screen(pipe->screen)->hJitMgr; ctx->vs->soFunc[info->mode] = JitCompileStreamout(hJitMgr, state); debug_printf("so shader %p\n", ctx->vs->soFunc[info->mode]); assert(ctx->vs->soFunc[info->mode] && "Error: SoShader = NULL"); } SwrSetSoFunc(ctx->swrContext, ctx->vs->soFunc[info->mode], 0); } struct swr_vertex_element_state *velems = ctx->velems; if (!velems->fsFunc || (velems->fsState.cutIndex != info->restart_index) || (velems->fsState.bEnableCutIndex != info->primitive_restart)) { velems->fsState.cutIndex = info->restart_index; velems->fsState.bEnableCutIndex = info->primitive_restart; /* Create Fetch Shader */ HANDLE hJitMgr = swr_screen(ctx->pipe.screen)->hJitMgr; velems->fsFunc = JitCompileFetch(hJitMgr, velems->fsState); debug_printf("fetch shader %p\n", velems->fsFunc); assert(velems->fsFunc && "Error: FetchShader = NULL"); } SwrSetFetchFunc(ctx->swrContext, velems->fsFunc); /* Set up frontend state * XXX setup provokingVertex & topologyProvokingVertex */ SWR_FRONTEND_STATE feState = {0}; if (ctx->rasterizer->flatshade_first) { feState.provokingVertex = {1, 0, 0}; } else { feState.provokingVertex = {2, 1, 2}; } switch (info->mode) { case PIPE_PRIM_TRIANGLE_FAN: feState.topologyProvokingVertex = feState.provokingVertex.triFan; break; case PIPE_PRIM_TRIANGLE_STRIP: case PIPE_PRIM_TRIANGLES: feState.topologyProvokingVertex = feState.provokingVertex.triStripList; break; case PIPE_PRIM_QUAD_STRIP: case PIPE_PRIM_QUADS: if (ctx->rasterizer->flatshade_first) feState.topologyProvokingVertex = 0; else feState.topologyProvokingVertex = 3; break; case PIPE_PRIM_LINES: case PIPE_PRIM_LINE_LOOP: case PIPE_PRIM_LINE_STRIP: feState.topologyProvokingVertex = feState.provokingVertex.lineStripList; break; default: feState.topologyProvokingVertex = 0; } feState.bEnableCutIndex = info->primitive_restart; SwrSetFrontendState(ctx->swrContext, &feState); if (info->indexed) SwrDrawIndexedInstanced(ctx->swrContext, swr_convert_prim_topology(info->mode), info->count, info->instance_count, info->start, info->index_bias, info->start_instance); else SwrDrawInstanced(ctx->swrContext, swr_convert_prim_topology(info->mode), info->count, info->instance_count, info->start, info->start_instance); }
struct pipe_context * swr_create_context(struct pipe_screen *p_screen, void *priv, unsigned flags) { struct swr_context *ctx = (struct swr_context *) AlignedMalloc(sizeof(struct swr_context), KNOB_SIMD_BYTES); memset(ctx, 0, sizeof(struct swr_context)); swr_screen(p_screen)->pfnSwrGetInterface(ctx->api); ctx->swrDC.pAPI = &ctx->api; ctx->blendJIT = new std::unordered_map<BLEND_COMPILE_STATE, PFN_BLEND_JIT_FUNC>; SWR_CREATECONTEXT_INFO createInfo; memset(&createInfo, 0, sizeof(createInfo)); createInfo.privateStateSize = sizeof(swr_draw_context); createInfo.pfnLoadTile = swr_LoadHotTile; createInfo.pfnStoreTile = swr_StoreHotTile; createInfo.pfnClearTile = swr_StoreHotTileClear; createInfo.pfnUpdateStats = swr_UpdateStats; createInfo.pfnUpdateStatsFE = swr_UpdateStatsFE; ctx->swrContext = ctx->api.pfnSwrCreateContext(&createInfo); ctx->api.pfnSwrInit(); if (ctx->swrContext == NULL) goto fail; ctx->pipe.screen = p_screen; ctx->pipe.destroy = swr_destroy; ctx->pipe.priv = priv; ctx->pipe.create_surface = swr_create_surface; ctx->pipe.surface_destroy = swr_surface_destroy; ctx->pipe.transfer_map = swr_transfer_map; ctx->pipe.transfer_unmap = swr_transfer_unmap; ctx->pipe.transfer_flush_region = swr_transfer_flush_region; ctx->pipe.buffer_subdata = u_default_buffer_subdata; ctx->pipe.texture_subdata = u_default_texture_subdata; ctx->pipe.clear_texture = util_clear_texture; ctx->pipe.resource_copy_region = swr_resource_copy; ctx->pipe.render_condition = swr_render_condition; swr_state_init(&ctx->pipe); swr_clear_init(&ctx->pipe); swr_draw_init(&ctx->pipe); swr_query_init(&ctx->pipe); ctx->pipe.stream_uploader = u_upload_create_default(&ctx->pipe); if (!ctx->pipe.stream_uploader) goto fail; ctx->pipe.const_uploader = ctx->pipe.stream_uploader; ctx->pipe.blit = swr_blit; ctx->blitter = util_blitter_create(&ctx->pipe); if (!ctx->blitter) goto fail; swr_init_scratch_buffers(ctx); return &ctx->pipe; fail: /* Should really validate the init steps and fail gracefully */ swr_destroy(&ctx->pipe); return NULL; }