ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

VideoBackends/D3D12: Include HRESULT in error messages

This commit is contained in:
Pokechu22 2021-12-12 13:18:39 -08:00
parent 23cdb5c576
commit 1b32e6dae2
11 changed files with 77 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Source/Core/VideoBackends/D3D12/D3D12BoundingBox.cpp
View File

@ -42,7 +42,7 @@ std::vector<BBoxType> D3D12BoundingBox::Read(u32 index, u32 length)
static constexpr D3D12_RANGE read_range = {0, BUFFER_SIZE};
void* mapped_pointer;
HRESULT hr = m_readback_buffer->Map(0, &read_range, &mapped_pointer);
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Map bounding box CPU buffer failed");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Map bounding box CPU buffer failed: {}", DX12HRWrap(hr));
if (FAILED(hr))
return values;
@ -103,7 +103,7 @@ bool D3D12BoundingBox::CreateBuffers()
HRESULT hr = g_dx_context->GetDevice()->CreateCommittedResource(
&gpu_heap_properties, D3D12_HEAP_FLAG_NONE, &buffer_desc,
D3D12_RESOURCE_STATE_UNORDERED_ACCESS, nullptr, IID_PPV_ARGS(&m_gpu_buffer));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Creating bounding box GPU buffer failed");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Creating bounding box GPU buffer failed: {}", DX12HRWrap(hr));
if (FAILED(hr) || !g_dx_context->GetDescriptorHeapManager().Allocate(&m_gpu_descriptor))
return false;
@ -116,7 +116,7 @@ bool D3D12BoundingBox::CreateBuffers()
hr = g_dx_context->GetDevice()->CreateCommittedResource(
&cpu_heap_properties, D3D12_HEAP_FLAG_NONE, &buffer_desc, D3D12_RESOURCE_STATE_COPY_DEST,
nullptr, IID_PPV_ARGS(&m_readback_buffer));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Creating bounding box CPU buffer failed");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Creating bounding box CPU buffer failed: {}", DX12HRWrap(hr));
if (FAILED(hr))
return false;

6
Source/Core/VideoBackends/D3D12/D3D12PerfQuery.cpp
View File

@ -23,7 +23,7 @@ bool PerfQuery::Initialize()
{
constexpr D3D12_QUERY_HEAP_DESC desc = {D3D12_QUERY_HEAP_TYPE_OCCLUSION, PERF_QUERY_BUFFER_SIZE};
HRESULT hr = g_dx_context->GetDevice()->CreateQueryHeap(&desc, IID_PPV_ARGS(&m_query_heap));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create query heap");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create query heap: {}", DX12HRWrap(hr));
if (FAILED(hr))
return false;
@ -41,7 +41,7 @@ bool PerfQuery::Initialize()
hr = g_dx_context->GetDevice()->CreateCommittedResource(
&heap_properties, D3D12_HEAP_FLAG_NONE, &resource_desc, D3D12_RESOURCE_STATE_COPY_DEST,
nullptr, IID_PPV_ARGS(&m_query_readback_buffer));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create query buffer");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create query buffer: {}", DX12HRWrap(hr));
if (FAILED(hr))
return false;
@ -221,7 +221,7 @@ void PerfQuery::AccumulateQueriesFromBuffer(u32 query_count)
(m_query_readback_pos + query_count) * sizeof(PerfQueryDataType)};
u8* mapped_ptr;
HRESULT hr = m_query_readback_buffer->Map(0, &read_range, reinterpret_cast<void**>(&mapped_ptr));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to map query readback buffer");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to map query readback buffer: {}", DX12HRWrap(hr));
if (FAILED(hr))
return;

5
Source/Core/VideoBackends/D3D12/D3D12StreamBuffer.cpp
View File

@ -46,13 +46,14 @@ bool StreamBuffer::AllocateBuffer(u32 size)
HRESULT hr = g_dx_context->GetDevice()->CreateCommittedResource(
&heap_properties, D3D12_HEAP_FLAG_NONE, &resource_desc, D3D12_RESOURCE_STATE_GENERIC_READ,
nullptr, IID_PPV_ARGS(&m_buffer));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to allocate buffer of size {}", size);
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to allocate buffer of size {}: {}", size,
DX12HRWrap(hr));
if (FAILED(hr))
return false;
static const D3D12_RANGE read_range = {};
hr = m_buffer->Map(0, &read_range, reinterpret_cast<void**>(&m_host_pointer));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to map buffer of size {}", size);
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to map buffer of size {}: {}", size, DX12HRWrap(hr));
if (FAILED(hr))
return false;

2
Source/Core/VideoBackends/D3D12/D3D12SwapChain.cpp
View File

