libobs: Add support for volume textures

Also fix some mip calculations along the way.

libobs-d3d11/CMakeLists.txt

@@ -26,6 +26,7 @@ set(libobs-d3d11_SOURCES
 	d3d11-stagesurf.cpp
 	d3d11-subsystem.cpp
 	d3d11-texture2d.cpp
+	d3d11-texture3d.cpp
 	d3d11-vertexbuffer.cpp
 	d3d11-duplicator.cpp
 	d3d11-rebuild.cpp

libobs-d3d11/d3d11-rebuild.cpp

@@ -251,6 +251,70 @@ void gs_timer_range::Rebuild(ID3D11Device *dev)
 		throw HRError("Failed to create timer", hr);
 }
 
+void gs_texture_3d::RebuildSharedTextureFallback()
+{
+	td = {};
+	td.Width = 2;
+	td.Height = 2;
+	td.Depth = 2;
+	td.MipLevels = 1;
+	td.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
+	td.BindFlags = D3D11_BIND_SHADER_RESOURCE;
+
+	width = td.Width;
+	height = td.Height;
+	depth = td.Depth;
+	dxgiFormat = td.Format;
+	levels = 1;
+
+	resourceDesc = {};
+	resourceDesc.Format = td.Format;
+	resourceDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
+	resourceDesc.Texture3D.MostDetailedMip = 0;
+	resourceDesc.Texture3D.MipLevels = 1;
+
+	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,
+			     "Failed to rebuild shared texture: ", "0x%08lX",
+			     hr);
+			RebuildSharedTextureFallback();
+		}
+	}
+
+	if (!isShared) {
+		hr = dev->CreateTexture3D(
+			&td, data.size() ? srd.data() : nullptr, &texture);
+		if (FAILED(hr))
+			throw HRError("Failed to create 3D texture", hr);
+	}
+
+	hr = dev->CreateShaderResourceView(texture, &resourceDesc, &shaderRes);
+	if (FAILED(hr))
+		throw HRError("Failed to create resource view", hr);
+
+	if (isRenderTarget)
+		InitRenderTargets();
+
+	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);
+	}
+}
+
 void SavedBlendState::Rebuild(ID3D11Device *dev)
 {
 	HRESULT hr = dev->CreateBlendState(&bd, &state);
@@ -327,6 +391,9 @@ try {
 		case gs_type::gs_timer_range:
 			((gs_timer_range *)obj)->Release();
 			break;
+		case gs_type::gs_texture_3d:
+			((gs_texture_3d *)obj)->Release();
+			break;
 		}
 
 		obj = obj->next;
@@ -409,6 +476,9 @@ try {
 		case gs_type::gs_timer_range:
 			((gs_timer_range *)obj)->Rebuild(dev);
 			break;
+		case gs_type::gs_texture_3d:
+			((gs_texture_3d *)obj)->Rebuild(dev);
+			break;
 		}
 
 		obj = obj->next;

libobs-d3d11/d3d11-subsystem.cpp

@@ -1145,19 +1145,23 @@ gs_texture_t *device_cubetexture_create(gs_device_t *device, uint32_t size,
 gs_texture_t *device_voltexture_create(gs_device_t *device, uint32_t width,
 				       uint32_t height, uint32_t depth,
 				       enum gs_color_format color_format,
-				       uint32_t levels, const uint8_t **data,
+				       uint32_t levels,
+				       const uint8_t *const *data,
 				       uint32_t flags)
 {
-	/* TODO */
-	UNUSED_PARAMETER(device);
-	UNUSED_PARAMETER(width);
-	UNUSED_PARAMETER(height);
-	UNUSED_PARAMETER(depth);
-	UNUSED_PARAMETER(color_format);
-	UNUSED_PARAMETER(levels);
-	UNUSED_PARAMETER(data);
-	UNUSED_PARAMETER(flags);
-	return NULL;
+	gs_texture *texture = NULL;
+	try {
+		texture = new gs_texture_3d(device, width, height, depth,
+					    color_format, levels, data, flags);
+	} catch (const HRError &error) {
+		blog(LOG_ERROR, "device_voltexture_create (D3D11): %s (%08lX)",
+		     error.str, error.hr);
+		LogD3D11ErrorDetails(error, device);
+	} catch (const char *error) {
+		blog(LOG_ERROR, "device_voltexture_create (D3D11): %s", error);
+	}
+
+	return texture;
 }
 
 gs_zstencil_t *device_zstencil_create(gs_device_t *device, uint32_t width,

libobs-d3d11/d3d11-subsystem.hpp

@@ -294,6 +294,7 @@ enum class gs_type {
 	gs_swap_chain,
 	gs_timer,
 	gs_timer_range,
+	gs_texture_3d,
 };
 
 struct gs_obj {
@@ -458,10 +459,10 @@ struct gs_texture_2d : gs_texture {
 	D3D11_TEXTURE2D_DESC td = {};
 
 	void InitSRD(vector<D3D11_SUBRESOURCE_DATA> &srd);
-	void InitTexture(const uint8_t **data);
+	void InitTexture(const uint8_t *const *data);
 	void InitResourceView();
 	void InitRenderTargets();
-	void BackupTexture(const uint8_t **data);
+	void BackupTexture(const uint8_t *const *data);
 	void GetSharedHandle(IDXGIResource *dxgi_res);
 
 	void RebuildSharedTextureFallback();
@@ -482,7 +483,7 @@ struct gs_texture_2d : gs_texture {
 
 	gs_texture_2d(gs_device_t *device, uint32_t width, uint32_t height,
 		      gs_color_format colorFormat, uint32_t levels,
-		      const uint8_t **data, uint32_t flags,
+		      const uint8_t *const *data, uint32_t flags,
 		      gs_texture_type type, bool gdiCompatible,
 		      bool nv12 = false);
 
@@ -491,6 +492,56 @@ struct gs_texture_2d : gs_texture {
 	gs_texture_2d(gs_device_t *device, uint32_t handle);
 };
 
+struct gs_texture_3d : gs_texture {
+	ComPtr<ID3D11Texture3D> texture;
+	ComPtr<ID3D11RenderTargetView> renderTarget[6];
+
+	uint32_t width = 0, height = 0, depth = 0;
+	uint32_t flags = 0;
+	DXGI_FORMAT dxgiFormat = DXGI_FORMAT_UNKNOWN;
+	bool isRenderTarget = false;
+	bool isDynamic = false;
+	bool isShared = false;
+	bool genMipmaps = false;
+	uint32_t sharedHandle = GS_INVALID_HANDLE;
+
+	bool chroma = false;
+	bool acquired = false;
+
+	vector<vector<uint8_t>> data;
+	vector<D3D11_SUBRESOURCE_DATA> srd;
+	D3D11_TEXTURE3D_DESC td = {};
+
+	void InitSRD(vector<D3D11_SUBRESOURCE_DATA> &srd);
+	void InitTexture(const uint8_t *const *data);
+	void InitResourceView();
+	void InitRenderTargets();
+	void BackupTexture(const uint8_t *const *data);
+	void GetSharedHandle(IDXGIResource *dxgi_res);
+
+	void RebuildSharedTextureFallback();
+	void Rebuild(ID3D11Device *dev);
+	void RebuildNV12_Y(ID3D11Device *dev);
+	void RebuildNV12_UV(ID3D11Device *dev);
+
+	inline void Release()
+	{
+		texture.Release();
+		for (auto &rt : renderTarget)
+			rt.Release();
+		shaderRes.Release();
+	}
+
+	inline gs_texture_3d() : gs_texture(GS_TEXTURE_3D, 0, GS_UNKNOWN) {}
+
+	gs_texture_3d(gs_device_t *device, uint32_t width, uint32_t height,
+		      uint32_t depth, gs_color_format colorFormat,
+		      uint32_t levels, const uint8_t *const *data,
+		      uint32_t flags);
+
+	gs_texture_3d(gs_device_t *device, uint32_t handle);
+};
+
 struct gs_zstencil_buffer : gs_obj {
 	ComPtr<ID3D11Texture2D> texture;
 	ComPtr<ID3D11DepthStencilView> view;

libobs-d3d11/d3d11-texture2d.cpp

@@ -27,7 +27,7 @@ void gs_texture_2d::InitSRD(vector<D3D11_SUBRESOURCE_DATA> &srd)
 	size_t curTex = 0;
 
 	if (!actual_levels)
-		actual_levels = gs_get_total_levels(width, height);
+		actual_levels = gs_get_total_levels(width, height, 1);
 
 	rowSizeBytes /= 8;
 
@@ -48,7 +48,7 @@ void gs_texture_2d::InitSRD(vector<D3D11_SUBRESOURCE_DATA> &srd)
 	}
 }
 
-void gs_texture_2d::BackupTexture(const uint8_t **data)
+void gs_texture_2d::BackupTexture(const uint8_t *const *data)
 {
 	this->data.resize(levels);
 
@@ -66,8 +66,10 @@ void gs_texture_2d::BackupTexture(const uint8_t **data)
 		vector<uint8_t> &subData = this->data[i];
 		memcpy(&subData[0], data[i], texSize);
 
-		w /= 2;
-		h /= 2;
+		if (w > 1)
+			w /= 2;
+		if (h > 1)
+			h /= 2;
 	}
 }
 
@@ -87,7 +89,7 @@ void gs_texture_2d::GetSharedHandle(IDXGIResource *dxgi_res)
 	}
 }
 
-void gs_texture_2d::InitTexture(const uint8_t **data)
+void gs_texture_2d::InitTexture(const uint8_t *const *data)
 {
 	HRESULT hr;
 
@@ -226,7 +228,7 @@ void gs_texture_2d::InitRenderTargets()
 
 gs_texture_2d::gs_texture_2d(gs_device_t *device, uint32_t width,
 			     uint32_t height, gs_color_format colorFormat,
-			     uint32_t levels, const uint8_t **data,
+			     uint32_t levels, const uint8_t *const *data,
 			     uint32_t flags_, gs_texture_type type,
 			     bool gdiCompatible, bool nv12_)
 	: gs_texture(device, gs_type::gs_texture_2d, type, levels, colorFormat),

libobs-d3d11/d3d11-texture3d.cpp

@@ -0,0 +1,252 @@
+/******************************************************************************
+    Copyright (C) 2013 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 <util/base.h>
+#include "d3d11-subsystem.hpp"
+
+void gs_texture_3d::InitSRD(vector<D3D11_SUBRESOURCE_DATA> &srd)
+{
+	uint32_t rowSizeBits = width * gs_get_format_bpp(format);
+	uint32_t sliceSizeBytes = height * rowSizeBits / 8;
+	uint32_t actual_levels = levels;
+
+	if (!actual_levels)
+		actual_levels = gs_get_total_levels(width, height, depth);
+
+	uint32_t newRowSize = rowSizeBits / 8;
+	uint32_t newSlizeSize = sliceSizeBytes;
+
+	for (uint32_t level = 0; level < actual_levels; ++level) {
+		D3D11_SUBRESOURCE_DATA newSRD;
+		newSRD.pSysMem = data[level].data();
+		newSRD.SysMemPitch = newRowSize;
+		newSRD.SysMemSlicePitch = newSlizeSize;
+		srd.push_back(newSRD);
+
+		newRowSize /= 2;
+		newSlizeSize /= 4;
+	}
+}
+
+void gs_texture_3d::BackupTexture(const uint8_t *const *data)
+{
+	this->data.resize(levels);
+
+	uint32_t w = width;
+	uint32_t h = height;
+	uint32_t d = depth;
+	const uint32_t bbp = gs_get_format_bpp(format);
+
+	for (uint32_t i = 0; i < levels; i++) {
+		if (!data[i])
+			break;
+
+		const uint32_t texSize = bbp * w * h * d / 8;
+		this->data[i].resize(texSize);
+
+		vector<uint8_t> &subData = this->data[i];
+		memcpy(&subData[0], data[i], texSize);
+
+		if (w > 1)
+			w /= 2;
+		if (h > 1)
+			h /= 2;
+		if (d > 1)
+			d /= 2;
+	}
+}
+
+void gs_texture_3d::GetSharedHandle(IDXGIResource *dxgi_res)
+{
+	HANDLE handle;
+	HRESULT hr;
+
+	hr = dxgi_res->GetSharedHandle(&handle);
+	if (FAILED(hr)) {
+		blog(LOG_WARNING,
+		     "GetSharedHandle: Failed to "
+		     "get shared handle: %08lX",
+		     hr);
+	} else {
+		sharedHandle = (uint32_t)(uintptr_t)handle;
+	}
+}
+
+void gs_texture_3d::InitTexture(const uint8_t *const *data)
+{
+	HRESULT hr;
+
+	memset(&td, 0, sizeof(td));
+	td.Width = width;
+	td.Height = height;
+	td.Depth = depth;
+	td.MipLevels = genMipmaps ? 0 : levels;
+	td.Format = dxgiFormat;
+	td.BindFlags = D3D11_BIND_SHADER_RESOURCE;
+	td.CPUAccessFlags = isDynamic ? D3D11_CPU_ACCESS_WRITE : 0;
+	td.Usage = isDynamic ? D3D11_USAGE_DYNAMIC : D3D11_USAGE_DEFAULT;
+
+	if (type == GS_TEXTURE_CUBE)
+		td.MiscFlags |= D3D11_RESOURCE_MISC_TEXTURECUBE;
+
+	if (isRenderTarget)
+		td.BindFlags |= D3D11_BIND_RENDER_TARGET;
+
+	if ((flags & GS_SHARED_KM_TEX) != 0)
+		td.MiscFlags |= D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX;
+	else if ((flags & GS_SHARED_TEX) != 0)
+		td.MiscFlags |= D3D11_RESOURCE_MISC_SHARED;
+
+	if (data) {
+		BackupTexture(data);
+		InitSRD(srd);
+	}
+
+	hr = device->device->CreateTexture3D(&td, data ? srd.data() : NULL,
+					     texture.Assign());
+	if (FAILED(hr))
+		throw HRError("Failed to create 3D texture", hr);
+
+	if (isShared) {
+		ComPtr<IDXGIResource> dxgi_res;
+
+		texture->SetEvictionPriority(DXGI_RESOURCE_PRIORITY_MAXIMUM);
+
+		hr = texture->QueryInterface(__uuidof(IDXGIResource),
+					     (void **)&dxgi_res);
+		if (FAILED(hr)) {
+			blog(LOG_WARNING,
+			     "InitTexture: Failed to query "
+			     "interface: %08lX",
+			     hr);
+		} else {
+			GetSharedHandle(dxgi_res);
+
+			if (flags & GS_SHARED_KM_TEX) {
+				ComPtr<IDXGIKeyedMutex> km;
+				hr = texture->QueryInterface(
+					__uuidof(IDXGIKeyedMutex),
+					(void **)&km);
+				if (FAILED(hr)) {
+					throw HRError("Failed to query "
+						      "IDXGIKeyedMutex",
+						      hr);
+				}
+
+				km->AcquireSync(0, INFINITE);
+				acquired = true;
+			}
+		}
+	}
+}
+
+void gs_texture_3d::InitResourceView()
+{
+	HRESULT hr;
+
+	memset(&resourceDesc, 0, sizeof(resourceDesc));
+	resourceDesc.Format = dxgiFormat;
+
+	resourceDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
+	resourceDesc.Texture3D.MostDetailedMip = 0;
+	resourceDesc.Texture3D.MipLevels = genMipmaps || !levels ? -1 : levels;
+
+	hr = device->device->CreateShaderResourceView(texture, &resourceDesc,
+						      shaderRes.Assign());
+	if (FAILED(hr))
+		throw HRError("Failed to create resource view", hr);
+}
+
+void gs_texture_3d::InitRenderTargets()
+{
+	D3D11_RENDER_TARGET_VIEW_DESC rtv;
+	rtv.Format = dxgiFormat;
+	rtv.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D;
+	rtv.Texture3D.MipSlice = 0;
+	rtv.Texture3D.WSize = 1;
+
+	for (UINT i = 0; i < 6; i++) {
+		rtv.Texture3D.FirstWSlice = i;
+		const HRESULT hr = device->device->CreateRenderTargetView(
+			texture, &rtv, renderTarget[i].Assign());
+		if (FAILED(hr))
+			throw HRError("Failed to create volume render "
+				      "target view",
+				      hr);
+	}
+}
+
+#define SHARED_FLAGS (GS_SHARED_TEX | GS_SHARED_KM_TEX)
+
+gs_texture_3d::gs_texture_3d(gs_device_t *device, uint32_t width,
+			     uint32_t height, uint32_t depth,
+			     gs_color_format colorFormat, uint32_t levels,
+			     const uint8_t *const *data, uint32_t flags_)
+	: gs_texture(device, gs_type::gs_texture_3d, GS_TEXTURE_3D, levels,
+		     colorFormat),
+	  width(width),
+	  height(height),
+	  depth(depth),
+	  flags(flags_),
+	  dxgiFormat(ConvertGSTextureFormat(format)),
+	  isRenderTarget((flags_ & GS_RENDER_TARGET) != 0),
+	  isDynamic((flags_ & GS_DYNAMIC) != 0),
+	  isShared((flags_ & SHARED_FLAGS) != 0),
+	  genMipmaps((flags_ & GS_BUILD_MIPMAPS) != 0),
+	  sharedHandle(GS_INVALID_HANDLE)
+{
+	InitTexture(data);
+	InitResourceView();
+
+	if (isRenderTarget)
+		InitRenderTargets();
+}
+
+gs_texture_3d::gs_texture_3d(gs_device_t *device, uint32_t handle)
+	: gs_texture(device, gs_type::gs_texture_3d, GS_TEXTURE_3D),
+	  isShared(true),
+	  sharedHandle(handle)
+{
+	HRESULT hr;
+	hr = device->device->OpenSharedResource((HANDLE)(uintptr_t)handle,
+						IID_PPV_ARGS(texture.Assign()));
+	if (FAILED(hr))
+		throw HRError("Failed to open shared 3D texture", hr);
+
+	texture->GetDesc(&td);
+
+	this->type = GS_TEXTURE_3D;
+	this->format = ConvertDXGITextureFormat(td.Format);
+	this->levels = 1;
+	this->device = device;
+
+	this->width = td.Width;
+	this->height = td.Height;
+	this->depth = td.Depth;
+	this->dxgiFormat = td.Format;
+
+	memset(&resourceDesc, 0, sizeof(resourceDesc));
+	resourceDesc.Format = td.Format;
+	resourceDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
+	resourceDesc.Texture3D.MostDetailedMip = 0;
+	resourceDesc.Texture3D.MipLevels = 1;
+
+	hr = device->device->CreateShaderResourceView(texture, &resourceDesc,
+						      shaderRes.Assign());
+	if (FAILED(hr))
+		throw HRError("Failed to create shader resource view", hr);
+}