MediaPipeUnityPlugin/mediapipe_api/framework/validated_graph_config.cc at master · newnon/MediaPipeUnityPlugin · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
#include "mediapipe_api/framework/validated_graph_config.h"

MpReturnCode mp_ValidatedGraphConfig__(mediapipe::ValidatedGraphConfig** config_out) {
  TRY
    *config_out = new mediapipe::ValidatedGraphConfig();
    RETURN_CODE(MpReturnCode::Success);
  CATCH_EXCEPTION
}

void mp_ValidatedGraphConfig__delete(mediapipe::ValidatedGraphConfig* config) { delete config; }

MpReturnCode mp_ValidatedGraphConfig__Initialize__Rcgc(mediapipe::ValidatedGraphConfig* config, const char* serialized_config, int size,
                                                       absl::Status** status_out) {
  TRY
    auto graph_config = ParseFromStringAsProto<mediapipe::CalculatorGraphConfig>(serialized_config, size);
    auto status = config->Initialize(graph_config);
    *status_out = new absl::Status(std::move(status));
    RETURN_CODE(MpReturnCode::Success);
  CATCH_EXCEPTION
}

MpReturnCode mp_ValidatedGraphConfig__Initialize__PKc(mediapipe::ValidatedGraphConfig* config, const char* graph_type, absl::Status** status_out) {
  TRY
    auto status = config->Initialize(graph_type);
    *status_out = new absl::Status(std::move(status));
    RETURN_CODE(MpReturnCode::Success);
  CATCH_EXCEPTION
}

bool mp_ValidatedGraphConfig__Initialized(mediapipe::ValidatedGraphConfig* config) { return config->Initialized(); }

MpReturnCode mp_ValidatedGraphConfig__ValidateRequiredSidePackets__Rsp(mediapipe::ValidatedGraphConfig* config, SidePackets* side_packets,
                                                                       absl::Status** status_out) {
  TRY
    auto status = config->ValidateRequiredSidePackets(*side_packets);
    *status_out = new absl::Status(std::move(status));
    RETURN_CODE(MpReturnCode::Success);
  CATCH_EXCEPTION
}

MpReturnCode mp_ValidatedGraphConfig__Config(mediapipe::ValidatedGraphConfig* config, mp_api::SerializedProto* value_out) {
  TRY
    SerializeProto(config->Config(), value_out);
    RETURN_CODE(MpReturnCode::Success);
  CATCH_EXCEPTION
}

MpReturnCode mp_ValidatedGraphConfig__InputStreamInfos(mediapipe::ValidatedGraphConfig* config, mp_api::StructArray<mp_api::EdgeInfo>* value_out) {
  TRY
    mp_api::CopyEdgeInfoVector(config->InputStreamInfos(), value_out);
    RETURN_CODE(MpReturnCode::Success);
  CATCH_EXCEPTION
}

MpReturnCode mp_ValidatedGraphConfig__OutputStreamInfos(mediapipe::ValidatedGraphConfig* config, mp_api::StructArray<mp_api::EdgeInfo>* value_out) {
  TRY
    mp_api::CopyEdgeInfoVector(config->OutputStreamInfos(), value_out);
    RETURN_CODE(MpReturnCode::Success);
  CATCH_EXCEPTION
}

MpReturnCode mp_ValidatedGraphConfig__InputSidePacketInfos(mediapipe::ValidatedGraphConfig* config, mp_api::StructArray<mp_api::EdgeInfo>* value_out) {
  TRY
    mp_api::CopyEdgeInfoVector(config->InputSidePacketInfos(), value_out);
    RETURN_CODE(MpReturnCode::Success);
  CATCH_EXCEPTION
}

MpReturnCode mp_ValidatedGraphConfig__OutputSidePacketInfos(mediapipe::ValidatedGraphConfig* config, mp_api::StructArray<mp_api::EdgeInfo>* value_out) {
  TRY
    mp_api::CopyEdgeInfoVector(config->OutputSidePacketInfos(), value_out);
    RETURN_CODE(MpReturnCode::Success);
  CATCH_EXCEPTION
}

int mp_ValidatedGraphConfig__OutputStreamIndex__PKc(mediapipe::ValidatedGraphConfig* config, const char* name) { return config->OutputStreamIndex(name); }

int mp_ValidatedGraphConfig__OutputSidePacketIndex__PKc(mediapipe::ValidatedGraphConfig* config, const char* name) {
  return config->OutputSidePacketIndex(name);
}

int mp_ValidatedGraphConfig__OutputStreamToNode__PKc(mediapipe::ValidatedGraphConfig* config, const char* name) { return config->OutputStreamToNode(name); }

MpReturnCode mp_ValidatedGraphConfig__RegisteredSidePacketTypeName(mediapipe::ValidatedGraphConfig* config, const char* name,
                                                                   absl::StatusOr<std::string>** status_or_string_out) {
  TRY
    auto status_or_string = config->RegisteredSidePacketTypeName(name);
    *status_or_string_out = new absl::StatusOr<std::string>{std::move(status_or_string)};
    RETURN_CODE(MpReturnCode::Success);
  CATCH_EXCEPTION
}

MpReturnCode mp_ValidatedGraphConfig__RegisteredStreamTypeName(mediapipe::ValidatedGraphConfig* config, const char* name,
                                                               absl::StatusOr<std::string>** status_or_string_out) {
  TRY
    auto status_or_string = config->RegisteredStreamTypeName(name);
    *status_or_string_out = new absl::StatusOr<std::string>{std::move(status_or_string)};
    RETURN_CODE(MpReturnCode::Success);
  CATCH_EXCEPTION
}

MpReturnCode mp_ValidatedGraphConfig__Package(mediapipe::ValidatedGraphConfig* config, const char** str_out) {
  TRY
    *str_out = strcpy_to_heap(config->Package());
    RETURN_CODE(MpReturnCode::Success);
  CATCH_EXCEPTION
}

bool mp_ValidatedGraphConfig_IsReservedExecutorName(const char* name) { return mediapipe::ValidatedGraphConfig::IsReservedExecutorName(name); }

bool mp_ValidatedGraphConfig__IsExternalSidePacket__PKc(mediapipe::ValidatedGraphConfig* config, const char* name) {
  return config->IsExternalSidePacket(name);
}

void mp_api_EdgeInfoArray__delete(mp_api::EdgeInfo* edge_info_vector_data, int size) {
  auto edge_info = edge_info_vector_data;
  for (auto i = 0; i < size; ++i) {
    delete (edge_info++)->name;
  }
  delete[] edge_info_vector_data;
}