s11n.hpp 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365
  1. // This file is part of OpenCV project.
  2. // It is subject to the license terms in the LICENSE file found in the top-level directory
  3. // of this distribution and at http://opencv.org/license.html.
  4. //
  5. // Copyright (C) 2020 Intel Corporation
  6. #ifndef OPENCV_GAPI_S11N_HPP
  7. #define OPENCV_GAPI_S11N_HPP
  8. #include <vector>
  9. #include <map>
  10. #include <unordered_map>
  11. #include <opencv2/gapi/s11n/base.hpp>
  12. #include <opencv2/gapi/gcomputation.hpp>
  13. #include <opencv2/gapi/rmat.hpp>
  14. namespace cv {
  15. namespace gapi {
  16. namespace detail {
  17. GAPI_EXPORTS cv::GComputation getGraph(const std::vector<char> &p);
  18. GAPI_EXPORTS cv::GMetaArgs getMetaArgs(const std::vector<char> &p);
  19. GAPI_EXPORTS cv::GRunArgs getRunArgs(const std::vector<char> &p);
  20. template<typename... Types>
  21. cv::GCompileArgs getCompileArgs(const std::vector<char> &p);
  22. template<typename RMatAdapterType>
  23. cv::GRunArgs getRunArgsWithRMats(const std::vector<char> &p);
  24. } // namespace detail
  25. GAPI_EXPORTS std::vector<char> serialize(const cv::GComputation &c);
  26. //namespace{
  27. template<typename T> static inline
  28. T deserialize(const std::vector<char> &p);
  29. //} //ananymous namespace
  30. GAPI_EXPORTS std::vector<char> serialize(const cv::GCompileArgs&);
  31. GAPI_EXPORTS std::vector<char> serialize(const cv::GMetaArgs&);
  32. GAPI_EXPORTS std::vector<char> serialize(const cv::GRunArgs&);
  33. template<> inline
  34. cv::GComputation deserialize(const std::vector<char> &p) {
  35. return detail::getGraph(p);
  36. }
  37. template<> inline
  38. cv::GMetaArgs deserialize(const std::vector<char> &p) {
  39. return detail::getMetaArgs(p);
  40. }
  41. template<> inline
  42. cv::GRunArgs deserialize(const std::vector<char> &p) {
  43. return detail::getRunArgs(p);
  44. }
  45. template<typename T, typename... Types> inline
  46. typename std::enable_if<std::is_same<T, GCompileArgs>::value, GCompileArgs>::
  47. type deserialize(const std::vector<char> &p) {
  48. return detail::getCompileArgs<Types...>(p);
  49. }
  50. template<typename T, typename RMatAdapterType> inline
  51. typename std::enable_if<std::is_same<T, GRunArgs>::value, GRunArgs>::
  52. type deserialize(const std::vector<char> &p) {
  53. return detail::getRunArgsWithRMats<RMatAdapterType>(p);
  54. }
  55. } // namespace gapi
  56. } // namespace cv
  57. namespace cv {
  58. namespace gapi {
  59. namespace s11n {
  60. struct GAPI_EXPORTS IOStream {
  61. virtual ~IOStream() = default;
  62. // Define the native support for basic C++ types at the API level:
  63. virtual IOStream& operator<< (bool) = 0;
  64. virtual IOStream& operator<< (char) = 0;
  65. virtual IOStream& operator<< (unsigned char) = 0;
  66. virtual IOStream& operator<< (short) = 0;
  67. virtual IOStream& operator<< (unsigned short) = 0;
  68. virtual IOStream& operator<< (int) = 0;
  69. virtual IOStream& operator<< (uint32_t) = 0;
  70. virtual IOStream& operator<< (uint64_t) = 0;
  71. virtual IOStream& operator<< (float) = 0;
  72. virtual IOStream& operator<< (double) = 0;
  73. virtual IOStream& operator<< (const std::string&) = 0;
  74. };
  75. struct GAPI_EXPORTS IIStream {
  76. virtual ~IIStream() = default;
  77. virtual IIStream& operator>> (bool &) = 0;
  78. virtual IIStream& operator>> (std::vector<bool>::reference) = 0;
  79. virtual IIStream& operator>> (char &) = 0;
  80. virtual IIStream& operator>> (unsigned char &) = 0;
  81. virtual IIStream& operator>> (short &) = 0;
  82. virtual IIStream& operator>> (unsigned short &) = 0;
  83. virtual IIStream& operator>> (int &) = 0;
  84. virtual IIStream& operator>> (float &) = 0;
  85. virtual IIStream& operator>> (double &) = 0;
  86. virtual IIStream& operator >> (uint32_t &) = 0;
  87. virtual IIStream& operator >> (uint64_t &) = 0;
  88. virtual IIStream& operator>> (std::string &) = 0;
  89. };
  90. namespace detail {
  91. GAPI_EXPORTS std::unique_ptr<IIStream> getInStream(const std::vector<char> &p);
  92. } // namespace detail
  93. ////////////////////////////////////////////////////////////////////////////////
  94. ////////////////////////////////////////////////////////////////////////////////
  95. // S11N operators
  96. // Note: operators for basic types are defined in IIStream/IOStream
  97. // OpenCV types ////////////////////////////////////////////////////////////////
  98. GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Point &pt);
  99. GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::Point &pt);
  100. GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Point2f &pt);
  101. GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::Point2f &pt);
  102. GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Size &sz);
  103. GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::Size &sz);
  104. GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Rect &rc);
  105. GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::Rect &rc);
  106. GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Scalar &s);
  107. GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::Scalar &s);
  108. GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Mat &m);
  109. GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::Mat &m);
  110. // FIXME: for GRunArgs serailization
  111. #if !defined(GAPI_STANDALONE)
  112. GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::UMat &);
  113. GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::UMat &);
  114. #endif // !defined(GAPI_STANDALONE)
  115. GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::RMat &r);
  116. GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::RMat &r);
  117. GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::gapi::wip::IStreamSource::Ptr &);
  118. GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::gapi::wip::IStreamSource::Ptr &);
  119. GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::detail::VectorRef &);
  120. GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::detail::VectorRef &);
  121. GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::detail::OpaqueRef &);
  122. GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::detail::OpaqueRef &);
  123. GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::MediaFrame &);
  124. GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::MediaFrame &);
  125. // Generic STL types ////////////////////////////////////////////////////////////////
  126. template<typename K, typename V>
  127. IOStream& operator<< (IOStream& os, const std::map<K, V> &m) {
  128. const uint32_t sz = static_cast<uint32_t>(m.size());
  129. os << sz;
  130. for (const auto& it : m) os << it.first << it.second;
  131. return os;
  132. }
  133. template<typename K, typename V>
  134. IIStream& operator>> (IIStream& is, std::map<K, V> &m) {
  135. m.clear();
  136. uint32_t sz = 0u;
  137. is >> sz;
  138. for (std::size_t i = 0; i < sz; ++i) {
  139. K k{};
  140. V v{};
  141. is >> k >> v;
  142. m[k] = v;
  143. }
  144. return is;
  145. }
  146. template<typename K, typename V>
  147. IOStream& operator<< (IOStream& os, const std::unordered_map<K, V> &m) {
  148. const uint32_t sz = static_cast<uint32_t>(m.size());
  149. os << sz;
  150. for (auto &&it : m) os << it.first << it.second;
  151. return os;
  152. }
  153. template<typename K, typename V>
  154. IIStream& operator>> (IIStream& is, std::unordered_map<K, V> &m) {
  155. m.clear();
  156. uint32_t sz = 0u;
  157. is >> sz;
  158. for (std::size_t i = 0; i < sz; ++i) {
  159. K k{};
  160. V v{};
  161. is >> k >> v;
  162. m[k] = v;
  163. }
  164. return is;
  165. }
  166. template<typename T>
  167. IOStream& operator<< (IOStream& os, const std::vector<T> &ts) {
  168. const uint32_t sz = static_cast<uint32_t>(ts.size());
  169. os << sz;
  170. for (auto &&v : ts) os << v;
  171. return os;
  172. }
  173. template<typename T>
  174. IIStream& operator>> (IIStream& is, std::vector<T> &ts) {
  175. uint32_t sz = 0u;
  176. is >> sz;
  177. if (sz == 0u) {
  178. ts.clear();
  179. }
  180. else {
  181. ts.resize(sz);
  182. for (std::size_t i = 0; i < sz; ++i) is >> ts[i];
  183. }
  184. return is;
  185. }
  186. // Generic: variant serialization
  187. namespace detail {
  188. template<typename V>
  189. IOStream& put_v(IOStream&, const V&, std::size_t) {
  190. GAPI_Assert(false && "variant>>: requested index is invalid");
  191. };
  192. template<typename V, typename X, typename... Xs>
  193. IOStream& put_v(IOStream& os, const V& v, std::size_t x) {
  194. return (x == 0u)
  195. ? os << cv::util::get<X>(v)
  196. : put_v<V, Xs...>(os, v, x-1);
  197. }
  198. template<typename V>
  199. IIStream& get_v(IIStream&, V&, std::size_t, std::size_t) {
  200. GAPI_Assert(false && "variant<<: requested index is invalid");
  201. }
  202. template<typename V, typename X, typename... Xs>
  203. IIStream& get_v(IIStream& is, V& v, std::size_t i, std::size_t gi) {
  204. if (i == gi) {
  205. X x{};
  206. is >> x;
  207. v = V{std::move(x)};
  208. return is;
  209. } else return get_v<V, Xs...>(is, v, i+1, gi);
  210. }
  211. } // namespace detail
  212. template<typename... Ts>
  213. IOStream& operator<< (IOStream& os, const cv::util::variant<Ts...> &v) {
  214. os << static_cast<uint32_t>(v.index());
  215. return detail::put_v<cv::util::variant<Ts...>, Ts...>(os, v, v.index());
  216. }
  217. template<typename... Ts>
  218. IIStream& operator>> (IIStream& is, cv::util::variant<Ts...> &v) {
  219. int idx = -1;
  220. is >> idx;
  221. GAPI_Assert(idx >= 0 && idx < (int)sizeof...(Ts));
  222. return detail::get_v<cv::util::variant<Ts...>, Ts...>(is, v, 0u, idx);
  223. }
  224. // FIXME: consider a better solution
  225. template<typename... Ts>
  226. void getRunArgByIdx (IIStream& is, cv::util::variant<Ts...> &v, uint32_t idx) {
  227. is = detail::get_v<cv::util::variant<Ts...>, Ts...>(is, v, 0u, idx);
  228. }
  229. } // namespace s11n
  230. namespace detail
  231. {
  232. template<typename T> struct try_deserialize_comparg;
  233. template<> struct try_deserialize_comparg<std::tuple<>> {
  234. static cv::util::optional<GCompileArg> exec(const std::string&, cv::gapi::s11n::IIStream&) {
  235. return { };
  236. }
  237. };
  238. template<typename T, typename... Types>
  239. struct try_deserialize_comparg<std::tuple<T, Types...>> {
  240. static cv::util::optional<GCompileArg> exec(const std::string& tag, cv::gapi::s11n::IIStream& is) {
  241. if (tag == cv::detail::CompileArgTag<T>::tag()) {
  242. static_assert(cv::gapi::s11n::detail::has_S11N_spec<T>::value,
  243. "cv::gapi::deserialize<GCompileArgs, Types...> expects Types to have S11N "
  244. "specializations with deserialization callbacks!");
  245. return cv::util::optional<GCompileArg>(
  246. GCompileArg { cv::gapi::s11n::detail::S11N<T>::deserialize(is) });
  247. }
  248. return try_deserialize_comparg<std::tuple<Types...>>::exec(tag, is);
  249. }
  250. };
  251. template<typename T> struct deserialize_runarg;
  252. template<typename RMatAdapterType>
  253. struct deserialize_runarg {
  254. static GRunArg exec(cv::gapi::s11n::IIStream& is, uint32_t idx) {
  255. if (idx == GRunArg::index_of<RMat>()) {
  256. auto ptr = std::make_shared<RMatAdapterType>();
  257. ptr->deserialize(is);
  258. return GRunArg { RMat(std::move(ptr)) };
  259. } else { // non-RMat arg - use default deserialization
  260. GRunArg arg;
  261. getRunArgByIdx(is, arg, idx);
  262. return arg;
  263. }
  264. }
  265. };
  266. template<typename... Types>
  267. inline cv::util::optional<GCompileArg> tryDeserializeCompArg(const std::string& tag,
  268. const std::vector<char>& sArg) {
  269. std::unique_ptr<cv::gapi::s11n::IIStream> pArgIs = cv::gapi::s11n::detail::getInStream(sArg);
  270. return try_deserialize_comparg<std::tuple<Types...>>::exec(tag, *pArgIs);
  271. }
  272. template<typename... Types>
  273. cv::GCompileArgs getCompileArgs(const std::vector<char> &sArgs) {
  274. cv::GCompileArgs args;
  275. std::unique_ptr<cv::gapi::s11n::IIStream> pIs = cv::gapi::s11n::detail::getInStream(sArgs);
  276. cv::gapi::s11n::IIStream& is = *pIs;
  277. uint32_t sz = 0;
  278. is >> sz;
  279. for (uint32_t i = 0; i < sz; ++i) {
  280. std::string tag;
  281. is >> tag;
  282. std::vector<char> sArg;
  283. is >> sArg;
  284. cv::util::optional<GCompileArg> dArg =
  285. cv::gapi::detail::tryDeserializeCompArg<Types...>(tag, sArg);
  286. if (dArg.has_value())
  287. {
  288. args.push_back(dArg.value());
  289. }
  290. }
  291. return args;
  292. }
  293. template<typename RMatAdapterType>
  294. cv::GRunArgs getRunArgsWithRMats(const std::vector<char> &p) {
  295. std::unique_ptr<cv::gapi::s11n::IIStream> pIs = cv::gapi::s11n::detail::getInStream(p);
  296. cv::gapi::s11n::IIStream& is = *pIs;
  297. cv::GRunArgs args;
  298. uint32_t sz = 0;
  299. is >> sz;
  300. for (uint32_t i = 0; i < sz; ++i) {
  301. uint32_t idx = 0;
  302. is >> idx;
  303. args.push_back(cv::gapi::detail::deserialize_runarg<RMatAdapterType>::exec(is, idx));
  304. }
  305. return args;
  306. }
  307. } // namespace detail
  308. } // namespace gapi
  309. } // namespace cv
  310. #endif // OPENCV_GAPI_S11N_HPP