From 679c3fb19851464d72fd162fc1b8cb073e888e56 Mon Sep 17 00:00:00 2001 From: homuler Date: Mon, 23 Nov 2020 11:00:09 +0900 Subject: [PATCH] feat: add CalculatorGraph APIs --- .../SDK/Scripts/Framework/CalculatorGraph.cs | 71 ++++++++-- .../Framework/CalculatorGraph_Safe.cs | 27 ++++ .../Framework/CalculatorGraph_Safe.cs.meta | 11 ++ .../Framework/CalculatorGraph_Unsafe.cs | 23 +++- .../Framework/CalculatorGraphConfigTest.cs | 1 - .../Tests/Framework/CalculatorGraphTest.cs | 121 ++++++++++++++++++ .../Framework/CalculatorGraphTest.cs.meta | 11 ++ .../Framework/Packet/ImageFramePacketTest.cs | 1 - .../Tests/Framework/Packet/SidePacketTest.cs | 1 - .../SDK/Tests/Framework/Port/StatusTest.cs | 5 +- C/mediapipe_api/framework/calculator_graph.cc | 115 +++++++++++++---- C/mediapipe_api/framework/calculator_graph.h | 41 ++++-- 12 files changed, 373 insertions(+), 55 deletions(-) create mode 100644 Assets/MediaPipe/SDK/Scripts/PInvoke/NativeMethods/Framework/CalculatorGraph_Safe.cs create mode 100644 Assets/MediaPipe/SDK/Scripts/PInvoke/NativeMethods/Framework/CalculatorGraph_Safe.cs.meta create mode 100644 Assets/MediaPipe/SDK/Tests/Framework/CalculatorGraphTest.cs create mode 100644 Assets/MediaPipe/SDK/Tests/Framework/CalculatorGraphTest.cs.meta diff --git a/Assets/MediaPipe/SDK/Scripts/Framework/CalculatorGraph.cs b/Assets/MediaPipe/SDK/Scripts/Framework/CalculatorGraph.cs index c36dcef53..0bb98028e 100644 --- a/Assets/MediaPipe/SDK/Scripts/Framework/CalculatorGraph.cs +++ b/Assets/MediaPipe/SDK/Scripts/Framework/CalculatorGraph.cs @@ -42,6 +42,25 @@ public CalculatorGraphConfig config { } } + public StatusOrPoller AddOutputStreamPoller(string streamName) { + UnsafeNativeMethods.mp_CalculatorGraph__AddOutputStreamPoller__PKc(mpPtr, streamName, out var statusOrPollerPtr).Assert(); + + GC.KeepAlive(this); + return new StatusOrPoller(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()); } @@ -49,6 +68,14 @@ public Status StartRun() { 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 Status WaitUntilDone() { 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(string streamName, Packet 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 AddOutputStreamPoller(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(statusOrPollerPtr); + return new Status(statusPtr); } - public Status AddPacketToInputStream(string name, Packet 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(); diff --git a/Assets/MediaPipe/SDK/Scripts/PInvoke/NativeMethods/Framework/CalculatorGraph_Safe.cs b/Assets/MediaPipe/SDK/Scripts/PInvoke/NativeMethods/Framework/CalculatorGraph_Safe.cs new file mode 100644 index 000000000..617c566ca --- /dev/null +++ b/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); + } +} diff --git a/Assets/MediaPipe/SDK/Scripts/PInvoke/NativeMethods/Framework/CalculatorGraph_Safe.cs.meta b/Assets/MediaPipe/SDK/Scripts/PInvoke/NativeMethods/Framework/CalculatorGraph_Safe.cs.meta new file mode 100644 index 000000000..0acda7156 --- /dev/null +++ b/Assets/MediaPipe/SDK/Scripts/PInvoke/NativeMethods/Framework/CalculatorGraph_Safe.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4151a04c25074315f99f586059854ebe +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/MediaPipe/SDK/Scripts/PInvoke/NativeMethods/Framework/CalculatorGraph_Unsafe.cs b/Assets/MediaPipe/SDK/Scripts/PInvoke/NativeMethods/Framework/CalculatorGraph_Unsafe.cs index 44582980d..b5478476d 100644 --- a/Assets/MediaPipe/SDK/Scripts/PInvoke/NativeMethods/Framework/CalculatorGraph_Unsafe.cs +++ b/Assets/MediaPipe/SDK/Scripts/PInvoke/NativeMethods/Framework/CalculatorGraph_Unsafe.cs @@ -22,20 +22,37 @@ public static extern MpReturnCode mp_CalculatorGraph__Initialize__Rconfig_Rsp( [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)] diff --git a/Assets/MediaPipe/SDK/Tests/Framework/CalculatorGraphConfigTest.cs b/Assets/MediaPipe/SDK/Tests/Framework/CalculatorGraphConfigTest.cs index 7f83cc796..3bf92dde5 100644 --- a/Assets/MediaPipe/SDK/Tests/Framework/CalculatorGraphConfigTest.cs +++ b/Assets/MediaPipe/SDK/Tests/Framework/CalculatorGraphConfigTest.cs @@ -1,6 +1,5 @@ using Mediapipe; using NUnit.Framework; -using System.Linq; namespace Tests { public class CalculatorGraphConfigTest { diff --git a/Assets/MediaPipe/SDK/Tests/Framework/CalculatorGraphTest.cs b/Assets/MediaPipe/SDK/Tests/Framework/CalculatorGraphTest.cs new file mode 100644 index 000000000..f21252d26 --- /dev/null +++ b/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 + } +} diff --git a/Assets/MediaPipe/SDK/Tests/Framework/CalculatorGraphTest.cs.meta b/Assets/MediaPipe/SDK/Tests/Framework/CalculatorGraphTest.cs.meta new file mode 100644 index 000000000..86978b843 --- /dev/null +++ b/Assets/MediaPipe/SDK/Tests/Framework/CalculatorGraphTest.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 083c8421f4820d09290f0de495a23ec2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/MediaPipe/SDK/Tests/Framework/Packet/ImageFramePacketTest.cs b/Assets/MediaPipe/SDK/Tests/Framework/Packet/ImageFramePacketTest.cs index 998899d8d..372c33a52 100644 --- a/Assets/MediaPipe/SDK/Tests/Framework/Packet/ImageFramePacketTest.cs +++ b/Assets/MediaPipe/SDK/Tests/Framework/Packet/ImageFramePacketTest.cs @@ -1,6 +1,5 @@ using Mediapipe; using NUnit.Framework; -using System; namespace Tests { public class ImageFramePacketTest { diff --git a/Assets/MediaPipe/SDK/Tests/Framework/Packet/SidePacketTest.cs b/Assets/MediaPipe/SDK/Tests/Framework/Packet/SidePacketTest.cs index efbfdc697..58dd72732 100644 --- a/Assets/MediaPipe/SDK/Tests/Framework/Packet/SidePacketTest.cs +++ b/Assets/MediaPipe/SDK/Tests/Framework/Packet/SidePacketTest.cs @@ -1,6 +1,5 @@ using Mediapipe; using NUnit.Framework; -using System; namespace Tests { public class SidePacketTest { diff --git a/Assets/MediaPipe/SDK/Tests/Framework/Port/StatusTest.cs b/Assets/MediaPipe/SDK/Tests/Framework/Port/StatusTest.cs index d5d5e7dc3..b799cd3da 100644 --- a/Assets/MediaPipe/SDK/Tests/Framework/Port/StatusTest.cs +++ b/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 { diff --git a/C/mediapipe_api/framework/calculator_graph.cc b/C/mediapipe_api/framework/calculator_graph.cc index 257c6711b..e9305a2f4 100644 --- a/C/mediapipe_api/framework/calculator_graph.cc +++ b/C/mediapipe_api/framework/calculator_graph.cc @@ -46,6 +46,25 @@ MpReturnCode mp_CalculatorGraph__Config(mediapipe::CalculatorGraph* graph, media } CATCH_ALL } +MpReturnCode mp_CalculatorGraph__AddOutputStreamPoller__PKc(mediapipe::CalculatorGraph* graph, + const char* stream_name, + mediapipe::StatusOrPoller** status_or_poller_out) { + TRY { + *status_or_poller_out = new mediapipe::StatusOrPoller { graph->AddOutputStreamPoller(stream_name) }; + RETURN_CODE(MpReturnCode::Success); + } CATCH_EXCEPTION +} + +MpReturnCode mp_CalculatorGraph__Run__Rsp(mediapipe::CalculatorGraph* graph, + SidePackets* side_packets, + mediapipe::Status** status_out) { + TRY { + auto status = graph->Run(*side_packets); + *status_out = new mediapipe::Status { std::move(status) }; + RETURN_CODE(MpReturnCode::Success); + } CATCH_EXCEPTION +} + MpReturnCode mp_CalculatorGraph__StartRun__Rsp(mediapipe::CalculatorGraph* graph, SidePackets* side_packets, mediapipe::Status** status_out) { @@ -56,6 +75,14 @@ MpReturnCode mp_CalculatorGraph__StartRun__Rsp(mediapipe::CalculatorGraph* graph } CATCH_EXCEPTION } +MpReturnCode mp_CalculatorGraph__WaitUntilIdle(mediapipe::CalculatorGraph* graph, mediapipe::Status** status_out) { + TRY { + auto status = graph->WaitUntilIdle(); + *status_out = new mediapipe::Status { std::move(status) }; + RETURN_CODE(MpReturnCode::Success); + } CATCH_EXCEPTION +} + MpReturnCode mp_CalculatorGraph__WaitUntilDone(mediapipe::CalculatorGraph* graph, mediapipe::Status** status_out) { TRY { auto status = graph->WaitUntilDone(); @@ -64,51 +91,85 @@ MpReturnCode mp_CalculatorGraph__WaitUntilDone(mediapipe::CalculatorGraph* graph } CATCH_EXCEPTION } -#ifndef MEDIAPIPE_DISABLE_GPU -MpReturnCode mp_CalculatorGraph__GetGpuResources(mediapipe::CalculatorGraph* graph, - std::shared_ptr** gpu_resources_out) { +bool mp_CalculatorGraph__HasError(mediapipe::CalculatorGraph* graph) { + return graph->HasError(); +} + +MpReturnCode mp_CalculatorGraph__AddPacketToInputStream__PKc_Ppacket(mediapipe::CalculatorGraph* graph, + const char* stream_name, + mediapipe::Packet* packet, + mediapipe::Status** status_out) { TRY { - auto gpu_resources = graph->GetGpuResources(); - *gpu_resources_out = new std::shared_ptr { gpu_resources }; + *status_out = new mediapipe::Status { graph->AddPacketToInputStream(stream_name, std::move(*packet)) }; RETURN_CODE(MpReturnCode::Success); } CATCH_EXCEPTION } -MpReturnCode mp_CalculatorGraph__SetGpuResources__SPgpu(mediapipe::CalculatorGraph* graph, - std::shared_ptr* gpu_resources, - mediapipe::Status** status_out) { - TRY_ALL { - *status_out = new mediapipe::Status { graph->SetGpuResources(*gpu_resources) }; +MpReturnCode mp_CalculatorGraph__SetInputStreamMaxQueueSize__PKc_i(mediapipe::CalculatorGraph* graph, + const char* stream_name, + int max_queue_size, + mediapipe::Status** status_out) { + TRY { + *status_out = new mediapipe::Status { graph->SetInputStreamMaxQueueSize(stream_name, max_queue_size) }; RETURN_CODE(MpReturnCode::Success); - } CATCH_ALL + } CATCH_EXCEPTION +} + +bool mp_CalculatorGraph__HasInputStream__PKc(mediapipe::CalculatorGraph* graph, const char* name) { + return graph->HasInputStream(name); } -#endif // !defined(MEDIAPIPE_DISABLE_GPU) +MpReturnCode mp_CalculatorGraph__CloseInputStream__PKc(mediapipe::CalculatorGraph* graph, + const char* stream_name, + mediapipe::Status** status_out) { + TRY { + *status_out = new mediapipe::Status { graph->CloseInputStream(stream_name) }; + RETURN_CODE(MpReturnCode::Success); + } CATCH_EXCEPTION +} -MpReturnCode mp_CalculatorGraph__AddOutputStreamPoller__PKc(mediapipe::CalculatorGraph* graph, - const char* name, - mediapipe::StatusOrPoller** status_or_poller_out) { +MpReturnCode mp_CalculatorGraph__CloseAllPacketSources(mediapipe::CalculatorGraph* graph, mediapipe::Status** status_out) { TRY { - *status_or_poller_out = new mediapipe::StatusOrPoller { graph->AddOutputStreamPoller(name) }; + *status_out = new mediapipe::Status { graph->CloseAllPacketSources() }; RETURN_CODE(MpReturnCode::Success); } CATCH_EXCEPTION } -MpReturnCode mp_CalculatorGraph__AddPacketToInputStream__PKc_Ppacket(mediapipe::CalculatorGraph* graph, - const char* name, - mediapipe::Packet* packet, - mediapipe::Status** status_out) { - TRY_ALL { - *status_out = new mediapipe::Status { graph->AddPacketToInputStream(name, std::move(*packet)) }; +MpReturnCode mp_CalculatorGraph__Cancel(mediapipe::CalculatorGraph* graph) { + TRY { + graph->Cancel(); RETURN_CODE(MpReturnCode::Success); - } CATCH_ALL + } CATCH_EXCEPTION } -MpReturnCode mp_CalculatorGraph__CloseInputStream__PKc(mediapipe::CalculatorGraph* graph, - const char* name, - mediapipe::Status** status_out) { +bool mp_CalculatorGraph__GraphInputStreamsClosed(mediapipe::CalculatorGraph* graph) { + return graph->GraphInputStreamsClosed(); +} + +bool mp_CalculatorGraph__IsNodeThrottled__i(mediapipe::CalculatorGraph* graph, int node_id) { + return graph->IsNodeThrottled(node_id); +} + +bool mp_CalculatorGraph__UnthrottleSources(mediapipe::CalculatorGraph* graph) { + return graph->UnthrottleSources(); +} + +#ifndef MEDIAPIPE_DISABLE_GPU +MpReturnCode mp_CalculatorGraph__GetGpuResources(mediapipe::CalculatorGraph* graph, + std::shared_ptr** gpu_resources_out) { + TRY { + auto gpu_resources = graph->GetGpuResources(); + *gpu_resources_out = new std::shared_ptr { gpu_resources }; + RETURN_CODE(MpReturnCode::Success); + } CATCH_EXCEPTION +} + +MpReturnCode mp_CalculatorGraph__SetGpuResources__SPgpu(mediapipe::CalculatorGraph* graph, + std::shared_ptr* gpu_resources, + mediapipe::Status** status_out) { TRY_ALL { - *status_out = new mediapipe::Status { graph->CloseInputStream(name) }; + *status_out = new mediapipe::Status { graph->SetGpuResources(*gpu_resources) }; RETURN_CODE(MpReturnCode::Success); } CATCH_ALL } +#endif // !defined(MEDIAPIPE_DISABLE_GPU) diff --git a/C/mediapipe_api/framework/calculator_graph.h b/C/mediapipe_api/framework/calculator_graph.h index 467d25d78..be50ec9bf 100644 --- a/C/mediapipe_api/framework/calculator_graph.h +++ b/C/mediapipe_api/framework/calculator_graph.h @@ -33,32 +33,51 @@ MP_CAPI(MpReturnCode) mp_CalculatorGraph__Initialize__Rconfig_Rsp( mediapipe::Status** status_out); MP_CAPI(MpReturnCode) mp_CalculatorGraph__Config(mediapipe::CalculatorGraph* graph, mediapipe::CalculatorGraphConfig** config_out); +MP_CAPI(MpReturnCode) mp_CalculatorGraph__AddOutputStreamPoller__PKc(mediapipe::CalculatorGraph* graph, + const char* stream_name, + mediapipe::StatusOrPoller** status_or_poller_out); + +MP_CAPI(MpReturnCode) mp_CalculatorGraph__Run__Rsp(mediapipe::CalculatorGraph* graph, + SidePackets* side_packets, + mediapipe::Status** status_out); + MP_CAPI(MpReturnCode) mp_CalculatorGraph__StartRun__Rsp(mediapipe::CalculatorGraph* graph, SidePackets* side_packets, mediapipe::Status** status_out); +MP_CAPI(MpReturnCode) mp_CalculatorGraph__WaitUntilIdle(mediapipe::CalculatorGraph* graph, mediapipe::Status** status_out); MP_CAPI(MpReturnCode) mp_CalculatorGraph__WaitUntilDone(mediapipe::CalculatorGraph* graph, mediapipe::Status** status_out); +MP_CAPI(bool) mp_CalculatorGraph__HasError(mediapipe::CalculatorGraph* graph); +MP_CAPI(MpReturnCode) mp_CalculatorGraph__AddPacketToInputStream__PKc_Ppacket(mediapipe::CalculatorGraph* graph, + const char* stream_name, + mediapipe::Packet* packet, + mediapipe::Status** status_out); -MP_CAPI(MpReturnCode) mp_CalculatorGraph__AddOutputStreamPoller__PKc(mediapipe::CalculatorGraph* graph, - const char* name, - mediapipe::StatusOrPoller** status_or_poller_out); +MP_CAPI(MpReturnCode) mp_CalculatorGraph__SetInputStreamMaxQueueSize__PKc_i(mediapipe::CalculatorGraph* graph, + const char* stream_name, + int max_queue_size, + mediapipe::Status** status_out); + +MP_CAPI(bool) mp_CalculatorGraph__HasInputStream__PKc(mediapipe::CalculatorGraph* graph, const char* name); +MP_CAPI(MpReturnCode) mp_CalculatorGraph__CloseInputStream__PKc(mediapipe::CalculatorGraph* graph, + const char* stream_name, + mediapipe::Status** status_out); + +MP_CAPI(MpReturnCode) mp_CalculatorGraph__CloseAllPacketSources(mediapipe::CalculatorGraph* graph, mediapipe::Status** status_out); +MP_CAPI(MpReturnCode) mp_CalculatorGraph__Cancel(mediapipe::CalculatorGraph* graph); +MP_CAPI(bool) mp_CalculatorGraph__GraphInputStreamsClosed(mediapipe::CalculatorGraph* graph); +MP_CAPI(bool) mp_CalculatorGraph__IsNodeThrottled__i(mediapipe::CalculatorGraph* graph, int node_id); +MP_CAPI(bool) mp_CalculatorGraph__UnthrottleSources(mediapipe::CalculatorGraph* graph); #ifndef MEDIAPIPE_DISABLE_GPU MP_CAPI(MpReturnCode) mp_CalculatorGraph__GetGpuResources(mediapipe::CalculatorGraph* graph, std::shared_ptr** gpu_resources_out); + MP_CAPI(MpReturnCode) mp_CalculatorGraph__SetGpuResources__SPgpu(mediapipe::CalculatorGraph* graph, std::shared_ptr* gpu_resources, mediapipe::Status** status_out); #endif // !defined(MEDIAPIPE_DISABLE_GPU) -MP_CAPI(MpReturnCode) mp_CalculatorGraph__AddPacketToInputStream__PKc_Ppacket(mediapipe::CalculatorGraph* graph, - const char* name, - mediapipe::Packet* packet, - mediapipe::Status** status_out); -MP_CAPI(MpReturnCode) mp_CalculatorGraph__CloseInputStream__PKc(mediapipe::CalculatorGraph* graph, - const char* name, - mediapipe::Status** status_out); - } // extern "C" #endif // C_MEDIAPIPE_API_FRAMEWORK_CALCULATOR_GRAPH_H_