feat: add CalculatorGraph APIs

Assets/MediaPipe/SDK/Scripts/Framework/CalculatorGraph.cs

@@ -42,13 +42,40 @@ public class CalculatorGraph : MpResourceHandle {
       }
     }
 
+    public StatusOrPoller<T> AddOutputStreamPoller<T>(string streamName) {
+      UnsafeNativeMethods.mp_CalculatorGraph__AddOutputStreamPoller__PKc(mpPtr, streamName, out var statusOrPollerPtr).Assert();
+
+      GC.KeepAlive(this);
+      return new StatusOrPoller<T>(statusOrPollerPtr);
+    }
+
+    public Status Run() {
+      return Run(new SidePacket());
+    }
+
+    public Status Run(SidePacket sidePacket) {
+      UnsafeNativeMethods.mp_CalculatorGraph__Run__Rsp(mpPtr, sidePacket.mpPtr, out var statusPtr).Assert();
+
+      GC.KeepAlive(sidePacket);
+      GC.KeepAlive(this);
+      return new Status(statusPtr);
+    }
+
     public Status StartRun() {
       return StartRun(new SidePacket());
     }
 
     public Status StartRun(SidePacket sidePacket) {
       UnsafeNativeMethods.mp_CalculatorGraph__StartRun__Rsp(mpPtr, sidePacket.mpPtr, out var statusPtr).Assert();
 
+      GC.KeepAlive(sidePacket);
+      GC.KeepAlive(this);
+      return new Status(statusPtr);
+    }
+
+    public Status WaitUntilIdle() {
+      UnsafeNativeMethods.mp_CalculatorGraph__WaitUntilIdle(mpPtr, out var statusPtr).Assert();
+
       GC.KeepAlive(this);
       return new Status(statusPtr);
     }
@@ -60,28 +87,56 @@ public class CalculatorGraph : MpResourceHandle {
       return new Status(statusPtr);
     }
 
