Add test to check ID3DDeviceContextState refcounting/rewrapping

util/test/demos/d3d11/d3d11_helpers.h

@@ -91,6 +91,8 @@ COM_SMARTPTR(ID3D11DepthStencilView);
 
 COM_SMARTPTR(ID3D11Fence);
 
+COM_SMARTPTR(ID3DDeviceContextState);
+
 COM_SMARTPTR(ID3D11InfoQueue);
 COM_SMARTPTR(ID3DUserDefinedAnnotation);
 

util/test/demos/d3d11/d3d11_parameter_zoo.cpp

@@ -0,0 +1,107 @@
+/******************************************************************************
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019-2021 Baldur Karlsson
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ ******************************************************************************/
+
+#include "d3d11_test.h"
+
+RD_TEST(D3D11_Parameter_Zoo, D3D11GraphicsTest)
+{
+  static constexpr const char *Description =
+      "General tests of parameters known to cause problems - e.g. optional values that should be "
+      "ignored, edge cases, special values, etc.";
+
+  int main()
+  {
+    // initialise, create window, create device, etc
+    if(!Init())
+      return 3;
+
+    ID3DBlobPtr vsblob = Compile(D3DDefaultVertex, "main", "vs_4_0");
+    ID3DBlobPtr psblob = Compile(D3DDefaultPixel, "main", "ps_4_0");
+
+    CreateDefaultInputLayout(vsblob);
+
+    ID3D11VertexShaderPtr vs = CreateVS(vsblob);
+    ID3D11PixelShaderPtr ps = CreatePS(psblob);
+
+    ID3D11BufferPtr vb = MakeBuffer().Vertex().Data(DefaultTri);
+
+    // make a simple texture so that the structured data includes texture initial states
+    ID3D11Texture2DPtr fltTex = MakeTexture(DXGI_FORMAT_R32G32B32A32_FLOAT, 4, 4).RTV();
+    ID3D11RenderTargetViewPtr fltRT = MakeRTV(fltTex);
+
+    ID3DDeviceContextStatePtr ctxstate, ctxstate_off;
+
+    D3D_FEATURE_LEVEL feat11 = D3D_FEATURE_LEVEL_11_0;
+    CHECK_HR(dev1->CreateDeviceContextState(0, &feat11, 1, D3D11_SDK_VERSION,
+                                            __uuidof(ID3D11Device), NULL, &ctxstate));
+    CHECK_HR(dev1->CreateDeviceContextState(0, &feat11, 1, D3D11_SDK_VERSION,
+                                            __uuidof(ID3D11Device), NULL, &ctxstate_off));
+
+    ctx1->SwapDeviceContextState(ctxstate_off, NULL);
+
+    while(Running())
+    {
+      ClearRenderTargetView(bbRTV, {0.2f, 0.2f, 0.2f, 1.0f});
+      ClearRenderTargetView(fltRT, {0.2f, 0.2f, 0.2f, 1.0f});
+
+      // set the ctxstate, so it only exists in the context's memory (which we don't track)
+      ctx1->SwapDeviceContextState(ctxstate, NULL);
+      // release our resource, renderdoc will destroy it now
+      ctxstate = NULL;
+
+      // repeatedly toggle between the states and re-destroy ctxstate
+      for(int i = 0; i < 100; i++)
+      {
+        // we always need an incoming state, pass it in and get back our old state that we destroyed
+        ctx1->SwapDeviceContextState(ctxstate_off, &ctxstate);
+
+        // again make it disappear
+        ctx1->SwapDeviceContextState(ctxstate, NULL);
+        ctxstate = NULL;
+      }
+
+      IASetVertexBuffer(vb, sizeof(DefaultA2V), 0);
+      ctx->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
+      ctx->IASetInputLayout(defaultLayout);
+
+      ctx->VSSetShader(vs, NULL, 0);
+      ctx->PSSetShader(ps, NULL, 0);
+
+      RSSetViewport({0.0f, 0.0f, (float)screenWidth, (float)screenHeight, 0.0f, 1.0f});
+
+      ctx->OMSetRenderTargets(1, &bbRTV.GetInterfacePtr(), NULL);
+
+      ctx->Draw(3, 0);
+
+      Present();
+
+      // get back to how we should be with a handle to ctxstate and ctxstate_off bound
+      ctx1->SwapDeviceContextState(ctxstate_off, &ctxstate);
+    }
+
+    return 0;
+  }
+};
+
+REGISTER_TEST();