@ -34,7 +34,7 @@ bool SwapChain::CreateSwapChainBuffers()
{
ComPtr<ID3D12Resource> resource;
HRESULT hr = m_swap_chain->GetBuffer(i, IID_PPV_ARGS(&resource));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to get swap chain buffer {}", i);
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to get swap chain buffer {}: {}", i, DX12HRWrap(hr));
BufferResources buffer;
buffer.texture = DXTexture::CreateAdopted(resource.Get());

29
Source/Core/VideoBackends/D3D12/DX12Context.cpp
View File

@ -152,7 +152,7 @@ bool DXContext::CreateDevice(u32 adapter_index, bool enable_debug_layer)
HRESULT hr = m_dxgi_factory->EnumAdapters(adapter_index, &adapter);
if (FAILED(hr))
{
ERROR_LOG_FMT(VIDEO, "Adapter {} not found, using default", adapter_index);
ERROR_LOG_FMT(VIDEO, "Adapter {} not found, using default: {}", adapter_index, DX12HRWrap(hr));
adapter = nullptr;
}
@ -166,14 +166,14 @@ bool DXContext::CreateDevice(u32 adapter_index, bool enable_debug_layer)
}
else
{
ERROR_LOG_FMT(VIDEO, "Debug layer requested but not available.");
ERROR_LOG_FMT(VIDEO, "Debug layer requested but not available: {}", DX12HRWrap(hr));
enable_debug_layer = false;
}
}
// Create the actual device.
hr = s_d3d12_create_device(adapter.Get(), D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&m_device));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create D3D12 device");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create D3D12 device: {}", DX12HRWrap(hr));
if (FAILED(hr))
return false;
@ -208,7 +208,7 @@ bool DXContext::CreateCommandQueue()
D3D12_COMMAND_QUEUE_PRIORITY_NORMAL,
D3D12_COMMAND_QUEUE_FLAG_NONE};
HRESULT hr = m_device->CreateCommandQueue(&queue_desc, IID_PPV_ARGS(&m_command_queue));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create command queue");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create command queue: {}", DX12HRWrap(hr));
return SUCCEEDED(hr);
}
@ -216,7 +216,7 @@ bool DXContext::CreateFence()
{
HRESULT hr =
m_device->CreateFence(m_completed_fence_value, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&m_fence));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create fence");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create fence: {}", DX12HRWrap(hr));
if (FAILED(hr))
return false;
@ -303,14 +303,15 @@ static bool BuildRootSignature(ID3D12Device* device, ID3D12RootSignature** sig_p
&root_signature_blob, &root_signature_error_blob);
if (FAILED(hr))
{
PanicAlertFmt("Failed to serialize root signature: {}",
static_cast<const char*>(root_signature_error_blob->GetBufferPointer()));
PanicAlertFmt("Failed to serialize root signature: {}\n{}",
static_cast<const char*>(root_signature_error_blob->GetBufferPointer()),
DX12HRWrap(hr));
return false;
}
hr = device->CreateRootSignature(0, root_signature_blob->GetBufferPointer(),
root_signature_blob->GetBufferSize(), IID_PPV_ARGS(sig_ptr));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create root signature");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create root signature: {}", DX12HRWrap(hr));
return true;
}
@ -417,13 +418,13 @@ bool DXContext::CreateCommandLists()
CommandListResources& res = m_command_lists[i];
HRESULT hr = m_device->CreateCommandAllocator(
D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(res.command_allocator.GetAddressOf()));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create command allocator");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create command allocator: {}", DX12HRWrap(hr));
if (FAILED(hr))
return false;
hr = m_device->CreateCommandList(1, D3D12_COMMAND_LIST_TYPE_DIRECT, res.command_allocator.Get(),
nullptr, IID_PPV_ARGS(res.command_list.GetAddressOf()));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create command list");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create command list: {}", DX12HRWrap(hr));
if (FAILED(hr))
{
return false;
@ -431,7 +432,7 @@ bool DXContext::CreateCommandLists()
// Close the command list, since the first thing we do is reset them.
hr = res.command_list->Close();
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Closing new command list failed");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Closing new command list failed: {}", DX12HRWrap(hr));
if (FAILED(hr))
return false;
@ -473,7 +474,7 @@ void DXContext::ExecuteCommandList(bool wait_for_completion)
// Close and queue command list.
HRESULT hr = res.command_list->Close();
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to close command list");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to close command list: {}", DX12HRWrap(hr));
const std::array<ID3D12CommandList*, 1> execute_lists{res.command_list.Get()};
m_command_queue->ExecuteCommandLists(static_cast<UINT>(execute_lists.size()),
execute_lists.data());
@ -481,7 +482,7 @@ void DXContext::ExecuteCommandList(bool wait_for_completion)
// Update fence when GPU has completed.
hr = m_command_queue->Signal(m_fence.Get(), m_current_fence_value);
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to signal fence");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to signal fence: {}", DX12HRWrap(hr));
MoveToNextCommandList();
if (wait_for_completion)
@ -534,7 +535,7 @@ void DXContext::WaitForFence(u64 fence)
{
// Fall back to event.
HRESULT hr = m_fence->SetEventOnCompletion(fence, m_fence_event);
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to set fence event on completion");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to set fence event on completion: {}", DX12HRWrap(hr));
WaitForSingleObject(m_fence_event, INFINITE);
m_completed_fence_value = m_fence->GetCompletedValue();
}