-    public Status CloseInputStream(string name) {
-      UnsafeNativeMethods.mp_CalculatorGraph__CloseInputStream__PKc(mpPtr, name, out var statusPtr).Assert();
+    public bool HasError() {
+      return SafeNativeMethods.mp_CalculatorGraph__HasError(mpPtr);
+    }
+
+    public Status AddPacketToInputStream<T>(string streamName, Packet<T> packet) {
+      UnsafeNativeMethods.mp_CalculatorGraph__AddPacketToInputStream__PKc_Ppacket(mpPtr, streamName, packet.mpPtr, out var statusPtr).Assert();
+      packet.Dispose(); // respect move semantics
 
       GC.KeepAlive(this);
       return new Status(statusPtr);
     }
 
-    public StatusOrPoller<T> AddOutputStreamPoller<T>(string name) {
-      UnsafeNativeMethods.mp_CalculatorGraph__AddOutputStreamPoller__PKc(mpPtr, name, out var statusOrPollerPtr).Assert();
+    public Status SetInputStreamMaxQueueSize(string streamName, int maxQueueSize) {
+      UnsafeNativeMethods.mp_CalculatorGraph__SetInputStreamMaxQueueSize__PKc_i(mpPtr, streamName, maxQueueSize, out var statusPtr).Assert();
 
       GC.KeepAlive(this);
-      return new StatusOrPoller<T>(statusOrPollerPtr);
+      return new Status(statusPtr);
     }
 
-    public Status AddPacketToInputStream<T>(string name, Packet<T> packet) {
-      UnsafeNativeMethods.mp_CalculatorGraph__AddPacketToInputStream__PKc_Ppacket(mpPtr, name, packet.mpPtr, out var statusPtr).Assert();
-      packet.Dispose(); // respect move semantics
+    public Status CloseInputStream(string streamName) {
+      UnsafeNativeMethods.mp_CalculatorGraph__CloseInputStream__PKc(mpPtr, streamName, out var statusPtr).Assert();
+
+      GC.KeepAlive(this);
+      return new Status(statusPtr);
+    }
+
+    public Status CloseAllPacketSources() {
+      UnsafeNativeMethods.mp_CalculatorGraph__CloseAllPacketSources(mpPtr, out var statusPtr).Assert();
 
       GC.KeepAlive(this);
       return new Status(statusPtr);
     }
 
+    public void Cancel() {
+      UnsafeNativeMethods.mp_CalculatorGraph__Cancel(mpPtr).Assert();
+      GC.KeepAlive(this);
+    }
+
+    public bool GraphInputStreamsClosed() {
+      return SafeNativeMethods.mp_CalculatorGraph__GraphInputStreamsClosed(mpPtr);
+    }
+
+    public bool IsNodeThrottled(int nodeId) {
+      return SafeNativeMethods.mp_CalculatorGraph__IsNodeThrottled__i(mpPtr, nodeId);
+    }
+
+    public bool UnthrottleSources() {
+      return SafeNativeMethods.mp_CalculatorGraph__UnthrottleSources(mpPtr);
+    }
+
     public GpuResources GetGpuResources() {
       UnsafeNativeMethods.mp_CalculatorGraph__GetGpuResources(mpPtr, out var gpuResourcesPtr).Assert();
 

Assets/MediaPipe/SDK/Scripts/PInvoke/NativeMethods/Framework/CalculatorGraph_Safe.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Diagnostics.Contracts;
+using System.Runtime.InteropServices;
+
+namespace Mediapipe {
+  internal static partial class SafeNativeMethods {
+    [Pure, DllImport (MediaPipeLibrary, ExactSpelling = true)]
+    [return: MarshalAs(UnmanagedType.I1)]
+    public static extern bool mp_CalculatorGraph__HasError(IntPtr graph);
+
+    [Pure, DllImport (MediaPipeLibrary, ExactSpelling = true)]
+    [return: MarshalAs(UnmanagedType.I1)]
+    public static extern bool mp_CalculatorGraph__HasInputStream__PKc(IntPtr graph, string name);
+
+    [Pure, DllImport (MediaPipeLibrary, ExactSpelling = true)]
+    [return: MarshalAs(UnmanagedType.I1)]
+    public static extern bool mp_CalculatorGraph__GraphInputStreamsClosed(IntPtr graph);
+
+    [Pure, DllImport (MediaPipeLibrary, ExactSpelling = true)]
+    [return: MarshalAs(UnmanagedType.I1)]
+    public static extern bool mp_CalculatorGraph__IsNodeThrottled__i(IntPtr graph, int nodeId);
+
+    [Pure, DllImport (MediaPipeLibrary, ExactSpelling = true)]
+    [return: MarshalAs(UnmanagedType.I1)]
+    public static extern bool mp_CalculatorGraph__UnthrottleSources(IntPtr graph);
+  }
+}

Assets/MediaPipe/SDK/Scripts/PInvoke/NativeMethods/Framework/CalculatorGraph_Unsafe.cs

@@ -22,20 +22,37 @@ internal static partial class UnsafeNativeMethods {
     [DllImport (MediaPipeLibrary, ExactSpelling = true)]
     public static extern MpReturnCode mp_CalculatorGraph__Config(IntPtr graph, out IntPtr config);
 
+    [DllImport (MediaPipeLibrary, ExactSpelling = true)]
+    public static extern MpReturnCode mp_CalculatorGraph__AddOutputStreamPoller__PKc(IntPtr graph, string streamName, out IntPtr statusOrPoller);
+
+    [DllImport (MediaPipeLibrary, ExactSpelling = true)]
+    public static extern MpReturnCode mp_CalculatorGraph__Run__Rsp(IntPtr graph, IntPtr sidePackets, out IntPtr status);
+
     [DllImport (MediaPipeLibrary, ExactSpelling = true)]
     public static extern MpReturnCode mp_CalculatorGraph__StartRun__Rsp(IntPtr graph, IntPtr sidePackets, out IntPtr status);
 
+    [DllImport (MediaPipeLibrary, ExactSpelling = true)]
+    public static extern MpReturnCode mp_CalculatorGraph__WaitUntilIdle(IntPtr graph, out IntPtr status);
+
     [DllImport (MediaPipeLibrary, ExactSpelling = true)]
     public static extern MpReturnCode mp_CalculatorGraph__WaitUntilDone(IntPtr graph, out IntPtr status);
 
     [DllImport (MediaPipeLibrary, ExactSpelling = true)]
-    public static extern MpReturnCode mp_CalculatorGraph__AddOutputStreamPoller__PKc(IntPtr graph, string name, out IntPtr statusOrPoller);
+    public static extern MpReturnCode mp_CalculatorGraph__AddPacketToInputStream__PKc_Ppacket(
+        IntPtr graph, string streamName, IntPtr packet, out IntPtr status);
+
+    [DllImport (MediaPipeLibrary, ExactSpelling = true)]
+    public static extern MpReturnCode mp_CalculatorGraph__SetInputStreamMaxQueueSize__PKc_i(
+        IntPtr graph, string streamName, int maxQueueSize, out IntPtr status);
+
+    [DllImport (MediaPipeLibrary, ExactSpelling = true)]
+    public static extern MpReturnCode mp_CalculatorGraph__CloseInputStream__PKc(IntPtr graph, string streamName, out IntPtr status);
 
     [DllImport (MediaPipeLibrary, ExactSpelling = true)]
-    public static extern MpReturnCode mp_CalculatorGraph__AddPacketToInputStream__PKc_Ppacket(IntPtr graph, string name, IntPtr packet, out IntPtr status);
+    public static extern MpReturnCode mp_CalculatorGraph__CloseAllPacketSources(IntPtr graph, out IntPtr status);
 
     [DllImport (MediaPipeLibrary, ExactSpelling = true)]
-    public static extern MpReturnCode mp_CalculatorGraph__CloseInputStream__PKc(IntPtr graph, string name, out IntPtr status);
+    public static extern MpReturnCode mp_CalculatorGraph__Cancel(IntPtr graph);
 
     #region GPU
     [DllImport (MediaPipeLibrary, ExactSpelling = true)]

Assets/MediaPipe/SDK/Tests/Framework/CalculatorGraphConfigTest.cs

@@ -1,6 +1,5 @@
 using Mediapipe;
 using NUnit.Framework;
-using System.Linq;
 
 namespace Tests {
   public class CalculatorGraphConfigTest {

Assets/MediaPipe/SDK/Tests/Framework/CalculatorGraphTest.cs

@@ -0,0 +1,121 @@
+using Mediapipe;
+using NUnit.Framework;
+
+namespace Tests {
+  public class CalculatorGraphTest {
+    private static string validConfigText = @"node {
+  calculator: ""PassThroughCalculator""
+  input_stream: ""in""
+  output_stream: ""out1""
+}
+node {
+  calculator: ""PassThroughCalculator""
+  input_stream: ""out1""
+  output_stream: ""out""
+}
+input_stream: ""in""
+output_stream: ""out""
+";
+
+    #region Constructor
+    [Test]
+    public void Ctor_ShouldInstantiateCalculatorGraph_When_CalledWithNoArguments() {
+      Assert.DoesNotThrow(() => { new CalculatorGraph(); });
+    }
+
+    [Test]
+    public void Ctor_ShouldInstantiateCalculatorGraph_When_CalledWithConfigText() {
+      var graph = new CalculatorGraph(validConfigText);
+      var config = graph.config;
+
+      Assert.Greater(config.byteSizeLong, 0);
+    }
+    #endregion
+
+    #region #isDisposed
+    [Test]
+    public void isDisposed_ShouldReturnFalse_When_NotDisposedYet() {
+      var graph = new CalculatorGraph();
+
+      Assert.False(graph.isDisposed);
+    }
+
+    [Test]
+    public void isDisposed_ShouldReturnTrue_When_AlreadyDisposed() {
+      var graph = new CalculatorGraph();
+      graph.Dispose();
+
+      Assert.True(graph.isDisposed);
+    }
+    #endregion
+
+    #region #Initialize
+    [Test]
+    public void Initialize_ShouldReturnOk_When_CalledWithConfig_And_ConfigIsNotSet() {
+      var graph = new CalculatorGraph();
+      var config = CalculatorGraphConfig.ParseFromString(validConfigText);
+      var status = graph.Initialize(config);
+
+      Assert.True(status.ok);
+      Assert.Greater(graph.config.byteSizeLong, 0);
+    }
+
+    [Test]
+    public void Initialize_ShouldReturnInternalError_When_CalledWithConfig_And_ConfigIsSet() {
+      var graph = new CalculatorGraph(validConfigText);
+      var config = CalculatorGraphConfig.ParseFromString(validConfigText);
+      var status = graph.Initialize(config);
+
+      Assert.AreEqual(status.code, Status.StatusCode.Internal);
+    }
+
+    [Test]
+    public void Initialize_ShouldReturnOk_When_CalledWithConfigAndSidePacket_And_ConfigIsNotSet() {
+      var graph = new CalculatorGraph();
+      var config = CalculatorGraphConfig.ParseFromString(validConfigText);
+      var sidePacket = new SidePacket();
+      sidePacket.Emplace("flag", new BoolPacket(true));
+      var status = graph.Initialize(config, sidePacket);
+
+      Assert.True(status.ok);
+    }
+
+
+    [Test]
+    public void Initialize_ShouldReturnInternalError_When_CalledWithConfigAndSidePacket_And_ConfigIsSet() {
+      var graph = new CalculatorGraph(validConfigText);
+      var config = CalculatorGraphConfig.ParseFromString(validConfigText);
+      var sidePacket = new SidePacket();
+      sidePacket.Emplace("flag", new BoolPacket(true));
+      var status = graph.Initialize(config, sidePacket);
+
+      Assert.AreEqual(status.code, Status.StatusCode.Internal);
+    }
+    #endregion
+
+    #region lifecycle
+    [Test]
+    public void LifecycleMethods_ShouldControlGraphLifeCycle() {
+      var graph = new CalculatorGraph(validConfigText);
+
+      Assert.True(graph.StartRun().ok);
+      Assert.False(graph.GraphInputStreamsClosed());
+
+      Assert.True(graph.WaitUntilIdle().ok);
+      Assert.True(graph.CloseAllPacketSources().ok);
+      Assert.True(graph.GraphInputStreamsClosed());
+      Assert.True(graph.WaitUntilDone().ok);
+      Assert.False(graph.HasError());
+    }
+
+    [Test]
+    public void Cancel_ShouldCancelGraph() {
+      var graph = new CalculatorGraph(validConfigText);
+
+      Assert.True(graph.StartRun().ok);
+      graph.Cancel();
+      Assert.AreEqual(graph.WaitUntilDone().code, Status.StatusCode.Cancelled);
+    }
+    #endregion
+  }
+}

Assets/MediaPipe/SDK/Tests/Framework/Packet/ImageFramePacketTest.cs

@@ -1,6 +1,5 @@
 using Mediapipe;
 using NUnit.Framework;
-using System;
 
 namespace Tests {
   public class ImageFramePacketTest {

Assets/MediaPipe/SDK/Tests/Framework/Packet/SidePacketTest.cs

@@ -1,6 +1,5 @@
 using Mediapipe;
 using NUnit.Framework;
-using System;
 
 namespace Tests {
   public class SidePacketTest {

Assets/MediaPipe/SDK/Tests/Framework/Port/StatusTest.cs

@@ -1,6 +1,5 @@
-using NUnit.Framework;
-
-using Mediapipe;
+using Mediapipe;
+using NUnit.Framework;
 
 namespace Tests {
   public class StatusTest {