jp9000
/
obs-studio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
obs-studio/libobs-d3d11/d3d11-rebuild.cpp

583 lines
15 KiB
C++
Raw Normal View History

libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
/******************************************************************************
Copyright (C) 2016 by Hugh Bailey <obs.jim@gmail.com>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
#include "d3d11-subsystem.hpp"
libobs-d3d11: Don't inline rebuild funcs Inlining these functions is pretty pointless.
2019-02-17 17:22:04 -08:00
void gs_vertex_buffer::Rebuild()
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
{
uvBuffers.clear();
uvSizes.clear();
BuildBuffers();
}
libobs-d3d11: Don't inline rebuild funcs Inlining these functions is pretty pointless.
2019-02-17 17:22:04 -08:00
void gs_index_buffer::Rebuild(ID3D11Device *dev)
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
{
HRESULT hr = dev->CreateBuffer(&bd, &srd, &indexBuffer);
if (FAILED(hr))
throw HRError("Failed to create buffer", hr);
}
libobs-d3d11: Don't crash if unable to rebuild shared texture When rebuilding the graphics subsystem, it's possible a shared texture may no longer be available. In this case, just soft fail and allow the texture to be rebuilt rather than crash the entire program over it.
2016-12-21 15:53:14 -08:00
void gs_texture_2d::RebuildSharedTextureFallback()
{
libobs: Add dormant SRGB format support GS_RGBA, GS_BGRX, and GS_BGRA now use TYPELESS DXGI formats, so we can alias them between UNORM and UNORM_SRGB as necessary. GS_RGBA_UNORM, GS_BGRX_UNORM, and GS_BGRA_UNORM have been added to support straight UNORM types, which Windows requires for sharing textures from D3D9 and OpenGL. The D3D path aliases via views, and GL aliases via GL_EXT_texture_sRGB_decode/GL_FRAMEBUFFER_SRGB. A significant amount of code has changed in the D3D/GL backends, but the concepts are simple. On the D3D side, we need separate SRVs and RTVs to support nonlinear/linear reads and writes. On the GL side, we need to set the proper GL parameters to emulate the same. Add gs_enable_framebuffer_srgb/gs_framebuffer_srgb_enabled to set/get the framebuffer as SRGB or not. Add gs_linear_srgb_active/gs_set_linear_srgb to instruct sources that they should render as SRGB. Legacy sources can ignore this setting without regression. Update obs_source_draw to use linear SRGB as needed. Update render_filter_tex to use linear SRGB as needed. Add gs_effect_set_texture_srgb next to gs_effect_set_texture to set texture with SRGB view instead. Add SRGB helpers for vec4 struct. Create GDI-compatible textures without SRGB support. Doesn't seem to work with SRGB formats.
2021-01-19 15:00:51 -08:00
static const gs_color_format format = GS_BGRA;
static const DXGI_FORMAT dxgi_format_resource =
ConvertGSTextureFormatResource(format);
static const DXGI_FORMAT dxgi_format_view =
ConvertGSTextureFormatView(format);
static const DXGI_FORMAT dxgi_format_view_linear =
ConvertGSTextureFormatViewLinear(format);
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
td = {};
td.Width = 2;
td.Height = 2;
td.MipLevels = 1;
libobs: Add dormant SRGB format support GS_RGBA, GS_BGRX, and GS_BGRA now use TYPELESS DXGI formats, so we can alias them between UNORM and UNORM_SRGB as necessary. GS_RGBA_UNORM, GS_BGRX_UNORM, and GS_BGRA_UNORM have been added to support straight UNORM types, which Windows requires for sharing textures from D3D9 and OpenGL. The D3D path aliases via views, and GL aliases via GL_EXT_texture_sRGB_decode/GL_FRAMEBUFFER_SRGB. A significant amount of code has changed in the D3D/GL backends, but the concepts are simple. On the D3D side, we need separate SRVs and RTVs to support nonlinear/linear reads and writes. On the GL side, we need to set the proper GL parameters to emulate the same. Add gs_enable_framebuffer_srgb/gs_framebuffer_srgb_enabled to set/get the framebuffer as SRGB or not. Add gs_linear_srgb_active/gs_set_linear_srgb to instruct sources that they should render as SRGB. Legacy sources can ignore this setting without regression. Update obs_source_draw to use linear SRGB as needed. Update render_filter_tex to use linear SRGB as needed. Add gs_effect_set_texture_srgb next to gs_effect_set_texture to set texture with SRGB view instead. Add SRGB helpers for vec4 struct. Create GDI-compatible textures without SRGB support. Doesn't seem to work with SRGB formats.
2021-01-19 15:00:51 -08:00
td.Format = dxgi_format_resource;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
td.ArraySize = 1;
libobs-d3d11: Don't crash if unable to rebuild shared texture When rebuilding the graphics subsystem, it's possible a shared texture may no longer be available. In this case, just soft fail and allow the texture to be rebuilt rather than crash the entire program over it.
2016-12-21 15:53:14 -08:00
td.SampleDesc.Count = 1;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
td.BindFlags = D3D11_BIND_SHADER_RESOURCE;
libobs-d3d11: Don't crash if unable to rebuild shared texture When rebuilding the graphics subsystem, it's possible a shared texture may no longer be available. In this case, just soft fail and allow the texture to be rebuilt rather than crash the entire program over it.
2016-12-21 15:53:14 -08:00
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
width = td.Width;
height = td.Height;
libobs: Add dormant SRGB format support GS_RGBA, GS_BGRX, and GS_BGRA now use TYPELESS DXGI formats, so we can alias them between UNORM and UNORM_SRGB as necessary. GS_RGBA_UNORM, GS_BGRX_UNORM, and GS_BGRA_UNORM have been added to support straight UNORM types, which Windows requires for sharing textures from D3D9 and OpenGL. The D3D path aliases via views, and GL aliases via GL_EXT_texture_sRGB_decode/GL_FRAMEBUFFER_SRGB. A significant amount of code has changed in the D3D/GL backends, but the concepts are simple. On the D3D side, we need separate SRVs and RTVs to support nonlinear/linear reads and writes. On the GL side, we need to set the proper GL parameters to emulate the same. Add gs_enable_framebuffer_srgb/gs_framebuffer_srgb_enabled to set/get the framebuffer as SRGB or not. Add gs_linear_srgb_active/gs_set_linear_srgb to instruct sources that they should render as SRGB. Legacy sources can ignore this setting without regression. Update obs_source_draw to use linear SRGB as needed. Update render_filter_tex to use linear SRGB as needed. Add gs_effect_set_texture_srgb next to gs_effect_set_texture to set texture with SRGB view instead. Add SRGB helpers for vec4 struct. Create GDI-compatible textures without SRGB support. Doesn't seem to work with SRGB formats.
2021-01-19 15:00:51 -08:00
dxgiFormatResource = dxgi_format_resource;
dxgiFormatView = dxgi_format_view;
dxgiFormatViewLinear = dxgi_format_view_linear;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
levels = 1;
libobs-d3d11: Don't crash if unable to rebuild shared texture When rebuilding the graphics subsystem, it's possible a shared texture may no longer be available. In this case, just soft fail and allow the texture to be rebuilt rather than crash the entire program over it.
2016-12-21 15:53:14 -08:00
libobs: Add dormant SRGB format support GS_RGBA, GS_BGRX, and GS_BGRA now use TYPELESS DXGI formats, so we can alias them between UNORM and UNORM_SRGB as necessary. GS_RGBA_UNORM, GS_BGRX_UNORM, and GS_BGRA_UNORM have been added to support straight UNORM types, which Windows requires for sharing textures from D3D9 and OpenGL. The D3D path aliases via views, and GL aliases via GL_EXT_texture_sRGB_decode/GL_FRAMEBUFFER_SRGB. A significant amount of code has changed in the D3D/GL backends, but the concepts are simple. On the D3D side, we need separate SRVs and RTVs to support nonlinear/linear reads and writes. On the GL side, we need to set the proper GL parameters to emulate the same. Add gs_enable_framebuffer_srgb/gs_framebuffer_srgb_enabled to set/get the framebuffer as SRGB or not. Add gs_linear_srgb_active/gs_set_linear_srgb to instruct sources that they should render as SRGB. Legacy sources can ignore this setting without regression. Update obs_source_draw to use linear SRGB as needed. Update render_filter_tex to use linear SRGB as needed. Add gs_effect_set_texture_srgb next to gs_effect_set_texture to set texture with SRGB view instead. Add SRGB helpers for vec4 struct. Create GDI-compatible textures without SRGB support. Doesn't seem to work with SRGB formats.
2021-01-19 15:00:51 -08:00
viewDesc = {};
viewDesc.Format = dxgi_format_view;
viewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
viewDesc.Texture2D.MipLevels = 1;
viewDescLinear = viewDesc;
viewDescLinear.Format = dxgi_format_view_linear;
libobs-d3d11: Don't crash if unable to rebuild shared texture When rebuilding the graphics subsystem, it's possible a shared texture may no longer be available. In this case, just soft fail and allow the texture to be rebuilt rather than crash the entire program over it.
2016-12-21 15:53:14 -08:00
isShared = false;
}
libobs-d3d11: Don't inline rebuild funcs Inlining these functions is pretty pointless.
2019-02-17 17:22:04 -08:00
void gs_texture_2d::Rebuild(ID3D11Device *dev)
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
{
HRESULT hr;
if (isShared) {
hr = dev->OpenSharedResource((HANDLE)(uintptr_t)sharedHandle,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
__uuidof(ID3D11Texture2D),
(void **)&texture);
libobs-d3d11: Don't crash if unable to rebuild shared texture When rebuilding the graphics subsystem, it's possible a shared texture may no longer be available. In this case, just soft fail and allow the texture to be rebuilt rather than crash the entire program over it.
2016-12-21 15:53:14 -08:00
if (FAILED(hr)) {
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
blog(LOG_WARNING,
libobs-d3d11: Fix formatting
2022-01-14 15:38:02 -08:00
"Failed to rebuild shared texture: 0x%08lX", hr);
libobs-d3d11: Don't crash if unable to rebuild shared texture When rebuilding the graphics subsystem, it's possible a shared texture may no longer be available. In this case, just soft fail and allow the texture to be rebuilt rather than crash the entire program over it.
2016-12-21 15:53:14 -08:00
RebuildSharedTextureFallback();
}
}
if (!isShared) {
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
hr = dev->CreateTexture2D(
&td, data.size() ? srd.data() : nullptr, &texture);
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
if (FAILED(hr))
throw HRError("Failed to create 2D texture", hr);
}
libobs: Add dormant SRGB format support GS_RGBA, GS_BGRX, and GS_BGRA now use TYPELESS DXGI formats, so we can alias them between UNORM and UNORM_SRGB as necessary. GS_RGBA_UNORM, GS_BGRX_UNORM, and GS_BGRA_UNORM have been added to support straight UNORM types, which Windows requires for sharing textures from D3D9 and OpenGL. The D3D path aliases via views, and GL aliases via GL_EXT_texture_sRGB_decode/GL_FRAMEBUFFER_SRGB. A significant amount of code has changed in the D3D/GL backends, but the concepts are simple. On the D3D side, we need separate SRVs and RTVs to support nonlinear/linear reads and writes. On the GL side, we need to set the proper GL parameters to emulate the same. Add gs_enable_framebuffer_srgb/gs_framebuffer_srgb_enabled to set/get the framebuffer as SRGB or not. Add gs_linear_srgb_active/gs_set_linear_srgb to instruct sources that they should render as SRGB. Legacy sources can ignore this setting without regression. Update obs_source_draw to use linear SRGB as needed. Update render_filter_tex to use linear SRGB as needed. Add gs_effect_set_texture_srgb next to gs_effect_set_texture to set texture with SRGB view instead. Add SRGB helpers for vec4 struct. Create GDI-compatible textures without SRGB support. Doesn't seem to work with SRGB formats.
2021-01-19 15:00:51 -08:00
hr = dev->CreateShaderResourceView(texture, &viewDesc, &shaderRes);
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
if (FAILED(hr))
libobs: Add dormant SRGB format support GS_RGBA, GS_BGRX, and GS_BGRA now use TYPELESS DXGI formats, so we can alias them between UNORM and UNORM_SRGB as necessary. GS_RGBA_UNORM, GS_BGRX_UNORM, and GS_BGRA_UNORM have been added to support straight UNORM types, which Windows requires for sharing textures from D3D9 and OpenGL. The D3D path aliases via views, and GL aliases via GL_EXT_texture_sRGB_decode/GL_FRAMEBUFFER_SRGB. A significant amount of code has changed in the D3D/GL backends, but the concepts are simple. On the D3D side, we need separate SRVs and RTVs to support nonlinear/linear reads and writes. On the GL side, we need to set the proper GL parameters to emulate the same. Add gs_enable_framebuffer_srgb/gs_framebuffer_srgb_enabled to set/get the framebuffer as SRGB or not. Add gs_linear_srgb_active/gs_set_linear_srgb to instruct sources that they should render as SRGB. Legacy sources can ignore this setting without regression. Update obs_source_draw to use linear SRGB as needed. Update render_filter_tex to use linear SRGB as needed. Add gs_effect_set_texture_srgb next to gs_effect_set_texture to set texture with SRGB view instead. Add SRGB helpers for vec4 struct. Create GDI-compatible textures without SRGB support. Doesn't seem to work with SRGB formats.
2021-01-19 15:00:51 -08:00
throw HRError("Failed to create SRV", hr);
if (viewDesc.Format == viewDescLinear.Format) {
shaderResLinear = shaderRes;
} else {
hr = dev->CreateShaderResourceView(texture, &viewDescLinear,
&shaderResLinear);
if (FAILED(hr))
throw HRError("Failed to create linear SRV", hr);
}
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
if (isRenderTarget)
InitRenderTargets();
libobs-d3d11: Include GDI surface in rebuild The GDI surface was not included in the rebuild process, therefore when window capture is used, it would cause a crash after a rebuild.
2016-11-06 16:46:38 -08:00
if (isGDICompatible) {
hr = texture->QueryInterface(__uuidof(IDXGISurface1),
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
(void **)&gdiSurface);
libobs-d3d11: Include GDI surface in rebuild The GDI surface was not included in the rebuild process, therefore when window capture is used, it would cause a crash after a rebuild.
2016-11-06 16:46:38 -08:00
if (FAILED(hr))
throw HRError("Failed to create GDI surface", hr);
}
libobs-d3d11: Reset handle and re-lock if texture rebuilt If a texture has to be rebuilt due to a driver reset and is a keyed mutex shared texture, make sure to reacquire the shared handle and acquire the lock.
2019-03-03 08:43:06 -08:00
acquired = false;
if ((td.MiscFlags & D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX) != 0) {
ComQIPtr<IDXGIResource> dxgi_res(texture);
if (dxgi_res)
GetSharedHandle(dxgi_res);
device_texture_acquire_sync(this, 0, INFINITE);
}
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
}
libobs/graphics, libobs-d3d11: Add P010 support
2022-03-02 23:15:02 -08:00
void gs_texture_2d::RebuildPaired_Y(ID3D11Device *dev)
libobs-d3d11: Fix rebuild of NV12 textures When NV12 textures were added, driver crashes and their rebuild process was not taken in to consideration. This fixes that by adding explicit NV12 rebuild functions.
2019-02-17 17:41:42 -08:00
{
libobs/graphics, libobs-d3d11: Add P010 support
2022-03-02 23:15:02 -08:00
gs_texture_2d *tex_uv = pairedTexture;
libobs-d3d11: Fix rebuild of NV12 textures When NV12 textures were added, driver crashes and their rebuild process was not taken in to consideration. This fixes that by adding explicit NV12 rebuild functions.
2019-02-17 17:41:42 -08:00
HRESULT hr;
hr = dev->CreateTexture2D(&td, nullptr, &texture);
if (FAILED(hr))
throw HRError("Failed to create 2D texture", hr);
libobs: Add dormant SRGB format support GS_RGBA, GS_BGRX, and GS_BGRA now use TYPELESS DXGI formats, so we can alias them between UNORM and UNORM_SRGB as necessary. GS_RGBA_UNORM, GS_BGRX_UNORM, and GS_BGRA_UNORM have been added to support straight UNORM types, which Windows requires for sharing textures from D3D9 and OpenGL. The D3D path aliases via views, and GL aliases via GL_EXT_texture_sRGB_decode/GL_FRAMEBUFFER_SRGB. A significant amount of code has changed in the D3D/GL backends, but the concepts are simple. On the D3D side, we need separate SRVs and RTVs to support nonlinear/linear reads and writes. On the GL side, we need to set the proper GL parameters to emulate the same. Add gs_enable_framebuffer_srgb/gs_framebuffer_srgb_enabled to set/get the framebuffer as SRGB or not. Add gs_linear_srgb_active/gs_set_linear_srgb to instruct sources that they should render as SRGB. Legacy sources can ignore this setting without regression. Update obs_source_draw to use linear SRGB as needed. Update render_filter_tex to use linear SRGB as needed. Add gs_effect_set_texture_srgb next to gs_effect_set_texture to set texture with SRGB view instead. Add SRGB helpers for vec4 struct. Create GDI-compatible textures without SRGB support. Doesn't seem to work with SRGB formats.
2021-01-19 15:00:51 -08:00
hr = dev->CreateShaderResourceView(texture, &viewDesc, &shaderRes);
libobs-d3d11: Fix rebuild of NV12 textures When NV12 textures were added, driver crashes and their rebuild process was not taken in to consideration. This fixes that by adding explicit NV12 rebuild functions.
2019-02-17 17:41:42 -08:00
if (FAILED(hr))
libobs: Add dormant SRGB format support GS_RGBA, GS_BGRX, and GS_BGRA now use TYPELESS DXGI formats, so we can alias them between UNORM and UNORM_SRGB as necessary. GS_RGBA_UNORM, GS_BGRX_UNORM, and GS_BGRA_UNORM have been added to support straight UNORM types, which Windows requires for sharing textures from D3D9 and OpenGL. The D3D path aliases via views, and GL aliases via GL_EXT_texture_sRGB_decode/GL_FRAMEBUFFER_SRGB. A significant amount of code has changed in the D3D/GL backends, but the concepts are simple. On the D3D side, we need separate SRVs and RTVs to support nonlinear/linear reads and writes. On the GL side, we need to set the proper GL parameters to emulate the same. Add gs_enable_framebuffer_srgb/gs_framebuffer_srgb_enabled to set/get the framebuffer as SRGB or not. Add gs_linear_srgb_active/gs_set_linear_srgb to instruct sources that they should render as SRGB. Legacy sources can ignore this setting without regression. Update obs_source_draw to use linear SRGB as needed. Update render_filter_tex to use linear SRGB as needed. Add gs_effect_set_texture_srgb next to gs_effect_set_texture to set texture with SRGB view instead. Add SRGB helpers for vec4 struct. Create GDI-compatible textures without SRGB support. Doesn't seem to work with SRGB formats.
2021-01-19 15:00:51 -08:00
throw HRError("Failed to create Y SRV", hr);
if (viewDesc.Format == viewDescLinear.Format) {
shaderResLinear = shaderRes;
} else {
hr = dev->CreateShaderResourceView(texture, &viewDescLinear,
&shaderResLinear);
if (FAILED(hr))
throw HRError("Failed to create linear Y SRV", hr);
}
libobs-d3d11: Fix rebuild of NV12 textures When NV12 textures were added, driver crashes and their rebuild process was not taken in to consideration. This fixes that by adding explicit NV12 rebuild functions.
2019-02-17 17:41:42 -08:00
if (isRenderTarget)
InitRenderTargets();
libobs/graphics, libobs-d3d11: Add P010 support
2022-03-02 23:15:02 -08:00
tex_uv->RebuildPaired_UV(dev);
libobs-d3d11: Reset handle and re-lock if texture rebuilt If a texture has to be rebuilt due to a driver reset and is a keyed mutex shared texture, make sure to reacquire the shared handle and acquire the lock.
2019-03-03 08:43:06 -08:00
acquired = false;
if ((td.MiscFlags & D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX) != 0) {
ComQIPtr<IDXGIResource> dxgi_res(texture);
if (dxgi_res)
GetSharedHandle(dxgi_res);
device_texture_acquire_sync(this, 0, INFINITE);
}
libobs-d3d11: Fix rebuild of NV12 textures When NV12 textures were added, driver crashes and their rebuild process was not taken in to consideration. This fixes that by adding explicit NV12 rebuild functions.
2019-02-17 17:41:42 -08:00
}
libobs/graphics, libobs-d3d11: Add P010 support
2022-03-02 23:15:02 -08:00
void gs_texture_2d::RebuildPaired_UV(ID3D11Device *dev)
libobs-d3d11: Fix rebuild of NV12 textures When NV12 textures were added, driver crashes and their rebuild process was not taken in to consideration. This fixes that by adding explicit NV12 rebuild functions.
2019-02-17 17:41:42 -08:00
{
libobs/graphics, libobs-d3d11: Add P010 support
2022-03-02 23:15:02 -08:00
gs_texture_2d *tex_y = pairedTexture;
libobs-d3d11: Fix rebuild of NV12 textures When NV12 textures were added, driver crashes and their rebuild process was not taken in to consideration. This fixes that by adding explicit NV12 rebuild functions.
2019-02-17 17:41:42 -08:00
HRESULT hr;
texture = tex_y->texture;
libobs: Add dormant SRGB format support GS_RGBA, GS_BGRX, and GS_BGRA now use TYPELESS DXGI formats, so we can alias them between UNORM and UNORM_SRGB as necessary. GS_RGBA_UNORM, GS_BGRX_UNORM, and GS_BGRA_UNORM have been added to support straight UNORM types, which Windows requires for sharing textures from D3D9 and OpenGL. The D3D path aliases via views, and GL aliases via GL_EXT_texture_sRGB_decode/GL_FRAMEBUFFER_SRGB. A significant amount of code has changed in the D3D/GL backends, but the concepts are simple. On the D3D side, we need separate SRVs and RTVs to support nonlinear/linear reads and writes. On the GL side, we need to set the proper GL parameters to emulate the same. Add gs_enable_framebuffer_srgb/gs_framebuffer_srgb_enabled to set/get the framebuffer as SRGB or not. Add gs_linear_srgb_active/gs_set_linear_srgb to instruct sources that they should render as SRGB. Legacy sources can ignore this setting without regression. Update obs_source_draw to use linear SRGB as needed. Update render_filter_tex to use linear SRGB as needed. Add gs_effect_set_texture_srgb next to gs_effect_set_texture to set texture with SRGB view instead. Add SRGB helpers for vec4 struct. Create GDI-compatible textures without SRGB support. Doesn't seem to work with SRGB formats.
2021-01-19 15:00:51 -08:00
hr = dev->CreateShaderResourceView(texture, &viewDesc, &shaderRes);
libobs-d3d11: Fix rebuild of NV12 textures When NV12 textures were added, driver crashes and their rebuild process was not taken in to consideration. This fixes that by adding explicit NV12 rebuild functions.
2019-02-17 17:41:42 -08:00
if (FAILED(hr))
libobs: Add dormant SRGB format support GS_RGBA, GS_BGRX, and GS_BGRA now use TYPELESS DXGI formats, so we can alias them between UNORM and UNORM_SRGB as necessary. GS_RGBA_UNORM, GS_BGRX_UNORM, and GS_BGRA_UNORM have been added to support straight UNORM types, which Windows requires for sharing textures from D3D9 and OpenGL. The D3D path aliases via views, and GL aliases via GL_EXT_texture_sRGB_decode/GL_FRAMEBUFFER_SRGB. A significant amount of code has changed in the D3D/GL backends, but the concepts are simple. On the D3D side, we need separate SRVs and RTVs to support nonlinear/linear reads and writes. On the GL side, we need to set the proper GL parameters to emulate the same. Add gs_enable_framebuffer_srgb/gs_framebuffer_srgb_enabled to set/get the framebuffer as SRGB or not. Add gs_linear_srgb_active/gs_set_linear_srgb to instruct sources that they should render as SRGB. Legacy sources can ignore this setting without regression. Update obs_source_draw to use linear SRGB as needed. Update render_filter_tex to use linear SRGB as needed. Add gs_effect_set_texture_srgb next to gs_effect_set_texture to set texture with SRGB view instead. Add SRGB helpers for vec4 struct. Create GDI-compatible textures without SRGB support. Doesn't seem to work with SRGB formats.
2021-01-19 15:00:51 -08:00
throw HRError("Failed to create UV SRV", hr);
if (viewDesc.Format == viewDescLinear.Format) {
shaderResLinear = shaderRes;
} else {
hr = dev->CreateShaderResourceView(texture, &viewDescLinear,
&shaderResLinear);
if (FAILED(hr))
throw HRError("Failed to create linear UV SRV", hr);
}
libobs-d3d11: Fix rebuild of NV12 textures When NV12 textures were added, driver crashes and their rebuild process was not taken in to consideration. This fixes that by adding explicit NV12 rebuild functions.
2019-02-17 17:41:42 -08:00
if (isRenderTarget)
InitRenderTargets();
}
libobs-d3d11: Don't inline rebuild funcs Inlining these functions is pretty pointless.
2019-02-17 17:22:04 -08:00
void gs_zstencil_buffer::Rebuild(ID3D11Device *dev)
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
{
HRESULT hr;
hr = dev->CreateTexture2D(&td, nullptr, &texture);
if (FAILED(hr))
throw HRError("Failed to create depth stencil texture", hr);
hr = dev->CreateDepthStencilView(texture, &dsvd, &view);
if (FAILED(hr))
throw HRError("Failed to create depth stencil view", hr);
}
libobs-d3d11: Don't inline rebuild funcs Inlining these functions is pretty pointless.
2019-02-17 17:22:04 -08:00
void gs_stage_surface::Rebuild(ID3D11Device *dev)
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
{
HRESULT hr = dev->CreateTexture2D(&td, nullptr, &texture);
if (FAILED(hr))
throw HRError("Failed to create staging surface", hr);
}
libobs-d3d11: Don't inline rebuild funcs Inlining these functions is pretty pointless.
2019-02-17 17:22:04 -08:00
void gs_sampler_state::Rebuild(ID3D11Device *dev)
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
{
HRESULT hr = dev->CreateSamplerState(&sd, state.Assign());
if (FAILED(hr))
throw HRError("Failed to create sampler state", hr);
}
libobs-d3d11: Don't inline rebuild funcs Inlining these functions is pretty pointless.
2019-02-17 17:22:04 -08:00
void gs_vertex_shader::Rebuild(ID3D11Device *dev)
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
{
HRESULT hr;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
hr = dev->CreateVertexShader(data.data(), data.size(), nullptr,
&shader);
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
if (FAILED(hr))
throw HRError("Failed to create vertex shader", hr);
libobs-d3d11: Fix null input layout rebuild Don't build input layout without VS inputs. Matches creation logic.
2019-10-17 09:24:13 -07:00
const UINT layoutSize = (UINT)layoutData.size();
if (layoutSize > 0) {
hr = dev->CreateInputLayout(layoutData.data(), layoutSize,
data.data(), data.size(), &layout);
if (FAILED(hr))
throw HRError("Failed to create input layout", hr);
}
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
if (constantSize) {
hr = dev->CreateBuffer(&bd, NULL, &constants);
if (FAILED(hr))
throw HRError("Failed to create constant buffer", hr);
}
for (gs_shader_param &param : params) {
param.nextSampler = nullptr;
param.curValue.clear();
gs_shader_set_default(&param);
}
}
libobs-d3d11: Don't inline rebuild funcs Inlining these functions is pretty pointless.
2019-02-17 17:22:04 -08:00
void gs_pixel_shader::Rebuild(ID3D11Device *dev)
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
{
HRESULT hr;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
hr = dev->CreatePixelShader(data.data(), data.size(), nullptr, &shader);
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
if (FAILED(hr))
throw HRError("Failed to create pixel shader", hr);
if (constantSize) {
hr = dev->CreateBuffer(&bd, NULL, &constants);
if (FAILED(hr))
throw HRError("Failed to create constant buffer", hr);
}
for (gs_shader_param &param : params) {
param.nextSampler = nullptr;
param.curValue.clear();
gs_shader_set_default(&param);
}
}
libobs-d3d11: Don't inline rebuild funcs Inlining these functions is pretty pointless.
2019-02-17 17:22:04 -08:00
void gs_swap_chain::Rebuild(ID3D11Device *dev)
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
{
HRESULT hr = device->factory->CreateSwapChain(dev, &swapDesc, &swap);
if (FAILED(hr))
throw HRError("Failed to create swap chain", hr);
Init();
}
libobs: Add GPU timestamp query support This change only wraps the functionality. I have rough code to exercise the the query functionality, but that part is not really clean enough to submit.
2019-07-27 13:31:07 -07:00
void gs_timer::Rebuild(ID3D11Device *dev)
{
D3D11_QUERY_DESC desc;
desc.Query = D3D11_QUERY_TIMESTAMP;
desc.MiscFlags = 0;
HRESULT hr = dev->CreateQuery(&desc, &query_begin);
if (FAILED(hr))
throw HRError("Failed to create timer", hr);
hr = dev->CreateQuery(&desc, &query_end);
if (FAILED(hr))
throw HRError("Failed to create timer", hr);
}
void gs_timer_range::Rebuild(ID3D11Device *dev)
{
D3D11_QUERY_DESC desc;
desc.Query = D3D11_QUERY_TIMESTAMP_DISJOINT;
desc.MiscFlags = 0;
HRESULT hr = dev->CreateQuery(&desc, &query_disjoint);
if (FAILED(hr))
throw HRError("Failed to create timer", hr);
}
libobs: Add support for volume textures Also fix some mip calculations along the way.
2019-12-15 11:36:24 -08:00
void gs_texture_3d::RebuildSharedTextureFallback()
{
libobs: Add dormant SRGB format support GS_RGBA, GS_BGRX, and GS_BGRA now use TYPELESS DXGI formats, so we can alias them between UNORM and UNORM_SRGB as necessary. GS_RGBA_UNORM, GS_BGRX_UNORM, and GS_BGRA_UNORM have been added to support straight UNORM types, which Windows requires for sharing textures from D3D9 and OpenGL. The D3D path aliases via views, and GL aliases via GL_EXT_texture_sRGB_decode/GL_FRAMEBUFFER_SRGB. A significant amount of code has changed in the D3D/GL backends, but the concepts are simple. On the D3D side, we need separate SRVs and RTVs to support nonlinear/linear reads and writes. On the GL side, we need to set the proper GL parameters to emulate the same. Add gs_enable_framebuffer_srgb/gs_framebuffer_srgb_enabled to set/get the framebuffer as SRGB or not. Add gs_linear_srgb_active/gs_set_linear_srgb to instruct sources that they should render as SRGB. Legacy sources can ignore this setting without regression. Update obs_source_draw to use linear SRGB as needed. Update render_filter_tex to use linear SRGB as needed. Add gs_effect_set_texture_srgb next to gs_effect_set_texture to set texture with SRGB view instead. Add SRGB helpers for vec4 struct. Create GDI-compatible textures without SRGB support. Doesn't seem to work with SRGB formats.
2021-01-19 15:00:51 -08:00
static const gs_color_format format = GS_BGRA;
static const DXGI_FORMAT dxgi_format_resource =
ConvertGSTextureFormatResource(format);
static const DXGI_FORMAT dxgi_format_view =
ConvertGSTextureFormatView(format);
static const DXGI_FORMAT dxgi_format_view_linear =
ConvertGSTextureFormatViewLinear(format);
libobs: Add support for volume textures Also fix some mip calculations along the way.
2019-12-15 11:36:24 -08:00
td = {};
td.Width = 2;
td.Height = 2;
td.Depth = 2;
td.MipLevels = 1;
libobs: Add dormant SRGB format support GS_RGBA, GS_BGRX, and GS_BGRA now use TYPELESS DXGI formats, so we can alias them between UNORM and UNORM_SRGB as necessary. GS_RGBA_UNORM, GS_BGRX_UNORM, and GS_BGRA_UNORM have been added to support straight UNORM types, which Windows requires for sharing textures from D3D9 and OpenGL. The D3D path aliases via views, and GL aliases via GL_EXT_texture_sRGB_decode/GL_FRAMEBUFFER_SRGB. A significant amount of code has changed in the D3D/GL backends, but the concepts are simple. On the D3D side, we need separate SRVs and RTVs to support nonlinear/linear reads and writes. On the GL side, we need to set the proper GL parameters to emulate the same. Add gs_enable_framebuffer_srgb/gs_framebuffer_srgb_enabled to set/get the framebuffer as SRGB or not. Add gs_linear_srgb_active/gs_set_linear_srgb to instruct sources that they should render as SRGB. Legacy sources can ignore this setting without regression. Update obs_source_draw to use linear SRGB as needed. Update render_filter_tex to use linear SRGB as needed. Add gs_effect_set_texture_srgb next to gs_effect_set_texture to set texture with SRGB view instead. Add SRGB helpers for vec4 struct. Create GDI-compatible textures without SRGB support. Doesn't seem to work with SRGB formats.
2021-01-19 15:00:51 -08:00
td.Format = dxgi_format_resource;
libobs: Add support for volume textures Also fix some mip calculations along the way.
2019-12-15 11:36:24 -08:00
td.BindFlags = D3D11_BIND_SHADER_RESOURCE;
width = td.Width;
height = td.Height;
depth = td.Depth;
libobs: Add dormant SRGB format support GS_RGBA, GS_BGRX, and GS_BGRA now use TYPELESS DXGI formats, so we can alias them between UNORM and UNORM_SRGB as necessary. GS_RGBA_UNORM, GS_BGRX_UNORM, and GS_BGRA_UNORM have been added to support straight UNORM types, which Windows requires for sharing textures from D3D9 and OpenGL. The D3D path aliases via views, and GL aliases via GL_EXT_texture_sRGB_decode/GL_FRAMEBUFFER_SRGB. A significant amount of code has changed in the D3D/GL backends, but the concepts are simple. On the D3D side, we need separate SRVs and RTVs to support nonlinear/linear reads and writes. On the GL side, we need to set the proper GL parameters to emulate the same. Add gs_enable_framebuffer_srgb/gs_framebuffer_srgb_enabled to set/get the framebuffer as SRGB or not. Add gs_linear_srgb_active/gs_set_linear_srgb to instruct sources that they should render as SRGB. Legacy sources can ignore this setting without regression. Update obs_source_draw to use linear SRGB as needed. Update render_filter_tex to use linear SRGB as needed. Add gs_effect_set_texture_srgb next to gs_effect_set_texture to set texture with SRGB view instead. Add SRGB helpers for vec4 struct. Create GDI-compatible textures without SRGB support. Doesn't seem to work with SRGB formats.
2021-01-19 15:00:51 -08:00
dxgiFormatResource = dxgi_format_resource;
dxgiFormatView = dxgi_format_view;
dxgiFormatViewLinear = dxgi_format_view_linear;
libobs: Add support for volume textures Also fix some mip calculations along the way.
2019-12-15 11:36:24 -08:00
levels = 1;
libobs: Add dormant SRGB format support GS_RGBA, GS_BGRX, and GS_BGRA now use TYPELESS DXGI formats, so we can alias them between UNORM and UNORM_SRGB as necessary. GS_RGBA_UNORM, GS_BGRX_UNORM, and GS_BGRA_UNORM have been added to support straight UNORM types, which Windows requires for sharing textures from D3D9 and OpenGL. The D3D path aliases via views, and GL aliases via GL_EXT_texture_sRGB_decode/GL_FRAMEBUFFER_SRGB. A significant amount of code has changed in the D3D/GL backends, but the concepts are simple. On the D3D side, we need separate SRVs and RTVs to support nonlinear/linear reads and writes. On the GL side, we need to set the proper GL parameters to emulate the same. Add gs_enable_framebuffer_srgb/gs_framebuffer_srgb_enabled to set/get the framebuffer as SRGB or not. Add gs_linear_srgb_active/gs_set_linear_srgb to instruct sources that they should render as SRGB. Legacy sources can ignore this setting without regression. Update obs_source_draw to use linear SRGB as needed. Update render_filter_tex to use linear SRGB as needed. Add gs_effect_set_texture_srgb next to gs_effect_set_texture to set texture with SRGB view instead. Add SRGB helpers for vec4 struct. Create GDI-compatible textures without SRGB support. Doesn't seem to work with SRGB formats.
2021-01-19 15:00:51 -08:00
viewDesc = {};
viewDesc.Format = dxgi_format_view;
viewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
viewDesc.Texture3D.MostDetailedMip = 0;
viewDesc.Texture3D.MipLevels = 1;
viewDescLinear = viewDesc;
viewDescLinear.Format = dxgi_format_view_linear;
libobs: Add support for volume textures Also fix some mip calculations along the way.
2019-12-15 11:36:24 -08:00
isShared = false;
}
void gs_texture_3d::Rebuild(ID3D11Device *dev)
{
HRESULT hr;
if (isShared) {
hr = dev->OpenSharedResource((HANDLE)(uintptr_t)sharedHandle,
__uuidof(ID3D11Texture3D),
(void **)&texture);
if (FAILED(hr)) {
blog(LOG_WARNING,
libobs-d3d11: Fix formatting
2022-01-14 15:38:02 -08:00
"Failed to rebuild shared texture: 0x%08lX", hr);
libobs: Add support for volume textures Also fix some mip calculations along the way.
2019-12-15 11:36:24 -08:00
RebuildSharedTextureFallback();
}
}
if (!isShared) {
hr = dev->CreateTexture3D(
&td, data.size() ? srd.data() : nullptr, &texture);
if (FAILED(hr))
throw HRError("Failed to create 3D texture", hr);
}
libobs: Add dormant SRGB format support GS_RGBA, GS_BGRX, and GS_BGRA now use TYPELESS DXGI formats, so we can alias them between UNORM and UNORM_SRGB as necessary. GS_RGBA_UNORM, GS_BGRX_UNORM, and GS_BGRA_UNORM have been added to support straight UNORM types, which Windows requires for sharing textures from D3D9 and OpenGL. The D3D path aliases via views, and GL aliases via GL_EXT_texture_sRGB_decode/GL_FRAMEBUFFER_SRGB. A significant amount of code has changed in the D3D/GL backends, but the concepts are simple. On the D3D side, we need separate SRVs and RTVs to support nonlinear/linear reads and writes. On the GL side, we need to set the proper GL parameters to emulate the same. Add gs_enable_framebuffer_srgb/gs_framebuffer_srgb_enabled to set/get the framebuffer as SRGB or not. Add gs_linear_srgb_active/gs_set_linear_srgb to instruct sources that they should render as SRGB. Legacy sources can ignore this setting without regression. Update obs_source_draw to use linear SRGB as needed. Update render_filter_tex to use linear SRGB as needed. Add gs_effect_set_texture_srgb next to gs_effect_set_texture to set texture with SRGB view instead. Add SRGB helpers for vec4 struct. Create GDI-compatible textures without SRGB support. Doesn't seem to work with SRGB formats.
2021-01-19 15:00:51 -08:00
hr = dev->CreateShaderResourceView(texture, &viewDesc, &shaderRes);
libobs: Add support for volume textures Also fix some mip calculations along the way.
2019-12-15 11:36:24 -08:00
if (FAILED(hr))
libobs: Add dormant SRGB format support GS_RGBA, GS_BGRX, and GS_BGRA now use TYPELESS DXGI formats, so we can alias them between UNORM and UNORM_SRGB as necessary. GS_RGBA_UNORM, GS_BGRX_UNORM, and GS_BGRA_UNORM have been added to support straight UNORM types, which Windows requires for sharing textures from D3D9 and OpenGL. The D3D path aliases via views, and GL aliases via GL_EXT_texture_sRGB_decode/GL_FRAMEBUFFER_SRGB. A significant amount of code has changed in the D3D/GL backends, but the concepts are simple. On the D3D side, we need separate SRVs and RTVs to support nonlinear/linear reads and writes. On the GL side, we need to set the proper GL parameters to emulate the same. Add gs_enable_framebuffer_srgb/gs_framebuffer_srgb_enabled to set/get the framebuffer as SRGB or not. Add gs_linear_srgb_active/gs_set_linear_srgb to instruct sources that they should render as SRGB. Legacy sources can ignore this setting without regression. Update obs_source_draw to use linear SRGB as needed. Update render_filter_tex to use linear SRGB as needed. Add gs_effect_set_texture_srgb next to gs_effect_set_texture to set texture with SRGB view instead. Add SRGB helpers for vec4 struct. Create GDI-compatible textures without SRGB support. Doesn't seem to work with SRGB formats.
2021-01-19 15:00:51 -08:00
throw HRError("Failed to create 3D SRV", hr);
if (viewDesc.Format == viewDescLinear.Format) {
shaderResLinear = shaderRes;
} else {
hr = dev->CreateShaderResourceView(texture, &viewDescLinear,
&shaderResLinear);
if (FAILED(hr))
throw HRError("Failed to create linear 3D SRV", hr);
}
libobs: Add support for volume textures Also fix some mip calculations along the way.
2019-12-15 11:36:24 -08:00
acquired = false;
if ((td.MiscFlags & D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX) != 0) {
ComQIPtr<IDXGIResource> dxgi_res(texture);
if (dxgi_res)
GetSharedHandle(dxgi_res);
device_texture_acquire_sync(this, 0, INFINITE);
}
}
libobs-d3d11: Don't inline rebuild funcs Inlining these functions is pretty pointless.
2019-02-17 17:22:04 -08:00
void SavedBlendState::Rebuild(ID3D11Device *dev)
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
{
HRESULT hr = dev->CreateBlendState(&bd, &state);
if (FAILED(hr))
throw HRError("Failed to create blend state", hr);
}
libobs-d3d11: Don't inline rebuild funcs Inlining these functions is pretty pointless.
2019-02-17 17:22:04 -08:00
void SavedZStencilState::Rebuild(ID3D11Device *dev)
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
{
HRESULT hr = dev->CreateDepthStencilState(&dsd, &state);
if (FAILED(hr))
throw HRError("Failed to create depth stencil state", hr);
}
libobs-d3d11: Don't inline rebuild funcs Inlining these functions is pretty pointless.
2019-02-17 17:22:04 -08:00
void SavedRasterState::Rebuild(ID3D11Device *dev)
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
{
HRESULT hr = dev->CreateRasterizerState(&rd, &state);
if (FAILED(hr))
throw HRError("Failed to create rasterizer state", hr);
}
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
const static D3D_FEATURE_LEVEL featureLevels[] = {
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
};
void gs_device::RebuildDevice()
try {
ID3D11Device *dev = nullptr;
HRESULT hr;
blog(LOG_WARNING, "Device Remove/Reset! Rebuilding all assets...");
/* ----------------------------------------------------------------- */
libobs: Support device loss registration Complex external systems using the D3D11 device may need to perform their own device loss handling, the upcoming Windows Graphics Capture support for example.
2019-11-27 16:35:27 -08:00
for (gs_device_loss &callback : loss_callbacks)
callback.device_loss_release(callback.data);
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
gs_obj *obj = first_obj;
while (obj) {
switch (obj->obj_type) {
case gs_type::gs_vertex_buffer:
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_vertex_buffer *)obj)->Release();
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
break;
case gs_type::gs_index_buffer:
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_index_buffer *)obj)->Release();
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
break;
case gs_type::gs_texture_2d:
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_texture_2d *)obj)->Release();
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
break;
case gs_type::gs_zstencil_buffer:
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_zstencil_buffer *)obj)->Release();
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
break;
case gs_type::gs_stage_surface:
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_stage_surface *)obj)->Release();
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
break;
case gs_type::gs_sampler_state:
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_sampler_state *)obj)->Release();
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
break;
case gs_type::gs_vertex_shader:
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_vertex_shader *)obj)->Release();
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
break;
case gs_type::gs_pixel_shader:
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_pixel_shader *)obj)->Release();
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
break;
case gs_type::gs_duplicator:
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_duplicator *)obj)->Release();
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
break;
case gs_type::gs_swap_chain:
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_swap_chain *)obj)->Release();
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
break;
libobs: Add GPU timestamp query support This change only wraps the functionality. I have rough code to exercise the the query functionality, but that part is not really clean enough to submit.
2019-07-27 13:31:07 -07:00
case gs_type::gs_timer:
((gs_timer *)obj)->Release();
break;
case gs_type::gs_timer_range:
((gs_timer_range *)obj)->Release();
break;
libobs: Add support for volume textures Also fix some mip calculations along the way.
2019-12-15 11:36:24 -08:00
case gs_type::gs_texture_3d:
((gs_texture_3d *)obj)->Release();
break;
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
}
obj = obj->next;
}
for (auto &state : zstencilStates)
state.Release();
for (auto &state : rasterStates)
state.Release();
for (auto &state : blendStates)
state.Release();
context->ClearState();
libobs: Support device loss registration Complex external systems using the D3D11 device may need to perform their own device loss handling, the upcoming Windows Graphics Capture support for example.
2019-11-27 16:35:27 -08:00
context->Flush();
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
libobs-d3d11: Prefer ComPtr Clear() over Release()
2021-09-14 21:17:33 -07:00
context.Clear();
device.Clear();
adapter.Clear();
factory.Clear();
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
/* ----------------------------------------------------------------- */
libobs-d3d11: Split InitFactory to InitAdapter Splits off the adapter initialization to its own function so we can modify what happens in between those actions. (-Jim)
2021-03-21 20:37:56 -07:00
InitFactory();
InitAdapter(adpIdx);
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
uint32_t createFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
hr = D3D11CreateDevice(adapter, D3D_DRIVER_TYPE_UNKNOWN, nullptr,
createFlags, featureLevels,
sizeof(featureLevels) /
sizeof(D3D_FEATURE_LEVEL),
D3D11_SDK_VERSION, &device, nullptr, &context);
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
if (FAILED(hr))
throw HRError("Failed to create device", hr);
dev = device;
obj = first_obj;
while (obj) {
switch (obj->obj_type) {
case gs_type::gs_vertex_buffer:
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_vertex_buffer *)obj)->Rebuild();
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
break;
case gs_type::gs_index_buffer:
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_index_buffer *)obj)->Rebuild(dev);
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
break;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
case gs_type::gs_texture_2d: {
gs_texture_2d *tex = (gs_texture_2d *)obj;
libobs/graphics, libobs-d3d11: Add P010 support
2022-03-02 23:15:02 -08:00
if (!tex->pairedTexture) {
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
tex->Rebuild(dev);
} else if (!tex->chroma) {
libobs/graphics, libobs-d3d11: Add P010 support
2022-03-02 23:15:02 -08:00
tex->RebuildPaired_Y(dev);
libobs-d3d11: Fix rebuild of NV12 textures When NV12 textures were added, driver crashes and their rebuild process was not taken in to consideration. This fixes that by adding explicit NV12 rebuild functions.
2019-02-17 17:41:42 -08:00
}
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
} break;
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
case gs_type::gs_zstencil_buffer:
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_zstencil_buffer *)obj)->Rebuild(dev);
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
break;
case gs_type::gs_stage_surface:
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_stage_surface *)obj)->Rebuild(dev);
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
break;
case gs_type::gs_sampler_state:
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_sampler_state *)obj)->Rebuild(dev);
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
break;
case gs_type::gs_vertex_shader:
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_vertex_shader *)obj)->Rebuild(dev);
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
break;
case gs_type::gs_pixel_shader:
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_pixel_shader *)obj)->Rebuild(dev);
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
break;
case gs_type::gs_duplicator:
libobs-d3d11: Allow rebuild even if output duplicator fails Prevents an issue where the output duplicator would cause the program to crash if the graphics driver crashes and the graphics subsystem needs to be rebuilt.
2017-11-16 20:33:03 -08:00
try {
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_duplicator *)obj)->Start();
libobs-d3d11: Allow rebuild even if output duplicator fails Prevents an issue where the output duplicator would cause the program to crash if the graphics driver crashes and the graphics subsystem needs to be rebuilt.
2017-11-16 20:33:03 -08:00
} catch (...) {
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_duplicator *)obj)->Release();
libobs-d3d11: Allow rebuild even if output duplicator fails Prevents an issue where the output duplicator would cause the program to crash if the graphics driver crashes and the graphics subsystem needs to be rebuilt.
2017-11-16 20:33:03 -08:00
}
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
break;
case gs_type::gs_swap_chain:
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
((gs_swap_chain *)obj)->Rebuild(dev);
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
break;
libobs: Add GPU timestamp query support This change only wraps the functionality. I have rough code to exercise the the query functionality, but that part is not really clean enough to submit.
2019-07-27 13:31:07 -07:00
case gs_type::gs_timer:
((gs_timer *)obj)->Rebuild(dev);
break;
case gs_type::gs_timer_range:
((gs_timer_range *)obj)->Rebuild(dev);
break;
libobs: Add support for volume textures Also fix some mip calculations along the way.
2019-12-15 11:36:24 -08:00
case gs_type::gs_texture_3d:
((gs_texture_3d *)obj)->Rebuild(dev);
break;
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
}
obj = obj->next;
}
curRenderTarget = nullptr;
curZStencilBuffer = nullptr;
curRenderSide = 0;
memset(&curTextures, 0, sizeof(curTextures));
memset(&curSamplers, 0, sizeof(curSamplers));
curVertexBuffer = nullptr;
curIndexBuffer = nullptr;
curVertexShader = nullptr;
curPixelShader = nullptr;
curSwapChain = nullptr;
zstencilStateChanged = true;
rasterStateChanged = true;
blendStateChanged = true;
curDepthStencilState = nullptr;
curRasterState = nullptr;
curBlendState = nullptr;
curToplogy = D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED;
for (auto &state : zstencilStates)
state.Rebuild(dev);
for (auto &state : rasterStates)
state.Rebuild(dev);
for (auto &state : blendStates)
state.Rebuild(dev);
libobs: Support device loss registration Complex external systems using the D3D11 device may need to perform their own device loss handling, the upcoming Windows Graphics Capture support for example.
2019-11-27 16:35:27 -08:00
for (gs_device_loss &callback : loss_callbacks)
callback.device_loss_rebuild(device.Get(), callback.data);
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
} catch (const char *error) {
bcrash("Failed to recreate D3D11: %s", error);
libobs-d3d11: Consistent exception catch parameters Fixed missing references, and stray usages of const references instead of reference to const types. Apply const correctly where applicable.
2019-08-28 21:10:51 -07:00
} catch (const HRError &error) {
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
bcrash("Failed to recreate D3D11: %s (%08lX)", error.str, error.hr);
libobs-d3d11: Rebuild device and assets if device removed/reset Due to an NVIDIA driver bug with the Windows 10 Anniversary Update, there are an increasingly large number of reports of "Device Removed" errors and TDRs. When this happens, OBS stops outputting all data because all graphics functions are failing, and it appears to just "freeze up" for users. To temporarily alleviate this issue while waiting for it to be fixed, the D3D subsystem can be rebuilt when that happens, all assets can be reloaded to ensure that it can continue functioning (with a minor hiccup in playback). To allow rebuilding the entire D3D subsystem, all objects that contain D3D references must be part of a linked list (with a few exceptions) so we can quickly traverse them all whenever needed, and all data for those resources (static resources primarily, such as shaders, textures, index buffers, vertex buffers) must be stored in RAM so they can be recreated whenever needed. Then if D3D reports a "device removed" or "device reset" error, all D3D references must first be fully released with no stray references; the linked list must be fully traversed until all references are released. Then, the linked list must once again be traversed again, and all those D3D objects must be recreated with the same data and descriptors (which are now saved in each object). Finally, all states need to be reset. After that's complete, the device is able to continue functioning almost as it was before, although the output to recording/stream may get a few green frames due to texture data being reset. This will temporarily alleviate the "Device Removed" issue while waiting for a fix from NVIDIA.
2016-11-03 07:41:23 -07:00
}