32
Source/Core/VideoBackends/D3D12/DX12Context.h
View File

@ -7,6 +7,8 @@
#include <memory>
#include "Common/CommonTypes.h"
#include "Common/HRWrap.h"
#include "VideoBackends/D3D12/Common.h"
#include "VideoBackends/D3D12/D3D12StreamBuffer.h"
#include "VideoBackends/D3D12/DescriptorAllocator.h"
@ -187,4 +189,34 @@ private:
extern std::unique_ptr<DXContext> g_dx_context;
// Wrapper for HRESULT to be used with fmt. Note that we can't create a fmt::formatter directly
// for HRESULT as HRESULT is simply a typedef on long and not a distinct type.
// Unlike the version in Common, this variant also knows to call GetDeviceRemovedReason if needed.
struct DX12HRWrap
{
constexpr explicit DX12HRWrap(HRESULT hr) : m_hr(hr) {}
const HRESULT m_hr;
};
} // namespace DX12
template <>
struct fmt::formatter<DX12::DX12HRWrap>
{
constexpr auto parse(fmt::format_parse_context& ctx) { return ctx.begin(); }
template <typename FormatContext>
auto format(const DX12::DX12HRWrap& hr, FormatContext& ctx)
{
if (hr.m_hr == DXGI_ERROR_DEVICE_REMOVED && DX12::g_dx_context != nullptr &&
DX12::g_dx_context->GetDevice() != nullptr)
{
return fmt::format_to(
ctx.out(), "{}\nDevice removal reason: {}", Common::HRWrap(hr.m_hr),
Common::HRWrap(DX12::g_dx_context->GetDevice()->GetDeviceRemovedReason()));
}
else
{
return fmt::format_to(ctx.out(), "{}", Common::HRWrap(hr.m_hr));
}
}
};

6
Source/Core/VideoBackends/D3D12/DX12Pipeline.cpp
View File

@ -210,8 +210,8 @@ std::unique_ptr<DXPipeline> DXPipeline::Create(const AbstractPipelineConfig& con
HRESULT hr = g_dx_context->GetDevice()->CreateGraphicsPipelineState(&desc, IID_PPV_ARGS(&pso));
if (FAILED(hr))
{
WARN_LOG_FMT(VIDEO, "CreateGraphicsPipelineState() {}failed with HRESULT {:08X}",
cache_data ? "with cache data " : "", hr);
WARN_LOG_FMT(VIDEO, "CreateGraphicsPipelineState() {}failed: {}",
cache_data ? "with cache data " : "", DX12HRWrap(hr));
return nullptr;
}
@ -227,7 +227,7 @@ AbstractPipeline::CacheData DXPipeline::GetCacheData() const
HRESULT hr = m_pipeline->GetCachedBlob(&blob);
if (FAILED(hr))
{
WARN_LOG_FMT(VIDEO, "ID3D12Pipeline::GetCachedBlob() failed with HRESULT {:08X}", hr);
WARN_LOG_FMT(VIDEO, "ID3D12Pipeline::GetCachedBlob() failed: {}", DX12HRWrap(hr));
return {};
}

2
Source/Core/VideoBackends/D3D12/DX12Shader.cpp
View File

@ -52,7 +52,7 @@ bool DXShader::CreateComputePipeline()
HRESULT hr = g_dx_context->GetDevice()->CreateComputePipelineState(
&desc, IID_PPV_ARGS(&m_compute_pipeline));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Creating compute pipeline failed");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Creating compute pipeline failed: {}", DX12HRWrap(hr));
if (m_compute_pipeline && !m_name.empty())
m_compute_pipeline->SetName(m_name.c_str());

18
Source/Core/VideoBackends/D3D12/DX12Texture.cpp
View File

