Google Git
Sign in
skia / skia / 1e6460d552f76058f6e94c9e8ae1f201e9c22317 / . / src / gpu / d3d / GrD3DGpu.cpp
blob: 3d9bf8f78fd46e12da147e556562fc9cbf9a2646 [file] [log] [blame]
/*
* Copyright 2020 Google LLC
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "src/gpu/d3d/GrD3DGpu.h"
#include "include/gpu/GrBackendSurface.h"
#include "include/gpu/d3d/GrD3DBackendContext.h"
#include "src/core/SkConvertPixels.h"
#include "src/core/SkMipMap.h"
#include "src/gpu/GrBackendUtils.h"
#include "src/gpu/GrDataUtils.h"
#include "src/gpu/GrTexturePriv.h"
#include "src/gpu/d3d/GrD3DBuffer.h"
#include "src/gpu/d3d/GrD3DCaps.h"
#include "src/gpu/d3d/GrD3DOpsRenderPass.h"
#include "src/gpu/d3d/GrD3DSemaphore.h"
#include "src/gpu/d3d/GrD3DStencilAttachment.h"
#include "src/gpu/d3d/GrD3DTexture.h"
#include "src/gpu/d3d/GrD3DTextureRenderTarget.h"
#include "src/gpu/d3d/GrD3DUtil.h"
#include "src/sksl/SkSLCompiler.h"
#if GR_TEST_UTILS
#include <DXProgrammableCapture.h>
#endif
sk_sp<GrGpu> GrD3DGpu::Make(const GrD3DBackendContext& backendContext,
const GrContextOptions& contextOptions, GrContext* context) {
return sk_sp<GrGpu>(new GrD3DGpu(context, contextOptions, backendContext));
}
// This constant determines how many OutstandingCommandLists are allocated together as a block in
// the deque. As such it needs to balance allocating too much memory vs. incurring
// allocation/deallocation thrashing. It should roughly correspond to the max number of outstanding
// command lists we expect to see.
static const int kDefaultOutstandingAllocCnt = 8;
GrD3DGpu::GrD3DGpu(GrContext* context, const GrContextOptions& contextOptions,
const GrD3DBackendContext& backendContext)
: INHERITED(context)
, fDevice(backendContext.fDevice)
, fQueue(backendContext.fQueue)
, fResourceProvider(this)
, fOutstandingCommandLists(sizeof(OutstandingCommandList), kDefaultOutstandingAllocCnt)
, fCompiler(new SkSL::Compiler()) {
fCaps.reset(new GrD3DCaps(contextOptions,
backendContext.fAdapter.get(),
backendContext.fDevice.get()));
fCurrentDirectCommandList = fResourceProvider.findOrCreateDirectCommandList();
SkASSERT(fCurrentDirectCommandList);
SkASSERT(fCurrentFenceValue == 0);
SkDEBUGCODE(HRESULT hr = ) fDevice->CreateFence(fCurrentFenceValue, D3D12_FENCE_FLAG_NONE,
IID_PPV_ARGS(&fFence));
SkASSERT(SUCCEEDED(hr));
#if GR_TEST_UTILS
HRESULT getAnalysis = DXGIGetDebugInterface1(0, IID_PPV_ARGS(&fGraphicsAnalysis));
if (FAILED(getAnalysis)) {
fGraphicsAnalysis = nullptr;
}
#endif
}
GrD3DGpu::~GrD3DGpu() {
this->destroyResources();
}
void GrD3DGpu::destroyResources() {
if (fCurrentDirectCommandList) {
fCurrentDirectCommandList->close();
fCurrentDirectCommandList->reset();
}
// We need to make sure everything has finished on the queue.
this->waitFence(fCurrentFenceValue);
SkDEBUGCODE(uint64_t fenceValue = fFence->GetCompletedValue();)
// We used a placement new for each object in fOutstandingCommandLists, so we're responsible
// for calling the destructor on each of them as well.
while (!fOutstandingCommandLists.empty()) {
OutstandingCommandList* list = (OutstandingCommandList*)fOutstandingCommandLists.front();
SkASSERT(list->fFenceValue <= fenceValue);
// No reason to recycle the command lists since we are destroying all resources anyways.
list->~OutstandingCommandList();
fOutstandingCommandLists.pop_front();
}
fResourceProvider.destroyResources();
}
GrOpsRenderPass* GrD3DGpu::getOpsRenderPass(
GrRenderTarget* rt, GrStencilAttachment*,
GrSurfaceOrigin origin, const SkIRect& bounds,
const GrOpsRenderPass::LoadAndStoreInfo& colorInfo,
const GrOpsRenderPass::StencilLoadAndStoreInfo& stencilInfo,
const SkTArray<GrSurfaceProxy*, true>& sampledProxies) {
if (!fCachedOpsRenderPass) {
fCachedOpsRenderPass.reset(new GrD3DOpsRenderPass(this));
}
if (!fCachedOpsRenderPass->set(rt, origin, bounds, colorInfo, stencilInfo, sampledProxies)) {
return nullptr;
}
return fCachedOpsRenderPass.get();
}
bool GrD3DGpu::submitDirectCommandList(SyncQueue sync) {
SkASSERT(fCurrentDirectCommandList);
fResourceProvider.prepForSubmit();
GrD3DDirectCommandList::SubmitResult result = fCurrentDirectCommandList->submit(fQueue.get());
if (result == GrD3DDirectCommandList::SubmitResult::kFailure) {
return false;
} else if (result == GrD3DDirectCommandList::SubmitResult::kNoWork) {
if (sync == SyncQueue::kForce) {
this->waitFence(fCurrentFenceValue);
this->checkForFinishedCommandLists();
}
return true;
}
// We just submitted the command list so make sure all GrD3DPipelineState's mark their cached
// uniform data as dirty.
fResourceProvider.markPipelineStateUniformsDirty();
GrFence fence = this->insertFence();
new (fOutstandingCommandLists.push_back()) OutstandingCommandList(
std::move(fCurrentDirectCommandList), fence);
if (sync == SyncQueue::kForce) {
this->waitFence(fence);
}
fCurrentDirectCommandList = fResourceProvider.findOrCreateDirectCommandList();
// This should be done after we have a new command list in case the freeing of any resources
// held by a finished command list causes us send a new command to the gpu (like changing the
// resource state.
this->checkForFinishedCommandLists();
SkASSERT(fCurrentDirectCommandList);
return true;
}
void GrD3DGpu::checkForFinishedCommandLists() {
uint64_t currentFenceValue = fFence->GetCompletedValue();
// Iterate over all the outstanding command lists to see if any have finished. The commands
// lists are in order from oldest to newest, so we start at the front to check if their fence
// value is less than the last signaled value. If so we pop it off and move onto the next.
// Repeat till we find a command list that has not finished yet (and all others afterwards are
// also guaranteed to not have finished).
OutstandingCommandList* front = (OutstandingCommandList*)fOutstandingCommandLists.front();
while (front && front->fFenceValue <= currentFenceValue) {
std::unique_ptr<GrD3DDirectCommandList> currList(std::move(front->fCommandList));
// Since we used placement new we are responsible for calling the destructor manually.
front->~OutstandingCommandList();
fOutstandingCommandLists.pop_front();
fResourceProvider.recycleDirectCommandList(std::move(currList));
front = (OutstandingCommandList*)fOutstandingCommandLists.front();
}
}
void GrD3DGpu::submit(GrOpsRenderPass* renderPass) {
SkASSERT(fCachedOpsRenderPass.get() == renderPass);
// TODO: actually submit something here
fCachedOpsRenderPass.reset();
}
void GrD3DGpu::addFinishedProc(GrGpuFinishedProc finishedProc,
GrGpuFinishedContext finishedContext) {
SkASSERT(finishedProc);
sk_sp<GrRefCntedCallback> finishedCallback(
new GrRefCntedCallback(finishedProc, finishedContext));
this->addFinishedCallback(std::move(finishedCallback));
}
void GrD3DGpu::addFinishedCallback(sk_sp<GrRefCntedCallback> finishedCallback) {
SkASSERT(finishedCallback);
// Besides the current command list, we also add the finishedCallback to the newest outstanding
// command list. Our contract for calling the proc is that all previous submitted command lists
// have finished when we call it. However, if our current command list has no work when it is
// flushed it will drop its ref to the callback immediately. But the previous work may not have
// finished. It is safe to only add the proc to the newest outstanding commandlist cause that
// must finish after all previously submitted command lists.
OutstandingCommandList* back = (OutstandingCommandList*)fOutstandingCommandLists.back();
if (back) {
back->fCommandList->addFinishedCallback(finishedCallback);
}
fCurrentDirectCommandList->addFinishedCallback(std::move(finishedCallback));
}
void GrD3DGpu::querySampleLocations(GrRenderTarget* rt, SkTArray<SkPoint>* sampleLocations) {
// TODO
}
sk_sp<GrTexture> GrD3DGpu::onCreateTexture(SkISize dimensions,
const GrBackendFormat& format,
GrRenderable renderable,
int renderTargetSampleCnt,
SkBudgeted budgeted,
GrProtected isProtected,
int mipLevelCount,
uint32_t levelClearMask) {
DXGI_FORMAT dxgiFormat;
SkAssertResult(format.asDxgiFormat(&dxgiFormat));
SkASSERT(!GrDxgiFormatIsCompressed(dxgiFormat));
D3D12_RESOURCE_FLAGS usageFlags = D3D12_RESOURCE_FLAG_NONE;
if (renderable == GrRenderable::kYes) {
usageFlags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
}
// This desc refers to the texture that will be read by the client. Thus even if msaa is
// requested, this describes the resolved texture. Therefore we always have samples set
// to 1.
SkASSERT(mipLevelCount > 0);
D3D12_RESOURCE_DESC resourceDesc = {};
resourceDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
// TODO: will use 4MB alignment for MSAA textures and 64KB for everything else
// might want to manually set alignment to 4KB for smaller textures
resourceDesc.Alignment = 0;
resourceDesc.Width = dimensions.fWidth;
resourceDesc.Height = dimensions.fHeight;
resourceDesc.DepthOrArraySize = 1;
resourceDesc.MipLevels = mipLevelCount;
resourceDesc.Format = dxgiFormat;
resourceDesc.SampleDesc.Count = 1;
// quality levels are only supported for tiled resources so ignore for now
resourceDesc.SampleDesc.Quality = GrD3DTextureResource::kDefaultQualityLevel;
resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; // use driver-selected swizzle
resourceDesc.Flags = usageFlags;
GrMipMapsStatus mipMapsStatus =
mipLevelCount > 1 ? GrMipMapsStatus::kDirty : GrMipMapsStatus::kNotAllocated;
sk_sp<GrD3DTexture> tex;
if (renderable == GrRenderable::kYes) {
tex = GrD3DTextureRenderTarget::MakeNewTextureRenderTarget(
this, budgeted, dimensions, renderTargetSampleCnt, resourceDesc, isProtected,
mipMapsStatus);
} else {
tex = GrD3DTexture::MakeNewTexture(this, budgeted, dimensions, resourceDesc, isProtected,
mipMapsStatus);
}
if (!tex) {
return nullptr;
}
if (levelClearMask) {
// TODO
}
return std::move(tex);
}
sk_sp<GrTexture> GrD3DGpu::onCreateCompressedTexture(SkISize dimensions,
const GrBackendFormat& format,
SkBudgeted budgeted,
GrMipMapped mipMapped,
GrProtected isProtected,
const void* data, size_t dataSize) {
// TODO
return nullptr;
}
static int get_surface_sample_cnt(GrSurface* surf) {
if (const GrRenderTarget* rt = surf->asRenderTarget()) {
return rt->numSamples();
}
return 0;
}
bool GrD3DGpu::onCopySurface(GrSurface* dst, GrSurface* src, const SkIRect& srcRect,
const SkIPoint& dstPoint) {
if (src->isProtected() && !dst->isProtected()) {
SkDebugf("Can't copy from protected memory to non-protected");
return false;
}
int dstSampleCnt = get_surface_sample_cnt(dst);
int srcSampleCnt = get_surface_sample_cnt(src);
GrD3DTextureResource* dstTexResource;
GrD3DTextureResource* srcTexResource;
GrRenderTarget* dstRT = dst->asRenderTarget();
if (dstRT) {
GrD3DRenderTarget* d3dRT = static_cast<GrD3DRenderTarget*>(dstRT);
dstTexResource = d3dRT->numSamples() > 1 ? d3dRT->msaaTextureResource() : d3dRT;
} else {
SkASSERT(dst->asTexture());
dstTexResource = static_cast<GrD3DTexture*>(dst->asTexture());
}
GrRenderTarget* srcRT = src->asRenderTarget();
if (srcRT) {
GrD3DRenderTarget* d3dRT = static_cast<GrD3DRenderTarget*>(srcRT);
srcTexResource = d3dRT->numSamples() > 1 ? d3dRT->msaaTextureResource() : d3dRT;
} else {
SkASSERT(src->asTexture());
srcTexResource = static_cast<GrD3DTexture*>(src->asTexture());
}
DXGI_FORMAT dstFormat = dstTexResource->dxgiFormat();
DXGI_FORMAT srcFormat = srcTexResource->dxgiFormat();
if (this->d3dCaps().canCopyAsResolve(dstFormat, dstSampleCnt, srcFormat, srcSampleCnt)) {
this->copySurfaceAsResolve(dst, src, srcRect, dstPoint);
return true;
}
if (this->d3dCaps().canCopyTexture(dstFormat, dstSampleCnt, srcFormat, srcSampleCnt)) {
this->copySurfaceAsCopyTexture(dst, src, dstTexResource, srcTexResource, srcRect, dstPoint);
return true;
}
return false;
}
void GrD3DGpu::copySurfaceAsCopyTexture(GrSurface* dst, GrSurface* src,
GrD3DTextureResource* dstResource,
GrD3DTextureResource* srcResource,
const SkIRect& srcRect, const SkIPoint& dstPoint) {
#ifdef SK_DEBUG
int dstSampleCnt = get_surface_sample_cnt(dst);
int srcSampleCnt = get_surface_sample_cnt(src);
DXGI_FORMAT dstFormat = dstResource->dxgiFormat();
DXGI_FORMAT srcFormat;
SkAssertResult(dst->backendFormat().asDxgiFormat(&srcFormat));
SkASSERT(this->d3dCaps().canCopyTexture(dstFormat, dstSampleCnt, srcFormat, srcSampleCnt));
#endif
if (src->isProtected() && !dst->isProtected()) {
SkDebugf("Can't copy from protected memory to non-protected");
return;
}
dstResource->setResourceState(this, D3D12_RESOURCE_STATE_COPY_DEST);
srcResource->setResourceState(this, D3D12_RESOURCE_STATE_COPY_SOURCE);
D3D12_TEXTURE_COPY_LOCATION dstLocation = {};
dstLocation.pResource = dstResource->d3dResource();
dstLocation.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
dstLocation.SubresourceIndex = 0;
D3D12_TEXTURE_COPY_LOCATION srcLocation = {};
srcLocation.pResource = srcResource->d3dResource();
srcLocation.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
srcLocation.SubresourceIndex = 0;
D3D12_BOX srcBox = {};
srcBox.left = srcRect.fLeft;
srcBox.top = srcRect.fTop;
srcBox.right = srcRect.fRight;
srcBox.bottom = srcRect.fBottom;
srcBox.front = 0;
srcBox.back = 1;
// TODO: use copyResource if copying full resource and sizes match
fCurrentDirectCommandList->copyTextureRegion(dstResource->resource(),
&dstLocation,
dstPoint.fX, dstPoint.fY,
srcResource->resource(),
&srcLocation,
&srcBox);
SkIRect dstRect = SkIRect::MakeXYWH(dstPoint.fX, dstPoint.fY,
srcRect.width(), srcRect.height());
// The rect is already in device space so we pass in kTopLeft so no flip is done.
this->didWriteToSurface(dst, kTopLeft_GrSurfaceOrigin, &dstRect);
}
void GrD3DGpu::copySurfaceAsResolve(GrSurface* dst, GrSurface* src, const SkIRect& srcRect,
const SkIPoint& dstPoint) {
// TODO
}
bool GrD3DGpu::onReadPixels(GrSurface* surface, int left, int top, int width, int height,
GrColorType surfaceColorType, GrColorType dstColorType, void* buffer,
size_t rowBytes) {
SkASSERT(surface);
if (surfaceColorType != dstColorType) {
return false;
}
// Set up src location and box
GrD3DTextureResource* texResource = nullptr;
GrD3DRenderTarget* rt = static_cast<GrD3DRenderTarget*>(surface->asRenderTarget());
if (rt) {
texResource = rt;
} else {
texResource = static_cast<GrD3DTexture*>(surface->asTexture());
}
if (!texResource) {
return false;
}
D3D12_TEXTURE_COPY_LOCATION srcLocation = {};
srcLocation.pResource = texResource->d3dResource();
SkASSERT(srcLocation.pResource);
srcLocation.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
srcLocation.SubresourceIndex = 0;
D3D12_BOX srcBox = {};
srcBox.left = left;
srcBox.top = top;
srcBox.right = left + width;
srcBox.bottom = top + height;
srcBox.front = 0;
srcBox.back = 1;
// Set up dst location and create transfer buffer
D3D12_TEXTURE_COPY_LOCATION dstLocation = {};
dstLocation.Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
UINT64 transferTotalBytes;
const UINT64 baseOffset = 0;
D3D12_RESOURCE_DESC desc = srcLocation.pResource->GetDesc();
fDevice->GetCopyableFootprints(&desc, 0, 1, baseOffset, &dstLocation.PlacedFootprint,
nullptr, nullptr, &transferTotalBytes);
SkASSERT(transferTotalBytes);
size_t bpp = GrColorTypeBytesPerPixel(dstColorType);
if (this->d3dCaps().bytesPerPixel(texResource->dxgiFormat()) != bpp) {
return false;
}
size_t tightRowBytes = bpp * width;
// TODO: implement some way of reusing buffers instead of making a new one every time.
sk_sp<GrGpuBuffer> transferBuffer = this->createBuffer(transferTotalBytes,
GrGpuBufferType::kXferGpuToCpu,
kDynamic_GrAccessPattern);
GrD3DBuffer* d3dBuf = static_cast<GrD3DBuffer*>(transferBuffer.get());
dstLocation.pResource = d3dBuf->d3dResource();
// Need to change the resource state to COPY_SOURCE in order to download from it
texResource->setResourceState(this, D3D12_RESOURCE_STATE_COPY_SOURCE);
fCurrentDirectCommandList->copyTextureRegion(d3dBuf->resource(), &dstLocation, 0, 0,
texResource->resource(), &srcLocation, &srcBox);
this->submitDirectCommandList(SyncQueue::kForce);
const void* mappedMemory = transferBuffer->map();
SkRectMemcpy(buffer, rowBytes, mappedMemory, dstLocation.PlacedFootprint.Footprint.RowPitch,
tightRowBytes, height);
transferBuffer->unmap();
return true;
}
bool GrD3DGpu::onWritePixels(GrSurface* surface, int left, int top, int width, int height,
GrColorType surfaceColorType, GrColorType srcColorType,
const GrMipLevel texels[], int mipLevelCount,
bool prepForTexSampling) {
GrD3DTexture* d3dTex = static_cast<GrD3DTexture*>(surface->asTexture());
if (!d3dTex) {
return false;
}
// Make sure we have at least the base level
if (!mipLevelCount || !texels[0].fPixels) {
return false;
}
SkASSERT(!GrDxgiFormatIsCompressed(d3dTex->dxgiFormat()));
bool success = false;
// Need to change the resource state to COPY_DEST in order to upload to it
d3dTex->setResourceState(this, D3D12_RESOURCE_STATE_COPY_DEST);
SkASSERT(mipLevelCount <= d3dTex->texturePriv().maxMipMapLevel() + 1);
success = this->uploadToTexture(d3dTex, left, top, width, height, srcColorType, texels,
mipLevelCount);
if (prepForTexSampling) {
d3dTex->setResourceState(this, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
}
return success;
}
bool GrD3DGpu::uploadToTexture(GrD3DTexture* tex, int left, int top, int width, int height,
GrColorType colorType, const GrMipLevel* texels, int mipLevelCount) {
SkASSERT(this->caps()->isFormatTexturable(tex->backendFormat()));
// The assumption is either that we have no mipmaps, or that our rect is the entire texture
SkASSERT(1 == mipLevelCount ||
(0 == left && 0 == top && width == tex->width() && height == tex->height()));
// We assume that if the texture has mip levels, we either upload to all the levels or just the
// first.
SkASSERT(1 == mipLevelCount || mipLevelCount == (tex->texturePriv().maxMipMapLevel() + 1));
if (width == 0 || height == 0) {
return false;
}
SkASSERT(this->d3dCaps().surfaceSupportsWritePixels(tex));
SkASSERT(this->d3dCaps().areColorTypeAndFormatCompatible(colorType, tex->backendFormat()));
ID3D12Resource* d3dResource = tex->d3dResource();
SkASSERT(d3dResource);
D3D12_RESOURCE_DESC desc = d3dResource->GetDesc();
// Either upload only the first miplevel or all miplevels
SkASSERT(1 == mipLevelCount || mipLevelCount == (int)desc.MipLevels);
if (1 == mipLevelCount && !texels[0].fPixels) {
return true; // no data to upload
}
for (int i = 0; i < mipLevelCount; ++i) {
// We do not allow any gaps in the mip data
if (!texels[i].fPixels) {
return false;
}
}
SkAutoTMalloc<D3D12_PLACED_SUBRESOURCE_FOOTPRINT> placedFootprints(mipLevelCount);
UINT64 combinedBufferSize;
// We reset the width and height in the description to match our subrectangle size
// so we don't end up allocating more space than we need.
desc.Width = width;
desc.Height = height;
fDevice->GetCopyableFootprints(&desc, 0, mipLevelCount, 0, placedFootprints.get(),
nullptr, nullptr, &combinedBufferSize);
size_t bpp = GrColorTypeBytesPerPixel(colorType);
SkASSERT(combinedBufferSize);
// TODO: do this until we have slices of buttery buffers
sk_sp<GrGpuBuffer> transferBuffer = this->createBuffer(combinedBufferSize,
GrGpuBufferType::kXferCpuToGpu,
kDynamic_GrAccessPattern);
if (!transferBuffer) {
return false;
}
char* bufferData = (char*)transferBuffer->map();
int currentWidth = width;
int currentHeight = height;
int layerHeight = tex->height();
for (int currentMipLevel = 0; currentMipLevel < mipLevelCount; currentMipLevel++) {
if (texels[currentMipLevel].fPixels) {
SkASSERT(1 == mipLevelCount || currentHeight == layerHeight);
const size_t trimRowBytes = currentWidth * bpp;
const size_t srcRowBytes = texels[currentMipLevel].fRowBytes;
char* dst = bufferData + placedFootprints[currentMipLevel].Offset;
// copy data into the buffer, skipping any trailing bytes
const char* src = (const char*)texels[currentMipLevel].fPixels;
SkRectMemcpy(dst, placedFootprints[currentMipLevel].Footprint.RowPitch,
src, srcRowBytes, trimRowBytes, currentHeight);
}
currentWidth = std::max(1, currentWidth / 2);
currentHeight = std::max(1, currentHeight / 2);
layerHeight = currentHeight;
}
transferBuffer->unmap();
GrD3DBuffer* d3dBuffer = static_cast<GrD3DBuffer*>(transferBuffer.get());
fCurrentDirectCommandList->copyBufferToTexture(d3dBuffer, tex, mipLevelCount,
placedFootprints.get(), left, top);
if (mipLevelCount < (int)desc.MipLevels) {
tex->texturePriv().markMipMapsDirty();
}
return true;
}
static bool check_resource_info(const GrD3DTextureResourceInfo& info) {
if (!info.fResource.get()) {
return false;
}
return true;
}
static bool check_tex_resource_info(const GrD3DCaps& caps, const GrD3DTextureResourceInfo& info) {
if (!caps.isFormatTexturable(info.fFormat)) {
return false;
}
return true;
}
static bool check_rt_resource_info(const GrD3DCaps& caps, const GrD3DTextureResourceInfo& info,
int sampleCnt) {
if (!caps.isFormatRenderable(info.fFormat, sampleCnt)) {
return false;
}
return true;
}
sk_sp<GrTexture> GrD3DGpu::onWrapBackendTexture(const GrBackendTexture& tex,
GrWrapOwnership,
GrWrapCacheable wrapType,
GrIOType ioType) {
GrD3DTextureResourceInfo textureInfo;
if (!tex.getD3DTextureResourceInfo(&textureInfo)) {
return nullptr;
}
if (!check_resource_info(textureInfo)) {
return nullptr;
}
if (!check_tex_resource_info(this->d3dCaps(), textureInfo)) {
return nullptr;
}
// TODO: support protected context
if (tex.isProtected()) {
return nullptr;
}
sk_sp<GrD3DResourceState> state = tex.getGrD3DResourceState();
SkASSERT(state);
return GrD3DTexture::MakeWrappedTexture(this, tex.dimensions(), wrapType, ioType, textureInfo,
std::move(state));
}
sk_sp<GrTexture> GrD3DGpu::onWrapCompressedBackendTexture(const GrBackendTexture& tex,
GrWrapOwnership,
GrWrapCacheable wrapType) {
GrD3DTextureResourceInfo textureInfo;
if (!tex.getD3DTextureResourceInfo(&textureInfo)) {
return nullptr;
}
if (!check_resource_info(textureInfo)) {
return nullptr;
}
if (!check_tex_resource_info(this->d3dCaps(), textureInfo)) {
return nullptr;
}
// TODO: support protected context
if (tex.isProtected()) {
return nullptr;
}
sk_sp<GrD3DResourceState> state = tex.getGrD3DResourceState();
SkASSERT(state);
return GrD3DTexture::MakeWrappedTexture(this, tex.dimensions(), wrapType, kRead_GrIOType,
textureInfo, std::move(state));
}
sk_sp<GrTexture> GrD3DGpu::onWrapRenderableBackendTexture(const GrBackendTexture& tex,
int sampleCnt,
GrWrapOwnership ownership,
GrWrapCacheable cacheable) {
GrD3DTextureResourceInfo textureInfo;
if (!tex.getD3DTextureResourceInfo(&textureInfo)) {
return nullptr;
}
if (!check_resource_info(textureInfo)) {
return nullptr;
}
if (!check_tex_resource_info(this->d3dCaps(), textureInfo)) {
return nullptr;
}
if (!check_rt_resource_info(this->d3dCaps(), textureInfo, sampleCnt)) {
return nullptr;
}
// TODO: support protected context
if (tex.isProtected()) {
return nullptr;
}
sampleCnt = this->d3dCaps().getRenderTargetSampleCount(sampleCnt, textureInfo.fFormat);
sk_sp<GrD3DResourceState> state = tex.getGrD3DResourceState();
SkASSERT(state);
return GrD3DTextureRenderTarget::MakeWrappedTextureRenderTarget(this, tex.dimensions(),
sampleCnt, cacheable,
textureInfo, std::move(state));
}
sk_sp<GrRenderTarget> GrD3DGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget& rt) {
// Currently the Direct3D backend does not support wrapping of msaa render targets directly. In
// general this is not an issue since swapchain images in D3D are never multisampled. Thus if
// you want a multisampled RT it is best to wrap the swapchain images and then let Skia handle
// creating and owning the MSAA images.
if (rt.sampleCnt() > 1) {
return nullptr;
}
GrD3DTextureResourceInfo info;
if (!rt.getD3DTextureResourceInfo(&info)) {
return nullptr;
}
if (!check_resource_info(info)) {
return nullptr;
}
if (!check_rt_resource_info(this->d3dCaps(), info, rt.sampleCnt())) {
return nullptr;
}
// TODO: support protected context
if (rt.isProtected()) {
return nullptr;
}
sk_sp<GrD3DResourceState> state = rt.getGrD3DResourceState();
sk_sp<GrD3DRenderTarget> tgt = GrD3DRenderTarget::MakeWrappedRenderTarget(
this, rt.dimensions(), 1, info, std::move(state));
// We don't allow the client to supply a premade stencil buffer. We always create one if needed.
SkASSERT(!rt.stencilBits());
if (tgt) {
SkASSERT(tgt->canAttemptStencilAttachment());
}
return std::move(tgt);
}
sk_sp<GrRenderTarget> GrD3DGpu::onWrapBackendTextureAsRenderTarget(const GrBackendTexture& tex,
int sampleCnt) {
GrD3DTextureResourceInfo textureInfo;
if (!tex.getD3DTextureResourceInfo(&textureInfo)) {
return nullptr;
}
if (!check_resource_info(textureInfo)) {
return nullptr;
}
if (!check_rt_resource_info(this->d3dCaps(), textureInfo, sampleCnt)) {
return nullptr;
}
// TODO: support protected context
if (tex.isProtected()) {
return nullptr;
}
sampleCnt = this->d3dCaps().getRenderTargetSampleCount(sampleCnt, textureInfo.fFormat);
if (!sampleCnt) {
return nullptr;
}
sk_sp<GrD3DResourceState> state = tex.getGrD3DResourceState();
SkASSERT(state);
return GrD3DRenderTarget::MakeWrappedRenderTarget(this, tex.dimensions(), sampleCnt,
textureInfo, std::move(state));
}
sk_sp<GrGpuBuffer> GrD3DGpu::onCreateBuffer(size_t sizeInBytes, GrGpuBufferType type,
GrAccessPattern accessPattern, const void* data) {
sk_sp<GrD3DBuffer> buffer = GrD3DBuffer::Make(this, sizeInBytes, type, accessPattern);
if (data && buffer) {
buffer->updateData(data, sizeInBytes);
}
return std::move(buffer);
}
GrStencilAttachment* GrD3DGpu::createStencilAttachmentForRenderTarget(
const GrRenderTarget* rt, int width, int height, int numStencilSamples) {
SkASSERT(numStencilSamples == rt->numSamples() || this->caps()->mixedSamplesSupport());
SkASSERT(width >= rt->width());
SkASSERT(height >= rt->height());
const GrD3DCaps::StencilFormat& sFmt = this->d3dCaps().preferredStencilFormat();
GrD3DStencilAttachment* stencil(GrD3DStencilAttachment::Make(this,
width,
height,
numStencilSamples,
sFmt));
fStats.incStencilAttachmentCreates();
return stencil;
}
bool GrD3DGpu::createTextureResourceForBackendSurface(DXGI_FORMAT dxgiFormat,
SkISize dimensions,
GrTexturable texturable,
GrRenderable renderable,
GrMipMapped mipMapped,
GrD3DTextureResourceInfo* info,
GrProtected isProtected) {
SkASSERT(texturable == GrTexturable::kYes || renderable == GrRenderable::kYes);
if (this->protectedContext() != (isProtected == GrProtected::kYes)) {
return false;
}
if (texturable == GrTexturable::kYes && !this->d3dCaps().isFormatTexturable(dxgiFormat)) {
return false;
}
if (renderable == GrRenderable::kYes && !this->d3dCaps().isFormatRenderable(dxgiFormat, 1)) {
return false;
}
int numMipLevels = 1;
if (mipMapped == GrMipMapped::kYes) {
numMipLevels = SkMipMap::ComputeLevelCount(dimensions.width(), dimensions.height()) + 1;
}
// create the texture
D3D12_RESOURCE_FLAGS usageFlags = D3D12_RESOURCE_FLAG_NONE;
if (renderable == GrRenderable::kYes) {
usageFlags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
}
D3D12_RESOURCE_DESC resourceDesc = {};
resourceDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
resourceDesc.Alignment = 0; // use default alignment
resourceDesc.Width = dimensions.fWidth;
resourceDesc.Height = dimensions.fHeight;
resourceDesc.DepthOrArraySize = 1;
resourceDesc.MipLevels = numMipLevels;
resourceDesc.Format = dxgiFormat;
resourceDesc.SampleDesc.Count = 1;
// quality levels are only supported for tiled resources so ignore for now
resourceDesc.SampleDesc.Quality = GrD3DTextureResource::kDefaultQualityLevel;
resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; // use driver-selected swizzle
resourceDesc.Flags = usageFlags;
D3D12_CLEAR_VALUE* clearValuePtr = nullptr;
D3D12_CLEAR_VALUE clearValue = {};
if (renderable == GrRenderable::kYes) {
clearValue.Format = dxgiFormat;
// Assume transparent black
clearValue.Color[0] = 0;
clearValue.Color[1] = 0;
clearValue.Color[2] = 0;
clearValue.Color[3] = 0;
clearValuePtr = &clearValue;
}
D3D12_RESOURCE_STATES initialState = (renderable == GrRenderable::kYes)
? D3D12_RESOURCE_STATE_RENDER_TARGET
: D3D12_RESOURCE_STATE_COPY_DEST;
if (!GrD3DTextureResource::InitTextureResourceInfo(this, resourceDesc, initialState,
isProtected, clearValuePtr, info)) {
SkDebugf("Failed to init texture resource info\n");
return false;
}
return true;
}
GrBackendTexture GrD3DGpu::onCreateBackendTexture(SkISize dimensions,
const GrBackendFormat& format,
GrRenderable renderable,
GrMipMapped mipMapped,
GrProtected isProtected) {
this->handleDirtyContext();
const GrD3DCaps& caps = this->d3dCaps();
if (this->protectedContext() != (isProtected == GrProtected::kYes)) {
return {};
}
DXGI_FORMAT dxgiFormat;
if (!format.asDxgiFormat(&dxgiFormat)) {
return {};
}
// TODO: move the texturability check up to GrGpu::createBackendTexture and just assert here
if (!caps.isFormatTexturable(dxgiFormat)) {
return {};
}
GrD3DTextureResourceInfo info;
if (!this->createTextureResourceForBackendSurface(dxgiFormat, dimensions, GrTexturable::kYes,
renderable, mipMapped,
&info, isProtected)) {
return {};
}
return GrBackendTexture(dimensions.width(), dimensions.height(), info);
}
bool copy_src_data(GrD3DGpu* gpu, char* mapPtr, DXGI_FORMAT dxgiFormat,
D3D12_PLACED_SUBRESOURCE_FOOTPRINT* placedFootprints,
const SkPixmap srcData[], int numMipLevels) {
SkASSERT(srcData && numMipLevels);
SkASSERT(!GrDxgiFormatIsCompressed(dxgiFormat));
SkASSERT(mapPtr);
size_t bytesPerPixel = gpu->d3dCaps().bytesPerPixel(dxgiFormat);
for (int currentMipLevel = 0; currentMipLevel < numMipLevels; currentMipLevel++) {
const size_t trimRowBytes = srcData[currentMipLevel].width() * bytesPerPixel;
// copy data into the buffer, skipping any trailing bytes
char* dst = mapPtr + placedFootprints[currentMipLevel].Offset;
SkRectMemcpy(dst, placedFootprints[currentMipLevel].Footprint.RowPitch,
srcData[currentMipLevel].addr(), srcData[currentMipLevel].rowBytes(),
trimRowBytes, srcData[currentMipLevel].height());
}
return true;
}
bool copy_color_data(const GrD3DCaps& caps, char* mapPtr, DXGI_FORMAT dxgiFormat,
SkISize dimensions, D3D12_PLACED_SUBRESOURCE_FOOTPRINT* placedFootprints,
SkColor4f color) {
auto colorType = caps.getFormatColorType(dxgiFormat);
if (colorType == GrColorType::kUnknown) {
return false;
}
GrImageInfo ii(colorType, kUnpremul_SkAlphaType, nullptr, dimensions);
if (!GrClearImage(ii, mapPtr, placedFootprints[0].Footprint.RowPitch, color)) {
return false;
}
return true;
}
bool GrD3DGpu::onUpdateBackendTexture(const GrBackendTexture& backendTexture,
sk_sp<GrRefCntedCallback> finishedCallback,
const BackendTextureData* data) {
GrD3DTextureResourceInfo info;
SkAssertResult(backendTexture.getD3DTextureResourceInfo(&info));
sk_sp<GrD3DResourceState> state = backendTexture.getGrD3DResourceState();
SkASSERT(state);
sk_sp<GrD3DTexture> texture =
GrD3DTexture::MakeWrappedTexture(this, backendTexture.dimensions(),
GrWrapCacheable::kNo,
kRW_GrIOType, info, std::move(state));
if (!texture) {
return false;
}
GrD3DDirectCommandList* cmdList = this->currentCommandList();
if (!cmdList) {
return false;
}
texture->setResourceState(this, D3D12_RESOURCE_STATE_COPY_DEST);
ID3D12Resource* d3dResource = texture->d3dResource();
SkASSERT(d3dResource);
D3D12_RESOURCE_DESC desc = d3dResource->GetDesc();
unsigned int mipLevelCount = 1;
if (backendTexture.fMipMapped == GrMipMapped::kYes) {
mipLevelCount = SkMipMap::ComputeLevelCount(backendTexture.dimensions().width(),
backendTexture.dimensions().height()) + 1;
}
SkASSERT(mipLevelCount == info.fLevelCount);
SkAutoTMalloc<D3D12_PLACED_SUBRESOURCE_FOOTPRINT> placedFootprints(mipLevelCount);
UINT64 combinedBufferSize;
fDevice->GetCopyableFootprints(&desc, 0, mipLevelCount, 0, placedFootprints.get(),
nullptr, nullptr, &combinedBufferSize);
SkASSERT(combinedBufferSize);
if (data->type() == BackendTextureData::Type::kColor &&
!GrDxgiFormatIsCompressed(info.fFormat) && mipLevelCount > 1) {
// For a single uncompressed color, we reuse the same top-level buffer area for all levels.
combinedBufferSize =
placedFootprints[0].Footprint.RowPitch * placedFootprints[0].Footprint.Height;
for (unsigned int i = 1; i < mipLevelCount; ++i) {
placedFootprints[i].Offset = 0;
placedFootprints[i].Footprint.RowPitch = placedFootprints[0].Footprint.RowPitch;
}
}
// TODO: do this until we have slices of buttery buffers
sk_sp<GrGpuBuffer> transferBuffer = this->createBuffer(combinedBufferSize,
GrGpuBufferType::kXferCpuToGpu,
kDynamic_GrAccessPattern);
if (!transferBuffer) {
return false;
}
char* bufferData = (char*)transferBuffer->map();
SkASSERT(bufferData);
bool result;
if (data->type() == BackendTextureData::Type::kPixmaps) {
result = copy_src_data(this, bufferData, info.fFormat, placedFootprints.get(),
data->pixmaps(), info.fLevelCount);
} else if (data->type() == BackendTextureData::Type::kCompressed) {
memcpy(bufferData, data->compressedData(), data->compressedSize());
result = true;
} else {
SkASSERT(data->type() == BackendTextureData::Type::kColor);
SkImage::CompressionType compression =
GrBackendFormatToCompressionType(backendTexture.getBackendFormat());
if (SkImage::CompressionType::kNone == compression) {
result = copy_color_data(this->d3dCaps(), bufferData, info.fFormat,
backendTexture.dimensions(),
placedFootprints, data->color());
} else {
GrFillInCompressedData(compression, backendTexture.dimensions(),
backendTexture.fMipMapped, bufferData, data->color());
result = true;
}
}
transferBuffer->unmap();
GrD3DBuffer* d3dBuffer = static_cast<GrD3DBuffer*>(transferBuffer.get());
cmdList->copyBufferToTexture(d3dBuffer, texture.get(), mipLevelCount, placedFootprints.get(),
0, 0);
if (finishedCallback) {
this->addFinishedCallback(std::move(finishedCallback));
}
return true;
}
GrBackendTexture GrD3DGpu::onCreateCompressedBackendTexture(
SkISize dimensions, const GrBackendFormat& format, GrMipMapped mipMapped,
GrProtected isProtected, sk_sp<GrRefCntedCallback> finishedCallback,
const BackendTextureData* data) {
this->handleDirtyContext();
const GrD3DCaps& caps = this->d3dCaps();
if (this->protectedContext() != (isProtected == GrProtected::kYes)) {
return {};
}
DXGI_FORMAT dxgiFormat;
if (!format.asDxgiFormat(&dxgiFormat)) {
return {};
}
// TODO: move the texturability check up to GrGpu::createBackendTexture and just assert here
if (!caps.isFormatTexturable(dxgiFormat)) {
return {};
}
GrD3DTextureResourceInfo info;
if (!this->createTextureResourceForBackendSurface(dxgiFormat, dimensions, GrTexturable::kYes,
GrRenderable::kNo, mipMapped,
&info, isProtected)) {
return {};
}
return GrBackendTexture(dimensions.width(), dimensions.height(), info);
}
void GrD3DGpu::deleteBackendTexture(const GrBackendTexture& tex) {
SkASSERT(GrBackendApi::kDirect3D == tex.fBackend);
// Nothing to do here, will get cleaned up when the GrBackendTexture object goes away
}
bool GrD3DGpu::compile(const GrProgramDesc&, const GrProgramInfo&) {
return false;
}
#if GR_TEST_UTILS
bool GrD3DGpu::isTestingOnlyBackendTexture(const GrBackendTexture& tex) const {
SkASSERT(GrBackendApi::kDirect3D == tex.backend());
GrD3DTextureResourceInfo info;
if (!tex.getD3DTextureResourceInfo(&info)) {
return false;
}
ID3D12Resource* textureResource = info.fResource.get();
if (!textureResource) {
return false;
}
return !(textureResource->GetDesc().Flags & D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE);
}
GrBackendRenderTarget GrD3DGpu::createTestingOnlyBackendRenderTarget(int w, int h,
GrColorType colorType) {
this->handleDirtyContext();
if (w > this->caps()->maxRenderTargetSize() || h > this->caps()->maxRenderTargetSize()) {
return {};
}
DXGI_FORMAT dxgiFormat = this->d3dCaps().getFormatFromColorType(colorType);
GrD3DTextureResourceInfo info;
if (!this->createTextureResourceForBackendSurface(dxgiFormat, { w, h }, GrTexturable::kNo,
GrRenderable::kYes, GrMipMapped::kNo,
&info, GrProtected::kNo)) {
return {};
}
return GrBackendRenderTarget(w, h, 1, info);
}
void GrD3DGpu::deleteTestingOnlyBackendRenderTarget(const GrBackendRenderTarget& rt) {
SkASSERT(GrBackendApi::kDirect3D == rt.backend());
GrD3DTextureResourceInfo info;
if (rt.getD3DTextureResourceInfo(&info)) {
this->testingOnly_flushGpuAndSync();
// Nothing else to do here, will get cleaned up when the GrBackendRenderTarget
// is deleted.
}
}
void GrD3DGpu::testingOnly_flushGpuAndSync() {
SkAssertResult(this->submitDirectCommandList(SyncQueue::kForce));
}
void GrD3DGpu::testingOnly_startCapture() {
if (fGraphicsAnalysis) {
fGraphicsAnalysis->BeginCapture();
}
}
void GrD3DGpu::testingOnly_endCapture() {
if (fGraphicsAnalysis) {
fGraphicsAnalysis->EndCapture();
}
}
#endif
///////////////////////////////////////////////////////////////////////////////
void GrD3DGpu::addResourceBarriers(sk_sp<GrManagedResource> resource,
int numBarriers,
D3D12_RESOURCE_TRANSITION_BARRIER* barriers) const {
SkASSERT(fCurrentDirectCommandList);
SkASSERT(resource);
fCurrentDirectCommandList->resourceBarrier(std::move(resource), numBarriers, barriers);
}
void GrD3DGpu::prepareSurfacesForBackendAccessAndStateUpdates(
GrSurfaceProxy* proxies[],
int numProxies,
SkSurface::BackendSurfaceAccess access,
const GrBackendSurfaceMutableState* newState) {
SkASSERT(numProxies >= 0);
SkASSERT(!numProxies || proxies);
// prepare proxies by transitioning to PRESENT renderState
if (numProxies && access == SkSurface::BackendSurfaceAccess::kPresent) {
GrD3DTextureResource* resource;
for (int i = 0; i < numProxies; ++i) {
SkASSERT(proxies[i]->isInstantiated());
if (GrTexture* tex = proxies[i]->peekTexture()) {
resource = static_cast<GrD3DTexture*>(tex);
} else {
GrRenderTarget* rt = proxies[i]->peekRenderTarget();
SkASSERT(rt);
resource = static_cast<GrD3DRenderTarget*>(rt);
}
resource->prepareForPresent(this);
}
}
}
bool GrD3DGpu::onSubmitToGpu(bool syncCpu) {
if (syncCpu) {
return this->submitDirectCommandList(SyncQueue::kForce);
} else {
return this->submitDirectCommandList(SyncQueue::kSkip);
}
}
std::unique_ptr<GrSemaphore> SK_WARN_UNUSED_RESULT GrD3DGpu::makeSemaphore(bool) {
return GrD3DSemaphore::Make(this);
}
std::unique_ptr<GrSemaphore> GrD3DGpu::wrapBackendSemaphore(
const GrBackendSemaphore& semaphore,
GrResourceProvider::SemaphoreWrapType,
GrWrapOwnership) {
SkASSERT(this->caps()->semaphoreSupport());
GrD3DFenceInfo fenceInfo;
if (!semaphore.getD3DFenceInfo(&fenceInfo)) {
return nullptr;
}
return GrD3DSemaphore::MakeWrapped(fenceInfo);
}
void GrD3DGpu::insertSemaphore(GrSemaphore* semaphore) {
GrD3DSemaphore* d3dSem = static_cast<GrD3DSemaphore*>(semaphore);
// TODO: Do we need to track the lifetime of this? How do we know it's done?
fQueue->Signal(d3dSem->fence(), d3dSem->value());
}
void GrD3DGpu::waitSemaphore(GrSemaphore* semaphore) {
GrD3DSemaphore* d3dSem = static_cast<GrD3DSemaphore*>(semaphore);
// TODO: Do we need to track the lifetime of this?
fQueue->Wait(d3dSem->fence(), d3dSem->value());
}
GrFence SK_WARN_UNUSED_RESULT GrD3DGpu::insertFence() {
SkDEBUGCODE(HRESULT hr = ) fQueue->Signal(fFence.get(), ++fCurrentFenceValue);
return fCurrentFenceValue;
}
bool GrD3DGpu::waitFence(GrFence fence) {
if (fFence->GetCompletedValue() < fence) {
HANDLE fenceEvent;
fenceEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
SkASSERT(fenceEvent);
SkDEBUGCODE(HRESULT hr = ) fFence->SetEventOnCompletion(fence, fenceEvent);
SkASSERT(SUCCEEDED(hr));
WaitForSingleObject(fenceEvent, INFINITE);
CloseHandle(fenceEvent);
}
return true;
}