Steve Lhomme pushed to branch master at VideoLAN / VLC
Commits: c3748d50 by Steve Lhomme at 2021-07-12T08:33:35+02:00 common: don't use [static] in C++ code This is a C99 thing. - - - - - 5fc6a7ca by Steve Lhomme at 2021-07-12T08:33:36+02:00 chroma: copy: allow use from C++ code - - - - - 6b7a6d86 by Steve Lhomme at 2021-07-12T08:34:00+02:00 vout: direct3d11: build in C++ This allows using COM helpers and shorter API calls. It's already built with C++ from the sensor and DirectComposition handlers. - - - - - 19 changed files: - include/vlc_common.h - modules/video_chroma/copy.h - modules/video_chroma/d3d11_fmt.h - modules/video_chroma/dxgi_fmt.h - modules/video_output/Makefile.am - modules/video_output/win32/common.h - modules/video_output/win32/d3d11_quad.c → modules/video_output/win32/d3d11_quad.cpp - modules/video_output/win32/d3d11_shaders.c → modules/video_output/win32/d3d11_shaders.cpp - modules/video_output/win32/d3d11_shaders.h - modules/video_output/win32/d3d11_swapchain.c → modules/video_output/win32/d3d11_swapchain.cpp - modules/video_output/win32/d3d11_swapchain.h - modules/video_output/win32/d3d_dynamic_shader.h - modules/video_output/win32/d3d_shaders.h - − modules/video_output/win32/dcomp_wrapper.cpp - − modules/video_output/win32/dcomp_wrapper.h - modules/video_output/win32/direct3d11.c → modules/video_output/win32/direct3d11.cpp - modules/video_output/win32/dxgi_swapchain.c → modules/video_output/win32/dxgi_swapchain.cpp - modules/video_output/win32/dxgi_swapchain.h - po/POTFILES.in Changes: ===================================== include/vlc_common.h ===================================== @@ -1230,4 +1230,10 @@ VLC_API const char * VLC_Compiler( void ) VLC_USED; "Public License;\nsee the file named COPYING for details.\n" \ "Written by the VideoLAN team; see the AUTHORS file.\n") +#if defined(__cplusplus) || defined(_MSC_VER) +#define ARRAY_STATIC_SIZE +#else +#define ARRAY_STATIC_SIZE static +#endif + #endif /* !VLC_COMMON_H */ ===================================== modules/video_chroma/copy.h ===================================== @@ -25,6 +25,10 @@ #include <assert.h> +#ifdef __cplusplus +extern "C" { +#endif + typedef struct { # ifdef CAN_COMPILE_SSE2 uint8_t *buffer; @@ -43,35 +47,35 @@ void CopyPacked(picture_t *dst, const uint8_t *src, const copy_cache_t *cache); /* Copy planes from NV12/NV21 to NV12/NV21 */ -void Copy420_SP_to_SP(picture_t *dst, const uint8_t *src[static 2], - const size_t src_pitch[static 2], unsigned height, +void Copy420_SP_to_SP(picture_t *dst, const uint8_t *src[ARRAY_STATIC_SIZE 2], + const size_t src_pitch[ARRAY_STATIC_SIZE 2], unsigned height, const copy_cache_t *cache); /* Copy planes from I420/YV12 to I420/YV12 */ -void Copy420_P_to_P(picture_t *dst, const uint8_t *src[static 3], - const size_t src_pitch[static 3], unsigned height, +void Copy420_P_to_P(picture_t *dst, const uint8_t *src[ARRAY_STATIC_SIZE 3], + const size_t src_pitch[ARRAY_STATIC_SIZE 3], unsigned height, const copy_cache_t *cache); /* Copy planes from I420/YV12 to NV12/NV21 */ -void Copy420_P_to_SP(picture_t *dst, const uint8_t *src[static 3], - const size_t src_pitch[static 3], unsigned height, +void Copy420_P_to_SP(picture_t *dst, const uint8_t *src[ARRAY_STATIC_SIZE 3], + const size_t src_pitch[ARRAY_STATIC_SIZE 3], unsigned height, const copy_cache_t *cache); /* Copy planes from NV12/NV21 to I420/YV12 */ -void Copy420_SP_to_P(picture_t *dst, const uint8_t *src[static 2], - const size_t src_pitch[static 2], unsigned height, +void Copy420_SP_to_P(picture_t *dst, const uint8_t *src[ARRAY_STATIC_SIZE 2], + const size_t src_pitch[ARRAY_STATIC_SIZE 2], unsigned height, const copy_cache_t *cache); /* Copy planes from I420_10 to P010. A positive bitshift value will shift bits * to the right, a negative value will shift to the left. */ -void Copy420_16_P_to_SP(picture_t *dst, const uint8_t *src[static 3], - const size_t src_pitch[static 3], unsigned height, +void Copy420_16_P_to_SP(picture_t *dst, const uint8_t *src[ARRAY_STATIC_SIZE 3], + const size_t src_pitch[ARRAY_STATIC_SIZE 3], unsigned height, int bitshift, const copy_cache_t *cache); /* Copy planes from P010 to I420_10. A positive bitshift value will shift bits * to the right, a negative value will shift to the left. */ -void Copy420_16_SP_to_P(picture_t *dst, const uint8_t *src[static 2], - const size_t src_pitch[static 2], unsigned height, +void Copy420_16_SP_to_P(picture_t *dst, const uint8_t *src[ARRAY_STATIC_SIZE 2], + const size_t src_pitch[ARRAY_STATIC_SIZE 2], unsigned height, int bitshift, const copy_cache_t *cache); /** @@ -85,4 +89,8 @@ void Copy420_16_SP_to_P(picture_t *dst, const uint8_t *src[static 2], */ int picture_UpdatePlanes(picture_t *picture, uint8_t *data, unsigned pitch); +#ifdef __cplusplus +} +#endif + #endif ===================================== modules/video_chroma/d3d11_fmt.h ===================================== @@ -29,6 +29,15 @@ #include "dxgi_fmt.h" +#ifdef __cplusplus +extern "C" { + +#ifndef IID_GRAPHICS_PPV_ARGS +#define IID_GRAPHICS_PPV_ARGS(ppType) IID_PPV_ARGS(ppType) +#endif + +#endif + DEFINE_GUID(GUID_CONTEXT_MUTEX, 0x472e8835, 0x3f8e, 0x4f93, 0xa0, 0xcb, 0x25, 0x79, 0x77, 0x6c, 0xed, 0x86); /* see https://msdn.microsoft.com/windows/hardware/commercialize/design/compatibility/device-graphics @@ -100,7 +109,7 @@ static inline d3d11_decoder_device_t *GetD3D11OpaqueDevice(vlc_decoder_device *d { if (device == NULL || device->type != VLC_DECODER_DEVICE_D3D11VA) return NULL; - return device->opaque; + return (d3d11_decoder_device_t *)device->opaque; } static inline d3d11_decoder_device_t *GetD3D11OpaqueContext(vlc_video_context *vctx) @@ -186,4 +195,8 @@ picture_context_t *d3d11_pic_context_copy(picture_context_t *); picture_t *D3D11_AllocPicture(vlc_object_t *, const video_format_t *, vlc_video_context *, const d3d_format_t *); +#ifdef __cplusplus +} +#endif + #endif /* include-guard */ ===================================== modules/video_chroma/dxgi_fmt.h ===================================== @@ -29,6 +29,10 @@ #include <vlc_common.h> #include <vlc_fourcc.h> +#ifdef __cplusplus +extern "C" { +#endif// __cplusplus + #define GPU_MANUFACTURER_AMD 0x1002 #define GPU_MANUFACTURER_NVIDIA 0x10DE #define GPU_MANUFACTURER_VIA 0x1106 @@ -83,4 +87,8 @@ void DXGI_GetBlackColor( const d3d_format_t *, union DXGI_Color black[DXGI_MAX_RENDER_TARGET], size_t colors[DXGI_MAX_RENDER_TARGET] ); +#ifdef __cplusplus +} +#endif// __cplusplus + #endif /* include-guard */ ===================================== modules/video_output/Makefile.am ===================================== @@ -137,18 +137,15 @@ vout_LTLIBRARIES += libglinterop_dxva2_plugin.la endif endif -libdirect3d11_plugin_la_SOURCES = video_output/win32/direct3d11.c \ - video_output/win32/d3d11_quad.c video_output/win32/d3d11_quad.h \ - video_output/win32/d3d11_shaders.c video_output/win32/d3d11_shaders.h \ +libdirect3d11_plugin_la_SOURCES = video_output/win32/direct3d11.cpp \ + video_output/win32/d3d11_quad.cpp video_output/win32/d3d11_quad.h \ + video_output/win32/d3d11_shaders.cpp video_output/win32/d3d11_shaders.h \ video_output/win32/d3d_shaders.c video_output/win32/d3d_shaders.h \ video_output/win32/d3d_dynamic_shader.c video_output/win32/d3d_dynamic_shader.h \ - video_output/win32/d3d11_swapchain.c video_output/win32/d3d11_swapchain.h \ - video_output/win32/dxgi_swapchain.c video_output/win32/dxgi_swapchain.h \ + video_output/win32/d3d11_swapchain.cpp video_output/win32/d3d11_swapchain.h \ + video_output/win32/dxgi_swapchain.cpp video_output/win32/dxgi_swapchain.h \ video_output/win32/common.c video_output/win32/common.h libdirect3d11_plugin_la_LIBADD = libchroma_copy.la libd3d11_common.la $(LIBCOM) -luuid -if HAVE_DCOMP -libdirect3d11_plugin_la_SOURCES += video_output/win32/dcomp_wrapper.cpp video_output/win32/dcomp_wrapper.h -endif if !HAVE_WINSTORE libdirect3d11_plugin_la_SOURCES += video_output/win32/events.c \ video_output/win32/events.h \ ===================================== modules/video_output/win32/common.h ===================================== @@ -24,6 +24,10 @@ #include <vlc_vout_display.h> +#ifdef __cplusplus +extern "C" { +#endif// __cplusplus + /***************************************************************************** * event_thread_t: event thread *****************************************************************************/ @@ -75,9 +79,6 @@ void CommonPlacePicture (vout_display_t *, display_win32_area_t *); void CommonInit(display_win32_area_t *); -# ifdef __cplusplus -extern "C" { -# endif void* HookWindowsSensors(vout_display_t*, HWND); void UnhookWindowsSensors(void*); # ifdef __cplusplus ===================================== modules/video_output/win32/d3d11_quad.c → modules/video_output/win32/d3d11_quad.cpp ===================================== @@ -29,15 +29,16 @@ # define _WIN32_WINNT 0x0601 // _WIN32_WINNT_WIN7 #endif -#include <assert.h> +#include <cassert> #include <vlc_common.h> -#define COBJMACROS #include <d3d11.h> #include "d3d11_quad.h" #include "common.h" +using Microsoft::WRL::ComPtr; + void D3D11_RenderQuad(d3d11_device_t *d3d_dev, d3d11_quad_t *quad, d3d11_vertex_shader_t *vsshader, ID3D11ShaderResourceView *resourceView[DXGI_MAX_SHADER_VIEW], d3d11_select_plane_t selectPlane, void *selectOpaque) @@ -45,29 +46,32 @@ void D3D11_RenderQuad(d3d11_device_t *d3d_dev, d3d11_quad_t *quad, d3d11_vertex_ UINT offset = 0; /* Render the quad */ - ID3D11DeviceContext_IASetPrimitiveTopology(d3d_dev->d3dcontext, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + d3d_dev->d3dcontext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); /* vertex shader */ - ID3D11DeviceContext_IASetInputLayout(d3d_dev->d3dcontext, vsshader->layout); - ID3D11DeviceContext_IASetVertexBuffers(d3d_dev->d3dcontext, 0, 1, &quad->pVertexBuffer, &quad->generic.vertexStride, &offset); - ID3D11DeviceContext_IASetIndexBuffer(d3d_dev->d3dcontext, quad->pIndexBuffer, DXGI_FORMAT_R16_UINT, 0); - if ( quad->viewpointShaderConstant ) - ID3D11DeviceContext_VSSetConstantBuffers(d3d_dev->d3dcontext, 0, 1, &quad->viewpointShaderConstant); + d3d_dev->d3dcontext->IASetInputLayout(vsshader->layout.Get()); + d3d_dev->d3dcontext->IASetVertexBuffers(0, 1, quad->vertexBuffer.GetAddressOf(), &quad->generic.vertexStride, &offset); + d3d_dev->d3dcontext->IASetIndexBuffer(quad->indexBuffer.Get(), DXGI_FORMAT_R16_UINT, 0); + if ( quad->viewpointShaderConstant.Get() ) + d3d_dev->d3dcontext->VSSetConstantBuffers(0, 1, quad->viewpointShaderConstant.GetAddressOf()); - ID3D11DeviceContext_VSSetShader(d3d_dev->d3dcontext, vsshader->shader, NULL, 0); + d3d_dev->d3dcontext->VSSetShader(vsshader->shader.Get(), NULL, 0); - if (quad->SamplerStates[0]) - ID3D11DeviceContext_PSSetSamplers(d3d_dev->d3dcontext, 0, 2, quad->SamplerStates); + if (quad->SamplerStates[0].Get()) + { + ID3D11SamplerState *states[] = {quad->SamplerStates[0].Get(), quad->SamplerStates[1].Get()}; + d3d_dev->d3dcontext->PSSetSamplers(0, 2, states); + } /* pixel shader */ - ID3D11DeviceContext_PSSetConstantBuffers(d3d_dev->d3dcontext, 0, 1, &quad->pPixelShaderConstants); + d3d_dev->d3dcontext->PSSetConstantBuffers(0, 1, quad->pPixelShaderConstants.GetAddressOf()); assert(quad->resourceCount <= DXGI_MAX_SHADER_VIEW); - ID3D11DeviceContext_PSSetShaderResources(d3d_dev->d3dcontext, 0, quad->resourceCount, resourceView); + d3d_dev->d3dcontext->PSSetShaderResources(0, quad->resourceCount, resourceView); for (size_t i=0; i<ARRAY_SIZE(quad->d3dpixelShader); i++) { - if (!quad->d3dpixelShader[i]) + if (!quad->d3dpixelShader[i].Get()) break; ID3D11RenderTargetView *renderView = NULL; @@ -75,18 +79,18 @@ void D3D11_RenderQuad(d3d11_device_t *d3d_dev, d3d11_quad_t *quad, d3d11_vertex_ continue; if (renderView != NULL) - ID3D11DeviceContext_OMSetRenderTargets(d3d_dev->d3dcontext, 1, &renderView, NULL); + d3d_dev->d3dcontext->OMSetRenderTargets(1, &renderView, NULL); - ID3D11DeviceContext_PSSetShader(d3d_dev->d3dcontext, quad->d3dpixelShader[i], NULL, 0); + d3d_dev->d3dcontext->PSSetShader(quad->d3dpixelShader[i].Get(), NULL, 0); - ID3D11DeviceContext_RSSetViewports(d3d_dev->d3dcontext, 1, &quad->cropViewport[i]); + d3d_dev->d3dcontext->RSSetViewports(1, &quad->cropViewport[i]); - ID3D11DeviceContext_DrawIndexed(d3d_dev->d3dcontext, quad->generic.indexCount, 0, 0); + d3d_dev->d3dcontext->DrawIndexed(quad->generic.indexCount, 0, 0); // /* force unbinding the input texture, otherwise we get: // * OMSetRenderTargets: Resource being set to OM RenderTarget slot 0 is still bound on input! */ // ID3D11ShaderResourceView *reset[DXGI_MAX_SHADER_VIEW] = { 0 }; - // ID3D11DeviceContext_PSSetShaderResources(d3d_dev->d3dcontext, 0, quad->resourceCount, reset); + // d3d_dev->d3dcontext->PSSetShaderResources(0, quad->resourceCount, reset); } } @@ -97,28 +101,24 @@ static bool AllocQuadVertices(vlc_object_t *o, d3d11_device_t *d3d_dev, d3d11_qu if (!D3D_QuadSetupBuffers(o, &quad->generic, projection)) return false; - D3D11_BUFFER_DESC bd; - memset(&bd, 0, sizeof(bd)); + D3D11_BUFFER_DESC bd = { }; + bd.Usage = D3D11_USAGE_DYNAMIC; bd.ByteWidth = quad->generic.vertexStride * quad->generic.vertexCount; bd.BindFlags = D3D11_BIND_VERTEX_BUFFER; bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; - hr = ID3D11Device_CreateBuffer(d3d_dev->d3ddevice, &bd, NULL, &quad->pVertexBuffer); + hr = d3d_dev->d3ddevice->CreateBuffer(&bd, NULL, quad->vertexBuffer.GetAddressOf()); if(FAILED(hr)) { msg_Err(o, "Failed to create vertex buffer. (hr=%lX)", hr); goto fail; } /* create the index of the vertices */ - D3D11_BUFFER_DESC quadDesc = { - .Usage = D3D11_USAGE_DYNAMIC, - .ByteWidth = sizeof(WORD) * quad->generic.indexCount, - .BindFlags = D3D11_BIND_INDEX_BUFFER, - .CPUAccessFlags = D3D11_CPU_ACCESS_WRITE, - }; - - hr = ID3D11Device_CreateBuffer(d3d_dev->d3ddevice, &quadDesc, NULL, &quad->pIndexBuffer); + bd.BindFlags = D3D11_BIND_INDEX_BUFFER; + bd.ByteWidth = sizeof(WORD) * quad->generic.indexCount; + + hr = d3d_dev->d3ddevice->CreateBuffer(&bd, NULL, quad->indexBuffer.GetAddressOf()); if(FAILED(hr)) { msg_Err(o, "Could not create the quad indices. (hr=0x%lX)", hr); goto fail; @@ -126,41 +126,17 @@ static bool AllocQuadVertices(vlc_object_t *o, d3d11_device_t *d3d_dev, d3d11_qu return true; fail: - if (quad->pVertexBuffer) - { - ID3D11Buffer_Release(quad->pVertexBuffer); - quad->pVertexBuffer = NULL; - } - if (quad->pIndexBuffer) - { - ID3D11Buffer_Release(quad->pIndexBuffer); - quad->pIndexBuffer = NULL; - } + quad->vertexBuffer.Reset(); + quad->indexBuffer.Reset(); return false; } void D3D11_ReleaseQuad(d3d11_quad_t *quad) { - if (quad->pPixelShaderConstants) - { - ID3D11Buffer_Release(quad->pPixelShaderConstants); - quad->pPixelShaderConstants = NULL; - } - if (quad->pVertexBuffer) - { - ID3D11Buffer_Release(quad->pVertexBuffer); - quad->pVertexBuffer = NULL; - } - if (quad->pIndexBuffer) - { - ID3D11Buffer_Release(quad->pIndexBuffer); - quad->pIndexBuffer = NULL; - } - if (quad->viewpointShaderConstant) - { - ID3D11Buffer_Release(quad->viewpointShaderConstant); - quad->viewpointShaderConstant = NULL; - } + quad->pPixelShaderConstants.Reset(); + quad->vertexBuffer.Reset(); + quad->indexBuffer.Reset(); + quad->viewpointShaderConstant.Reset(); D3D11_ReleaseQuadPixelShader(quad); ReleaseD3D11PictureSys(&quad->picSys); } @@ -174,29 +150,29 @@ bool D3D11_UpdateQuadPosition( vlc_object_t *o, d3d11_device_t *d3d_dev, d3d11_q D3D11_MAPPED_SUBRESOURCE mappedResource; d3d_vertex_t *dst_data; - if (unlikely(quad->pVertexBuffer == NULL)) + if (unlikely(quad->vertexBuffer.Get() == NULL)) return false; /* create the vertices */ - hr = ID3D11DeviceContext_Map(d3d_dev->d3dcontext, (ID3D11Resource *)quad->pVertexBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); + hr = d3d_dev->d3dcontext->Map(quad->vertexBuffer.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if (FAILED(hr)) { msg_Err(o, "Failed to lock the vertex buffer (hr=0x%lX)", hr); return false; } - dst_data = mappedResource.pData; + dst_data = static_cast<d3d_vertex_t*>(mappedResource.pData); /* create the vertex indices */ - hr = ID3D11DeviceContext_Map(d3d_dev->d3dcontext, (ID3D11Resource *)quad->pIndexBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); + hr = d3d_dev->d3dcontext->Map(quad->indexBuffer.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if (FAILED(hr)) { msg_Err(o, "Failed to lock the index buffer (hr=0x%lX)", hr); - ID3D11DeviceContext_Unmap(d3d_dev->d3dcontext, (ID3D11Resource *)quad->pVertexBuffer, 0); + d3d_dev->d3dcontext->Unmap(quad->vertexBuffer.Get(), 0); return false; } result = D3D_SetupQuadData(o, &quad->generic, output, dst_data, mappedResource.pData, orientation); - ID3D11DeviceContext_Unmap(d3d_dev->d3dcontext, (ID3D11Resource *)quad->pIndexBuffer, 0); - ID3D11DeviceContext_Unmap(d3d_dev->d3dcontext, (ID3D11Resource *)quad->pVertexBuffer, 0); + d3d_dev->d3dcontext->Unmap(quad->indexBuffer.Get(), 0); + d3d_dev->d3dcontext->Unmap(quad->vertexBuffer.Get(), 0); return result; } @@ -207,15 +183,15 @@ static bool ShaderUpdateConstants(vlc_object_t *o, d3d11_device_t *d3d_dev, d3d1 switch (type) { case PS_CONST_LUMI_BOUNDS: - res = (ID3D11Resource *)quad->pPixelShaderConstants; + res = quad->pPixelShaderConstants.Get(); break; case VS_CONST_VIEWPOINT: - res = (ID3D11Resource *)quad->viewpointShaderConstant; + res = quad->viewpointShaderConstant.Get(); break; } D3D11_MAPPED_SUBRESOURCE mappedResource; - HRESULT hr = ID3D11DeviceContext_Map(d3d_dev->d3dcontext, res, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); + HRESULT hr = d3d_dev->d3dcontext->Map(res, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if (unlikely(FAILED(hr))) { msg_Err(o, "Failed to lock the picture shader constants (hr=0x%lX)", hr); @@ -231,7 +207,7 @@ static bool ShaderUpdateConstants(vlc_object_t *o, d3d11_device_t *d3d_dev, d3d1 memcpy(mappedResource.pData, new_buf, sizeof(VS_PROJECTION_CONST)); break; } - ID3D11DeviceContext_Unmap(d3d_dev->d3dcontext, res, 0); + d3d_dev->d3dcontext->Unmap(res, 0); return true; } @@ -258,7 +234,7 @@ void (D3D11_UpdateQuadLuminanceScale)(vlc_object_t *o, d3d11_device_t *d3d_dev, void (D3D11_UpdateViewpoint)(vlc_object_t *o, d3d11_device_t *d3d_dev, d3d11_quad_t *quad, const vlc_viewpoint_t *viewpoint, float f_sar) { - if (!quad->viewpointShaderConstant) + if (!quad->viewpointShaderConstant.Get()) return; D3D_UpdateViewpoint(&quad->generic, viewpoint, f_sar); @@ -275,13 +251,12 @@ int D3D11_AllocateQuad(vlc_object_t *o, d3d11_device_t *d3d_dev, HRESULT hr; static_assert((sizeof(PS_CONSTANT_BUFFER)%16)==0,"Constant buffers require 16-byte alignment"); - D3D11_BUFFER_DESC constantDesc = { - .Usage = D3D11_USAGE_DYNAMIC, - .ByteWidth = sizeof(PS_CONSTANT_BUFFER), - .BindFlags = D3D11_BIND_CONSTANT_BUFFER, - .CPUAccessFlags = D3D11_CPU_ACCESS_WRITE, - }; - hr = ID3D11Device_CreateBuffer(d3d_dev->d3ddevice, &constantDesc, NULL, &quad->pPixelShaderConstants); + D3D11_BUFFER_DESC constantDesc = { }; + constantDesc.Usage = D3D11_USAGE_DYNAMIC; + constantDesc.ByteWidth = sizeof(PS_CONSTANT_BUFFER); + constantDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; + constantDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + hr = d3d_dev->d3ddevice->CreateBuffer(&constantDesc, NULL, quad->pPixelShaderConstants.GetAddressOf()); if(FAILED(hr)) { msg_Err(o, "Could not create the pixel shader constant buffer. (hr=0x%lX)", hr); goto error; @@ -291,7 +266,7 @@ int D3D11_AllocateQuad(vlc_object_t *o, d3d11_device_t *d3d_dev, { static_assert((sizeof(VS_PROJECTION_CONST)%16)==0,"Constant buffers require 16-byte alignment"); constantDesc.ByteWidth = sizeof(VS_PROJECTION_CONST); - hr = ID3D11Device_CreateBuffer(d3d_dev->d3ddevice, &constantDesc, NULL, &quad->viewpointShaderConstant); + hr = d3d_dev->d3ddevice->CreateBuffer(&constantDesc, NULL, quad->viewpointShaderConstant.GetAddressOf()); if(FAILED(hr)) { msg_Err(o, "Could not create the vertex shader constant buffer. (hr=0x%lX)", hr); goto error; ===================================== modules/video_output/win32/d3d11_shaders.c → modules/video_output/win32/d3d11_shaders.cpp ===================================== @@ -31,7 +31,7 @@ #include <vlc_common.h> -#include <assert.h> +#include <cassert> #define COBJMACROS #include <d3d11.h> @@ -39,6 +39,8 @@ #include "d3d11_shaders.h" #include "d3d_dynamic_shader.h" +using Microsoft::WRL::ComPtr; + HRESULT (D3D11_CompilePixelShaderBlob)(vlc_object_t *o, const d3d_shader_compiler_t *compiler, d3d11_device_t *d3d_dev, const display_info_t *display, @@ -56,8 +58,7 @@ HRESULT D3D11_SetQuadPixelShader(vlc_object_t *o, d3d11_device_t *d3d_dev, bool sharp, d3d11_quad_t *quad, d3d_shader_blob pPSBlob[DXGI_MAX_RENDER_TARGET]) { - D3D11_SAMPLER_DESC sampDesc; - memset(&sampDesc, 0, sizeof(sampDesc)); + D3D11_SAMPLER_DESC sampDesc = { }; sampDesc.Filter = sharp ? D3D11_FILTER_MIN_MAG_MIP_POINT : D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT; sampDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP; sampDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP; @@ -67,31 +68,31 @@ HRESULT D3D11_SetQuadPixelShader(vlc_object_t *o, d3d11_device_t *d3d_dev, sampDesc.MaxLOD = D3D11_FLOAT32_MAX; HRESULT hr; - hr = ID3D11Device_CreateSamplerState(d3d_dev->d3ddevice, &sampDesc, &quad->SamplerStates[0]); + hr = d3d_dev->d3ddevice->CreateSamplerState(&sampDesc, quad->SamplerStates[0].GetAddressOf()); if (FAILED(hr)) { msg_Err(o, "Could not Create the D3d11 Sampler State. (hr=0x%lX)", hr); return hr; } sampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT; - hr = ID3D11Device_CreateSamplerState(d3d_dev->d3ddevice, &sampDesc, &quad->SamplerStates[1]); + hr = d3d_dev->d3ddevice->CreateSamplerState(&sampDesc, quad->SamplerStates[1].GetAddressOf()); if (FAILED(hr)) { msg_Err(o, "Could not Create the D3d11 Sampler State. (hr=0x%lX)", hr); - ID3D11SamplerState_Release(quad->SamplerStates[0]); + quad->SamplerStates[0].Reset(); return hr; } - hr = ID3D11Device_CreatePixelShader(d3d_dev->d3ddevice, + hr = d3d_dev->d3ddevice->CreatePixelShader( pPSBlob[0].buffer, pPSBlob[0].buf_size, - NULL, &quad->d3dpixelShader[0]); + NULL, quad->d3dpixelShader[0].GetAddressOf()); D3D_ShaderBlobRelease(&pPSBlob[0]); if (pPSBlob[1].buffer) { - hr = ID3D11Device_CreatePixelShader(d3d_dev->d3ddevice, + hr = d3d_dev->d3ddevice->CreatePixelShader( pPSBlob[1].buffer, pPSBlob[1].buf_size, - NULL, &quad->d3dpixelShader[1]); + NULL, quad->d3dpixelShader[1].GetAddressOf()); D3D_ShaderBlobRelease(&pPSBlob[1]); } @@ -102,21 +103,13 @@ void D3D11_ReleaseQuadPixelShader(d3d11_quad_t *quad) { for (size_t i=0; i<ARRAY_SIZE(quad->d3dpixelShader); i++) { - if (quad->d3dpixelShader[i]) - { - ID3D11PixelShader_Release(quad->d3dpixelShader[i]); - quad->d3dpixelShader[i] = NULL; - } - if (quad->SamplerStates[i]) - { - ID3D11SamplerState_Release(quad->SamplerStates[i]); - quad->SamplerStates[i] = NULL; - } + quad->d3dpixelShader[i].Reset(); + quad->SamplerStates[i].Reset(); } } HRESULT D3D11_CreateRenderTargets( d3d11_device_t *d3d_dev, ID3D11Resource *texture, - const d3d_format_t *cfg, ID3D11RenderTargetView *output[DXGI_MAX_RENDER_TARGET] ) + const d3d_format_t *cfg, ComPtr<ID3D11RenderTargetView> output[DXGI_MAX_RENDER_TARGET] ) { D3D11_RENDER_TARGET_VIEW_DESC renderTargetViewDesc; renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; @@ -127,8 +120,8 @@ HRESULT D3D11_CreateRenderTargets( d3d11_device_t *d3d_dev, ID3D11Resource *text if (cfg->resourceFormat[i]) { renderTargetViewDesc.Format = cfg->resourceFormat[i]; - HRESULT hr = ID3D11Device_CreateRenderTargetView(d3d_dev->d3ddevice, texture, - &renderTargetViewDesc, &output[i]); + HRESULT hr = d3d_dev->d3ddevice->CreateRenderTargetView(texture, + &renderTargetViewDesc, output[i].GetAddressOf()); if (FAILED(hr)) { return hr; @@ -139,7 +132,7 @@ HRESULT D3D11_CreateRenderTargets( d3d11_device_t *d3d_dev, ID3D11Resource *text } void D3D11_ClearRenderTargets(d3d11_device_t *d3d_dev, const d3d_format_t *cfg, - ID3D11RenderTargetView *targets[DXGI_MAX_RENDER_TARGET]) + ComPtr<ID3D11RenderTargetView> targets[DXGI_MAX_RENDER_TARGET]) { union DXGI_Color black[DXGI_MAX_RENDER_TARGET]; size_t colorCount[DXGI_MAX_RENDER_TARGET]; @@ -147,11 +140,11 @@ void D3D11_ClearRenderTargets(d3d11_device_t *d3d_dev, const d3d_format_t *cfg, if (colorCount[0]) { - ID3D11DeviceContext_ClearRenderTargetView( d3d_dev->d3dcontext, targets[0], black[0].array); + d3d_dev->d3dcontext->ClearRenderTargetView(targets[0].Get(), black[0].array); } if (colorCount[1]) { - ID3D11DeviceContext_ClearRenderTargetView( d3d_dev->d3dcontext, targets[1], black[1].array); + d3d_dev->d3dcontext->ClearRenderTargetView(targets[1].Get(), black[1].array); } } @@ -159,8 +152,8 @@ HRESULT (D3D11_CreateVertexShader)(vlc_object_t *obj, d3d_shader_blob *pVSBlob, d3d11_device_t *d3d_dev, d3d11_vertex_shader_t *output) { HRESULT hr; - hr = ID3D11Device_CreateVertexShader(d3d_dev->d3ddevice, pVSBlob->buffer, - pVSBlob->buf_size, NULL, &output->shader); + hr = d3d_dev->d3ddevice->CreateVertexShader(pVSBlob->buffer, pVSBlob->buf_size, + NULL, output->shader.GetAddressOf()); if(FAILED(hr)) { msg_Err(obj, "Failed to create the flat vertex shader. (hr=0x%lX)", hr); @@ -173,8 +166,8 @@ HRESULT (D3D11_CreateVertexShader)(vlc_object_t *obj, d3d_shader_blob *pVSBlob, { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0}, }; - hr = ID3D11Device_CreateInputLayout(d3d_dev->d3ddevice, layout, 2, pVSBlob->buffer, - pVSBlob->buf_size, &output->layout); + hr = d3d_dev->d3ddevice->CreateInputLayout(layout, 2, pVSBlob->buffer, + pVSBlob->buf_size, output->layout.GetAddressOf()); if(FAILED(hr)) { msg_Err(obj, "Failed to create the vertex input layout. (hr=0x%lX)", hr); @@ -188,16 +181,8 @@ error: void D3D11_ReleaseVertexShader(d3d11_vertex_shader_t *shader) { - if (shader->layout) - { - ID3D11InputLayout_Release(shader->layout); - shader->layout = NULL; - } - if (shader->shader) - { - ID3D11VertexShader_Release(shader->shader); - shader->shader = NULL; - } + shader->layout.Reset(); + shader->shader.Reset(); } HRESULT D3D11_CompileVertexShaderBlob(vlc_object_t *obj, const d3d_shader_compiler_t *compiler, ===================================== modules/video_output/win32/d3d11_shaders.h ===================================== @@ -28,30 +28,32 @@ #include "../../video_chroma/d3d11_fmt.h" +#include <wrl/client.h> + /* Vertex Shader compiled sructures */ -typedef struct { - ID3D11VertexShader *shader; - ID3D11InputLayout *layout; -} d3d11_vertex_shader_t; +struct d3d11_vertex_shader_t { + Microsoft::WRL::ComPtr<ID3D11VertexShader> shader; + Microsoft::WRL::ComPtr<ID3D11InputLayout> layout; +}; /* A Quad is texture that can be displayed in a rectangle */ -typedef struct +struct d3d11_quad_t { picture_sys_d3d11_t picSys; d3d_quad_t generic; - UINT resourceCount; - ID3D11Buffer *pVertexBuffer; - ID3D11Buffer *pIndexBuffer; - ID3D11Buffer *viewpointShaderConstant; - ID3D11Buffer *pPixelShaderConstants; - UINT PSConstantsCount; - ID3D11PixelShader *d3dpixelShader[DXGI_MAX_RENDER_TARGET]; - ID3D11SamplerState *SamplerStates[2]; + UINT resourceCount = 0; + Microsoft::WRL::ComPtr<ID3D11Buffer> vertexBuffer; + Microsoft::WRL::ComPtr<ID3D11Buffer> indexBuffer; + Microsoft::WRL::ComPtr<ID3D11Buffer> viewpointShaderConstant; + Microsoft::WRL::ComPtr<ID3D11Buffer> pPixelShaderConstants; + UINT PSConstantsCount = 0; + Microsoft::WRL::ComPtr<ID3D11PixelShader> d3dpixelShader[DXGI_MAX_RENDER_TARGET]; + Microsoft::WRL::ComPtr<ID3D11SamplerState> SamplerStates[2]; D3D11_VIEWPORT cropViewport[DXGI_MAX_RENDER_TARGET]; PS_CONSTANT_BUFFER pConstants; VS_PROJECTION_CONST vConstants; -} d3d11_quad_t; +}; HRESULT D3D11_CompilePixelShaderBlob(vlc_object_t *, const d3d_shader_compiler_t *, d3d11_device_t *, const display_info_t *, @@ -72,10 +74,10 @@ HRESULT D3D11_CreateVertexShader(vlc_object_t *, d3d_shader_blob *, d3d11_device #define D3D11_CreateVertexShader(a,b,c,d) D3D11_CreateVertexShader(VLC_OBJECT(a),b,c,d) HRESULT D3D11_CreateRenderTargets(d3d11_device_t *, ID3D11Resource *, const d3d_format_t *, - ID3D11RenderTargetView *output[DXGI_MAX_RENDER_TARGET]); + Microsoft::WRL::ComPtr<ID3D11RenderTargetView> output[DXGI_MAX_RENDER_TARGET]); void D3D11_ClearRenderTargets(d3d11_device_t *, const d3d_format_t *, - ID3D11RenderTargetView *targets[DXGI_MAX_RENDER_TARGET]); + Microsoft::WRL::ComPtr<ID3D11RenderTargetView> targets[DXGI_MAX_RENDER_TARGET]); void D3D11_ReleaseVertexShader(d3d11_vertex_shader_t *); ===================================== modules/video_output/win32/d3d11_swapchain.c → modules/video_output/win32/d3d11_swapchain.cpp ===================================== @@ -31,7 +31,7 @@ #include <vlc/libvlc_renderer_discoverer.h> #include <vlc/libvlc_media_player.h> -#include <assert.h> +#include <cassert> #if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0601 // _WIN32_WINNT_WIN7 # undef _WIN32_WINNT @@ -40,45 +40,44 @@ #include <windows.h> -#define COBJMACROS -#include <initguid.h> #include <d3d11.h> #include "dxgi_swapchain.h" #include "d3d11_swapchain.h" #include "d3d11_shaders.h" -#ifdef HAVE_DCOMP_H -# include "dcomp_wrapper.h" -#endif +#include <new> + +using Microsoft::WRL::ComPtr; struct d3d11_local_swapchain { - struct dxgi_swapchain *sys; + struct dxgi_swapchain *sys = nullptr; - vlc_object_t *obj; - d3d11_device_t *d3d_dev; + vlc_object_t *obj = nullptr; + d3d11_device_t *d3d_dev = nullptr; - ID3D11RenderTargetView *swapchainTargetView[DXGI_MAX_RENDER_TARGET]; + ComPtr<ID3D11RenderTargetView> swapchainTargetView[DXGI_MAX_RENDER_TARGET]; }; DEFINE_GUID(GUID_SWAPCHAIN_WIDTH, 0xf1b59347, 0x1643, 0x411a, 0xad, 0x6b, 0xc7, 0x80, 0x17, 0x7a, 0x06, 0xb6); DEFINE_GUID(GUID_SWAPCHAIN_HEIGHT, 0x6ea976a0, 0x9d60, 0x4bb7, 0xa5, 0xa9, 0x7d, 0xd1, 0x18, 0x7f, 0xc9, 0xbd); -static bool UpdateSwapchain( struct d3d11_local_swapchain *display, const libvlc_video_render_cfg_t *cfg ) +static bool UpdateSwapchain( d3d11_local_swapchain *display, const libvlc_video_render_cfg_t *cfg ) { HRESULT hr; - D3D11_TEXTURE2D_DESC dsc = { 0 }; + D3D11_TEXTURE2D_DESC dsc = { }; uint8_t bitsPerChannel = 0; - if ( display->swapchainTargetView[0] ) { - ID3D11Resource *res = NULL; - ID3D11RenderTargetView_GetResource( display->swapchainTargetView[0], &res ); + if ( display->swapchainTargetView[0].Get() ) { + ComPtr<ID3D11Resource> res; + display->swapchainTargetView[0]->GetResource( res.GetAddressOf() ); if ( res ) { - ID3D11Texture2D_GetDesc( (ID3D11Texture2D*) res, &dsc ); - ID3D11Resource_Release( res ); + ComPtr<ID3D11Texture2D> res2d; + if (SUCCEEDED(res.As(&res2d))) + res2d->GetDesc( &dsc ); } assert(DXGI_GetPixelFormat(display->sys)->formatTexture == dsc.Format); bitsPerChannel = DXGI_GetPixelFormat(display->sys)->bitsPerChannel; @@ -89,22 +88,17 @@ static bool UpdateSwapchain( struct d3d11_local_swapchain *display, const libvlc return true; /* nothing changed */ for ( size_t i = 0; i < ARRAY_SIZE( display->swapchainTargetView ); i++ ) - { - if ( display->swapchainTargetView[i] ) { - ID3D11RenderTargetView_Release( display->swapchainTargetView[i] ); - display->swapchainTargetView[i] = NULL; - } - } + display->swapchainTargetView[i].Reset(); const d3d_format_t *newPixelFormat = NULL; #if VLC_WINSTORE_APP - IDXGISwapChain1 *dxgiswapChain = DXGI_GetSwapChain1(display->sys); - if (dxgiswapChain == NULL) - dxgiswapChain = (void*)(uintptr_t)var_InheritInteger(display->obj, "winrt-swapchain"); - if (dxgiswapChain != NULL) + ComPtr<IDXGISwapChain1> dxgiswapChain = DXGI_GetSwapChain1(display->sys); + if (!dxgiswapChain.Get()) + dxgiswapChain = static_cast<IDXGISwapChain1*>((void*)(uintptr_t)var_InheritInteger(display->obj, "winrt-swapchain")); + if (dxgiswapChain.Get()) { DXGI_SWAP_CHAIN_DESC1 scd; - if (SUCCEEDED(IDXGISwapChain1_GetDesc1(dxgiswapChain, &scd))) + if (SUCCEEDED(dxgiswapChain->GetDesc1(&scd))) { for (const d3d_format_t *output_format = DxgiGetRenderFormatList(); output_format->name != NULL; ++output_format) @@ -135,35 +129,29 @@ static bool UpdateSwapchain( struct d3d11_local_swapchain *display, const libvlc return false; } - IDXGIDevice *pDXGIDevice = NULL; - hr = ID3D11Device_QueryInterface(display->d3d_dev->d3ddevice, &IID_IDXGIDevice, (void **)&pDXGIDevice); + ComPtr<IDXGIDevice> pDXGIDevice; + hr = display->d3d_dev->d3ddevice->QueryInterface(IID_GRAPHICS_PPV_ARGS(pDXGIDevice.GetAddressOf())); if (FAILED(hr)) { return false; } - IDXGIAdapter *dxgiadapter; - hr = IDXGIDevice_GetAdapter(pDXGIDevice, &dxgiadapter); - IDXGIDevice_Release(pDXGIDevice); + ComPtr<IDXGIAdapter> dxgiadapter; + hr = pDXGIDevice->GetAdapter(dxgiadapter.GetAddressOf()); if (FAILED(hr)) { return false; } - if (!DXGI_UpdateSwapChain( display->sys, dxgiadapter, (IUnknown*) display->d3d_dev->d3ddevice, newPixelFormat, cfg )) - { - IDXGIAdapter_Release(dxgiadapter); + if (!DXGI_UpdateSwapChain( display->sys, dxgiadapter.Get(), display->d3d_dev->d3ddevice, newPixelFormat, cfg )) return false; - } - IDXGIAdapter_Release(dxgiadapter); - ID3D11Resource* pBackBuffer; - hr = IDXGISwapChain1_GetBuffer( DXGI_GetSwapChain1(display->sys), 0, &IID_ID3D11Resource, (LPVOID *) &pBackBuffer ); + ComPtr<ID3D11Resource> pBackBuffer; + hr = DXGI_GetSwapChain1(display->sys)->GetBuffer( 0, IID_GRAPHICS_PPV_ARGS(pBackBuffer.GetAddressOf()) ); if ( FAILED( hr ) ) { msg_Err( display->obj, "Could not get the backbuffer for the Swapchain. (hr=0x%lX)", hr ); return false; } - hr = D3D11_CreateRenderTargets( display->d3d_dev, pBackBuffer, + hr = D3D11_CreateRenderTargets( display->d3d_dev, pBackBuffer.Get(), DXGI_GetPixelFormat(display->sys), display->swapchainTargetView ); - ID3D11Resource_Release( pBackBuffer ); if ( FAILED( hr ) ) { msg_Err( display->obj, "Failed to create the target view. (hr=0x%lX)", hr ); return false; @@ -176,20 +164,14 @@ static bool UpdateSwapchain( struct d3d11_local_swapchain *display, const libvlc void D3D11_LocalSwapchainCleanupDevice( void *opaque ) { - struct d3d11_local_swapchain *display = opaque; - for (size_t i=0; i < ARRAY_SIZE(display->swapchainTargetView); i++) - { - if (display->swapchainTargetView[i]) { - ID3D11RenderTargetView_Release(display->swapchainTargetView[i]); - display->swapchainTargetView[i] = NULL; - } - } + d3d11_local_swapchain *display = static_cast<d3d11_local_swapchain *>(opaque); DXGI_LocalSwapchainCleanupDevice(display->sys); + delete display; } bool D3D11_LocalSwapchainUpdateOutput( void *opaque, const libvlc_video_render_cfg_t *cfg, libvlc_video_output_cfg_t *out ) { - struct d3d11_local_swapchain *display = opaque; + d3d11_local_swapchain *display = static_cast<d3d11_local_swapchain *>(opaque); if ( !UpdateSwapchain( display, cfg ) ) return false; DXGI_SwapchainUpdateOutput(display->sys, out); @@ -198,26 +180,26 @@ bool D3D11_LocalSwapchainUpdateOutput( void *opaque, const libvlc_video_render_c void D3D11_LocalSwapchainSwap( void *opaque ) { - struct d3d11_local_swapchain *display = opaque; + d3d11_local_swapchain *display = static_cast<d3d11_local_swapchain *>(opaque); DXGI_LocalSwapchainSwap( display->sys ); } void D3D11_LocalSwapchainSetMetadata( void *opaque, libvlc_video_metadata_type_t type, const void *metadata ) { - struct d3d11_local_swapchain *display = opaque; + d3d11_local_swapchain *display = static_cast<d3d11_local_swapchain *>(opaque); DXGI_LocalSwapchainSetMetadata( display->sys, type, metadata ); } bool D3D11_LocalSwapchainWinstoreSize( void *opaque, uint32_t *width, uint32_t *height ) { #if VLC_WINSTORE_APP - struct d3d11_local_swapchain *display = opaque; + d3d11_local_swapchain *display = static_cast<d3d11_local_swapchain *>(opaque); /* legacy UWP mode, the width/height was set in GUID_SWAPCHAIN_WIDTH/HEIGHT */ UINT dataSize = sizeof(*width); - HRESULT hr = IDXGISwapChain1_GetPrivateData(DXGI_GetSwapChain1(display->sys), &GUID_SWAPCHAIN_WIDTH, &dataSize, width); + HRESULT hr = DXGI_GetSwapChain1(display->sys)->GetPrivateData(GUID_SWAPCHAIN_WIDTH, &dataSize, width); if (SUCCEEDED(hr)) { dataSize = sizeof(*height); - hr = IDXGISwapChain1_GetPrivateData(DXGI_GetSwapChain1(display->sys), &GUID_SWAPCHAIN_HEIGHT, &dataSize, height); + hr = DXGI_GetSwapChain1(display->sys)->GetPrivateData(GUID_SWAPCHAIN_HEIGHT, &dataSize, height); return SUCCEEDED(hr); } #else @@ -228,7 +210,7 @@ bool D3D11_LocalSwapchainWinstoreSize( void *opaque, uint32_t *width, uint32_t * bool D3D11_LocalSwapchainStartEndRendering( void *opaque, bool enter ) { - struct d3d11_local_swapchain *display = opaque; + d3d11_local_swapchain *display = static_cast<d3d11_local_swapchain *>(opaque); if ( enter ) D3D11_ClearRenderTargets( display->d3d_dev, DXGI_GetPixelFormat(display->sys), display->swapchainTargetView ); @@ -238,17 +220,17 @@ bool D3D11_LocalSwapchainStartEndRendering( void *opaque, bool enter ) bool D3D11_LocalSwapchainSelectPlane( void *opaque, size_t plane, void *out ) { - struct d3d11_local_swapchain *display = opaque; - if (!display->swapchainTargetView[plane]) + d3d11_local_swapchain *display = static_cast<d3d11_local_swapchain *>(opaque); + if (!display->swapchainTargetView[plane].Get()) return false; - ID3D11RenderTargetView **output = out; - *output = display->swapchainTargetView[plane]; + ID3D11RenderTargetView **output = static_cast<ID3D11RenderTargetView **>(out); + *output = display->swapchainTargetView[plane].Get(); return true; } void *D3D11_CreateLocalSwapchainHandleHwnd(vlc_object_t *o, HWND hwnd, d3d11_device_t *d3d_dev) { - struct d3d11_local_swapchain *display = vlc_obj_calloc(o, 1, sizeof(*display)); + d3d11_local_swapchain *display = new (std::nothrow) d3d11_local_swapchain(); if (unlikely(display == NULL)) return NULL; @@ -262,10 +244,10 @@ void *D3D11_CreateLocalSwapchainHandleHwnd(vlc_object_t *o, HWND hwnd, d3d11_dev return display; } -#ifdef HAVE_DCOMP_H +#if defined(HAVE_DCOMP_H) && !VLC_WINSTORE_APP void *D3D11_CreateLocalSwapchainHandleDComp(vlc_object_t *o, void* dcompDevice, void* dcompVisual, d3d11_device_t *d3d_dev) { - struct d3d11_local_swapchain *display = vlc_obj_calloc(o, 1, sizeof(*display)); + d3d11_local_swapchain *display = new (std::nothrow) d3d11_local_swapchain(); if (unlikely(display == NULL)) return NULL; ===================================== modules/video_output/win32/d3d11_swapchain.h ===================================== @@ -29,7 +29,7 @@ #include "../../video_chroma/d3d11_fmt.h" void *D3D11_CreateLocalSwapchainHandleHwnd(vlc_object_t *, HWND, d3d11_device_t *d3d_dev); -#ifdef HAVE_DCOMP_H +#if defined(HAVE_DCOMP_H) && !VLC_WINSTORE_APP void *D3D11_CreateLocalSwapchainHandleDComp(vlc_object_t *, void* dcompDevice, void* dcompVisual, d3d11_device_t *d3d_dev); #endif ===================================== modules/video_output/win32/d3d_dynamic_shader.h ===================================== @@ -23,6 +23,10 @@ #ifndef VLC_D3D_DYNAMIC_SHADER_H #define VLC_D3D_DYNAMIC_SHADER_H +#ifdef __cplusplus +extern "C" { +#endif// __cplusplus + typedef struct { HINSTANCE compiler_dll; /* handle of the opened d3dcompiler dll */ @@ -45,4 +49,8 @@ HRESULT D3D_CompileVertexShader(vlc_object_t *, const d3d_shader_compiler_t *, D3D_FEATURE_LEVEL, bool flat, d3d_shader_blob *); +#ifdef __cplusplus +} +#endif// __cplusplus + #endif /* VLC_D3D_DYNAMIC_SHADER_H */ ===================================== modules/video_output/win32/d3d_shaders.h ===================================== @@ -29,6 +29,10 @@ #include <vlc_es.h> +#ifdef __cplusplus +extern "C" { +#endif// __cplusplus + #define DEFAULT_BRIGHTNESS 100 #define DEFAULT_SRGB_BRIGHTNESS 100 #define MAX_HLG_BRIGHTNESS 1000 @@ -101,7 +105,7 @@ static inline void D3D_ShaderBlobRelease(d3d_shader_blob *blob) { if (blob->pf_release) blob->pf_release(blob); - *blob = (d3d_shader_blob) { 0 }; + *blob = (d3d_shader_blob) { }; } float D3D_GetFormatLuminance(vlc_object_t *, const video_format_t *); @@ -118,4 +122,8 @@ bool D3D_SetupQuadData(vlc_object_t *, d3d_quad_t *, const RECT *, d3d_vertex_t* void D3D_UpdateViewpoint(d3d_quad_t *, const vlc_viewpoint_t *, float f_sar); +#ifdef __cplusplus +} +#endif// __cplusplus + #endif /* VLC_D3D_SHADERS_H */ ===================================== modules/video_output/win32/dcomp_wrapper.cpp deleted ===================================== @@ -1,38 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2020 VideoLAN - * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. - *****************************************************************************/ -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - -#undef WINAPI_FAMILY -#define WINAPI_FAMILY WINAPI_FAMILY_DESKTOP_APP - -#include "dcomp_wrapper.h" -#include <dcomp.h> - -HRESULT IDCompositionVisual_SetContent(void* opaque, IUnknown *content) -{ - IDCompositionVisual* visual = (IDCompositionVisual*)opaque; - return visual->SetContent(content); -} - -HRESULT IDCompositionDevice_Commit(void* opaque) -{ - IDCompositionDevice* device = (IDCompositionDevice*)opaque; - return device->Commit(); -} ===================================== modules/video_output/win32/dcomp_wrapper.h deleted ===================================== @@ -1,35 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2020 VideoLAN - * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. - *****************************************************************************/ -#ifndef VLC_DCOMP_WRAPPER_H_ -#define VLC_DCOMP_WRAPPER_H_ - -#include <windows.h> -#include <unknwn.h> - -#ifdef __cplusplus -extern "C" { -#endif - -HRESULT IDCompositionVisual_SetContent(void* visual, IUnknown *content); -HRESULT IDCompositionDevice_Commit(void* device); - -#ifdef __cplusplus -} -#endif - -#endif ===================================== modules/video_output/win32/direct3d11.c → modules/video_output/win32/direct3d11.cpp ===================================== @@ -1,7 +1,7 @@ /***************************************************************************** - * direct3d11.c: Windows Direct3D11 video output module + * direct3d11.cpp: Windows Direct3D11 video output module ***************************************************************************** - * Copyright (C) 2014-2015 VLC authors and VideoLAN + * Copyright (C) 2014-2021 VLC authors and VideoLAN * * Authors: Martell Malone <martellmal...@gmail.com> * Steve Lhomme <rob...@gmail.com> @@ -40,11 +40,10 @@ #include <vlc/libvlc_renderer_discoverer.h> #include <vlc/libvlc_media_player.h> -#include <assert.h> +#include <cassert> #include <math.h> +#include <new> -#define COBJMACROS -#include <initguid.h> #include <d3d11.h> #ifdef HAVE_D3D11_4_H #include <d3d11_4.h> @@ -62,6 +61,8 @@ #include "common.h" #include "../../video_chroma/copy.h" +using Microsoft::WRL::ComPtr; + static int Open(vout_display_t *, const vout_display_cfg_t *, video_format_t *, vlc_video_context *); static void Close(vout_display_t *); @@ -96,20 +97,20 @@ typedef struct vout_display_sys_t int log_level; /* Sensors */ - void *p_sensors; + void *p_sensors = NULL; - display_info_t display; + display_info_t display = {}; - d3d11_device_t *d3d_dev; - d3d11_decoder_device_t *local_d3d_dev; // when opened without a video context - d3d_shader_compiler_t shaders; + d3d11_device_t *d3d_dev = NULL; + d3d11_decoder_device_t *local_d3d_dev = NULL; // when opened without a video context + d3d_shader_compiler_t shaders = {}; d3d11_quad_t picQuad; #ifdef HAVE_D3D11_4_H - ID3D11Fence *d3dRenderFence; - ID3D11DeviceContext4 *d3dcontext4; - UINT64 renderFence; - HANDLE renderFinished; + ComPtr<ID3D11Fence> d3dRenderFence; + ComPtr<ID3D11DeviceContext4> d3dcontext4; + UINT64 renderFence = 0; + HANDLE renderFinished = NULL; #endif picture_sys_d3d11_t stagingSys; @@ -120,16 +121,16 @@ typedef struct vout_display_sys_t /* copy from the decoder pool into picSquad before display * Uses a Texture2D with slices rather than a Texture2DArray for the decoder */ - bool legacy_shader; + bool legacy_shader = false; // SPU vlc_fourcc_t pSubpictureChromas[2]; - d3d11_quad_t regionQuad; - int d3dregion_count; - picture_t **d3dregions; + d3d11_quad_t regionQuad; + int d3dregion_count = 0; + picture_t **d3dregions = NULL; /* outside rendering */ - void *outside_opaque; + void *outside_opaque = NULL; libvlc_video_update_output_cb updateOutputCb; libvlc_video_swap_cb swapCb; libvlc_video_makeCurrent_cb startEndRenderingCb; @@ -156,7 +157,7 @@ static int Control(vout_display_t *, int); static int UpdateDisplayFormat(vout_display_t *vd, const video_format_t *fmt) { - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); libvlc_video_render_cfg_t cfg; cfg.width = vd->cfg->display.width; @@ -204,7 +205,7 @@ static int UpdateDisplayFormat(vout_display_t *vd, const video_format_t *fmt) return VLC_EGENERIC; } - display_info_t new_display = { 0 }; + display_info_t new_display = { }; for (const d3d_format_t *output_format = DxgiGetRenderFormatList(); output_format->name != NULL; ++output_format) @@ -228,7 +229,7 @@ static int UpdateDisplayFormat(vout_display_t *vd, const video_format_t *fmt) new_display.b_full_range = out.full_range; /* guestimate the display peak luminance */ - switch (out.transfer) + switch (new_display.transfer) { case TRANSFER_FUNC_LINEAR: case TRANSFER_FUNC_SRGB: @@ -263,27 +264,25 @@ static int UpdateDisplayFormat(vout_display_t *vd, const video_format_t *fmt) static void UpdateSize(vout_display_t *vd) { - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); msg_Dbg(vd, "Detected size change %dx%d", sys->area.place.width, sys->area.place.height); UpdateDisplayFormat(vd, vd->fmt); - RECT rect_dst = { - .left = sys->area.place.x, - .right = sys->area.place.x + sys->area.place.width, - .top = sys->area.place.y, - .bottom = sys->area.place.y + sys->area.place.height - }; + RECT rect_dst; + rect_dst.left = sys->area.place.x; + rect_dst.right = sys->area.place.x + sys->area.place.width; + rect_dst.top = sys->area.place.y; + rect_dst.bottom = sys->area.place.y + sys->area.place.height; D3D11_UpdateViewport( &sys->picQuad, &rect_dst, sys->display.pixelFormat ); - RECT source_rect = { - .left = vd->source->i_x_offset, - .right = vd->source->i_x_offset + vd->source->i_visible_width, - .top = vd->source->i_y_offset, - .bottom = vd->source->i_y_offset + vd->source->i_visible_height, - }; + RECT source_rect; + source_rect.left = vd->source->i_x_offset; + source_rect.right = vd->source->i_x_offset + vd->source->i_visible_width; + source_rect.top = vd->source->i_y_offset; + source_rect.bottom = vd->source->i_y_offset + vd->source->i_visible_height; d3d11_device_lock( sys->d3d_dev ); D3D11_UpdateQuadPosition(vd, sys->d3d_dev, &sys->picQuad, &source_rect, @@ -303,8 +302,8 @@ static void UpdateSize(vout_display_t *vd) static int SetViewpoint(vout_display_t *vd, const vlc_viewpoint_t *viewpoint) { - vout_display_sys_t *sys = vd->sys; - if ( sys->picQuad.viewpointShaderConstant ) + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); + if ( sys->picQuad.viewpointShaderConstant.Get() ) { d3d11_device_lock( sys->d3d_dev ); D3D11_UpdateViewpoint( vd, sys->d3d_dev, &sys->picQuad, viewpoint, @@ -316,7 +315,7 @@ static int SetViewpoint(vout_display_t *vd, const vlc_viewpoint_t *viewpoint) static int UpdateStaging(vout_display_t *vd, const video_format_t *fmt) { - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); #ifdef HAVE_ID3D11VIDEODECODER if (sys->legacy_shader) { @@ -359,9 +358,12 @@ static const struct vlc_display_operations ops = { static int Open(vout_display_t *vd, const vout_display_cfg_t *cfg, video_format_t *fmtp, vlc_video_context *context) { - vout_display_sys_t *sys = vd->sys = vlc_obj_calloc(VLC_OBJECT(vd), 1, sizeof(vout_display_sys_t)); + vout_display_sys_t *sys = new (std::nothrow) vout_display_sys_t(); if (!sys) return VLC_ENOMEM; + vd->sys = sys; + + d3d11_decoder_device_t *dev_sys = NULL; int ret = D3D_InitShaderCompiler(VLC_OBJECT(vd), &sys->shaders); if (ret != VLC_SUCCESS) @@ -370,13 +372,13 @@ static int Open(vout_display_t *vd, const vout_display_cfg_t *cfg, CommonInit(&sys->area); sys->outside_opaque = var_InheritAddress( vd, "vout-cb-opaque" ); - sys->updateOutputCb = var_InheritAddress( vd, "vout-cb-update-output" ); - sys->swapCb = var_InheritAddress( vd, "vout-cb-swap" ); - sys->startEndRenderingCb = var_InheritAddress( vd, "vout-cb-make-current" ); - sys->sendMetadataCb = var_InheritAddress( vd, "vout-cb-metadata" ); - sys->selectPlaneCb = var_InheritAddress( vd, "vout-cb-select-plane" ); + sys->updateOutputCb = (libvlc_video_update_output_cb)var_InheritAddress( vd, "vout-cb-update-output" ); + sys->swapCb = (libvlc_video_swap_cb)var_InheritAddress( vd, "vout-cb-swap" ); + sys->startEndRenderingCb = (libvlc_video_makeCurrent_cb)var_InheritAddress( vd, "vout-cb-make-current" ); + sys->sendMetadataCb = (libvlc_video_frameMetadata_cb)var_InheritAddress( vd, "vout-cb-metadata" ); + sys->selectPlaneCb = (libvlc_video_output_select_plane_cb)var_InheritAddress( vd, "vout-cb-select-plane" ); - d3d11_decoder_device_t *dev_sys = GetD3D11OpaqueContext( context ); + dev_sys = GetD3D11OpaqueContext( context ); if ( dev_sys == NULL ) { // No d3d11 device, we create one @@ -402,7 +404,7 @@ static int Open(vout_display_t *vd, const vout_display_cfg_t *cfg, #endif /* !VLC_WINSTORE_APP */ /* use our internal swapchain callbacks */ -#ifdef HAVE_DCOMP_H +#if defined(HAVE_DCOMP_H) && !VLC_WINSTORE_APP if (cfg->window->type == VOUT_WINDOW_TYPE_DCOMP) sys->outside_opaque = D3D11_CreateLocalSwapchainHandleDComp(VLC_OBJECT(vd), cfg->window->display.dcomp_device, cfg->window->handle.dcomp_visual, sys->d3d_dev); else @@ -455,18 +457,18 @@ error: static void Close(vout_display_t *vd) { - vout_display_sys_t *sys = vd->sys; - + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); D3D_ReleaseShaderCompiler(&sys->shaders); - Direct3D11Close(vd); #if !VLC_WINSTORE_APP UnhookWindowsSensors(sys->p_sensors); CommonWindowClean(&sys->sys); #endif + Direct3D11Close(vd); + delete sys; } static int Control(vout_display_t *vd, int query) { - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); int res = CommonControl( vd, &sys->area, &sys->sys, query ); if ( sys->area.place_changed ) @@ -480,7 +482,7 @@ static int Control(vout_display_t *vd, int query) static bool SelectRenderPlane(void *opaque, size_t plane, ID3D11RenderTargetView **targetView) { - vout_display_sys_t *sys = opaque; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(opaque); if (!sys->selectPlaneCb) { *targetView = NULL; @@ -493,7 +495,7 @@ static void PreparePicture(vout_display_t *vd, picture_t *picture, subpicture_t vlc_tick_t date) { VLC_UNUSED(date); - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); if (sys->picQuad.generic.textureFormat->formatTexture == DXGI_FORMAT_UNKNOWN) { @@ -503,17 +505,17 @@ static void PreparePicture(vout_display_t *vd, picture_t *picture, subpicture_t bool b_mapped = true; for (i = 0; i < picture->i_planes; i++) { - hr = ID3D11DeviceContext_Map(sys->d3d_dev->d3dcontext, sys->stagingSys.resource[i], + hr = sys->d3d_dev->d3dcontext->Map(sys->stagingSys.resource[i], 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if( unlikely(FAILED(hr)) ) { while (i-- > 0) - ID3D11DeviceContext_Unmap(sys->d3d_dev->d3dcontext, sys->stagingSys.resource[i], 0); + sys->d3d_dev->d3dcontext->Unmap(sys->stagingSys.resource[i], 0); b_mapped = false; break; } sys->stagingPlanes[i].i_pitch = mappedResource.RowPitch; - sys->stagingPlanes[i].p_pixels = mappedResource.pData; + sys->stagingPlanes[i].p_pixels = static_cast<uint8_t*>(mappedResource.pData); } if (b_mapped) @@ -522,7 +524,7 @@ static void PreparePicture(vout_display_t *vd, picture_t *picture, subpicture_t plane_CopyPixels(&sys->stagingPlanes[i], &picture->p[i]); for (i = 0; i < picture->i_planes; i++) - ID3D11DeviceContext_Unmap(sys->d3d_dev->d3dcontext, sys->stagingSys.resource[i], 0); + sys->d3d_dev->d3dcontext->Unmap(sys->stagingSys.resource[i], 0); } } else if (!is_d3d11_opaque(picture->format.i_chroma)) @@ -530,13 +532,13 @@ static void PreparePicture(vout_display_t *vd, picture_t *picture, subpicture_t D3D11_MAPPED_SUBRESOURCE mappedResource; HRESULT hr; - hr = ID3D11DeviceContext_Map(sys->d3d_dev->d3dcontext, sys->stagingSys.resource[0], + hr = sys->d3d_dev->d3dcontext->Map(sys->stagingSys.resource[0], 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if( unlikely(FAILED(hr)) ) msg_Err(vd, "Failed to map the %4.4s staging picture. (hr=0x%lX)", (const char*)&picture->format.i_chroma, hr); else { - uint8_t *buf = mappedResource.pData; + uint8_t *buf = static_cast<uint8_t*>(mappedResource.pData); for (int i = 0; i < picture->i_planes; i++) { sys->stagingPlanes[i].i_pitch = mappedResource.RowPitch; @@ -547,7 +549,7 @@ static void PreparePicture(vout_display_t *vd, picture_t *picture, subpicture_t buf += sys->stagingPlanes[i].i_pitch * sys->stagingPlanes[i].i_lines; } - ID3D11DeviceContext_Unmap(sys->d3d_dev->d3dcontext, sys->stagingSys.resource[0], 0); + sys->d3d_dev->d3dcontext->Unmap(sys->stagingSys.resource[0], 0); } } else @@ -556,16 +558,15 @@ static void PreparePicture(vout_display_t *vd, picture_t *picture, subpicture_t if (sys->legacy_shader) { D3D11_TEXTURE2D_DESC srcDesc,texDesc; - ID3D11Texture2D_GetDesc(p_sys->texture[KNOWN_DXGI_INDEX], &srcDesc); - ID3D11Texture2D_GetDesc(sys->stagingSys.texture[0], &texDesc); - D3D11_BOX box = { - .top = 0, - .bottom = __MIN(srcDesc.Height, texDesc.Height), - .left = 0, - .right = __MIN(srcDesc.Width, texDesc.Width), - .back = 1, - }; - ID3D11DeviceContext_CopySubresourceRegion(sys->d3d_dev->d3dcontext, + p_sys->texture[KNOWN_DXGI_INDEX]->GetDesc(&srcDesc); + sys->stagingSys.texture[0]->GetDesc(&texDesc); + D3D11_BOX box; + box.top = 0; + box.bottom = __MIN(srcDesc.Height, texDesc.Height); + box.left = 0; + box.right = __MIN(srcDesc.Width, texDesc.Width); + box.back = 1; + sys->d3d_dev->d3dcontext->CopySubresourceRegion( sys->stagingSys.resource[KNOWN_DXGI_INDEX], 0, 0, 0, 0, p_sys->resource[KNOWN_DXGI_INDEX], @@ -574,7 +575,7 @@ static void PreparePicture(vout_display_t *vd, picture_t *picture, subpicture_t else { D3D11_TEXTURE2D_DESC texDesc; - ID3D11Texture2D_GetDesc(p_sys->texture[0], &texDesc); + p_sys->texture[0]->GetDesc(&texDesc); if (texDesc.BindFlags & D3D11_BIND_SHADER_RESOURCE) { /* for performance reason we don't want to allocate this during @@ -634,7 +635,7 @@ static void PreparePicture(vout_display_t *vd, picture_t *picture, subpicture_t } #ifdef HAVE_D3D11_4_H - if (sys->d3dcontext4) + if (sys->d3dcontext4.Get()) { vlc_tick_t render_start; if (sys->log_level >= 4) @@ -645,8 +646,8 @@ static void PreparePicture(vout_display_t *vd, picture_t *picture, subpicture_t sys->renderFence++; ResetEvent(sys->renderFinished); - ID3D11Fence_SetEventOnCompletion(sys->d3dRenderFence, sys->renderFence, sys->renderFinished); - ID3D11DeviceContext4_Signal(sys->d3dcontext4, sys->d3dRenderFence, sys->renderFence); + sys->d3dRenderFence->SetEventOnCompletion(sys->renderFence, sys->renderFinished); + sys->d3dcontext4->Signal(sys->d3dRenderFence.Get(), sys->renderFence); WaitForSingleObject(sys->renderFinished, INFINITE); if (sys->log_level >= 4) @@ -658,7 +659,7 @@ static void PreparePicture(vout_display_t *vd, picture_t *picture, subpicture_t static void Prepare(vout_display_t *vd, picture_t *picture, subpicture_t *subpicture, vlc_tick_t date) { - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); d3d11_device_lock( sys->d3d_dev ); #if VLC_WINSTORE_APP @@ -704,7 +705,7 @@ static void Prepare(vout_display_t *vd, picture_t *picture, static void Display(vout_display_t *vd, picture_t *picture) { - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); VLC_UNUSED(picture); d3d11_device_lock( sys->d3d_dev ); @@ -714,7 +715,7 @@ static void Display(vout_display_t *vd, picture_t *picture) static const d3d_format_t *GetDirectRenderingFormat(vout_display_t *vd, vlc_fourcc_t i_src_chroma) { - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); UINT supportFlags = D3D11_FORMAT_SUPPORT_SHADER_LOAD; if (is_d3d11_opaque(i_src_chroma)) @@ -725,7 +726,7 @@ static const d3d_format_t *GetDirectRenderingFormat(vout_display_t *vd, vlc_four static const d3d_format_t *GetDirectDecoderFormat(vout_display_t *vd, vlc_fourcc_t i_src_chroma) { - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); UINT supportFlags = D3D11_FORMAT_SUPPORT_DECODER_OUTPUT; return FindD3D11Format( vd, sys->d3d_dev, i_src_chroma, DXGI_RGB_FORMAT|DXGI_YUV_FORMAT, 0, 0, 0, @@ -738,7 +739,7 @@ static const d3d_format_t *GetDisplayFormatByDepth(vout_display_t *vd, uint8_t b bool from_processor, int rgb_yuv) { - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); UINT supportFlags = D3D11_FORMAT_SUPPORT_SHADER_LOAD; if (from_processor) @@ -750,7 +751,7 @@ static const d3d_format_t *GetDisplayFormatByDepth(vout_display_t *vd, uint8_t b static const d3d_format_t *GetBlendableFormat(vout_display_t *vd, vlc_fourcc_t i_src_chroma) { - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); UINT supportFlags = D3D11_FORMAT_SUPPORT_SHADER_LOAD | D3D11_FORMAT_SUPPORT_BLENDABLE; return FindD3D11Format( vd, sys->d3d_dev, i_src_chroma, DXGI_RGB_FORMAT|DXGI_YUV_FORMAT, 0, 0, 0, DXGI_CHROMA_CPU, supportFlags ); @@ -758,7 +759,7 @@ static const d3d_format_t *GetBlendableFormat(vout_display_t *vd, vlc_fourcc_t i static int Direct3D11Open(vout_display_t *vd, video_format_t *fmtp, vlc_video_context *vctx) { - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); video_format_t fmt; video_format_Copy(&fmt, vd->source); int err = SetupOutputFormat(vd, &fmt, vctx); @@ -825,7 +826,7 @@ static int Direct3D11Open(vout_display_t *vd, video_format_t *fmtp, vlc_video_co static int SetupOutputFormat(vout_display_t *vd, video_format_t *fmt, vlc_video_context *vctx) { - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); d3d11_video_context_t *vtcx_sys = GetD3D11ContextPrivate(vctx); if (vtcx_sys != NULL && @@ -951,7 +952,7 @@ static int SetupOutputFormat(vout_display_t *vd, video_format_t *fmt, vlc_video_ static void Direct3D11Close(vout_display_t *vd) { - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); Direct3D11DestroyResources(vd); @@ -966,7 +967,7 @@ static void Direct3D11Close(vout_display_t *vd) static bool CanUseTextureArray(vout_display_t *vd) { - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); #ifndef HAVE_ID3D11VIDEODECODER (void) vd; @@ -1000,7 +1001,7 @@ static bool CanUseTextureArray(vout_display_t *vd) static bool BogusZeroCopy(const vout_display_t *vd) { - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); if (sys->d3d_dev->adapterDesc.VendorId != GPU_MANUFACTURER_AMD) return false; @@ -1025,13 +1026,13 @@ static bool BogusZeroCopy(const vout_display_t *vd) TODO : seperate out into smaller functions like createshaders */ static int Direct3D11CreateFormatResources(vout_display_t *vd, const video_format_t *fmt) { - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); HRESULT hr; sys->legacy_shader = sys->d3d_dev->feature_level < D3D_FEATURE_LEVEL_10_0 || !CanUseTextureArray(vd) || BogusZeroCopy(vd) || !is_d3d11_opaque(fmt->i_chroma); - d3d_shader_blob pPSBlob[DXGI_MAX_RENDER_TARGET] = { 0 }; + d3d_shader_blob pPSBlob[DXGI_MAX_RENDER_TARGET] = { }; hr = D3D11_CompilePixelShaderBlob(vd, &sys->shaders, sys->d3d_dev, &sys->display, fmt->transfer, fmt->color_range == COLOR_RANGE_FULL, @@ -1061,12 +1062,11 @@ static int Direct3D11CreateFormatResources(vout_display_t *vd, const video_forma return VLC_EGENERIC; } - RECT source_rect = { - .left = fmt->i_x_offset, - .right = fmt->i_x_offset + fmt->i_visible_width, - .top = fmt->i_y_offset, - .bottom = fmt->i_y_offset + fmt->i_visible_height, - }; + RECT source_rect; + source_rect.left = fmt->i_x_offset; + source_rect.right = fmt->i_x_offset + fmt->i_visible_width; + source_rect.top = fmt->i_y_offset; + source_rect.bottom = fmt->i_y_offset + fmt->i_visible_height; if (!D3D11_UpdateQuadPosition(vd, sys->d3d_dev, &sys->picQuad, &source_rect, vd->source->orientation)) { msg_Err(vd, "Could not set quad picture position."); @@ -1079,12 +1079,10 @@ static int Direct3D11CreateFormatResources(vout_display_t *vd, const video_forma (float) vd->cfg->display.width / vd->cfg->display.height ); if (is_d3d11_opaque(fmt->i_chroma)) { - ID3D10Multithread *pMultithread; - hr = ID3D11Device_QueryInterface( sys->d3d_dev->d3ddevice, &IID_ID3D10Multithread, (void **)&pMultithread); - if (SUCCEEDED(hr)) { - ID3D10Multithread_SetMultithreadProtected(pMultithread, TRUE); - ID3D10Multithread_Release(pMultithread); - } + ComPtr<ID3D10Multithread> pMultithread; + hr = sys->d3d_dev->d3ddevice->QueryInterface(IID_GRAPHICS_PPV_ARGS(pMultithread.GetAddressOf())); + if (SUCCEEDED(hr)) + pMultithread->SetMultithreadProtected(TRUE); } return UpdateStaging(vd, fmt); @@ -1094,34 +1092,23 @@ static int Direct3D11CreateFormatResources(vout_display_t *vd, const video_forma static HRESULT InitRenderFence(vout_display_sys_t *sys) { HRESULT hr; - sys->renderFinished = CreateEvent(NULL, TRUE, FALSE, NULL); - if (unlikely(sys->renderFinished == NULL)) - return S_FALSE; - ID3D11Device5 *d3ddev5 = NULL; - hr = ID3D11DeviceContext_QueryInterface(sys->d3d_dev->d3dcontext, &IID_ID3D11DeviceContext4, (void**)&sys->d3dcontext4); + ComPtr<ID3D11Device5> d3ddev5; + hr = sys->d3d_dev->d3ddevice->QueryInterface(IID_GRAPHICS_PPV_ARGS(d3ddev5.GetAddressOf())); if (FAILED(hr)) goto error; - hr = ID3D11Device_QueryInterface(sys->d3d_dev->d3ddevice, &IID_ID3D11Device5, (void**)&d3ddev5); + hr = d3ddev5->CreateFence(sys->renderFence, D3D11_FENCE_FLAG_NONE, IID_GRAPHICS_PPV_ARGS(sys->d3dRenderFence.GetAddressOf())); if (FAILED(hr)) goto error; - hr = ID3D11Device5_CreateFence(d3ddev5, sys->renderFence, D3D11_FENCE_FLAG_NONE, &IID_ID3D11Fence, (void**)&sys->d3dRenderFence); + hr = sys->d3d_dev->d3dcontext->QueryInterface(IID_GRAPHICS_PPV_ARGS(sys->d3dcontext4.GetAddressOf())); if (FAILED(hr)) goto error; - ID3D11Device5_Release(d3ddev5); - return hr; + sys->renderFinished = CreateEvent(NULL, TRUE, FALSE, NULL); + if (unlikely(sys->renderFinished == NULL)) + goto error; + return S_OK; error: - if (d3ddev5) - ID3D11Device5_Release(d3ddev5); - if (sys->d3dRenderFence) - { - ID3D11Fence_Release(sys->d3dRenderFence); - sys->d3dRenderFence = NULL; - } - if (sys->d3dcontext4) - { - ID3D11DeviceContext4_Release(sys->d3dcontext4); - sys->d3dcontext4 = NULL; - } + sys->d3dRenderFence.Reset(); + sys->d3dcontext4.Reset(); CloseHandle(sys->renderFinished); return hr; } @@ -1129,7 +1116,7 @@ error: static int Direct3D11CreateGenericResources(vout_display_t *vd) { - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); HRESULT hr; #ifdef HAVE_D3D11_4_H @@ -1140,8 +1127,8 @@ static int Direct3D11CreateGenericResources(vout_display_t *vd) } #endif - ID3D11BlendState *pSpuBlendState; - D3D11_BLEND_DESC spuBlendDesc = { 0 }; + ComPtr<ID3D11BlendState> pSpuBlendState; + D3D11_BLEND_DESC spuBlendDesc = { }; spuBlendDesc.RenderTarget[0].BlendEnable = TRUE; spuBlendDesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL; /* output colors */ @@ -1153,31 +1140,27 @@ static int Direct3D11CreateGenericResources(vout_display_t *vd) spuBlendDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE; /* keep source intact */ spuBlendDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO; /* discard */ - hr = ID3D11Device_CreateBlendState(sys->d3d_dev->d3ddevice, &spuBlendDesc, &pSpuBlendState); + hr = sys->d3d_dev->d3ddevice->CreateBlendState(&spuBlendDesc, pSpuBlendState.GetAddressOf()); if (FAILED(hr)) { msg_Err(vd, "Could not create SPU blend state. (hr=0x%lX)", hr); return VLC_EGENERIC; } - ID3D11DeviceContext_OMSetBlendState(sys->d3d_dev->d3dcontext, pSpuBlendState, NULL, 0xFFFFFFFF); - ID3D11BlendState_Release(pSpuBlendState); + sys->d3d_dev->d3dcontext->OMSetBlendState(pSpuBlendState.Get(), NULL, 0xFFFFFFFF); /* disable depth testing as we're only doing 2D * see https://msdn.microsoft.com/en-us/library/windows/desktop/bb205074%28v=vs.85%29.aspx * see http://rastertek.com/dx11tut11.html */ - D3D11_DEPTH_STENCIL_DESC stencilDesc; - ZeroMemory(&stencilDesc, sizeof(stencilDesc)); - - ID3D11DepthStencilState *pDepthStencilState; - hr = ID3D11Device_CreateDepthStencilState(sys->d3d_dev->d3ddevice, &stencilDesc, &pDepthStencilState ); - if (SUCCEEDED(hr)) { - ID3D11DeviceContext_OMSetDepthStencilState(sys->d3d_dev->d3dcontext, pDepthStencilState, 0); - ID3D11DepthStencilState_Release(pDepthStencilState); - } + D3D11_DEPTH_STENCIL_DESC stencilDesc = { }; + + ComPtr<ID3D11DepthStencilState> pDepthStencilState; + hr = sys->d3d_dev->d3ddevice->CreateDepthStencilState(&stencilDesc, pDepthStencilState.GetAddressOf() ); + if (SUCCEEDED(hr)) + sys->d3d_dev->d3dcontext->OMSetDepthStencilState(pDepthStencilState.Get(), 0); if (sys->regionQuad.generic.textureFormat != NULL) { - d3d_shader_blob pPSBlob[DXGI_MAX_RENDER_TARGET] = { 0 }; + d3d_shader_blob pPSBlob[DXGI_MAX_RENDER_TARGET] = { }; hr = D3D11_CompilePixelShaderBlob(vd, &sys->shaders, sys->d3d_dev, &sys->display, TRANSFER_FUNC_SRGB, true, &sys->regionQuad, pPSBlob); @@ -1195,7 +1178,7 @@ static int Direct3D11CreateGenericResources(vout_display_t *vd) } } - d3d_shader_blob VSBlob = { 0 }; + d3d_shader_blob VSBlob = { }; hr = D3D11_CompileVertexShaderBlob(VLC_OBJECT(vd), &sys->shaders, sys->d3d_dev, true, &VSBlob); if(FAILED(hr)) { msg_Err(vd, "Failed to compile the flat vertex shader. (hr=0x%lX)", hr); @@ -1219,12 +1202,11 @@ static int Direct3D11CreateGenericResources(vout_display_t *vd) return VLC_EGENERIC; } - RECT rect_dst = { - .left = sys->area.place.x, - .right = sys->area.place.x + sys->area.place.width, - .top = sys->area.place.y, - .bottom = sys->area.place.y + sys->area.place.height - }; + RECT rect_dst; + rect_dst.left = sys->area.place.x; + rect_dst.right = sys->area.place.x + sys->area.place.width; + rect_dst.top = sys->area.place.y; + rect_dst.bottom = sys->area.place.y + sys->area.place.height; D3D11_UpdateViewport( &sys->picQuad, &rect_dst, sys->display.pixelFormat ); @@ -1243,7 +1225,7 @@ static int Direct3D11CreateGenericResources(vout_display_t *vd) static void Direct3D11DestroyResources(vout_display_t *vd) { - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); D3D11_ReleaseQuad(&sys->picQuad); Direct3D11DeleteRegions(sys->d3dregion_count, sys->d3dregions); @@ -1256,12 +1238,10 @@ static void Direct3D11DestroyResources(vout_display_t *vd) D3D11_ReleaseVertexShader(&sys->projectionVShader); #ifdef HAVE_D3D11_4_H - if (sys->d3dcontext4) + if (sys->d3dcontext4.Get()) { - ID3D11Fence_Release(sys->d3dRenderFence); - sys->d3dRenderFence = NULL; - ID3D11DeviceContext4_Release(sys->d3dcontext4); - sys->d3dcontext4 = NULL; + sys->d3dRenderFence.Reset(); + sys->d3dcontext4.Reset(); CloseHandle(sys->renderFinished); sys->renderFinished = NULL; } @@ -1288,7 +1268,7 @@ static void DestroyPictureQuad(picture_t *p_picture) static int Direct3D11MapSubpicture(vout_display_t *vd, int *subpicture_region_count, picture_t ***region, subpicture_t *subpicture) { - vout_display_sys_t *sys = vd->sys; + vout_display_sys_t *sys = static_cast<vout_display_sys_t *>(vd->sys); D3D11_MAPPED_SUBRESOURCE mappedResource; D3D11_TEXTURE2D_DESC texDesc; HRESULT hr; @@ -1301,7 +1281,7 @@ static int Direct3D11MapSubpicture(vout_display_t *vd, int *subpicture_region_co for (subpicture_region_t *r = subpicture->p_region; r; r = r->p_next) count++; - *region = calloc(count, sizeof(picture_t *)); + *region = static_cast<picture_t**>(calloc(count, sizeof(picture_t *))); if (unlikely(*region==NULL)) return VLC_ENOMEM; *subpicture_region_count = count; @@ -1314,7 +1294,7 @@ static int Direct3D11MapSubpicture(vout_display_t *vd, int *subpicture_region_co for (int j = 0; j < sys->d3dregion_count; j++) { picture_t *cache = sys->d3dregions[j]; if (cache != NULL && ((d3d11_quad_t *) cache->p_sys)->picSys.texture[KNOWN_DXGI_INDEX]) { - ID3D11Texture2D_GetDesc( ((d3d11_quad_t *) cache->p_sys)->picSys.texture[KNOWN_DXGI_INDEX], &texDesc ); + ((d3d11_quad_t *) cache->p_sys)->picSys.texture[KNOWN_DXGI_INDEX]->GetDesc(&texDesc ); if (texDesc.Format == sys->regionQuad.generic.textureFormat->formatTexture && texDesc.Width == r->p_picture->format.i_width && texDesc.Height == r->p_picture->format.i_height) { @@ -1328,10 +1308,10 @@ static int Direct3D11MapSubpicture(vout_display_t *vd, int *subpicture_region_co picture_t *quad_picture = (*region)[i]; d3d11_quad_t *quad; if (quad_picture != NULL) - quad = quad_picture->p_sys; + quad = static_cast<d3d11_quad_t*>(quad_picture->p_sys); else { - d3d11_quad_t *d3dquad = calloc(1, sizeof(*d3dquad)); + d3d11_quad_t *d3dquad = static_cast<d3d11_quad_t *>(calloc(1, sizeof(*d3dquad))); if (unlikely(d3dquad==NULL)) { continue; } @@ -1341,7 +1321,7 @@ static int Direct3D11MapSubpicture(vout_display_t *vd, int *subpicture_region_co r->fmt.i_visible_width, r->fmt.i_visible_height); for (int j=0; j<DXGI_MAX_SHADER_VIEW; j++) if (d3dquad->picSys.texture[j]) - ID3D11Texture2D_Release(d3dquad->picSys.texture[j]); + d3dquad->picSys.texture[j]->Release(); free(d3dquad); continue; } @@ -1392,17 +1372,17 @@ static int Direct3D11MapSubpicture(vout_display_t *vd, int *subpicture_region_co if (sys->regionQuad.d3dpixelShader[j]) { d3dquad->d3dpixelShader[j] = sys->regionQuad.d3dpixelShader[j]; - ID3D11PixelShader_AddRef(d3dquad->d3dpixelShader[j]); + d3dquad->d3dpixelShader[j]->AddRef(); } } } - hr = ID3D11DeviceContext_Map(sys->d3d_dev->d3dcontext, ((d3d11_quad_t *) quad_picture->p_sys)->picSys.resource[KNOWN_DXGI_INDEX], 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); + hr = sys->d3d_dev->d3dcontext->Map(((d3d11_quad_t *) quad_picture->p_sys)->picSys.resource[KNOWN_DXGI_INDEX], 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if( SUCCEEDED(hr) ) { - err = picture_UpdatePlanes(quad_picture, mappedResource.pData, mappedResource.RowPitch); + err = picture_UpdatePlanes(quad_picture, static_cast<uint8_t*>(mappedResource.pData), mappedResource.RowPitch); if (err != VLC_SUCCESS) { msg_Err(vd, "Failed to set the buffer on the SPU picture" ); - ID3D11DeviceContext_Unmap(sys->d3d_dev->d3dcontext, ((d3d11_quad_t *) quad_picture->p_sys)->picSys.resource[KNOWN_DXGI_INDEX], 0); + sys->d3d_dev->d3dcontext->Unmap(((d3d11_quad_t *) quad_picture->p_sys)->picSys.resource[KNOWN_DXGI_INDEX], 0); picture_Release(quad_picture); if ((*region)[i] == quad_picture) (*region)[i] = NULL; @@ -1411,7 +1391,7 @@ static int Direct3D11MapSubpicture(vout_display_t *vd, int *subpicture_region_co picture_CopyPixels(quad_picture, r->p_picture); - ID3D11DeviceContext_Unmap(sys->d3d_dev->d3dcontext, ((d3d11_quad_t *) quad_picture->p_sys)->picSys.resource[KNOWN_DXGI_INDEX], 0); + sys->d3d_dev->d3dcontext->Unmap(((d3d11_quad_t *) quad_picture->p_sys)->picSys.resource[KNOWN_DXGI_INDEX], 0); } else { msg_Err(vd, "Failed to map the SPU texture (hr=0x%lX)", hr ); picture_Release(quad_picture); ===================================== modules/video_output/win32/dxgi_swapchain.c → modules/video_output/win32/dxgi_swapchain.cpp ===================================== @@ -25,7 +25,7 @@ # include "config.h" #endif -#include <assert.h> +#include <cassert> #if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0601 // _WIN32_WINNT_WIN7 # undef _WIN32_WINNT @@ -34,10 +34,8 @@ #include <vlc_es.h> -#define COBJMACROS - -#ifdef HAVE_DCOMP_H -# include "dcomp_wrapper.h" +#if defined(HAVE_DCOMP_H) && !VLC_WINSTORE_APP +# include <dcomp.h> #endif #include <initguid.h> @@ -49,6 +47,12 @@ #include "../../video_chroma/dxgi_fmt.h" +#include <new> + +#include <wrl/client.h> + +using Microsoft::WRL::ComPtr; + typedef enum video_color_axis { COLOR_AXIS_RGB, COLOR_AXIS_YCBCR, @@ -71,30 +75,30 @@ typedef struct { struct dxgi_swapchain { - vlc_object_t *obj; + vlc_object_t *obj = nullptr; - const d3d_format_t *pixelFormat; - const dxgi_color_space *colorspace; + const d3d_format_t *pixelFormat = nullptr; + const dxgi_color_space *colorspace = nullptr; swapchain_surface_type swapchainSurfaceType; - union { #if !VLC_WINSTORE_APP + union { HWND hwnd; -#endif /* !VLC_WINSTORE_APP */ -#ifdef HAVE_DCOMP_H +#if defined(HAVE_DCOMP_H) struct { - void* device; // IDCompositionDevice - void* visual; // IDCompositionVisual + IDCompositionDevice *device; + IDCompositionVisual *visual; } dcomp; #endif // HAVE_DCOMP_H } swapchainSurface; +#endif /* !VLC_WINSTORE_APP */ - IDXGISwapChain1 *dxgiswapChain; /* DXGI 1.2 swap chain */ - IDXGISwapChain4 *dxgiswapChain4; /* DXGI 1.5 for HDR metadata */ + ComPtr<IDXGISwapChain1> dxgiswapChain; /* DXGI 1.2 swap chain */ + ComPtr<IDXGISwapChain4> dxgiswapChain4; /* DXGI 1.5 for HDR metadata */ bool send_metadata; DXGI_HDR_METADATA_HDR10 hdr10; - bool logged_capabilities; + bool logged_capabilities = false; }; DEFINE_GUID(GUID_SWAPCHAIN_WIDTH, 0xf1b59347, 0x1643, 0x411a, 0xad, 0x6b, 0xc7, 0x80, 0x17, 0x7a, 0x06, 0xb6); @@ -135,7 +139,7 @@ static const dxgi_color_space color_spaces[] = { DXGIMAP(YCBCR, STUDIO, HLG, TOPLEFT, 2020) DXGIMAP(YCBCR, FULL, HLG, TOPLEFT, 2020) /*DXGIMAP(YCBCR, FULL, 22, NONE, 2020, 601)*/ - {DXGI_COLOR_SPACE_RESERVED, NULL, 0, 0, 0, 0, 0}, + {DXGI_COLOR_SPACE_RESERVED, NULL, COLOR_AXIS_RGB, COLOR_PRIMARIES_UNDEF, TRANSFER_FUNC_UNDEF, COLOR_SPACE_UNDEF, 0}, #undef DXGIMAP }; @@ -152,14 +156,16 @@ static bool canHandleConversion(const dxgi_color_space *src, const dxgi_color_sp } #endif -void DXGI_SelectSwapchainColorspace(struct dxgi_swapchain *display, const libvlc_video_render_cfg_t *cfg) +void DXGI_SelectSwapchainColorspace(dxgi_swapchain *display, const libvlc_video_render_cfg_t *cfg) { HRESULT hr; int best = 0; int score, best_score = 0; UINT support; - IDXGISwapChain3 *dxgiswapChain3 = NULL; - hr = IDXGISwapChain_QueryInterface( display->dxgiswapChain, &IID_IDXGISwapChain3, (void **)&dxgiswapChain3); + ComPtr<IDXGISwapChain3> dxgiswapChain3; + ComPtr<IDXGIOutput> dxgiOutput; + + hr = display->dxgiswapChain.As(&dxgiswapChain3); if (FAILED(hr)) { msg_Warn(display->obj, "could not get a IDXGISwapChain3"); goto done; @@ -170,7 +176,7 @@ void DXGI_SelectSwapchainColorspace(struct dxgi_swapchain *display, const libvlc best = -1; for (int i=0; color_spaces[i].name; ++i) { - hr = IDXGISwapChain3_CheckColorSpaceSupport(dxgiswapChain3, color_spaces[i].dxgi, &support); + hr = dxgiswapChain3->CheckColorSpaceSupport(color_spaces[i].dxgi, &support); if (SUCCEEDED(hr) && support) { if (!display->logged_capabilities) msg_Dbg(display->obj, "supports colorspace %s", color_spaces[i].name); @@ -181,7 +187,7 @@ void DXGI_SelectSwapchainColorspace(struct dxgi_swapchain *display, const libvlc score += 2; /* we don't want to translate color spaces */ if (color_spaces[i].transfer == (video_transfer_func_t) cfg->transfer || /* favor 2084 output for HLG source */ - (color_spaces[i].transfer == TRANSFER_FUNC_SMPTE_ST2084 && cfg->transfer == TRANSFER_FUNC_HLG)) + (color_spaces[i].transfer == TRANSFER_FUNC_SMPTE_ST2084 && cfg->transfer == libvlc_video_transfer_func_HLG)) score++; if (color_spaces[i].b_full_range == cfg->full_range) score++; @@ -199,18 +205,16 @@ void DXGI_SelectSwapchainColorspace(struct dxgi_swapchain *display, const libvlc msg_Warn(display->obj, "no matching colorspace found force %s", color_spaces[best].name); } - IDXGISwapChain_QueryInterface( display->dxgiswapChain, &IID_IDXGISwapChain4, (void **)&display->dxgiswapChain4); + display->dxgiswapChain.As(&display->dxgiswapChain4); #ifdef HAVE_DXGI1_6_H - IDXGIOutput *dxgiOutput = NULL; - - if (SUCCEEDED(IDXGISwapChain_GetContainingOutput( display->dxgiswapChain, &dxgiOutput ))) + if (SUCCEEDED(display->dxgiswapChain->GetContainingOutput(dxgiOutput.GetAddressOf()))) { - IDXGIOutput6 *dxgiOutput6 = NULL; - if (SUCCEEDED(IDXGIOutput_QueryInterface( dxgiOutput, &IID_IDXGIOutput6, (void **)&dxgiOutput6 ))) + ComPtr<IDXGIOutput6> dxgiOutput6; + if (SUCCEEDED(dxgiOutput.As(&dxgiOutput6))) { DXGI_OUTPUT_DESC1 desc1; - if (SUCCEEDED(IDXGIOutput6_GetDesc1( dxgiOutput6, &desc1 ))) + if (SUCCEEDED(dxgiOutput6->GetDesc1(&desc1 ))) { const dxgi_color_space *csp = NULL; for (int i=0; color_spaces[i].name; ++i) @@ -231,13 +235,11 @@ void DXGI_SelectSwapchainColorspace(struct dxgi_swapchain *display, const libvlc msg_Dbg(display->obj, "Output max luminance: %.1f, colorspace %s, bits per pixel %d", desc1.MaxFullFrameLuminance, csp?csp->name:"unknown", desc1.BitsPerColor); //sys->display.luminance_peak = desc1.MaxFullFrameLuminance; } - IDXGIOutput6_Release( dxgiOutput6 ); } - IDXGIOutput_Release( dxgiOutput ); } #endif - hr = IDXGISwapChain3_SetColorSpace1(dxgiswapChain3, color_spaces[best].dxgi); + hr = dxgiswapChain3->SetColorSpace1(color_spaces[best].dxgi); if (SUCCEEDED(hr)) msg_Dbg(display->obj, "using colorspace %s", color_spaces[best].name); else @@ -247,12 +249,10 @@ done: display->send_metadata = color_spaces[best].transfer == (video_transfer_func_t) cfg->transfer && color_spaces[best].primaries == (video_color_primaries_t) cfg->primaries && color_spaces[best].color == (video_color_space_t) cfg->colorspace; - if (dxgiswapChain3) - IDXGISwapChain3_Release(dxgiswapChain3); } #if !VLC_WINSTORE_APP -static void FillSwapChainDesc(struct dxgi_swapchain *display, UINT width, UINT height, DXGI_SWAP_CHAIN_DESC1 *out) +static void FillSwapChainDesc(dxgi_swapchain *display, UINT width, UINT height, DXGI_SWAP_CHAIN_DESC1 *out) { ZeroMemory(out, sizeof(*out)); out->BufferCount = DXGI_SWAP_FRAME_COUNT; @@ -285,7 +285,7 @@ static void FillSwapChainDesc(struct dxgi_swapchain *display, UINT width, UINT h } } -static void DXGI_CreateSwapchainHwnd(struct dxgi_swapchain *display, +static void DXGI_CreateSwapchainHwnd(dxgi_swapchain *display, IDXGIAdapter *dxgiadapter, IUnknown *pFactoryDevice, UINT width, UINT height) { @@ -299,38 +299,37 @@ static void DXGI_CreateSwapchainHwnd(struct dxgi_swapchain *display, DXGI_SWAP_CHAIN_DESC1 scd; FillSwapChainDesc(display, width, height, &scd); - IDXGIFactory2 *dxgifactory; - HRESULT hr = IDXGIAdapter_GetParent(dxgiadapter, &IID_IDXGIFactory2, (void **)&dxgifactory); + ComPtr<IDXGIFactory2> dxgifactory; + HRESULT hr = dxgiadapter->GetParent(IID_GRAPHICS_PPV_ARGS(dxgifactory.GetAddressOf())); if (FAILED(hr)) { msg_Err(display->obj, "Could not get the DXGI Factory. (hr=0x%lX)", hr); return; } - hr = IDXGIFactory2_CreateSwapChainForHwnd(dxgifactory, pFactoryDevice, + hr = dxgifactory->CreateSwapChainForHwnd(pFactoryDevice, display->swapchainSurface.hwnd, &scd, - NULL, NULL, &display->dxgiswapChain); + NULL, NULL, display->dxgiswapChain.GetAddressOf()); if (hr == DXGI_ERROR_INVALID_CALL && scd.Format == DXGI_FORMAT_R10G10B10A2_UNORM) { msg_Warn(display->obj, "10 bits swapchain failed, try 8 bits"); scd.Format = DXGI_FORMAT_R8G8B8A8_UNORM; - hr = IDXGIFactory2_CreateSwapChainForHwnd(dxgifactory, pFactoryDevice, + hr = dxgifactory->CreateSwapChainForHwnd(pFactoryDevice, display->swapchainSurface.hwnd, &scd, - NULL, NULL, &display->dxgiswapChain); + NULL, NULL, display->dxgiswapChain.GetAddressOf()); } - IDXGIFactory2_Release(dxgifactory); if (FAILED(hr)) { msg_Err(display->obj, "Could not create the SwapChain. (hr=0x%lX)", hr); } } -#ifdef HAVE_DCOMP_H -static void DXGI_CreateSwapchainDComp(struct dxgi_swapchain *display, +#if defined(HAVE_DCOMP_H) +static void DXGI_CreateSwapchainDComp(dxgi_swapchain *display, IDXGIAdapter *dxgiadapter, IUnknown *pFactoryDevice, UINT width, UINT height) { vlc_assert(display->swapchainSurfaceType == SWAPCHAIN_SURFACE_DCOMP); - if (display->swapchainSurface.dcomp.device == NULL || display->swapchainSurface.dcomp.visual == NULL) + if (!display->swapchainSurface.dcomp.device || !display->swapchainSurface.dcomp.visual) { msg_Err(display->obj, "missing a HWND to create the swapchain"); return; @@ -342,28 +341,26 @@ static void DXGI_CreateSwapchainDComp(struct dxgi_swapchain *display, scd.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; scd.AlphaMode = DXGI_ALPHA_MODE_IGNORE; - IDXGIFactory2 *dxgifactory; - HRESULT hr = IDXGIAdapter_GetParent(dxgiadapter, &IID_IDXGIFactory2, (void **)&dxgifactory); + ComPtr<IDXGIFactory2> dxgifactory; + HRESULT hr = dxgiadapter->GetParent(IID_GRAPHICS_PPV_ARGS(dxgifactory.GetAddressOf())); if (FAILED(hr)) { msg_Err(display->obj, "Could not get the DXGI Factory. (hr=0x%lX)", hr); return; } - hr = IDXGIFactory2_CreateSwapChainForComposition(dxgifactory, pFactoryDevice, - &scd, NULL, &display->dxgiswapChain); + hr = dxgifactory->CreateSwapChainForComposition(pFactoryDevice, + &scd, NULL, display->dxgiswapChain.GetAddressOf()); if (hr == DXGI_ERROR_INVALID_CALL && scd.Format == DXGI_FORMAT_R10G10B10A2_UNORM) { msg_Warn(display->obj, "10 bits swapchain failed, try 8 bits"); scd.Format = DXGI_FORMAT_R8G8B8A8_UNORM; - hr = IDXGIFactory2_CreateSwapChainForComposition(dxgifactory, pFactoryDevice, - &scd, NULL, &display->dxgiswapChain); + hr = dxgifactory->CreateSwapChainForComposition(pFactoryDevice, + &scd, NULL, display->dxgiswapChain.GetAddressOf()); } - IDXGIFactory2_Release(dxgifactory); if (SUCCEEDED(hr)) { - IDCompositionVisual_SetContent(display->swapchainSurface.dcomp.visual, (IUnknown *)display->dxgiswapChain); - IDCompositionDevice_Commit(display->swapchainSurface.dcomp.device); - } - if (FAILED(hr)) { + display->swapchainSurface.dcomp.visual->SetContent(display->dxgiswapChain.Get()); + display->swapchainSurface.dcomp.device->Commit(); + } else { msg_Err(display->obj, "Could not create the SwapChain. (hr=0x%lX)", hr); } } @@ -371,11 +368,11 @@ static void DXGI_CreateSwapchainDComp(struct dxgi_swapchain *display, #endif /* !VLC_WINSTORE_APP */ -void DXGI_LocalSwapchainSwap( struct dxgi_swapchain *display ) +void DXGI_LocalSwapchainSwap( dxgi_swapchain *display ) { - DXGI_PRESENT_PARAMETERS presentParams = { 0 }; + DXGI_PRESENT_PARAMETERS presentParams = { }; - HRESULT hr = IDXGISwapChain1_Present1( display->dxgiswapChain, 0, 0, &presentParams ); + HRESULT hr = display->dxgiswapChain->Present1(0, 0, &presentParams ); if ( hr == DXGI_ERROR_DEVICE_REMOVED || hr == DXGI_ERROR_DEVICE_RESET ) { /* TODO device lost */ @@ -383,14 +380,14 @@ void DXGI_LocalSwapchainSwap( struct dxgi_swapchain *display ) } } -void DXGI_LocalSwapchainSetMetadata( struct dxgi_swapchain *display, libvlc_video_metadata_type_t type, const void *metadata ) +void DXGI_LocalSwapchainSetMetadata( dxgi_swapchain *display, libvlc_video_metadata_type_t type, const void *metadata ) { assert(type == libvlc_video_metadata_frame_hdr10); if ( type == libvlc_video_metadata_frame_hdr10 && metadata && - display->send_metadata && display->dxgiswapChain4 ) + display->send_metadata && display->dxgiswapChain4.Get() ) { - const libvlc_video_frame_hdr10_metadata_t *p_hdr10 = metadata; - DXGI_HDR_METADATA_HDR10 hdr10 = { 0 }; + const libvlc_video_frame_hdr10_metadata_t *p_hdr10 = static_cast<const libvlc_video_frame_hdr10_metadata_t *>(metadata); + DXGI_HDR_METADATA_HDR10 hdr10 = { }; hdr10.GreenPrimary[0] = p_hdr10->GreenPrimary[0]; hdr10.GreenPrimary[1] = p_hdr10->GreenPrimary[1]; hdr10.BluePrimary[0] = p_hdr10->BluePrimary[0]; @@ -406,15 +403,15 @@ void DXGI_LocalSwapchainSetMetadata( struct dxgi_swapchain *display, libvlc_vide if (memcmp(&display->hdr10, &hdr10, sizeof(hdr10))) { memcpy(&display->hdr10, &hdr10, sizeof(hdr10)); - IDXGISwapChain4_SetHDRMetaData( display->dxgiswapChain4, DXGI_HDR_METADATA_TYPE_HDR10, + display->dxgiswapChain4->SetHDRMetaData(DXGI_HDR_METADATA_TYPE_HDR10, sizeof( &display->hdr10 ), &display->hdr10 ); } } } -struct dxgi_swapchain *DXGI_CreateLocalSwapchainHandleHwnd(vlc_object_t *o, HWND hwnd) +dxgi_swapchain *DXGI_CreateLocalSwapchainHandleHwnd(vlc_object_t *o, HWND hwnd) { - struct dxgi_swapchain *display = vlc_obj_calloc(o, 1, sizeof(*display)); + dxgi_swapchain *display = new (std::nothrow) dxgi_swapchain(); if (unlikely(display == NULL)) return NULL; @@ -429,37 +426,28 @@ struct dxgi_swapchain *DXGI_CreateLocalSwapchainHandleHwnd(vlc_object_t *o, HWND return display; } -#ifdef HAVE_DCOMP_H -struct dxgi_swapchain *DXGI_CreateLocalSwapchainHandleDComp(vlc_object_t *o, void* dcompDevice, void* dcompVisual) +#if defined(HAVE_DCOMP_H) && !VLC_WINSTORE_APP +dxgi_swapchain *DXGI_CreateLocalSwapchainHandleDComp(vlc_object_t *o, void* dcompDevice, void* dcompVisual) { - struct dxgi_swapchain *display = vlc_obj_calloc(o, 1, sizeof(*display)); + dxgi_swapchain *display = new (std::nothrow) dxgi_swapchain(); if (unlikely(display == NULL)) return NULL; display->obj = o; display->swapchainSurfaceType = SWAPCHAIN_SURFACE_DCOMP; - display->swapchainSurface.dcomp.device = dcompDevice; - display->swapchainSurface.dcomp.visual = dcompVisual; + display->swapchainSurface.dcomp.device = static_cast<IDCompositionDevice*>(dcompDevice); + display->swapchainSurface.dcomp.visual = static_cast<IDCompositionVisual*>(dcompVisual); return display; } #endif -void DXGI_LocalSwapchainCleanupDevice( struct dxgi_swapchain *display ) +void DXGI_LocalSwapchainCleanupDevice( dxgi_swapchain *display ) { - if (display->dxgiswapChain4) - { - IDXGISwapChain4_Release(display->dxgiswapChain4); - display->dxgiswapChain4 = NULL; - } - if (display->dxgiswapChain) - { - IDXGISwapChain_Release(display->dxgiswapChain); - display->dxgiswapChain = NULL; - } + delete display; } -void DXGI_SwapchainUpdateOutput( struct dxgi_swapchain *display, libvlc_video_output_cfg_t *out ) +void DXGI_SwapchainUpdateOutput( dxgi_swapchain *display, libvlc_video_output_cfg_t *out ) { out->dxgi_format = display->pixelFormat->formatTexture; out->full_range = display->colorspace->b_full_range; @@ -468,45 +456,44 @@ void DXGI_SwapchainUpdateOutput( struct dxgi_swapchain *display, libvlc_video_ou out->transfer = (libvlc_video_transfer_func_t) display->colorspace->transfer; } -bool DXGI_UpdateSwapChain( struct dxgi_swapchain *display, IDXGIAdapter *dxgiadapter, +bool DXGI_UpdateSwapChain( dxgi_swapchain *display, IDXGIAdapter *dxgiadapter, IUnknown *pFactoryDevice, const d3d_format_t *newPixelFormat, const libvlc_video_render_cfg_t *cfg ) { #if !VLC_WINSTORE_APP - if (display->dxgiswapChain != NULL && display->pixelFormat != newPixelFormat) + if (display->dxgiswapChain.Get() && display->pixelFormat != newPixelFormat) { // the pixel format changed, we need a new swapchain - IDXGISwapChain_Release(display->dxgiswapChain); - display->dxgiswapChain = NULL; + display->dxgiswapChain.Reset(); display->logged_capabilities = false; } - if ( display->dxgiswapChain == NULL ) + if ( !display->dxgiswapChain.Get() ) { display->pixelFormat = newPixelFormat; -#ifdef HAVE_DCOMP_H +#if defined(HAVE_DCOMP_H) if (display->swapchainSurfaceType == SWAPCHAIN_SURFACE_DCOMP) DXGI_CreateSwapchainDComp(display, dxgiadapter, pFactoryDevice, cfg->width, cfg->height); else // SWAPCHAIN_TARGET_HWND -#endif +#endif // HAVE_DCOMP_H DXGI_CreateSwapchainHwnd(display, dxgiadapter, pFactoryDevice, cfg->width, cfg->height); } #else /* VLC_WINSTORE_APP */ - if ( display->dxgiswapChain == NULL ) + if ( !display->dxgiswapChain.Get() ) { - display->dxgiswapChain = (void*)(uintptr_t)var_InheritInteger(display->obj, "winrt-swapchain"); + display->dxgiswapChain = static_cast<IDXGISwapChain1*>((void*)(uintptr_t)var_InheritInteger(display->obj, "winrt-swapchain")); } #endif /* VLC_WINSTORE_APP */ - if (display->dxgiswapChain == NULL) + if ( !display->dxgiswapChain.Get() ) return false; /* TODO detect is the size is the same as the output and switch to fullscreen mode */ HRESULT hr; - hr = IDXGISwapChain_ResizeBuffers( display->dxgiswapChain, 0, cfg->width, cfg->height, + hr = display->dxgiswapChain->ResizeBuffers(0, cfg->width, cfg->height, DXGI_FORMAT_UNKNOWN, 0 ); if ( FAILED( hr ) ) { msg_Err( display->obj, "Failed to resize the backbuffer. (hr=0x%lX)", hr ); @@ -517,17 +504,17 @@ bool DXGI_UpdateSwapChain( struct dxgi_swapchain *display, IDXGIAdapter *dxgiada return true; } -IDXGISwapChain1 *DXGI_GetSwapChain1( struct dxgi_swapchain *display ) +Microsoft::WRL::ComPtr<IDXGISwapChain1> & DXGI_GetSwapChain1( dxgi_swapchain *display ) { return display->dxgiswapChain; } -IDXGISwapChain4 *DXGI_GetSwapChain4( struct dxgi_swapchain *display ) +Microsoft::WRL::ComPtr<IDXGISwapChain4> & DXGI_GetSwapChain4( dxgi_swapchain *display ) { return display->dxgiswapChain4; } -const d3d_format_t *DXGI_GetPixelFormat( struct dxgi_swapchain *display ) +const d3d_format_t *DXGI_GetPixelFormat( dxgi_swapchain *display ) { return display->pixelFormat; } ===================================== modules/video_output/win32/dxgi_swapchain.h ===================================== @@ -32,23 +32,30 @@ #include <vlc/libvlc_renderer_discoverer.h> #include <vlc/libvlc_media_player.h> +#include <wrl/client.h> + #include <dxgi1_5.h> #include "../../video_chroma/dxgi_fmt.h" + +#ifndef IID_GRAPHICS_PPV_ARGS +#define IID_GRAPHICS_PPV_ARGS(ppType) IID_PPV_ARGS(ppType) +#endif + #define DXGI_SWAP_FRAME_COUNT 3 struct dxgi_swapchain; struct dxgi_swapchain *DXGI_CreateLocalSwapchainHandleHwnd(vlc_object_t *, HWND); -#ifdef HAVE_DCOMP_H +#if defined(HAVE_DCOMP_H) && !VLC_WINSTORE_APP struct dxgi_swapchain *DXGI_CreateLocalSwapchainHandleDComp(vlc_object_t *, void /*IDCompositionDevice*/ * dcompDevice, void /*IDCompositionVisual*/ * dcompVisual); #endif -IDXGISwapChain1 *DXGI_GetSwapChain1( struct dxgi_swapchain * ); -IDXGISwapChain4 *DXGI_GetSwapChain4( struct dxgi_swapchain * ); +Microsoft::WRL::ComPtr<IDXGISwapChain1> & DXGI_GetSwapChain1( struct dxgi_swapchain * ); +Microsoft::WRL::ComPtr<IDXGISwapChain4> & DXGI_GetSwapChain4( struct dxgi_swapchain * ); const d3d_format_t *DXGI_GetPixelFormat( struct dxgi_swapchain * ); void DXGI_SelectSwapchainColorspace( struct dxgi_swapchain *, const libvlc_video_render_cfg_t * ); @@ -61,4 +68,4 @@ bool DXGI_UpdateSwapChain( struct dxgi_swapchain *, IDXGIAdapter *, void DXGI_LocalSwapchainSwap( struct dxgi_swapchain * ); void DXGI_LocalSwapchainSetMetadata( struct dxgi_swapchain *, libvlc_video_metadata_type_t, const void * ); -#endif /* VLC_D3D11_SWAPCHAIN_H */ +#endif /* VLC_DXGI_SWAPCHAIN_H */ ===================================== po/POTFILES.in ===================================== @@ -1310,7 +1310,7 @@ modules/video_output/opengl/display.c modules/video_output/opengl/egl.c modules/video_output/opengl/vout_helper.h modules/video_output/win32/direct3d9.c -modules/video_output/win32/direct3d11.c +modules/video_output/win32/direct3d11.cpp modules/video_output/win32/drawable.c modules/video_output/win32/events.c modules/video_output/win32/glwin32.c View it on GitLab: https://code.videolan.org/videolan/vlc/-/compare/676666ab37a38b4cd9b471430c7a51c0849f4184...6b7a6d86ae30109bed34fec0b5ffc1f013ca4a81 -- View it on GitLab: https://code.videolan.org/videolan/vlc/-/compare/676666ab37a38b4cd9b471430c7a51c0849f4184...6b7a6d86ae30109bed34fec0b5ffc1f013ca4a81 You're receiving this email because of your account on code.videolan.org.
_______________________________________________ vlc-commits mailing list vlc-commits@videolan.org https://mailman.videolan.org/listinfo/vlc-commits