@ -39,7 +39,7 @@ static ComPtr<ID3D12Resource> CreateTextureUploadBuffer(u32 buffer_size)
HRESULT hr = g_dx_context->GetDevice()->CreateCommittedResource(
&heap_properties, D3D12_HEAP_FLAG_NONE, &desc, D3D12_RESOURCE_STATE_GENERIC_READ, nullptr,
IID_PPV_ARGS(&resource));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create texture upload buffer");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create texture upload buffer: {}", DX12HRWrap(hr));
return resource;
}
@ -116,7 +116,7 @@ std::unique_ptr<DXTexture> DXTexture::Create(const TextureConfig& config, std::s
HRESULT hr = g_dx_context->GetDevice()->CreateCommittedResource(
&heap_properties, D3D12_HEAP_FLAG_NONE, &resource_desc, resource_state,
config.IsRenderTarget() ? &optimized_clear_value : nullptr, IID_PPV_ARGS(&resource));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create D3D12 texture resource");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create D3D12 texture resource: {}", DX12HRWrap(hr));
if (FAILED(hr))
return nullptr;
@ -230,9 +230,15 @@ void DXTexture::Load(u32 level, u32 width, u32 height, u32 row_length, const u8*
{
const D3D12_RANGE read_range = {0, 0};
staging_buffer = CreateTextureUploadBuffer(upload_size);
if (!staging_buffer || FAILED(staging_buffer->Map(0, &read_range, &upload_buffer_ptr)))
if (!staging_buffer)
{
PanicAlertFmt("Failed to allocate/map temporary texture upload buffer");
PanicAlertFmt("Failed to allocate temporary texture upload buffer");
return;
}
HRESULT hr = staging_buffer->Map(0, &read_range, &upload_buffer_ptr);
if (FAILED(hr))
{
PanicAlertFmt("Failed to map temporary texture upload buffer: {}", DX12HRWrap(hr));
return;
}
@ -598,7 +604,7 @@ bool DXStagingTexture::Map()
const D3D12_RANGE read_range = {0u, m_type == StagingTextureType::Upload ? 0u : m_buffer_size};
HRESULT hr = m_resource->Map(0, &read_range, reinterpret_cast<void**>(&m_map_pointer));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Map resource failed");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Map resource failed: {}", DX12HRWrap(hr));
if (FAILED(hr))
return false;
@ -663,7 +669,7 @@ std::unique_ptr<DXStagingTexture> DXStagingTexture::Create(StagingTextureType ty
&heap_properties, D3D12_HEAP_FLAG_NONE, &desc,
is_upload ? D3D12_RESOURCE_STATE_GENERIC_READ : D3D12_RESOURCE_STATE_COPY_DEST, nullptr,
IID_PPV_ARGS(&resource));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create staging texture resource");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create staging texture resource: {}", DX12HRWrap(hr));
if (FAILED(hr))
return nullptr;

3
Source/Core/VideoBackends/D3D12/DescriptorAllocator.cpp
View File

@ -18,7 +18,8 @@ bool DescriptorAllocator::Create(ID3D12Device* device, D3D12_DESCRIPTOR_HEAP_TYP
const D3D12_DESCRIPTOR_HEAP_DESC desc = {type, static_cast<UINT>(num_descriptors),
D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE};
HRESULT hr = device->CreateDescriptorHeap(&desc, IID_PPV_ARGS(&m_descriptor_heap));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Creating descriptor heap for linear allocator failed");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Creating descriptor heap for linear allocator failed: {}",
DX12HRWrap(hr));
if (FAILED(hr))
return false;

4
Source/Core/VideoBackends/D3D12/DescriptorHeapManager.cpp
View File

@ -20,7 +20,7 @@ bool DescriptorHeapManager::Create(ID3D12Device* device, D3D12_DESCRIPTOR_HEAP_T
D3D12_DESCRIPTOR_HEAP_FLAG_NONE};
HRESULT hr = device->CreateDescriptorHeap(&desc, IID_PPV_ARGS(&m_descriptor_heap));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create descriptor heap");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create descriptor heap: {}", DX12HRWrap(hr));
if (FAILED(hr))
return false;
@ -176,7 +176,7 @@ bool SamplerHeapManager::Create(ID3D12Device* device, u32 num_descriptors)
{
const D3D12_DESCRIPTOR_HEAP_DESC desc = {D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, num_descriptors};
HRESULT hr = device->CreateDescriptorHeap(&desc, IID_PPV_ARGS(&m_descriptor_heap));
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create sampler descriptor heap");
ASSERT_MSG(VIDEO, SUCCEEDED(hr), "Failed to create sampler descriptor heap: {}", DX12HRWrap(hr));
if (FAILED(hr))
return false;