util/test/demos/demos.vcxproj

@@ -148,6 +148,7 @@
     <ClCompile Include="d3d11\d3d11_mip_gen_rt.cpp" />
     <ClCompile Include="d3d11\d3d11_mip_rtv.cpp" />
     <ClCompile Include="d3d11\d3d11_overdraw_stress.cpp" />
+    <ClCompile Include="d3d11\d3d11_parameter_zoo.cpp" />
     <ClCompile Include="d3d11\d3d11_pixel_history_zoo.cpp" />
     <ClCompile Include="d3d11\d3d11_primitiveid.cpp" />
     <ClCompile Include="d3d11\d3d11_shader_debug_zoo.cpp" />

util/test/demos/demos.vcxproj.filters

@@ -568,6 +568,9 @@
     <ClCompile Include="d3d11\d3d11_amd_shader_extensions.cpp">
       <Filter>D3D11\demos</Filter>
     </ClCompile>
+    <ClCompile Include="d3d11\d3d11_parameter_zoo.cpp">
+      <Filter>D3D11\demos</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <Filter Include="D3D11">

util/test/rdtest/capture.py

@@ -6,12 +6,6 @@ from . import util
 from .logging import log
 
 
-# Keep running until we get a capture
-def run_until_capture(control):
-    """Exits when the first capture is made"""
-    return len(control.captures()) == 0
-
-
 class TargetControl():
     def __init__(self, ident: int, host="localhost", username="testrunner", force=True, timeout=None, exit_kill=True):
         """
@@ -60,7 +54,7 @@ class TargetControl():
         if self.control is not None:
             self.control.QueueCapture(frame, num)
 
-    def run(self, keep_running=run_until_capture):
+    def run(self, keep_running):
         """
         Runs a loop ticking the target control. The callback is called each time and
         can be used to determine if the loop should keep running. The default callback
@@ -92,12 +86,12 @@ class TargetControl():
             # If we got a new capture, add it to our list
             if msg.type == rd.TargetControlMessageType.NewCapture:
                 self._captures.append(msg.newCapture)
-                break
+                continue
 
             # Similarly for a new child
             if msg.type == rd.TargetControlMessageType.NewChild:
                 self._children.append(msg.newChild)
-                break
+                continue
 
         # Shut down the connection
         self.control.Shutdown()
@@ -180,15 +174,18 @@ def run_and_capture(exe: str, cmdline: str, frame: int, *, frame_count=1, captur
     # Capture frame
     control.queue_capture(frame, frame_count)
 
-    # By default, runs until the first capture is made
-    control.run()
+    # Run until we have all expected captures (probably just 1). If the program
+    # exits or times out we will also stop, of course
+    control.run(keep_running=lambda x: len(x.captures()) < frame_count)
 
     captures = control.captures()
 
     if logfile is not None and os.path.exists(logfile):
         log.inline_file('Process output', logfile, with_stdout=True)
 
-    if len(captures) == 0:
-        raise RuntimeError("No capture made")
+    if len(captures) != frame_count:
+        if len(captures) == 0:
+            raise RuntimeError("No capture made in program")
+        raise RuntimeError("Expected {} captures, but only got {}".format(frame_count, len(captures)))
 
-    return captures[0].path
+    return captures[0].path

util/test/tests/D3D11/D3D11_Parameter_Zoo.py

@@ -0,0 +1,13 @@
+import renderdoc as rd
+import rdtest
+
+
+class D3D11_Parameter_Zoo(rdtest.TestCase):
+    demos_test_name = 'D3D11_Parameter_Zoo'
+    demos_frame_cap = 50
+    demos_frame_count = 10
+
+    def check_capture(self):
+        rdtest.log.success("Got {} captures as expected".format(self.demos_frame_count))
+        # if we successfully got all the captures, so far that's all we care about
+        pass