OSCR

Thalamus: a real-time system for synchronized, closed-loop multimodal behavioral and electrophysiological data capture.

Code ↔ Paper

7 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 7 matches
  1. [1] § Methods › Methods: timestamp latency ↔ src/thalamus/node_graph_impl.cpp, lines 1966 to 2022 · score 0.69 · Wave Generator Node, Pulse Node, Storage Node, NIDAQ, channel · Report a mismatch
  2. [2] § Methods › Methods: Performance Trace ↔ src/thalamus/node_graph_impl.cpp, lines 1966 to 2022 · score 0.64 · VideoNode, Algebra Node, Storage Node · Report a mismatch
  3. [3] § Methods › Synchrony › Timestamp logic ↔ src/thalamus/genicam_node.cpp, lines 86 to 147 · score 0.61 · GENICAM nodes, GenTL, ASIO, Boost, interfaces, threads · Report a mismatch
  4. [4] § Methods › Customizable user interface ↔ thalamus/task_controller/controller.py, lines 173 to 311 · score 0.55 · Add Task Cluster, Add Task button, UI, queue · Report a mismatch
  5. [5] § Methods › Real-time capabilities and closed-loop via gRPC ↔ thalamus/pipeline/main_impl.py, lines 93 to 236 · score 0.55 · native.exe, gRPC, client, loop, Thalamus · Report a mismatch
  6. [6] § Methods › Dependency management ↔ thalamus/build.py, lines 152 to 209 · score 0.53 · win amd64, py3, whl, Thalamus · Report a mismatch
  7. [7] § Methods › Real-time capabilities and closed-loop via gRPC ↔ thalamus/task_controller/main_impl.py, lines 169 to 235 · score 0.51 · native.exe, gRPC, client, Thalamus · Report a mismatch

Paper

Loaded from Europe PMC by your browser; OSCR does not store it: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

C++ · 2,439 lines · 94 KB · GPL-3.0 · 2 matches

  1. #include <cstddef>
  2. #include <limits>
  3. #include <thalamus/tracing.hpp>
  4. #include <chrono>
  5. #include <thalamus/algebra_node.hpp>
  6. #include <thalamus/nidaq_node.hpp>
  7. #include <thalamus/storage_node.hpp>
  8. #include <thalamus/xsens_node.hpp>
  9. #include <thalamus/analog_node.hpp>
  10. #include <thalamus/aruco_node.hpp>
  11. #include <thalamus/alpha_omega_node.hpp>
  12. #include <thalamus/channel_picker_node.hpp>
  13. #include <thalamus/chessboard_node.hpp>
  14. #include <thalamus/distortion_node.hpp>
  15. #include <thalamus/genicam_node.hpp>
  16. #include <thalamus/hexascope_node.hpp>
  17. #include <thalamus/image_node.hpp>
  18. #include <thalamus/intan_node.hpp>
  19. #include <thalamus/log_node.hpp>
  20. #include <thalamus/lua_node.hpp>
  21. #include <thalamus/node_graph_impl.hpp>
  22. #include <thalamus/grpc_tls.hpp>
  23. #include <thalamus/normalize_node.hpp>
  24. #include <thalamus/oculomatic_node.hpp>
  25. #include <thalamus/ophanim_node.hpp>
  26. #include <thalamus/pupil_node.hpp>
  27. #include <thalamus/remote_node.hpp>
  28. #include <thalamus/remotelog_node.hpp>
  29. #include <thalamus/serialtouchscreen_node.hpp>
  30. #include <thalamus/joystick_node.hpp>
  31. #include <variant>
  32. #ifndef _WIN32
  33. #include <thalamus/ros2_node.hpp>
  34. #endif
  35. #ifdef _WIN32
  36. #include <thalamus/brainproducts_node.hpp>
  37. #endif
  38. #include <thalamus/run_node.hpp>
  39. #include <thalamus/run2_node.hpp>
  40. #include <thalamus/spikeglx_node.hpp>
  41. #include <thalamus/stim_printer_node.hpp>
  42. #include <thalamus/sync_node.hpp>
  43. #include <thalamus/storage2_node.hpp>
  44. #include <thalamus/task_controller_node.hpp>
  45. #include <thalamus_config.h>
  46. #include <thalamus/thread_pool.hpp>
  47. #include <thalamus/touchscreen_node.hpp>
  48. #include <thalamus/video_node.hpp>
  49. #include <thalamus/test_pulse_node.hpp>
  50. #include <thalamus/wallclock_node.hpp>
  51. #include <thalamus/delsys_node.hpp>
  52. #include <thalamus/ceci_node.hpp>
  53. #include <thalamus/frequency_node.hpp>
  54. #include <thalamus/samplemonitor_node.hpp>
  55. #include <thalamus/plugin.h>
  56. #include <thalamus/modalities_util.hpp>
  57. #include <thalamus/node_util.hpp>
  59. #ifdef __clang__
  60. #pragma clang diagnostic push
  61. #pragma clang diagnostic ignored "-Weverything"
  62. #endif
  63. #include "boost/signals2/connection.hpp"
  64. #include <grpcpp/create_channel.h>
  65. #include <thalamus.grpc.pb.h>
  66. #include <SDL3/SDL.h>
  67. #include <SDL3/SDL_vulkan.h>
  68. #ifdef __clang__
  69. #pragma clang diagnostic pop
  70. #endif
  71. #include <thalamus/image_viewer.hpp>
  73. struct ThalamusState {
  74. int count;
  75. thalamus::ObservableCollection::Value value;
  76. };
  78. struct ThalamusStateIter {
  79. thalamus::ObservableCollection::Value value;
  80. std::variant<thalamus::ObservableCollection::VectorIteratorWrapper,
  81. thalamus::ObservableCollection::MapIteratorWrapper> begin;
  82. std::variant<thalamus::ObservableCollection::VectorIteratorWrapper,
  83. thalamus::ObservableCollection::MapIteratorWrapper> pos;
  84. std::variant<thalamus::ObservableCollection::VectorIteratorWrapper,
  85. thalamus::ObservableCollection::MapIteratorWrapper> end;
  86. bool started;
  87. };
  89. struct ThalamusIoContext {
  90. boost::asio::io_context& io_context;
  91. ThalamusIoContext(boost::asio::io_context& _io_context) : io_context(_io_context) {}
  92. };
  94. struct ThalamusNodeGraph {
  95. thalamus::NodeGraph* graph;
  96. ThalamusNodeGraph(thalamus::NodeGraph* _graph) : graph(_graph) {}
  97. };
  99. struct ThalamusVkQueueLock {
  100. std::unique_lock<std::mutex> lock;
  101. };
  103. struct ThalamusStateConnection {
  104. boost::signals2::scoped_connection connection;
  105. ThalamusStateConnection(boost::signals2::connection _connection) : connection(_connection) {}
  106. };
  108. struct ThalamusTimer {
  109. boost::asio::steady_timer timer;
  110. ThalamusTimer(boost::asio::io_context& _io_context) : timer(_io_context) {}
  111. };
  112. struct ThalamusErrorCode {
  113. const boost::system::error_code *error;
  114. ThalamusErrorCode() : error(nullptr) {}
  115. ThalamusErrorCode(const boost::system::error_code &_error) : error(&_error) {}
  116. };
  118. struct ThalamusSerialPort {
  119. boost::asio::serial_port port;
  120. boost::system::error_code error;
  121. ThalamusErrorCode error_wrapper;
  122. };
  124. struct ThalamusStreamBuf {
  125. boost::asio::streambuf buffer;
  126. };
  128. struct ThalamusJson {
  129. size_t refs;
  130. boost::json::value value;
  131. };
  133. struct ThalamusRequestHandle {
  134. std::function<void(const boost::json::value &)> callback;
  135. };
  137. struct ThalamusNodeGetConnection {
  138. boost::signals2::scoped_connection connection;
  139. };
  141. struct ThalamusNodeReadyConnection {
  142. boost::signals2::scoped_connection connection;
  143. ThalamusNode* node;
  144. };
  146. struct ThalamusOffMainSignaler {
  147. thalamus::node::OffMainSignaler signaler;
  148. };
  150. static std::string to_string(const ThalamusCharSpan& span) {
  151. return std::string(span.data, span.size);
  152. }
  154. static std::string_view to_string_view(const ThalamusCharSpan& span) {
  155. return std::string_view(span.data, span.size);
  156. }
  158. inline std::ostream& operator<<(std::ostream& os, const ThalamusCharSpan& span) {
  159. return os.write(span.data, std::streamsize(span.size));
  160. }
  162. namespace thalamus {
  163. using namespace std::chrono_literals;
  165. struct INodeFactory {
  166. virtual ~INodeFactory();
  167. virtual Node *create(ObservableDictPtr state,
  168. boost::asio::io_context &io_context,
  169. NodeGraph *graph) = 0;
  170. virtual bool prepare() = 0;
  171. virtual void cleanup() = 0;
  172. virtual std::string type_name() = 0;
  173. };
  174. INodeFactory::~INodeFactory() {}
  176. template <typename T> struct NodeFactory : public INodeFactory {
  177. Node *create(ObservableDictPtr state, boost::asio::io_context &io_context,
  178. NodeGraph *graph) override {
  179. return new T(state, io_context, graph);
  180. }
  181. bool prepare() override {
  182. constexpr bool has_prepare = requires { T::prepare(); };
  183. if constexpr (has_prepare) {
  184. return T::prepare();
  185. } else {
  186. return true;
  187. }
  188. }
  189. void cleanup() override {
  190. constexpr bool has_cleanup = requires { T::cleanup(); };
  191. if constexpr (has_cleanup) {
  192. T::cleanup();
  193. }
  194. }
  195. std::string type_name() override { return T::type_name(); }
  196. };
  198. static void string_to_span(struct ThalamusCharSpan* output, const std::string& input) {
  199. auto data = new char[input.size()];
  200. std::copy(input.begin(), input.end(), data);
  201. output->data = data;
  202. output->size = input.size();
  203. output->owns_data = 1;
  204. }
  206. struct ExtNode : public Node, public AnalogNode, public ImageNode, public MotionCaptureNode, public TextNode {
  207. ThalamusNode* node;
  208. ThalamusNodeFactory *factory;
  209. ThalamusAPI *api;
  210. std::function<void()> drop_ready;
  212. ExtNode(ThalamusNode *_node, ThalamusNodeFactory *_factory, ThalamusAPI *_api)
  213. : node(_node), factory(_factory), api(_api) {
  214. if(node && node->signals_offmain) {
  215. ready_multithreaded.emplace();
  216. }
  217. }
  218. ~ExtNode() override;
  220. void predrop(std::function<void()> on_drop_ready) override {
  221. THALAMUS_LOG(info) << "*ext* ExtNode::predrop";
  222. drop_ready = on_drop_ready;
  223. node->predrop(node);
  224. }
  226. size_t modalities() const override {
  227. size_t result = 0;
  228. result |= node->analog != nullptr ? THALAMUS_MODALITY_ANALOG : 0;
  229. result |= node->mocap != nullptr ? THALAMUS_MODALITY_MOCAP : 0;
  230. result |= node->image != nullptr ? THALAMUS_MODALITY_IMAGE : 0;
  231. result |= node->text != nullptr ? THALAMUS_MODALITY_TEXT : 0;
  232. return result;
  233. }
  235. static std::string type_name() {
  236. THALAMUS_ABORT("Unimplemented");
  237. }
  239. std::span<const double> data(int channel) const override {
  240. ThalamusDoubleSpan temp;
  241. node->analog->data(&temp, node, channel);
  242. return std::span<const double>(temp.data, temp.data+temp.size);
  243. }
  244. std::span<const short> short_data(int channel) const override {
  245. ThalamusShortSpan temp;
  246. node->analog->short_data(&temp, node, channel);
  247. return std::span<const short>(temp.data, temp.data+temp.size);
  248. }
  249. std::span<const int> int_data(int channel) const override {
  250. ThalamusIntSpan temp;
  251. node->analog->int_data(&temp, node, channel);
  252. return std::span<const int>(temp.data, temp.data+temp.size);
  253. }
  254. std::span<const uint64_t> ulong_data(int channel) const override {
  255. ThalamusULongSpan temp;
  256. node->analog->ulong_data(&temp, node, channel);
  257. return std::span<const uint64_t>(temp.data, temp.data+temp.size);
  258. }
  259. int num_channels() const override {
  260. return node->analog->num_channels(node);
  261. }
  262. std::chrono::nanoseconds sample_interval(int channel) const override {
  263. return std::chrono::nanoseconds(node->analog->sample_interval_ns(node, channel));
  264. }
  265. std::chrono::nanoseconds time() const override {
  266. return std::chrono::nanoseconds(node->time_ns(node));
  267. }
  268. std::chrono::nanoseconds remote_time() const override {
  269. return 0ns;
  270. }
  271. std::string_view name(int channel) const override {
  272. ThalamusCharSpan temp2;
  273. node->analog->name(&temp2, node, channel);
  274. return std::string_view(temp2.data, temp2.data + temp2.size);
  275. }
  276. void inject(const thalamus::vector<std::span<double const>> &,
  277. const thalamus::vector<std::chrono::nanoseconds> &,
  278. const thalamus::vector<std::string_view> &) override {
  279. THALAMUS_ABORT("Unimplemented");
  280. }
  281. bool has_analog_data() const override {
  282. return node->analog->has_analog_data(node);
  283. }
  284. bool is_short_data() const override {
  285. return node->analog->is_short_data ? node->analog->is_short_data(node) : false;
  286. }
  287. bool is_int_data() const override {
  288. return node->analog->is_int_data ? node->analog->is_int_data(node) : false;
  289. }
  290. bool is_ulong_data() const override {
  291. return node->analog->is_ulong_data ? node->analog->is_ulong_data(node) : false;
  292. }
  294. bool is_transformed() const override {
  295. return node->analog->is_transformed ? node->analog->is_transformed(node) : false;
  296. }
  297. double scale(int channel) const override {
  298. return node->analog->scale(node, channel);
  299. }
  300. double offset(int channel) const override {
  301. return node->analog->offset(node, channel);
  302. }
  304. Plane plane(int i) const override {
  305. ThalamusByteSpan temp;
  306. node->image->plane(&temp, node, i);
  307. return std::span<const uint8_t>(temp.data, temp.data+temp.size);
  308. }
  309. size_t num_planes() const override {
  310. return node->image->num_planes(node);
  311. }
  312. Format format() const override {
  313. auto format = node->image->format(node);
  314. switch(format) {
  315. case ThalamusImageFormat_Gray:
  316. return ImageNode::Format::Gray;
  317. case ThalamusImageFormat_RGB:
  318. return ImageNode::Format::RGB;
  319. case ThalamusImageFormat_YUV420P:
  320. return ImageNode::Format::YUV420P;
  321. case ThalamusImageFormat_YUYV422:
  322. return ImageNode::Format::YUYV422;
  323. case ThalamusImageFormat_YUVJ420P:
  324. return ImageNode::Format::YUVJ420P;
  325. case ThalamusImageFormat_NV12:
  326. return ImageNode::Format::NV12;
  327. case ThalamusImageFormat_BGR:
  328. return ImageNode::Format::BGR;
  329. case ThalamusImageFormat_MJPEG:
  330. return ImageNode::Format::MJPEG;
  331. case ThalamusImageFormat_Gray16:
  332. return ImageNode::Format::Gray16;
  333. case ThalamusImageFormat_RGB16:
  334. return ImageNode::Format::RGB16;
  335. case ThalamusImageFormat_MPEG4:
  336. return ImageNode::Format::MPEG4;
  337. case ThalamusImageFormat_MPEG1:
  338. THALAMUS_ABORT("MPEG1 is no longer supported");
  339. }
  340. }
  341. size_t width() const override {
  342. return node->image->width(node);
  343. }
  344. size_t height() const override {
  345. return node->image->height(node);
  346. }
  347. std::chrono::nanoseconds frame_interval() const override {
  348. return std::chrono::nanoseconds(node->image->frame_interval_ns(node));
  349. }
  350. void inject(const thalamus_grpc::Image &) override {
  351. THALAMUS_ABORT("Unimplemented");
  352. }
  353. bool has_image_data() const override {
  354. return node->image->has_image_data(node);
  355. }
  357. std::span<MotionCaptureNode::Segment const> segments() const override {
  358. ThalamusMocapSegmentSpan temp;
  359. node->mocap->segments(&temp, node);
  360. return std::span<MotionCaptureNode::Segment const>(temp.data, temp.data+temp.size);
  361. }
  362. const std::string_view pose_name() const override {
  363. ThalamusCharSpan temp;
  364. node->mocap->pose_name(&temp, node);
  365. return std::string_view(temp.data, temp.data+temp.size);
  366. }
  367. void inject(const std::span<MotionCaptureNode::Segment const> &) override {
  368. THALAMUS_ABORT("Unimplemented");
  369. }
  370. bool has_motion_data() const override {
  371. return node->mocap->has_motion_data(node);
  372. }
  374. std::string_view text() const override {
  375. ThalamusCharSpan span;
  376. node->text->text(&span, node);
  377. return to_string_view(span);
  378. }
  380. bool has_text_data() const override {
  381. return node->text->has_text_data(node);
  382. }
  384. void process(const boost::json::value & request, std::function<void(const boost::json::value &)> callback) override {
  385. if(node->process == nullptr) {
  386. callback(boost::json::value());
  387. return;
  388. }
  389. auto json = new ThalamusJson{1, request};
  390. auto handle = new ThalamusRequestHandle {callback};
  391. node->process(node, handle, json);
  392. api->json_dec_ref(json);
  393. }
  394. };
  396. ExtNode::~ExtNode() {
  397. factory->destroy(factory, node);
  398. }
  400. struct Interfaces {
  401. Node* node = nullptr;
  402. AnalogNode* analog = nullptr;
  403. ImageNode* image = nullptr;
  404. MotionCaptureNode* mocap = nullptr;
  405. std::atomic_int safe = 0;
  406. std::atomic_int count = 0;
  407. };
  409. #define ASSERT_SAFE() do { if(!interfaces->safe) [[unlikely]] { THALAMUS_ABORT("Node should only be accessed in get_node or ready callback"); } } while(0)
  411. static uint64_t plugin_analog_time_ns(struct ThalamusNode* node) {
  412. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  413. ASSERT_SAFE();
  414. std::chrono::nanoseconds t = interfaces->analog->time();
  415. return uint64_t(t.count());
  416. }
  418. static uint64_t plugin_image_time_ns(struct ThalamusNode* node) {
  419. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  420. ASSERT_SAFE();
  421. std::chrono::nanoseconds t = interfaces->image->time();
  422. return uint64_t(t.count());
  423. }
  425. static uint64_t plugin_mocap_time_ns(struct ThalamusNode* node) {
  426. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  427. ASSERT_SAFE();
  428. std::chrono::nanoseconds t = interfaces->mocap->time();
  429. return uint64_t(t.count());
  430. }
  432. static void plugin_node_process(struct ThalamusNode* node, struct ThalamusRequestHandle* handle, struct ThalamusJson* request) {
  433. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  434. ASSERT_SAFE();
  435. interfaces->node->process(request->value, [handle](const boost::json::value & response) {
  436. handle->callback(response);
  437. delete handle;
  438. });
  439. }
  441. static void plugin_analog_data(struct ThalamusDoubleSpan* output, struct ThalamusNode* node, int channel) {
  442. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  443. ASSERT_SAFE();
  444. auto span = interfaces->analog->data(channel);
  445. output->data = span.data();
  446. output->size = span.size();
  447. }
  449. static void plugin_analog_short_data(struct ThalamusShortSpan* output, struct ThalamusNode* node, int channel) {
  450. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  451. ASSERT_SAFE();
  452. auto span = interfaces->analog->short_data(channel);
  453. output->data = span.data();
  454. output->size = span.size();
  455. }
  457. static void plugin_analog_int_data(struct ThalamusIntSpan* output, struct ThalamusNode* node, int channel) {
  458. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  459. ASSERT_SAFE();
  460. auto span = interfaces->analog->int_data(channel);
  461. output->data = span.data();
  462. output->size = span.size();
  463. }
  465. static void plugin_analog_ulong_data(struct ThalamusULongSpan* output, struct ThalamusNode* node, int channel) {
  466. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  467. ASSERT_SAFE();
  468. auto span = interfaces->analog->ulong_data(channel);
  469. output->data = span.data();
  470. output->size = span.size();
  471. }
  473. static int plugin_analog_num_channels(struct ThalamusNode* node) {
  474. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  475. ASSERT_SAFE();
  476. return interfaces->analog->num_channels();
  477. }
  479. static uint64_t plugin_analog_sample_interval_ns(struct ThalamusNode* node, int channel) {
  480. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  481. ASSERT_SAFE();
  482. std::chrono::nanoseconds ns = interfaces->analog->sample_interval(channel);
  483. return uint64_t(ns.count());
  484. }
  486. static void plugin_analog_name(ThalamusCharSpan* output, struct ThalamusNode* node, int channel) {
  487. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  488. ASSERT_SAFE();
  489. auto name = interfaces->analog->name(channel);
  490. output->data = name.data();
  491. output->size = name.size();
  492. }
  494. static char plugin_analog_has_analog_data(struct ThalamusNode* node) {
  495. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  496. ASSERT_SAFE();
  497. return interfaces->analog->has_analog_data() ? 1 : 0;
  498. }
  500. static char plugin_analog_is_short_data(struct ThalamusNode* node) {
  501. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  502. ASSERT_SAFE();
  503. return interfaces->analog->is_short_data() ? 1 : 0;
  504. }
  506. static char plugin_analog_is_int_data(struct ThalamusNode* node) {
  507. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  508. ASSERT_SAFE();
  509. return interfaces->analog->is_int_data() ? 1 : 0;
  510. }
  512. static char plugin_analog_is_ulong_data(struct ThalamusNode* node) {
  513. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  514. ASSERT_SAFE();
  515. return interfaces->analog->is_ulong_data() ? 1 : 0;
  516. }
  518. static char plugin_analog_is_transformed(struct ThalamusNode* node) {
  519. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  520. ASSERT_SAFE();
  521. return interfaces->analog->is_transformed() ? 1 : 0;
  522. }
  524. static double plugin_analog_scale(struct ThalamusNode* node, int channel) {
  525. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  526. ASSERT_SAFE();
  527. return interfaces->analog->scale(channel);
  528. }
  530. static double plugin_analog_offset(struct ThalamusNode* node, int channel) {
  531. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  532. ASSERT_SAFE();
  533. return interfaces->analog->offset(channel);
  534. }
  536. static void plugin_image_plane(struct ThalamusByteSpan* output, struct ThalamusNode* node, int channel) {
  537. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  538. ASSERT_SAFE();
  539. auto span = interfaces->image->plane(channel);
  540. output->data = span.data();
  541. output->size = span.size();
  542. }
  544. static uint64_t plugin_image_num_planes(struct ThalamusNode* node) {
  545. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  546. ASSERT_SAFE();
  547. return interfaces->image->num_planes();
  548. }
  550. static ThalamusImageFormat plugin_image_format(struct ThalamusNode* node) {
  551. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  552. ASSERT_SAFE();
  553. switch(interfaces->image->format()) {
  554. case ImageNode::Format::Gray:
  555. return ThalamusImageFormat_Gray;
  556. case ImageNode::Format::RGB:
  557. return ThalamusImageFormat_RGB;
  558. case ImageNode::Format::YUYV422:
  559. return ThalamusImageFormat_YUYV422;
  560. case ImageNode::Format::YUV420P:
  561. return ThalamusImageFormat_YUV420P;
  562. case ImageNode::Format::YUVJ420P:
  563. return ThalamusImageFormat_YUVJ420P;
  564. case ImageNode::Format::NV12:
  565. return ThalamusImageFormat_NV12;
  566. case ImageNode::Format::BGR:
  567. return ThalamusImageFormat_BGR;
  568. case ImageNode::Format::MJPEG:
  569. return ThalamusImageFormat_MJPEG;
  570. case ImageNode::Format::Gray16:
  571. return ThalamusImageFormat_Gray16;
  572. case ImageNode::Format::RGB16:
  573. return ThalamusImageFormat_RGB16;
  574. case ImageNode::Format::MPEG4:
  575. return ThalamusImageFormat_MPEG4;
  576. }
  577. }
  579. static uint64_t plugin_image_width(struct ThalamusNode* node) {
  580. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  581. ASSERT_SAFE();
  582. return interfaces->image->width();
  583. }
  585. static uint64_t plugin_image_height(struct ThalamusNode* node) {
  586. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  587. ASSERT_SAFE();
  588. return interfaces->image->height();
  589. }
  591. static uint64_t plugin_image_frame_interval_ns(struct ThalamusNode* node) {
  592. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  593. ASSERT_SAFE();
  594. std::chrono::nanoseconds ns = interfaces->image->frame_interval();
  595. return uint64_t(ns.count());
  596. }
  598. static char plugin_image_has_image_data(struct ThalamusNode* node) {
  599. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  600. ASSERT_SAFE();
  601. return interfaces->image->has_image_data() ? 1 : 0;
  602. }
  604. static void plugin_mocap_segments(ThalamusMocapSegmentSpan* output, struct ThalamusNode* node) {
  605. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  606. ASSERT_SAFE();
  607. auto segments = interfaces->mocap->segments();
  608. output->data = segments.data();
  609. output->size = segments.size();
  610. }
  612. static void plugin_mocap_pose_name(ThalamusCharSpan* output, struct ThalamusNode* node) {
  613. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  614. ASSERT_SAFE();
  615. auto name = interfaces->mocap->pose_name();
  616. output->data = name.data();
  617. output->size = name.size();
  618. }
  620. static char plugin_mocap_has_motion_data(struct ThalamusNode* node) {
  621. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  622. ASSERT_SAFE();
  623. return interfaces->mocap->has_motion_data() ? 1 : 0;
  624. }
  626. struct NodeGuard {
  627. Interfaces* interfaces;
  628. NodeGuard(ThalamusNode* node) : interfaces(reinterpret_cast<Interfaces*>(node->impl)) {
  629. ++interfaces->safe;
  630. }
  631. ~NodeGuard() {
  632. --interfaces->safe;
  633. }
  634. };
  637. static std::function<void()> to_closure(ThalamusPostCallback callback, void* data) {
  638. if(callback) {
  639. return [callback, data] { callback(data); };
  640. } else {
  641. return []{};
  642. }
  643. }
  645. struct ThalamusAPIImpl {
  646. static std::map<ObservableCollection::Value, ThalamusState*>* cpp_to_c;
  647. static std::map<ThalamusState*, ObservableCollection::Value>* c_to_cpp;
  649. static std::mutex* mutex;
  650. static std::map<Node*, ThalamusNode*>* node_cpp_to_c;
  651. static std::map<ThalamusNode*, Node*>* node_c_to_cpp;
  653. static boost::asio::io_context* io_context;
  654. static NodeGraphImpl* node_graph;
  656. static ThalamusNode* wrap_node(Node* node) {
  657. auto result = new ThalamusNode();
  658. memset(result, 0, sizeof(ThalamusNode));
  660. auto interfaces = new Interfaces();
  661. interfaces->node = node;
  662. interfaces->count = 1;
  663. result->impl = interfaces;
  664. result->process = plugin_node_process;
  666. auto analog = node_cast<AnalogNode *>(node);
  667. auto image = node_cast<ImageNode *>(node);
  668. auto mocap = node_cast<MotionCaptureNode *>(node);
  669. if(analog) {
  670. interfaces->analog = analog;
  671. result->time_ns = result->time_ns ? result->time_ns : plugin_analog_time_ns;
  672. result->analog = new ThalamusAnalogNode();
  673. result->analog->data = plugin_analog_data;
  674. result->analog->short_data = plugin_analog_short_data;
  675. result->analog->int_data = plugin_analog_int_data;
  676. result->analog->ulong_data = plugin_analog_ulong_data;
  677. result->analog->num_channels = plugin_analog_num_channels;
  678. result->analog->sample_interval_ns = plugin_analog_sample_interval_ns;
  679. result->analog->name = plugin_analog_name;
  680. result->analog->has_analog_data = plugin_analog_has_analog_data;
  681. result->analog->is_short_data = plugin_analog_is_short_data;
  682. result->analog->is_int_data = plugin_analog_is_int_data;
  683. result->analog->is_ulong_data = plugin_analog_is_ulong_data;
  684. result->analog->is_transformed = plugin_analog_is_transformed;
  685. result->analog->scale = plugin_analog_scale;
  686. result->analog->offset = plugin_analog_offset;
  687. }
  688. if (image) {
  689. interfaces->image = image;
  690. result->time_ns = result->time_ns ? result->time_ns : plugin_image_time_ns;
  691. result->image = new ThalamusImageNode();
  692. result->image->plane = plugin_image_plane;
  693. result->image->num_planes = plugin_image_num_planes;
  694. result->image->format = plugin_image_format;
  695. result->image->width = plugin_image_width;
  696. result->image->height = plugin_image_height;
  697. result->image->frame_interval_ns = plugin_image_frame_interval_ns;
  698. result->image->has_image_data = plugin_image_has_image_data;
  699. }
  700. if (mocap) {
  701. interfaces->mocap = mocap;
  702. result->time_ns = result->time_ns ? result->time_ns : plugin_mocap_time_ns;
  703. result->mocap = new ThalamusMocapNode();
  704. result->mocap->segments = plugin_mocap_segments;
  705. result->mocap->pose_name = plugin_mocap_pose_name;
  706. result->mocap->has_motion_data = plugin_mocap_has_motion_data;
  707. }
  709. return result;
  710. }
  712. static ThalamusNode* get_node_ref(Node* val) {
  713. std::lock_guard<std::mutex> lock(*mutex);
  715. auto i = node_cpp_to_c->find(val);
  716. if(i == node_cpp_to_c->end()) {
  717. auto new_ptr = wrap_node(val);
  718. //THALAMUS_LOG(info) << "new_state " << get_path(new_ptr->value) << " " << new_ptr->count;
  719. (*node_cpp_to_c)[val] = new_ptr;
  720. (*node_c_to_cpp)[new_ptr] = val;
  721. return new_ptr;
  722. } else {
  723. node_inc_ref(i->second);
  724. return i->second;
  725. }
  726. }
  728. static ObservableCollection::Value key_to_value(ObservableCollection::Key key) {
  729. if(std::holds_alternative<std::monostate>(key)) {
  730. return ObservableCollection::Value(std::get<std::monostate>(key));
  731. } else if (std::holds_alternative<int64_t>(key)) {
  732. return ObservableCollection::Value(std::get<int64_t>(key));
  733. } else if (std::holds_alternative<bool>(key)) {
  734. return ObservableCollection::Value(std::get<bool>(key));
  735. } else if (std::holds_alternative<std::string>(key)) {
  736. return ObservableCollection::Value(std::get<std::string>(key));
  737. }
  738. THALAMUS_ABORT("Unexpected type");
  739. }
  741. static ThalamusState* get_state_ref(ObservableCollection::Key key) {
  742. if(std::holds_alternative<std::monostate>(key)) {
  743. return get_state_ref(ObservableCollection::Value(std::get<std::monostate>(key)));
  744. } else if (std::holds_alternative<int64_t>(key)) {
  745. return get_state_ref(ObservableCollection::Value(std::get<int64_t>(key)));
  746. } else if (std::holds_alternative<bool>(key)) {
  747. return get_state_ref(ObservableCollection::Value(std::get<bool>(key)));
  748. } else if (std::holds_alternative<std::string>(key)) {
  749. return get_state_ref(ObservableCollection::Value(std::get<std::string>(key)));
  750. }
  751. THALAMUS_ABORT("Unexpected type");
  752. }
  754. static std::string get_path(ObservableCollection::Value state) {
  755. if(std::holds_alternative<ObservableDictPtr>(state)) {
  756. return std::get<ObservableDictPtr>(state)->address();
  757. } else if(std::holds_alternative<ObservableListPtr>(state)) {
  758. return std::get<ObservableListPtr>(state)->address();
  759. } else {
  760. return "";
  761. }
  762. }
  764. static ThalamusState* get_state_ref(ObservableCollection::Value val) {
  765. auto i = cpp_to_c->find(val);
  766. if(i == cpp_to_c->end()) {
  767. auto new_ptr = new ThalamusState{1, val};
  768. THALAMUS_LOG(trace) << "new_state " << get_path(new_ptr->value) << " " << new_ptr->count;
  769. (*cpp_to_c)[val] = new_ptr;
  770. (*c_to_cpp)[new_ptr] = val;
  771. return new_ptr;
  772. } else {
  773. state_inc_ref(i->second);
  774. return i->second;
  775. }
  776. }
  778. static void state_inc_ref(ThalamusState* state) {
  779. ++state->count;
  780. THALAMUS_LOG(trace) << "state_inc_ref " << get_path(state->value) << " " << state->count;
  781. }
  783. static void state_dec_ref(ThalamusState* state) {
  784. --state->count;
  785. THALAMUS_LOG(trace) << "state_dec_ref " << get_path(state->value) << " " << state->count;
  786. if(state->count == 0) {
  787. c_to_cpp->erase(state);
  788. cpp_to_c->erase(state->value);
  789. delete state;
  790. }
  791. }
  793. static char state_is_dict(ThalamusState* value) {
  794. return std::holds_alternative<ObservableDictPtr>(value->value) ? 1 : 0;
  795. }
  796. static char state_is_list(ThalamusState* value) {
  797. return std::holds_alternative<ObservableListPtr>(value->value) ? 1 : 0;
  798. }
  799. static char state_is_string(ThalamusState* value) {
  800. return std::holds_alternative<std::string>(value->value) ? 1 : 0;
  801. }
  802. static char state_is_int(ThalamusState* value) {
  803. return std::holds_alternative<int64_t>(value->value) ? 1 : 0;
  804. }
  805. static char state_is_float(ThalamusState* value) {
  806. return std::holds_alternative<double>(value->value) ? 1 : 0;
  807. }
  808. static char state_is_null(ThalamusState* value) {
  809. return std::holds_alternative<std::monostate>(value->value) ? 1 : 0;
  810. }
  811. static char state_is_bool(ThalamusState* value) {
  812. return std::holds_alternative<bool>(value->value) ? 1 : 0;
  813. }
  815. static void state_get_string(ThalamusCharSpan* span, ThalamusState* state) {
  816. const auto& s = std::get<std::string>(state->value);
  817. span->data = s.data();
  818. span->size = s.size();
  819. span->owns_data = 0;
  820. }
  821. static int64_t state_get_int(ThalamusState* state) {
  822. return std::get<int64_t>(state->value);
  823. }
  824. static double state_get_float(ThalamusState* state) {
  825. return std::get<double>(state->value);
  826. }
  827. static char state_get_bool(ThalamusState* state) {
  828. return std::get<bool>(state->value);
  829. }
  831. static ThalamusState* state_get_at_name(ThalamusState* state, const ThalamusCharSpan* key) {
  832. std::string key_str(key->data, key->size);
  833. if(std::holds_alternative<ObservableDictPtr>(state->value)) {
  834. auto dict = std::get<ObservableDictPtr>(state->value);
  835. if(dict->contains(key_str)) {
  836. return get_state_ref((*dict)[key_str]);
  837. } else {
  838. return nullptr;
  839. }
  840. }
  841. THALAMUS_ABORT("State does not contain dict");
  842. }
  843. static ThalamusState* state_get_at_index(ThalamusState* state, uint64_t key) {
  844. if(std::holds_alternative<ObservableDictPtr>(state->value)) {
  845. auto dict = std::get<ObservableDictPtr>(state->value);
  846. if(dict->contains(int64_t(key))) {
  847. return get_state_ref((*dict)[int64_t(key)]);
  848. } else {
  849. return nullptr;
  850. }
  851. } else if (std::holds_alternative<ObservableListPtr>(state->value)) {
  852. auto list = std::get<ObservableListPtr>(state->value);
  853. if(key < list->size()) {
  854. return get_state_ref((*list)[key]);
  855. } else {
  856. return nullptr;
  857. }
  858. }
  859. THALAMUS_ABORT("State does not contain dict or list");
  860. }
  862. static ThalamusStateConnection* state_recursive_change_connect(ThalamusState* state, ThalamusStateRecursiveCallback callback, void* data) {
  863. auto handler = [callback,data](ObservableCollection* source,
  864. ObservableCollection::Action action,
  865. ObservableCollection::Key key,
  866. ObservableCollection::Value value) {
  867. ObservableDict* as_dict;
  868. ObservableList* as_list;
  869. ThalamusState* source_wrapper;
  870. if((as_dict = dynamic_cast<ObservableDict*>(source)) != nullptr) {
  871. source_wrapper = get_state_ref(as_dict->shared_from_this());
  872. } else if ((as_list = dynamic_cast<ObservableList*>(source)) != nullptr) {
  873. source_wrapper = get_state_ref(as_list->shared_from_this());
  874. } else {
  875. THALAMUS_ABORT("state is not a collection");
  876. }
  877. auto action_wrapper = action == ObservableCollection::Action::Set ? ThalamusStateAction_Set : ThalamusStateAction_Delete;
  878. auto wrapped_key = get_state_ref(key);
  879. auto wrapped_value = get_state_ref(value);
  880. callback(source_wrapper, action_wrapper, wrapped_key, wrapped_value, data);
  881. state_dec_ref(source_wrapper);
  882. state_dec_ref(wrapped_key);
  883. state_dec_ref(wrapped_value);
  884. };
  886. boost::signals2::connection connection;
  887. if(std::holds_alternative<ObservableDictPtr>(state->value)) {
  888. connection = std::get<ObservableDictPtr>(state->value)->recursive_changed.connect(handler);
  889. } else {
  890. connection = std::get<ObservableListPtr>(state->value)->recursive_changed.connect(handler);
  891. }
  892. return new ThalamusStateConnection(connection);
  893. }
  895. static void state_recursive_change_disconnect(ThalamusStateConnection *connection) {
  896. delete connection;
  897. }
  899. static ThalamusTimer *timer_create() {
  900. return new ThalamusTimer(*io_context);
  901. }
  902. static void timer_destroy(ThalamusTimer *timer) {
  903. delete timer;
  904. }
  905. static void timer_expire_after_ns(ThalamusTimer *timer, uint64_t ns) {
  906. timer->timer.expires_after(std::chrono::nanoseconds(ns));
  907. }
  908. static void timer_async_wait(ThalamusTimer *timer,
  909. ThalamusTimerCallback callback, void *data) {
  910. timer->timer.async_wait([callback, data](const boost::system::error_code& error) {
  911. ThalamusErrorCode error_wrapper(error);
  912. callback(&error_wrapper, data);
  913. });
  914. }
  916. static int error_code_value(ThalamusErrorCode *error) {
  917. return error->error->value();
  918. }
  920. static void node_ready(ThalamusNode* node) {
  921. auto ext_node = reinterpret_cast<ExtNode*>(node->impl);
  922. ext_node->ready(ext_node);
  923. }
  925. static void node_ready_offmain(ThalamusNode* node) {
  926. auto ext_node = reinterpret_cast<ExtNode*>(node->impl);
  927. node::signal_ready_offmain(ext_node, *io_context);
  928. }
  930. static void node_predrop_ready(ThalamusNode* node) {
  931. THALAMUS_LOG(info) << "*ext* node_predrop_ready";
  932. auto ext_node = reinterpret_cast<ExtNode*>(node->impl);
  933. THALAMUS_ASSERT(ext_node->drop_ready, "No predrop callback available");
  934. ext_node->drop_ready();
  935. }
  937. static uint64_t time_ns() {
  938. std::chrono::nanoseconds ns = std::chrono::steady_clock::now().time_since_epoch();
  939. return uint64_t(ns.count());
  940. }
  942. static int error_code_operation_aborted() {
  943. return boost::asio::error::operation_aborted;
  944. }
  946. static void state_recap(ThalamusState* state) {
  947. if(std::holds_alternative<ObservableDictPtr>(state->value)) {
  948. std::get<ObservableDictPtr>(state->value)->recap();
  949. } else if(std::holds_alternative<ObservableListPtr>(state->value)) {
  950. std::get<ObservableListPtr>(state->value)->recap();
  951. } else {
  952. THALAMUS_ABORT("Attempt to recap a value that is neither a dict or list");
  953. }
  954. }
  956. static void state_recap_with(ThalamusState* state, ThalamusStateRecursiveCallback callback, void* data) {
  957. auto handler = [state,callback,data](ObservableCollection::Action action,
  958. ObservableCollection::Key key,
  959. ObservableCollection::Value value) {
  960. auto action_wrapper = action == ObservableCollection::Action::Set ? ThalamusStateAction_Set : ThalamusStateAction_Delete;
  961. auto wrapped_key = get_state_ref(key);
  962. auto wrapped_value = get_state_ref(value);
  963. callback(state, action_wrapper, wrapped_key, wrapped_value, data);
  964. state_dec_ref(wrapped_key);
  965. state_dec_ref(wrapped_value);
  966. };
  968. if(std::holds_alternative<ObservableDictPtr>(state->value)) {
  969. std::get<ObservableDictPtr>(state->value)->recap(handler);
  970. } else if(std::holds_alternative<ObservableListPtr>(state->value)) {
  971. std::get<ObservableListPtr>(state->value)->recap(handler);
  972. } else {
  973. THALAMUS_ABORT("Attempt to recap a value that is neither a dict or list");
  974. }
  975. }
  977. template <typename T1, typename T2> static void assign_state(struct ThalamusState* state, T1 key, T2 value, std::function<void()> callback = nullptr) {
  978. if(std::holds_alternative<ObservableDictPtr>(state->value)) {
  979. auto coll = std::get<ObservableDictPtr>(state->value);
  980. (*coll)[key].assign(value, callback);
  981. } else if(std::holds_alternative<ObservableListPtr>(state->value)) {
  982. if constexpr (std::is_integral<T1>::value) {
  983. auto coll = std::get<ObservableListPtr>(state->value);
  984. if(size_t(key) < coll->size()) {
  985. (*coll)[size_t(key)].assign(value, callback);
  986. } else {
  987. THALAMUS_ABORT("Index out of bounds");
  988. }
  989. } else {
  990. THALAMUS_ABORT("Can only index list with integer");
  991. }
  992. } else {
  993. THALAMUS_ABORT("Attempt to recap a value that is neither a dict or list");
  994. }
  995. }
  997. template <typename T1> static void erase_state(struct ThalamusState* state, T1 key, std::function<void()> callback = nullptr) {
  998. if(std::holds_alternative<ObservableDictPtr>(state->value)) {
  999. auto coll = std::get<ObservableDictPtr>(state->value);
  1000. coll->erase(key, [callback] (auto) {
  1001. callback();
  1002. });
  1003. } else if(std::holds_alternative<ObservableListPtr>(state->value)) {
  1004. if constexpr (std::is_integral<T1>::value) {
  1005. auto coll = std::get<ObservableListPtr>(state->value);
  1006. if(size_t(key) < coll->size()) {
  1007. coll->erase(size_t(key), [callback] (auto) {
  1008. callback();
  1009. });
  1010. } else {
  1011. THALAMUS_ABORT("Index out of bounds");
  1012. }
  1013. } else {
  1014. THALAMUS_ABORT("Can only index list with integer");
  1015. }
  1016. } else {
  1017. THALAMUS_ABORT("Attempt to recap a value that is neither a dict or list");
  1018. }
  1019. }
  1021. template <typename T1> static void push_state(struct ThalamusState* state, T1 value, std::function<void()> callback) {
  1022. if(std::holds_alternative<ObservableListPtr>(state->value)) {
  1023. auto coll = std::get<ObservableListPtr>(state->value);
  1024. coll->push_back(value, callback);
  1025. } else {
  1026. THALAMUS_ABORT("Attempt to recap a value that is neither a dict or list");
  1027. }
  1028. }
  1030. static void state_set_at_name_state(struct ThalamusState* state, const ThalamusCharSpan* key, struct ThalamusState* value) {
  1031. assign_state(state, std::string(key->data, key->size), value->value);
  1032. }
  1033. static void state_set_at_name_string(struct ThalamusState* state, const ThalamusCharSpan* key, const ThalamusCharSpan* value) {
  1034. assign_state(state, std::string(key->data, key->size), std::string(value->data, value->size));
  1035. }
  1036. static void state_set_at_name_int(struct ThalamusState* state, const ThalamusCharSpan* key, int64_t value) {
  1037. assign_state(state, std::string(key->data, key->size), value);
  1038. }
  1039. static void state_set_at_name_float(struct ThalamusState* state, const ThalamusCharSpan* key, double value) {
  1040. assign_state(state, std::string(key->data, key->size), value);
  1041. }
  1042. static void state_set_at_name_null(struct ThalamusState* state, const ThalamusCharSpan* key) {
  1043. assign_state(state, std::string(key->data, key->size), std::monostate());
  1044. }
  1045. static void state_set_at_name_bool(struct ThalamusState* state, const ThalamusCharSpan* key, char value) {
  1046. assign_state(state, std::string(key->data, key->size), value != 0);
  1047. }
  1049. static void state_set_at_index_state(struct ThalamusState* state, int64_t key, struct ThalamusState* value) {
  1050. assign_state(state, key, value->value);
  1051. }
  1052. static void state_set_at_index_string(struct ThalamusState* state, int64_t key, const ThalamusCharSpan* value) {
  1053. assign_state(state, key, std::string(value->data, value->size));
  1054. }
  1055. static void state_set_at_index_int(struct ThalamusState* state, int64_t key, int64_t value) {
  1056. assign_state(state, key, value);
  1057. }
  1058. static void state_set_at_index_float(struct ThalamusState* state, int64_t key, double value) {
  1059. assign_state(state, key, value);
  1060. }
  1061. static void state_set_at_index_null(struct ThalamusState* state, int64_t key) {
  1062. assign_state(state, key, std::monostate());
  1063. }
  1064. static void state_set_at_index_bool(struct ThalamusState* state, int64_t key, char value) {
  1065. assign_state(state, key, value != 0);
  1066. }
  1068. static void state_set_at_name_state_with_callback(struct ThalamusState* state, const ThalamusCharSpan* key, struct ThalamusState* value, ThalamusPostCallback callback, void* data) {
  1069. auto closure = to_closure(callback, data);
  1070. assign_state(state, std::string(key->data, key->size), value->value, closure);
  1071. }
  1072. static void state_set_at_name_string_with_callback(struct ThalamusState* state, const ThalamusCharSpan* key, const ThalamusCharSpan* value, ThalamusPostCallback callback, void* data) {
  1073. auto closure = to_closure(callback, data);
  1074. assign_state(state, std::string(key->data, key->size), std::string(value->data, value->size), closure);
  1075. }
  1076. static void state_set_at_name_int_with_callback(struct ThalamusState* state, const ThalamusCharSpan* key, int64_t value, ThalamusPostCallback callback, void* data) {
  1077. auto closure = to_closure(callback, data);
  1078. assign_state(state, std::string(key->data, key->size), value, closure);
  1079. }
  1080. static void state_set_at_name_float_with_callback(struct ThalamusState* state, const ThalamusCharSpan* key, double value, ThalamusPostCallback callback, void* data) {
  1081. auto closure = to_closure(callback, data);
  1082. assign_state(state, std::string(key->data, key->size), value, closure);
  1083. }
  1084. static void state_set_at_name_null_with_callback(struct ThalamusState* state, const ThalamusCharSpan* key, ThalamusPostCallback callback, void* data) {
  1085. auto closure = to_closure(callback, data);
  1086. assign_state(state, std::string(key->data, key->size), std::monostate(), closure);
  1087. }
  1088. static void state_set_at_name_bool_with_callback(struct ThalamusState* state, const ThalamusCharSpan* key, char value, ThalamusPostCallback callback, void* data) {
  1089. auto closure = to_closure(callback, data);
  1090. assign_state(state, std::string(key->data, key->size), value != 0, closure);
  1091. }
  1093. static void state_set_at_index_state_with_callback(struct ThalamusState* state, int64_t key, struct ThalamusState* value, ThalamusPostCallback callback, void* data) {
  1094. auto closure = to_closure(callback, data);
  1095. assign_state(state, key, value->value, closure);
  1096. }
  1097. static void state_set_at_index_string_with_callback(struct ThalamusState* state, int64_t key, const ThalamusCharSpan* value, ThalamusPostCallback callback, void* data) {
  1098. auto closure = to_closure(callback, data);
  1099. assign_state(state, key, std::string(value->data, value->size), closure);
  1100. }
  1101. static void state_set_at_index_int_with_callback(struct ThalamusState* state, int64_t key, int64_t value, ThalamusPostCallback callback, void* data) {
  1102. auto closure = to_closure(callback, data);
  1103. assign_state(state, key, value, closure);
  1104. }
  1105. static void state_set_at_index_float_with_callback(struct ThalamusState* state, int64_t key, double value, ThalamusPostCallback callback, void* data) {
  1106. auto closure = to_closure(callback, data);
  1107. assign_state(state, key, value, closure);
  1108. }
  1109. static void state_set_at_index_null_with_callback(struct ThalamusState* state, int64_t key, ThalamusPostCallback callback, void* data) {
  1110. auto closure = to_closure(callback, data);
  1111. assign_state(state, key, std::monostate(), closure);
  1112. }
  1113. static void state_set_at_index_bool_with_callback(struct ThalamusState* state, int64_t key, char value, ThalamusPostCallback callback, void* data) {
  1114. auto closure = to_closure(callback, data);
  1115. assign_state(state, key, value != 0, closure);
  1116. }
  1118. static void state_push_state_with_callback(struct ThalamusState* state, struct ThalamusState* value, ThalamusPostCallback callback, void* data) {
  1119. auto closure = to_closure(callback, data);
  1120. push_state(state, value->value, closure);
  1121. }
  1122. static void state_push_string_with_callback(struct ThalamusState* state, const ThalamusCharSpan* value, ThalamusPostCallback callback, void* data) {
  1123. auto closure = to_closure(callback, data);
  1124. push_state(state, std::string(value->data, value->size), closure);
  1125. }
  1126. static void state_push_int_with_callback(struct ThalamusState* state, int64_t value, ThalamusPostCallback callback, void* data) {
  1127. auto closure = to_closure(callback, data);
  1128. push_state(state, value, closure);
  1129. }
  1130. static void state_push_float_with_callback(struct ThalamusState* state, double value, ThalamusPostCallback callback, void* data) {
  1131. auto closure = to_closure(callback, data);
  1132. push_state(state, value, closure);
  1133. }
  1134. static void state_push_null_with_callback(struct ThalamusState* state, ThalamusPostCallback callback, void* data) {
  1135. auto closure = to_closure(callback, data);
  1136. push_state(state, std::monostate(), closure);
  1137. }
  1138. static void state_push_bool_with_callback(struct ThalamusState* state, char value, ThalamusPostCallback callback, void* data) {
  1139. auto closure = to_closure(callback, data);
  1140. push_state(state, value != 0, closure);
  1141. }
  1143. static struct ThalamusState* state_parent(struct ThalamusState* state) {
  1144. ObservableCollection* parent = nullptr;
  1145. if(std::holds_alternative<ObservableDictPtr>(state->value)) {
  1146. parent = std::get<ObservableDictPtr>(state->value)->parent;
  1147. } else if (std::holds_alternative<ObservableListPtr>(state->value)) {
  1148. parent = std::get<ObservableListPtr>(state->value)->parent;
  1149. } else {
  1150. THALAMUS_ABORT("Attempt to recap a value that is neither a dict or list");
  1151. }
  1152. if (parent == nullptr) {
  1153. return nullptr;
  1154. }
  1156. ObservableList* list;
  1157. ObservableDict* dict;
  1158. ObservableCollection::Value parent_value;
  1159. if((list = parent->as_list())) {
  1160. parent_value = ObservableCollection::Value(list->shared_from_this());
  1161. } else if ((dict = parent->as_dict())) {
  1162. parent_value = ObservableCollection::Value(dict->shared_from_this());
  1163. } else {
  1164. return nullptr;
  1165. }
  1166. return get_state_ref(parent_value);
  1167. }
  1169. static struct ThalamusStateIter* state_iter_create(struct ThalamusState* state) {
  1170. if(std::holds_alternative<ObservableDictPtr>(state->value)) {
  1171. auto value = std::get<ObservableDictPtr>(state->value);
  1172. return new ThalamusStateIter{state->value, value->begin(), value->begin(), value->end(), false};
  1173. } else if (std::holds_alternative<ObservableListPtr>(state->value)) {
  1174. auto value = std::get<ObservableListPtr>(state->value);
  1175. return new ThalamusStateIter{state->value, value->begin(), value->begin(), value->end(), false};
  1176. }
  1177. THALAMUS_ABORT("Attempt to iterate a value that is neither a dict or list");
  1178. }
  1180. static uint8_t state_iter_next(struct ThalamusStateIter* iter) {
  1181. if (iter->pos == iter->end) {
  1182. return 0;
  1183. }
  1184. if(std::holds_alternative<thalamus::ObservableCollection::VectorIteratorWrapper>(iter->begin)) {
  1185. auto& pos = std::get<thalamus::ObservableCollection::VectorIteratorWrapper>(iter->pos);
  1186. auto end = std::get<thalamus::ObservableCollection::VectorIteratorWrapper>(iter->pos);
  1187. if(iter->started) {
  1188. ++pos;
  1189. } else {
  1190. iter->started = true;
  1191. }
  1192. return iter->pos == iter->end ? 0 : 1;
  1193. } else if (std::holds_alternative<thalamus::ObservableCollection::MapIteratorWrapper>(iter->begin)) {
  1194. auto& pos = std::get<thalamus::ObservableCollection::MapIteratorWrapper>(iter->pos);
  1195. auto end = std::get<thalamus::ObservableCollection::MapIteratorWrapper>(iter->pos);
  1196. if(iter->started) {
  1197. ++pos;
  1198. } else {
  1199. iter->started = true;
  1200. }
  1201. return iter->pos == iter->end ? 0 : 1;
  1202. }
  1203. THALAMUS_ABORT("Bad Iterator");
  1204. }
  1206. static struct ThalamusState* state_iter_key(struct ThalamusStateIter* iter) {
  1207. THALAMUS_ASSERT(iter->pos != iter->end, "Attempted to read finished iterator");
  1208. thalamus::ObservableCollection::Value result;
  1209. if(std::holds_alternative<thalamus::ObservableCollection::VectorIteratorWrapper>(iter->begin)) {
  1210. auto begin = std::get<thalamus::ObservableCollection::VectorIteratorWrapper>(iter->begin);
  1211. auto pos = std::get<thalamus::ObservableCollection::VectorIteratorWrapper>(iter->pos);
  1212. result = int64_t(std::distance(begin, pos));
  1213. } else if (std::holds_alternative<thalamus::ObservableCollection::MapIteratorWrapper>(iter->begin)) {
  1214. auto pos = std::get<thalamus::ObservableCollection::MapIteratorWrapper>(iter->pos);
  1215. result = key_to_value(pos->first);
  1216. }
  1217. return get_state_ref(result);
  1218. }
  1220. static struct ThalamusState* state_iter_value(struct ThalamusStateIter* iter) {
  1221. THALAMUS_ASSERT(iter->pos != iter->end, "Attempted to read finished iterator");
  1222. thalamus::ObservableCollection::Value result;
  1223. if(std::holds_alternative<thalamus::ObservableCollection::VectorIteratorWrapper>(iter->begin)) {
  1224. auto pos = std::get<thalamus::ObservableCollection::VectorIteratorWrapper>(iter->pos);
  1225. result = *pos;
  1226. } else if (std::holds_alternative<thalamus::ObservableCollection::MapIteratorWrapper>(iter->begin)) {
  1227. auto pos = std::get<thalamus::ObservableCollection::MapIteratorWrapper>(iter->pos);
  1228. result = pos->second;
  1229. }
  1230. return get_state_ref(result);
  1231. }
  1233. static struct ThalamusState* state_key_of(struct ThalamusState* parent, struct ThalamusState* child) {
  1234. ObservableCollection* parent_col = nullptr;
  1235. ObservableCollection* child_col = nullptr;
  1236. if(std::holds_alternative<ObservableDictPtr>(parent->value)) {
  1237. parent_col = std::get<ObservableDictPtr>(parent->value).get();
  1238. } else if (std::holds_alternative<ObservableListPtr>(parent->value)) {
  1239. parent_col = std::get<ObservableListPtr>(parent->value).get();
  1240. } else {
  1241. THALAMUS_ABORT("Attempt to iterate a value that is neither a dict or list");
  1242. }
  1243. if(std::holds_alternative<ObservableDictPtr>(child->value)) {
  1244. child_col = std::get<ObservableDictPtr>(child->value).get();
  1245. } else if (std::holds_alternative<ObservableListPtr>(child->value)) {
  1246. child_col = std::get<ObservableListPtr>(child->value).get();
  1247. } else {
  1248. THALAMUS_ABORT("Attempt to iterate a value that is neither a dict or list");
  1249. }
  1251. auto key = parent_col->key_of(*child_col);
  1253. return key ? get_state_ref(*key) : nullptr;
  1254. }
  1256. static void state_iter_destroy(struct ThalamusStateIter* iter) {
  1257. delete iter;
  1258. }
  1260. static void io_context_post(ThalamusPostCallback callback, void* data) {
  1261. boost::asio::post(*io_context, [callback, data] {
  1262. callback(data);
  1263. });
  1264. }
  1266. static void threadpool_post(ThalamusPostCallback callback, void* data) {
  1267. node_graph->get_thread_pool().push([callback, data] {
  1268. callback(data);
  1269. });
  1270. }
  1272. static void trace_event_begin(const ThalamusCharSpan* name) {
  1273. TRACE_EVENT_BEGIN("plugin", perfetto::DynamicString(name->data, name->size));
  1274. }
  1276. static void trace_event_end() {
  1277. TRACE_EVENT_END("plugin");
  1278. }
  1280. static ThalamusSerialPort* serial_port_create() {
  1281. auto result = new ThalamusSerialPort{
  1282. boost::asio::serial_port(*io_context),
  1283. boost::system::error_code(),
  1284. ThalamusErrorCode()
  1285. };
  1286. result->error_wrapper.error = &result->error;
  1287. return result;
  1288. }
  1290. static void serial_port_destroy(ThalamusSerialPort* port) {
  1291. delete port;
  1292. }
  1294. static void serial_set_baud_rate(ThalamusSerialPort* port, uint32_t rate) {
  1295. port->port.set_option(boost::asio::serial_port_base::baud_rate(rate));
  1296. }
  1298. static void serial_port_open(ThalamusSerialPort* port, const ThalamusCharSpan* name) {
  1299. port->port.open(std::string(name->data, name->size), port->error);
  1300. }
  1302. static ThalamusErrorCode* serial_port_error(ThalamusSerialPort* port) {
  1303. return &port->error_wrapper;
  1304. }
  1306. static void serial_port_read_until(ThalamusSerialPort* port, ThalamusStreamBuf* buffer, const ThalamusCharSpan* delimiter, ThalamusIOCallback callback, void* data) {
  1307. auto view = boost::asio::string_view(delimiter->data, delimiter->size);
  1308. boost::asio::async_read_until(port->port, buffer->buffer, view, [callback, data] (auto ec, auto count) {
  1309. ThalamusErrorCode err{ec};
  1310. callback(&err, count, data);
  1311. });
  1312. }
  1314. static void serial_port_read_some(ThalamusSerialPort* port, ThalamusMutableByteSpan* span, ThalamusIOCallback callback, void* data) {
  1315. port->port.async_read_some(boost::asio::buffer(span->data, span->size), [callback, data] (auto ec, auto count) {
  1316. ThalamusErrorCode err{ec};
  1317. callback(&err, count, data);
  1318. });
  1319. }
  1321. static void serial_port_read(ThalamusSerialPort* port, ThalamusMutableByteSpan* span, ThalamusIOCallback callback, void* data) {
  1322. boost::asio::async_read(port->port, boost::asio::buffer(span->data, span->size), [callback, data] (auto ec, auto count) {
  1323. ThalamusErrorCode err{ec};
  1324. callback(&err, count, data);
  1325. });
  1326. }
  1328. static void serial_port_write(ThalamusSerialPort* port, ThalamusByteSpan* span, ThalamusIOCallback callback, void* data) {
  1329. boost::asio::async_write(port->port, boost::asio::buffer(span->data, span->size), [callback, data] (auto ec, auto count) {
  1330. ThalamusErrorCode err{ec};
  1331. callback(&err, count, data);
  1332. });
  1333. }
  1335. static ThalamusStreamBuf* streambuf_create() {
  1336. auto result = new ThalamusStreamBuf{
  1337. boost::asio::streambuf()
  1338. };
  1339. return result;
  1340. }
  1342. static void streambuf_destroy(ThalamusStreamBuf* port) {
  1343. delete port;
  1344. }
  1346. static void streambuf_to_span(struct ThalamusCharSpan* result, ThalamusStreamBuf* buffer) {
  1347. std::istream stream(&buffer->buffer);
  1348. auto size = buffer->buffer.size();
  1349. char* data = new char[size];
  1350. std::copy_n(std::istreambuf_iterator<char>(&buffer->buffer), buffer->buffer.size(), data);
  1352. result->data = data;
  1353. result->size = size;
  1354. result->owns_data = true;
  1355. }
  1357. static void streambuf_consume(ThalamusStreamBuf* buffer, uint64_t count) {
  1358. buffer->buffer.consume(count);
  1359. }
  1361. static uint64_t streambuf_size(ThalamusStreamBuf* buffer) {
  1362. return buffer->buffer.size();
  1363. }
  1365. static void charspan_release(ThalamusCharSpan* span) {
  1366. if(span->owns_data) {
  1367. delete span->data;
  1368. }
  1369. }
  1371. static void error_code_message(struct ThalamusCharSpan* result, ThalamusErrorCode *error) {
  1372. auto message = error->error->message();
  1373. char* data = new char[message.size()];
  1374. std::copy_n(message.begin(), message.size(), data);
  1375. result->data = data;
  1376. result->size = message.size();
  1377. result->owns_data = true;
  1378. }
  1380. static void json_to_string(struct ThalamusCharSpan* output, const struct ThalamusJson* input) {
  1381. auto serialized = boost::json::serialize(input->value);
  1382. string_to_span(output, serialized);
  1383. }
  1385. static struct ThalamusJson* json_from_string(const struct ThalamusCharSpan* input) {
  1386. return new ThalamusJson{1, boost::json::parse(std::string_view(input->data, input->size))};
  1387. }
  1389. static void json_inc_ref(struct ThalamusJson* input) {
  1390. ++input->refs;
  1391. }
  1393. static void json_dec_ref(struct ThalamusJson* input) {
  1394. if(--input->refs == 0) {
  1395. delete input;
  1396. }
  1397. }
  1399. static void request_respond(struct ThalamusRequestHandle* handle, const struct ThalamusJson* response) {
  1400. handle->callback(response->value);
  1401. delete handle;
  1402. }
  1404. static ThalamusNodeGetConnection* node_get_node(struct ThalamusNodeSelector* c_selector, ThalamusNodeGetCallback callback, void* data) {
  1405. thalamus_grpc::NodeSelector selector;
  1406. if(c_selector->name.data) {
  1407. selector.set_name(std::string(c_selector->name.data, c_selector->name.size));
  1408. }
  1409. if(c_selector->type.data) {
  1410. selector.set_type(std::string(c_selector->type.data, c_selector->type.size));
  1411. }
  1413. auto result = new ThalamusNodeGetConnection();
  1414. result->connection = node_graph->get_node_scoped(selector, [callback, data] (auto node) {
  1415. auto ref = get_node_ref(node.lock().get());
  1416. {
  1417. NodeGuard lock(ref);
  1418. callback(ref, data);
  1419. }
  1420. node_dec_ref(ref);
  1421. });
  1422. return result;
  1423. }
  1425. static void node_inc_ref(struct ThalamusNode* node) {
  1426. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  1427. ++interfaces->count;
  1428. }
  1430. static void node_dec_ref(struct ThalamusNode* node) {
  1431. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  1432. if(--interfaces->count == 0) {
  1433. std::lock_guard<std::mutex> lock(*mutex);
  1434. node_c_to_cpp->erase(node);
  1435. node_cpp_to_c->erase(interfaces->node);
  1436. delete node;
  1437. }
  1438. }
  1440. static ThalamusNodeReadyConnection* node_ready_connect(struct ThalamusNode* node, ThalamusNodeReadyCallback callback, void* data) {
  1441. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  1443. auto result = new ThalamusNodeReadyConnection();
  1444. result->node = node;
  1445. node_inc_ref(node);
  1446. result->connection = interfaces->node->ready.connect([node, callback, data] (auto) {
  1447. NodeGuard lock(node);
  1448. callback(node, data);
  1449. });
  1450. return result;
  1451. }
  1453. static ThalamusNodeReadyConnection* node_ready_multithreaded_connect(struct ThalamusNode* node, ThalamusNodeReadyCallback callback, void* data) {
  1454. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  1456. auto result = new ThalamusNodeReadyConnection();
  1457. result->node = node;
  1458. node_inc_ref(node);
  1459. result->connection = node::connect_ready_multithreaded(interfaces->node, [node, callback, data] (auto) {
  1460. NodeGuard lock(node);
  1461. callback(node, data);
  1462. });
  1463. return result;
  1464. }
  1466. static void node_get_node_disconnect(struct ThalamusNodeGetConnection* conn) {
  1467. delete conn;
  1468. }
  1469. static void node_ready_disconnect(struct ThalamusNodeReadyConnection* conn) {
  1470. node_dec_ref(conn->node);
  1471. delete conn;
  1472. }
  1474. static void node_channels_changed(struct ThalamusNode* node) {
  1475. auto ext_node = reinterpret_cast<ExtNode*>(node->impl);
  1476. ext_node->channels_changed(ext_node);
  1477. }
  1479. static ThalamusNodeReadyConnection* node_channels_changed_connect(struct ThalamusNode* node, ThalamusNodeReadyCallback callback, void* data) {
  1480. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  1482. auto result = new ThalamusNodeReadyConnection();
  1483. result->node = node;
  1484. node_inc_ref(node);
  1485. if(interfaces->analog) {
  1486. result->connection = interfaces->analog->channels_changed.connect([node, callback, data] (auto) {
  1487. NodeGuard lock(node);
  1488. callback(node, data);
  1489. });
  1490. }
  1491. return result;
  1492. }
  1494. static void node_channels_changed_disconnect(struct ThalamusNodeReadyConnection* conn) {
  1495. node_dec_ref(conn->node);
  1496. delete conn;
  1497. }
  1499. static ThalamusState* node_get_state(struct ThalamusNode* node) {
  1500. auto interfaces = reinterpret_cast<Interfaces*>(node->impl);
  1501. ASSERT_SAFE();
  1502. return get_state_ref(node_graph->get_node_state(interfaces->node));
  1503. }
  1505. static VkInstance get_vulkan_instance() {
  1506. return node_graph->get_vulkan_instance();
  1507. }
  1509. static VkDevice get_vulkan_device() {
  1510. return node_graph->get_vulkan_device();
  1511. }
  1513. static VkPhysicalDevice get_vulkan_physical_device() {
  1514. return node_graph->get_vulkan_physical_device();
  1515. }
  1517. static VkQueue get_vulkan_queue() {
  1518. return node_graph->get_vulkan_queue();
  1519. }
  1521. static VkCommandPool create_vulkan_command_pool() {
  1522. return node_graph->create_vulkan_command_pool();
  1523. }
  1525. static ThalamusVkQueueLock* lock_vulkan_queue() {
  1526. return new ThalamusVkQueueLock{node_graph->lock_vulkan_queue()};
  1527. }
  1529. static void unlock_vulkan_queue(ThalamusVkQueueLock* lock) {
  1530. delete lock;
  1531. }
  1533. static struct THALAMUS_SDL_Window* sdl_create_window(struct ThalamusCharSpan* name, int32_t width, int32_t height, uint64_t flags) {
  1534. auto window = SDL_CreateWindow(std::string(name->data, name->size).c_str(), width, height, flags);
  1535. return reinterpret_cast<struct THALAMUS_SDL_Window*>(window);
  1536. }
  1538. static void sdl_destroy_window(struct THALAMUS_SDL_Window* window) {
  1539. SDL_DestroyWindow(reinterpret_cast<SDL_Window*>(window));
  1540. }
  1542. static void sdl_set_window_position(struct THALAMUS_SDL_Window* window, int32_t x, int32_t y) {
  1543. SDL_SetWindowPosition(reinterpret_cast<SDL_Window*>(window), x, y);
  1544. }
  1546. static void sdl_set_window_size(struct THALAMUS_SDL_Window* window, int32_t w, int32_t h) {
  1547. SDL_SetWindowSize(reinterpret_cast<SDL_Window*>(window), w, h);
  1548. }
  1550. static void sdl_set_window_title(struct THALAMUS_SDL_Window* window, struct ThalamusCharSpan* title) {
  1551. SDL_SetWindowTitle(reinterpret_cast<SDL_Window*>(window), std::string(title->data, title->size).c_str());
  1552. }
  1554. static void sdl_get_error(struct ThalamusCharSpan* error) {
  1555. const char* message = SDL_GetError();
  1556. error->data = message;
  1557. error->size = message ? strlen(message) : 0;
  1558. error->owns_data = 0;
  1559. }
  1561. static uint8_t sdl_vulkan_create_surface(struct THALAMUS_SDL_Window* window, VkInstance instance, const struct VkAllocationCallbacks* allocator, VkSurfaceKHR* surface) {
  1562. return SDL_Vulkan_CreateSurface(reinterpret_cast<SDL_Window*>(window), instance, allocator, surface) ? 1 : 0;
  1563. }
  1565. static void sdl_get_window_size_in_pixels(struct THALAMUS_SDL_Window* window, int32_t* w, int32_t* h) {
  1566. SDL_GetWindowSizeInPixels(reinterpret_cast<SDL_Window*>(window), w, h);
  1567. }
  1569. static uint32_t sdl_get_window_id(struct THALAMUS_SDL_Window* window) {
  1570. return SDL_GetWindowID(reinterpret_cast<SDL_Window*>(window));
  1571. }
  1573. static void sdl_get_window_position(struct THALAMUS_SDL_Window* window, int32_t* x, int32_t* y) {
  1574. SDL_GetWindowPosition(reinterpret_cast<SDL_Window*>(window), x, y);
  1575. }
  1577. static void sdl_get_window_size(struct THALAMUS_SDL_Window* window, int32_t* w, int32_t* h) {
  1578. SDL_GetWindowSize(reinterpret_cast<SDL_Window*>(window), w, h);
  1579. }
  1581. static struct THALAMUS_SDL_EventSubscription* sdl_events_subscribe(THALAMUS_SDL_EventCallback callback, void* data) {
  1582. return ImageViewer::subscribe([callback, data](THALAMUS_SDL_Event* event) {
  1583. callback(event, data);
  1584. });
  1585. }
  1587. static void sdl_events_unsubscribe(struct THALAMUS_SDL_EventSubscription* subscription) {
  1588. ImageViewer::unsubscribe(subscription);
  1589. }
  1591. static void sdl_get_clipboard_text(struct ThalamusCharSpan* result) {
  1592. char* text = SDL_GetClipboardText();
  1593. string_to_span(result, text ? std::string(text) : std::string());
  1594. SDL_free(text);
  1595. }
  1597. static uint8_t sdl_set_clipboard_text(const struct ThalamusCharSpan* text) {
  1598. return SDL_SetClipboardText(std::string(text->data, text->size).c_str()) ? 1 : 0;
  1599. }
  1601. static struct THALAMUS_SDL_Cursor* sdl_create_system_cursor(int32_t id) {
  1602. return reinterpret_cast<struct THALAMUS_SDL_Cursor*>(SDL_CreateSystemCursor(static_cast<SDL_SystemCursor>(id)));
  1603. }
  1605. static uint8_t sdl_set_cursor(struct THALAMUS_SDL_Cursor* cursor) {
  1606. return SDL_SetCursor(reinterpret_cast<SDL_Cursor*>(cursor)) ? 1 : 0;
  1607. }
  1609. static void sdl_destroy_cursor(struct THALAMUS_SDL_Cursor* cursor) {
  1610. SDL_DestroyCursor(reinterpret_cast<SDL_Cursor*>(cursor));
  1611. }
  1613. static uint8_t sdl_show_cursor() {
  1614. return SDL_ShowCursor() ? 1 : 0;
  1615. }
  1617. static uint8_t sdl_hide_cursor() {
  1618. return SDL_HideCursor() ? 1 : 0;
  1619. }
  1621. static struct ThalamusState* state_make_dict() {
  1622. auto dict = ObservableCollection::Value(std::make_shared<ObservableDict>());
  1623. auto ref = get_state_ref(dict);
  1624. return ref;
  1625. }
  1627. static struct ThalamusState* state_make_list() {
  1628. auto dict = ObservableCollection::Value(std::make_shared<ObservableList>());
  1629. auto ref = get_state_ref(dict);
  1630. return ref;
  1631. }
  1633. static struct ThalamusOffMainSignaler* node_offmain_signaler_create(struct ThalamusNode* node) {
  1634. auto ext_node = reinterpret_cast<ExtNode*>(node->impl);
  1635. return new ThalamusOffMainSignaler{node::OffMainSignaler(*ext_node, *io_context)};
  1636. }
  1637. static void node_offmain_signaler_destroy(struct ThalamusOffMainSignaler* signaler) {
  1638. delete signaler;
  1639. }
  1640. static void node_offmain_signaler_block(struct ThalamusOffMainSignaler* signaler) {
  1641. signaler->signaler.block();
  1642. }
  1643. static void node_offmain_signaler_unblock(struct ThalamusOffMainSignaler* signaler) {
  1644. signaler->signaler.unblock();
  1645. }
  1646. static uint8_t node_offmain_signaler_ready(struct ThalamusOffMainSignaler* signaler) {
  1647. return signaler->signaler.ready() ? 1 : 0;
  1648. }
  1649. static void dialog_show(struct ThalamusCharSpan* title, struct ThalamusCharSpan* message, ThalamusDialogType type) {
  1650. thalamus_grpc::Dialog dialog;
  1651. dialog.set_title(to_string(*title));
  1652. dialog.set_message(to_string(*message));
  1653. switch(type) {
  1654. case ThalamusDialogType_Info:
  1655. dialog.set_type(thalamus_grpc::Dialog::Type::Dialog_Type_INFO);
  1656. break;
  1657. case ThalamusDialogType_Warn:
  1658. dialog.set_type(thalamus_grpc::Dialog::Type::Dialog_Type_WARN);
  1659. break;
  1660. case ThalamusDialogType_Error:
  1661. dialog.set_type(thalamus_grpc::Dialog::Type::Dialog_Type_ERROR);
  1662. break;
  1663. case ThalamusDialogType_Fatal:
  1664. dialog.set_type(thalamus_grpc::Dialog::Type::Dialog_Type_FATAL);
  1665. break;
  1666. }
  1667. node_graph->dialog(dialog);
  1668. }
  1670. static void state_remove_at_name(struct ThalamusState* state, const struct ThalamusCharSpan* key, ThalamusPostCallback callback, void* data) {
  1671. auto closure = to_closure(callback, data);
  1672. erase_state(state, std::string(key->data, key->size), closure);
  1673. }
  1675. static void state_remove_at_index(struct ThalamusState* state, int64_t key, ThalamusPostCallback callback, void* data) {
  1676. auto closure = to_closure(callback, data);
  1677. erase_state(state, key, closure);
  1678. }
  1679. };
  1681. std::map<ObservableCollection::Value, ThalamusState*>* ThalamusAPIImpl::cpp_to_c = nullptr;
  1682. std::map<ThalamusState*, ObservableCollection::Value>* ThalamusAPIImpl::c_to_cpp = nullptr;
  1683. boost::asio::io_context* ThalamusAPIImpl::io_context = nullptr;
  1684. NodeGraphImpl* ThalamusAPIImpl::node_graph = nullptr;
  1687. std::mutex* ThalamusAPIImpl::mutex = nullptr;
  1688. std::map<Node*, ThalamusNode*>* ThalamusAPIImpl::node_cpp_to_c = nullptr;
  1689. std::map<ThalamusNode*, Node*>* ThalamusAPIImpl::node_c_to_cpp = nullptr;
  1691. struct ExtNodeFactory : public INodeFactory {
  1692. int version;
  1693. ThalamusNodeFactory* underlying;
  1694. ThalamusIoContext io_context;
  1695. ThalamusNodeGraph node_graph;
  1696. ThalamusAPI* api;
  1698. ExtNodeFactory(int _version, ThalamusNodeFactory* _underlying, boost::asio::io_context &_io_context, NodeGraph *graph, ThalamusAPI* _api)
  1699. : version(_version), underlying(_underlying), io_context(_io_context), node_graph(graph), api(_api) {}
  1701. Node *create(ObservableDictPtr state, boost::asio::io_context &,
  1702. NodeGraph *) override {
  1703. auto state_wrapper = ThalamusAPIImpl::get_state_ref(state);
  1705. auto result = new ExtNode(nullptr, underlying, api);
  1706. ThalamusNode* node;
  1707. if (version < 1) {
  1708. node = underlying->create(underlying, state_wrapper, &io_context, &node_graph);
  1709. } else {
  1710. node = underlying->create2(underlying, state_wrapper, &io_context, &node_graph, result);
  1711. }
  1712. result->node = node;
  1713. if(node->signals_offmain) {
  1714. result->ready_multithreaded.emplace();
  1715. }
  1717. ThalamusAPIImpl::state_dec_ref(state_wrapper);
  1719. return result;
  1720. }
  1722. bool prepare() override {
  1723. if(underlying->prepare != nullptr) {
  1724. return underlying->prepare(underlying);
  1725. } else {
  1726. return true;
  1727. }
  1728. }
  1729. void cleanup() override {
  1730. if(underlying->cleanup != nullptr) {
  1731. return underlying->cleanup(underlying);
  1732. }
  1733. }
  1734. std::string type_name() override;
  1735. };
  1737. std::string ExtNodeFactory::type_name() { return std::string("*EXT* ") + to_string(underlying->type); }
  1740. struct NodeGraphImpl::Impl {
  1741. ObservableListPtr nodes;
  1742. std::vector<std::string> node_next_type;
  1743. std::vector<std::shared_ptr<Node>> node_impls;
  1744. std::vector<std::string> node_types;
  1745. std::vector<ObservableDictPtr> node_configs;
  1746. size_t num_nodes;
  1747. boost::asio::io_context &io_context;
  1748. std::optional<Service *> service;
  1749. std::vector<std::pair<thalamus_grpc::NodeSelector,
  1750. std::function<void(std::weak_ptr<Node>)>>>
  1751. callbacks;
  1752. std::vector<std::pair<thalamus_grpc::NodeSelector,
  1753. boost::signals2::signal<void(std::weak_ptr<Node>)>>>
  1754. signals;
  1755. NodeGraphImpl *outer;
  1756. thalamus::map<std::string, std::weak_ptr<grpc::Channel>> channels;
  1757. thalamus::map<std::string, std::unique_ptr<thalamus_grpc::Thalamus::Stub>> stubs;
  1758. std::chrono::system_clock::time_point system_time;
  1759. std::chrono::steady_clock::time_point steady_time;
  1760. ThreadPool thread_pool;
  1761. thalamus_grpc::Thalamus::Stub* stub;
  1762. std::vector<SharedLibrary>& extension;
  1763. std::mutex vulkan_mutex;
  1764. Vulkan vulkan;
  1766. std::map<std::string, INodeFactory *> node_factories;
  1768. ThalamusAPIImpl thalamus_api_impl;
  1769. ThalamusAPI thalamus_api;
  1770. int creating_index = -1;
  1771. boost::signals2::scoped_connection nodes_connection;
  1772. std::vector<boost::signals2::scoped_connection> node_connections;
  1774. public:
  1775. Impl(ObservableListPtr _nodes, boost::asio::io_context &_io_context,
  1776. NodeGraphImpl *_outer,
  1777. std::chrono::system_clock::time_point _system_time,
  1778. std::chrono::steady_clock::time_point _steady_time,
  1779. thalamus_grpc::Thalamus::Stub* _stub,
  1780. std::vector<SharedLibrary>& _extension, Vulkan _vulkan)
  1781. : nodes(_nodes), num_nodes(nodes->size()), io_context(_io_context),
  1782. outer(_outer), system_time(_system_time), steady_time(_steady_time),
  1783. thread_pool("ThreadPool"), stub(_stub), extension(_extension), vulkan(_vulkan) {
  1785. ThalamusAPIImpl::cpp_to_c = new std::map<ObservableCollection::Value, ThalamusState*>();
  1786. ThalamusAPIImpl::c_to_cpp = new std::map<ThalamusState*, ObservableCollection::Value>();
  1787. ThalamusAPIImpl::mutex = new std::mutex();
  1788. ThalamusAPIImpl::node_cpp_to_c = new std::map<Node*, ThalamusNode*>();
  1789. ThalamusAPIImpl::node_c_to_cpp = new std::map<ThalamusNode*, Node*>();
  1790. ThalamusAPIImpl::io_context = &io_context;
  1791. ThalamusAPIImpl::node_graph = _outer;
  1793. thalamus_api.state_is_dict = ThalamusAPIImpl::state_is_dict;
  1794. thalamus_api.state_is_list = ThalamusAPIImpl::state_is_list;
  1795. thalamus_api.state_is_string = ThalamusAPIImpl::state_is_string;
  1796. thalamus_api.state_is_int = ThalamusAPIImpl::state_is_int;
  1797. thalamus_api.state_is_float = ThalamusAPIImpl::state_is_float;
  1798. thalamus_api.state_is_null = ThalamusAPIImpl::state_is_null;
  1799. thalamus_api.state_is_bool = ThalamusAPIImpl::state_is_bool;
  1801. thalamus_api.state_get_string = ThalamusAPIImpl::state_get_string;
  1802. thalamus_api.state_get_int = ThalamusAPIImpl::state_get_int;
  1803. thalamus_api.state_get_float = ThalamusAPIImpl::state_get_float;
  1804. thalamus_api.state_get_bool = ThalamusAPIImpl::state_get_bool;
  1806. thalamus_api.state_get_at_name = ThalamusAPIImpl::state_get_at_name;
  1807. thalamus_api.state_get_at_index = ThalamusAPIImpl::state_get_at_index;
  1809. thalamus_api.state_dec_ref = ThalamusAPIImpl::state_dec_ref;
  1810. thalamus_api.state_inc_ref = ThalamusAPIImpl::state_inc_ref;
  1812. thalamus_api.state_recursive_change_connect = ThalamusAPIImpl::state_recursive_change_connect;
  1814. thalamus_api.state_recursive_change_disconnect = ThalamusAPIImpl::state_recursive_change_disconnect;
  1815. thalamus_api.timer_create = ThalamusAPIImpl::timer_create;
  1816. thalamus_api.timer_destroy = ThalamusAPIImpl::timer_destroy;
  1817. thalamus_api.timer_expire_after_ns = ThalamusAPIImpl::timer_expire_after_ns;
  1818. thalamus_api.timer_async_wait = ThalamusAPIImpl::timer_async_wait;
  1819. thalamus_api.error_code_value = ThalamusAPIImpl::error_code_value;
  1820. thalamus_api.node_ready = ThalamusAPIImpl::node_ready;
  1821. thalamus_api.time_ns = ThalamusAPIImpl::time_ns;
  1822. thalamus_api.error_code_operation_aborted = ThalamusAPIImpl::error_code_operation_aborted;
  1823. thalamus_api.state_recap = ThalamusAPIImpl::state_recap;
  1825. thalamus_api.state_set_at_name_state = ThalamusAPIImpl::state_set_at_name_state;
  1826. thalamus_api.state_set_at_name_string = ThalamusAPIImpl::state_set_at_name_string;
  1827. thalamus_api.state_set_at_name_int = ThalamusAPIImpl::state_set_at_name_int;
  1828. thalamus_api.state_set_at_name_float = ThalamusAPIImpl::state_set_at_name_float;
  1829. thalamus_api.state_set_at_name_null = ThalamusAPIImpl::state_set_at_name_null;
  1830. thalamus_api.state_set_at_name_bool = ThalamusAPIImpl::state_set_at_name_bool;
  1832. thalamus_api.state_set_at_index_state = ThalamusAPIImpl::state_set_at_index_state;
  1833. thalamus_api.state_set_at_index_string = ThalamusAPIImpl::state_set_at_index_string;
  1834. thalamus_api.state_set_at_index_int = ThalamusAPIImpl::state_set_at_index_int;
  1835. thalamus_api.state_set_at_index_float = ThalamusAPIImpl::state_set_at_index_float;
  1836. thalamus_api.state_set_at_index_null = ThalamusAPIImpl::state_set_at_index_null;
  1837. thalamus_api.state_set_at_index_bool = ThalamusAPIImpl::state_set_at_index_bool;
  1839. thalamus_api.io_context_post = ThalamusAPIImpl::io_context_post;
  1840. thalamus_api.trace_event_begin = ThalamusAPIImpl::trace_event_begin;
  1841. thalamus_api.trace_event_end = ThalamusAPIImpl::trace_event_end;
  1842. thalamus_api.serial_port_create = ThalamusAPIImpl::serial_port_create;
  1843. thalamus_api.serial_port_destroy = ThalamusAPIImpl::serial_port_destroy;
  1844. thalamus_api.serial_set_baud_rate = ThalamusAPIImpl::serial_set_baud_rate;
  1845. thalamus_api.serial_port_open = ThalamusAPIImpl::serial_port_open;
  1846. thalamus_api.serial_port_error = ThalamusAPIImpl::serial_port_error;
  1848. thalamus_api.serial_port_read_until = ThalamusAPIImpl::serial_port_read_until;
  1849. thalamus_api.serial_port_read_some = ThalamusAPIImpl::serial_port_read_some;
  1850. thalamus_api.serial_port_read = ThalamusAPIImpl::serial_port_read;
  1851. thalamus_api.serial_port_write = ThalamusAPIImpl::serial_port_write;
  1853. thalamus_api.streambuf_create = ThalamusAPIImpl::streambuf_create;
  1855. thalamus_api.streambuf_destroy = ThalamusAPIImpl::streambuf_destroy;
  1857. thalamus_api.streambuf_to_span = ThalamusAPIImpl::streambuf_to_span;
  1859. thalamus_api.streambuf_consume = ThalamusAPIImpl::streambuf_consume;
  1861. thalamus_api.streambuf_size = ThalamusAPIImpl::streambuf_size;
  1863. thalamus_api.charspan_release = ThalamusAPIImpl::charspan_release;
  1864. thalamus_api.error_code_message = ThalamusAPIImpl::error_code_message;
  1865. thalamus_api.json_to_string = ThalamusAPIImpl::json_to_string;
  1866. thalamus_api.json_from_string = ThalamusAPIImpl::json_from_string;
  1867. thalamus_api.request_respond = ThalamusAPIImpl::request_respond;
  1868. thalamus_api.json_inc_ref = ThalamusAPIImpl::json_inc_ref;
  1869. thalamus_api.json_dec_ref = ThalamusAPIImpl::json_dec_ref;
  1871. thalamus_api.node_get_node = ThalamusAPIImpl::node_get_node;
  1872. thalamus_api.node_ready_connect = ThalamusAPIImpl::node_ready_connect;
  1874. thalamus_api.node_get_node_disconnect = ThalamusAPIImpl::node_get_node_disconnect;
  1875. thalamus_api.node_ready_disconnect = ThalamusAPIImpl::node_ready_disconnect;
  1876. thalamus_api.node_channels_changed = ThalamusAPIImpl::node_channels_changed;
  1878. thalamus_api.node_channels_changed_connect = ThalamusAPIImpl::node_channels_changed_connect;
  1879. thalamus_api.node_channels_changed_disconnect = ThalamusAPIImpl::node_channels_changed_disconnect;
  1881. thalamus_api.node_inc_ref = ThalamusAPIImpl::node_inc_ref;
  1882. thalamus_api.node_dec_ref = ThalamusAPIImpl::node_dec_ref;
  1883. thalamus_api.state_parent = ThalamusAPIImpl::state_parent;
  1885. thalamus_api.state_iter_create = ThalamusAPIImpl::state_iter_create;
  1886. thalamus_api.state_iter_next = ThalamusAPIImpl::state_iter_next;
  1887. thalamus_api.state_iter_key = ThalamusAPIImpl::state_iter_key;
  1888. thalamus_api.state_iter_value = ThalamusAPIImpl::state_iter_value;
  1889. thalamus_api.state_iter_destroy = ThalamusAPIImpl::state_iter_destroy;
  1891. thalamus_api.state_key_of = ThalamusAPIImpl::state_key_of;
  1892. thalamus_api.state_recap_with = ThalamusAPIImpl::state_recap_with;
  1893. thalamus_api.node_get_state = ThalamusAPIImpl::node_get_state;
  1895. thalamus_api.threadpool_post = ThalamusAPIImpl::threadpool_post;
  1896. thalamus_api.node_ready_multithreaded_connect = ThalamusAPIImpl::node_ready_multithreaded_connect;
  1897. thalamus_api.node_ready_offmain = ThalamusAPIImpl::node_ready_offmain;
  1899. thalamus_api.node_predrop_ready = ThalamusAPIImpl::node_predrop_ready;
  1901. thalamus_api.get_vulkan_instance = ThalamusAPIImpl::get_vulkan_instance;
  1902. thalamus_api.get_vulkan_device = ThalamusAPIImpl::get_vulkan_device;
  1903. thalamus_api.get_vulkan_physical_device = ThalamusAPIImpl::get_vulkan_physical_device;
  1904. thalamus_api.get_vulkan_queue = ThalamusAPIImpl::get_vulkan_queue;
  1905. thalamus_api.create_vulkan_command_pool = ThalamusAPIImpl::create_vulkan_command_pool;
  1906. thalamus_api.lock_vulkan_queue = ThalamusAPIImpl::lock_vulkan_queue;
  1907. thalamus_api.unlock_vulkan_queue = ThalamusAPIImpl::unlock_vulkan_queue;
  1909. thalamus_api.sdl_create_window = ThalamusAPIImpl::sdl_create_window;
  1910. thalamus_api.sdl_destroy_window = ThalamusAPIImpl::sdl_destroy_window;
  1911. thalamus_api.sdl_set_window_position = ThalamusAPIImpl::sdl_set_window_position;
  1912. thalamus_api.sdl_set_window_size = ThalamusAPIImpl::sdl_set_window_size;
  1913. thalamus_api.sdl_set_window_title = ThalamusAPIImpl::sdl_set_window_title;
  1914. thalamus_api.sdl_get_error = ThalamusAPIImpl::sdl_get_error;
  1915. thalamus_api.sdl_vulkan_create_surface = ThalamusAPIImpl::sdl_vulkan_create_surface;
  1916. thalamus_api.sdl_get_window_size_in_pixels = ThalamusAPIImpl::sdl_get_window_size_in_pixels;
  1917. thalamus_api.sdl_get_window_id = ThalamusAPIImpl::sdl_get_window_id;
  1918. thalamus_api.sdl_get_window_position = ThalamusAPIImpl::sdl_get_window_position;
  1919. thalamus_api.sdl_get_window_size = ThalamusAPIImpl::sdl_get_window_size;
  1920. thalamus_api.sdl_events_subscribe = ThalamusAPIImpl::sdl_events_subscribe;
  1921. thalamus_api.sdl_events_unsubscribe = ThalamusAPIImpl::sdl_events_unsubscribe;
  1923. thalamus_api.sdl_get_clipboard_text = ThalamusAPIImpl::sdl_get_clipboard_text;
  1924. thalamus_api.sdl_set_clipboard_text = ThalamusAPIImpl::sdl_set_clipboard_text;
  1925. thalamus_api.sdl_create_system_cursor = ThalamusAPIImpl::sdl_create_system_cursor;
  1926. thalamus_api.sdl_set_cursor = ThalamusAPIImpl::sdl_set_cursor;
  1927. thalamus_api.sdl_destroy_cursor = ThalamusAPIImpl::sdl_destroy_cursor;
  1928. thalamus_api.sdl_show_cursor = ThalamusAPIImpl::sdl_show_cursor;
  1929. thalamus_api.sdl_hide_cursor = ThalamusAPIImpl::sdl_hide_cursor;
  1931. thalamus_api.state_make_dict = ThalamusAPIImpl::state_make_dict;
  1932. thalamus_api.state_make_list = ThalamusAPIImpl::state_make_list;
  1934. thalamus_api.state_set_at_name_state_with_callback = ThalamusAPIImpl::state_set_at_name_state_with_callback;
  1935. thalamus_api.state_set_at_name_string_with_callback = ThalamusAPIImpl::state_set_at_name_string_with_callback;
  1936. thalamus_api.state_set_at_name_int_with_callback = ThalamusAPIImpl::state_set_at_name_int_with_callback;
  1937. thalamus_api.state_set_at_name_float_with_callback = ThalamusAPIImpl::state_set_at_name_float_with_callback;
  1938. thalamus_api.state_set_at_name_null_with_callback = ThalamusAPIImpl::state_set_at_name_null_with_callback;
  1939. thalamus_api.state_set_at_name_bool_with_callback = ThalamusAPIImpl::state_set_at_name_bool_with_callback;
  1941. thalamus_api.state_set_at_index_state_with_callback = ThalamusAPIImpl::state_set_at_index_state_with_callback;
  1942. thalamus_api.state_set_at_index_string_with_callback = ThalamusAPIImpl::state_set_at_index_string_with_callback;
  1943. thalamus_api.state_set_at_index_int_with_callback = ThalamusAPIImpl::state_set_at_index_int_with_callback;
  1944. thalamus_api.state_set_at_index_float_with_callback = ThalamusAPIImpl::state_set_at_index_float_with_callback;
  1945. thalamus_api.state_set_at_index_null_with_callback = ThalamusAPIImpl::state_set_at_index_null_with_callback;
  1946. thalamus_api.state_set_at_index_bool_with_callback = ThalamusAPIImpl::state_set_at_index_bool_with_callback;
  1948. thalamus_api.state_push_state_with_callback = ThalamusAPIImpl::state_push_state_with_callback;
  1949. thalamus_api.state_push_string_with_callback = ThalamusAPIImpl::state_push_string_with_callback;
  1950. thalamus_api.state_push_int_with_callback = ThalamusAPIImpl::state_push_int_with_callback;
  1951. thalamus_api.state_push_float_with_callback = ThalamusAPIImpl::state_push_float_with_callback;
  1952. thalamus_api.state_push_null_with_callback = ThalamusAPIImpl::state_push_null_with_callback;
  1953. thalamus_api.state_push_bool_with_callback = ThalamusAPIImpl::state_push_bool_with_callback;
  1955. thalamus_api.node_offmain_signaler_create = ThalamusAPIImpl::node_offmain_signaler_create;
  1956. thalamus_api.node_offmain_signaler_destroy = ThalamusAPIImpl::node_offmain_signaler_destroy;
  1957. thalamus_api.node_offmain_signaler_block = ThalamusAPIImpl::node_offmain_signaler_block;
  1958. thalamus_api.node_offmain_signaler_unblock = ThalamusAPIImpl::node_offmain_signaler_unblock;
  1959. thalamus_api.node_offmain_signaler_ready = ThalamusAPIImpl::node_offmain_signaler_ready;
  1961. thalamus_api.dialog_show = ThalamusAPIImpl::dialog_show;
  1962. thalamus_api.state_remove_at_name = ThalamusAPIImpl::state_remove_at_name;
  1963. thalamus_api.state_remove_at_index = ThalamusAPIImpl::state_remove_at_index;
  1964. thalamus_api.version = 139;
  1966. node_factories = {
  1967. {"NONE", new NodeFactory<NoneNode>()},
  1968. {"NIDAQ", new NodeFactory<NidaqNode>()},
  1969. {"NIDAQ_OUT", new NodeFactory<NidaqOutputNode>()},
  1970. {"ALPHA_OMEGA", new NodeFactory<AlphaOmegaNode>()},
  1971. {"TOGGLE", new NodeFactory<ToggleNode>()},
  1972. {"XSENS", new NodeFactory<XsensNode>()},
  1973. {"MOCAP", new NodeFactory<MotionCaptureNodeImpl>()},
  1974. {"HAND_ENGINE", new NodeFactory<HandEngineNode>()},
  1975. {"WAVE", new NodeFactory<WaveGeneratorNode>()},
  1976. {"STORAGE", new NodeFactory<StorageNode>()},
  1977. {"STORAGE2", new NodeFactory<Storage2Node>()},
  1978. {"RUNNER", new NodeFactory<RunNode>()},
  1979. {"RUNNER2", new NodeFactory<Run2Node>()},
  1980. {"OPHANIM", new NodeFactory<OphanimNode>()},
  1981. {"TASK_CONTROLLER", new NodeFactory<TaskControllerNode>()},
  1982. {"ANALOG", new NodeFactory<AnalogNodeImpl>()},
  1983. {"FFMPEG", new NodeFactory<FfmpegNode>()},
  1984. {"VIDEO", new NodeFactory<VideoNode>()},
  1985. {"OCULOMATIC", new NodeFactory<OculomaticNode>()},
  1986. {"DISTORTION", new NodeFactory<DistortionNode>()},
  1987. {"GENICAM", new NodeFactory<GenicamNode>()},
  1988. {"THREAD_POOL", new NodeFactory<ThreadPoolNode>()},
  1989. {"CHANNEL_PICKER", new NodeFactory<ChannelPickerNode>()},
  1990. {"NORMALIZE", new NodeFactory<NormalizeNode>()},
  1991. {"ALGEBRA", new NodeFactory<AlgebraNode>()},
  1992. {"LUA", new NodeFactory<LuaNode>()},
  1993. #if !defined(_WIN32) && !defined(__APPLE__)
  1994. {"ROS2", new NodeFactory<Ros2Node>()},
  1995. #endif
  1996. #ifdef _WIN32
  1997. {"BRAINPRODUCTS", new NodeFactory<BrainProductsNode>()},
  1998. #endif
  1999. {"REMOTE", new NodeFactory<RemoteNode>()},
  2000. {"REMOTE_LOG", new NodeFactory<RemoteLogNode>()},
  2001. {"CHESSBOARD", new NodeFactory<ChessBoardNode>()},
  2002. {"PUPIL", new NodeFactory<PupilNode>()},
  2003. {"LOG", new NodeFactory<LogNode>()},
  2004. {"INTAN", new NodeFactory<IntanNode>()},
  2005. {"SPIKEGLX", new NodeFactory<SpikeGlxNode>()},
  2006. {"SYNC", new NodeFactory<SyncNode>()},
  2007. {"TOUCH_SCREEN", new NodeFactory<TouchScreenNode>()},
  2008. {"STIM_PRINTER", new NodeFactory<StimPrinterNode>()},
  2009. {"TEST_PULSE_NODE", new NodeFactory<TestPulseNode>()},
  2010. {"WALLCLOCK", new NodeFactory<WallClockNode>()},
  2011. {"CECI", new NodeFactory<CeciNode>()},
  2012. //{"HEXASCOPE", new NodeFactory<HexascopeNode>()},
  2013. {"DELSYS", new NodeFactory<DelsysNode>()},
  2014. {"FREQUENCY", new NodeFactory<FrequencyNode>()},
  2015. {"SAMPLE_MONITOR", new NodeFactory<SampleMonitorNode>()},
  2016. {"JOYSTICK", new NodeFactory<JoystickNode>()},
  2017. {"SERIAL_TOUCH_SCREEN", new NodeFactory<SerialTouchScreenNode>()},
  2018. {"ARUCO", new NodeFactory<ArucoNode>()}};
  2020. for(auto& ext : extension) {
  2021. THALAMUS_LOG(info) << "Loading " << ext.name();
  2022. //auto library_handle = LoadLibrary("C:\\Thalamus\\ext.dll");
  2024. //auto get_node_factories = reinterpret_cast<get_node_factories_fun>(
  2025. // ::GetProcAddress(library_handle, "get_node_factories"));
  2027. auto get_node_factory_version = ext.load<thalamus_get_node_factory_version_t>("thalamus_get_node_factory_version");
  2028. int32_t version;
  2029. if(get_node_factory_version != nullptr) {
  2030. version = get_node_factory_version();
  2031. } else {
  2032. version = 0;
  2033. }
  2035. auto get_node_factories = ext.load<thalamus_get_node_factories_t>("thalamus_get_node_factories");
  2036. THALAMUS_ASSERT(get_node_factories, "thalamus_get_node_factories not found in extension");
  2038. auto factory = get_node_factories(&thalamus_api);
  2039. while(*factory != nullptr) {
  2040. THALAMUS_LOG(info) << "Found " << (*factory)->type;
  2041. auto type_name = to_string((*factory)->type);
  2042. node_factories[type_name] = new ExtNodeFactory(version, *factory, io_context, outer, &thalamus_api);
  2043. ++factory;
  2044. }
  2045. }
  2047. using namespace std::placeholders;
  2048. auto i = node_factories.begin();
  2049. while (i != node_factories.end()) {
  2050. if (!i->second->prepare()) {
  2051. i = node_factories.erase(i);
  2052. } else {
  2053. ++i;
  2054. }
  2055. }
  2057. nodes_connection = nodes->changed.connect(std::bind(&Impl::on_nodes, this, _1, _2, _3));
  2058. }
  2060. ~Impl() {
  2061. nodes_connection.disconnect();
  2062. node_connections.clear();
  2063. node_impls.clear();
  2064. auto i = node_factories.begin();
  2065. while (i != node_factories.end()) {
  2066. i->second->cleanup();
  2067. delete i->second;
  2068. ++i;
  2069. }
  2071. for(auto& ext : extension) {
  2072. auto thalamus_teardown = ext.load<thalamus_teardown_t>("thalamus_teardown");
  2073. if(thalamus_teardown) {
  2074. thalamus_teardown();
  2075. }
  2076. }
  2078. delete ThalamusAPIImpl::cpp_to_c;
  2079. delete ThalamusAPIImpl::c_to_cpp;
  2080. }
  2082. void clean_signals() {
  2083. for (auto i = signals.begin(); i != signals.end();) {
  2084. if (i->second.empty()) {
  2085. i = signals.erase(i);
  2086. } else {
  2087. ++i;
  2088. }
  2089. }
  2090. }
  2092. void on_nodes(ObservableCollection::Action a,
  2093. const ObservableCollection::Key &k,
  2094. const ObservableCollection::Value &v) {
  2095. using namespace std::placeholders;
  2096. if (a == ObservableCollection::Action::Set) {
  2097. auto index = std::get<int64_t>(k);
  2098. ObservableDictPtr node = std::get<ObservableDictPtr>(v);
  2099. boost::signals2::scoped_connection conn = node->changed.connect(
  2100. std::bind(&Impl::on_node, this, node.get(), _1, _2, _3));
  2102. std::string type_str = node->at("type");
  2103. auto factory = node_factories.at(type_str);
  2105. creating_index = int32_t(index);
  2106. auto node_impl =
  2107. std::shared_ptr<Node>(factory->create(node, io_context, outer));
  2108. creating_index = -1;
  2110. node_connections.insert(node_connections.begin() + index, std::move(conn));
  2111. node_next_type.insert(node_next_type.begin() + index, "");
  2112. node_impls.insert(node_impls.begin() + index, node_impl);
  2113. node_types.insert(node_types.begin() + index, type_str);
  2114. node_configs.insert(node_configs.begin() + index, node);
  2115. node->recap(std::bind(&Impl::on_node, this, node.get(), _1, _2, _3));
  2116. } else {
  2117. auto index = std::get<int64_t>(k);
  2118. node_connections.erase(node_connections.begin() + index);
  2119. node_next_type.erase(node_next_type.begin() + index);
  2120. node_impls.erase(node_impls.begin() + index);
  2121. node_types.erase(node_types.begin() + index);
  2122. node_configs.erase(node_configs.begin() + index);
  2123. }
  2124. }
  2126. void notify(std::function<bool(const thalamus_grpc::NodeSelector &)> selector,
  2127. std::weak_ptr<Node> node_impl) {
  2128. for (auto i = callbacks.begin(); i != callbacks.end();) {
  2129. if (selector(i->first)) {
  2130. i->second(std::weak_ptr<Node>(node_impl));
  2131. i = callbacks.erase(i);
  2132. } else {
  2133. ++i;
  2134. }
  2135. }
  2136. for (auto i = signals.begin(); i != signals.end();) {
  2137. if (selector(i->first)) {
  2138. i->second(std::weak_ptr<Node>(node_impl));
  2139. i = signals.erase(i);
  2140. } else if (i->second.empty()) {
  2141. i = signals.erase(i);
  2142. } else {
  2143. ++i;
  2144. }
  2145. }
  2146. }
  2148. void on_node(ObservableDict *node, ObservableCollection::Action a,
  2149. const ObservableCollection::Key &k,
  2150. const ObservableCollection::Value &v) {
  2151. if (a == ObservableCollection::Action::Set) {
  2152. auto node_index = 0;
  2153. ObservableDictPtr shared_node;
  2154. for (auto i = 0u; i < nodes->size(); ++i) {
  2155. shared_node = nodes->at(i);
  2156. if (node == shared_node.get()) {
  2157. node_index = int(i);
  2158. break;
  2159. }
  2160. }
  2161. if(creating_index == node_index) {
  2162. return;
  2163. }
  2165. auto key_str = std::get<std::string>(k);
  2166. if (key_str == "type") {
  2167. auto value_str = std::get<std::string>(v);
  2168. if (value_str != node_types.at(size_t(node_index))) {
  2169. auto current_node = node_impls.at(size_t(node_index));
  2170. auto current_next_type = node_next_type[size_t(node_index)];
  2172. if(!current_next_type.empty()) {
  2173. node_next_type[size_t(node_index)] = value_str;
  2174. } else {
  2175. node_next_type[size_t(node_index)] = value_str;
  2176. current_node->predrop([this,current_node] {
  2177. boost::asio::post(io_context, [this, current_node] {
  2178. size_t new_node_index = std::numeric_limits<size_t>::max();
  2179. for(size_t i = 0;i < node_impls.size();++i) {
  2180. if(node_impls[i] == current_node) {
  2181. new_node_index = i;
  2182. break;
  2183. }
  2184. }
  2185. THALAMUS_ASSERT(new_node_index != std::numeric_limits<size_t>::max(), "Node is missing");
  2186. auto node_config = node_configs[new_node_index];
  2188. auto type_str = node_next_type[new_node_index];
  2189. auto factory = node_factories.at(type_str);
  2191. node_types.at(new_node_index) = type_str;
  2192. creating_index = int(new_node_index);
  2193. node_impls.at(new_node_index)
  2194. .reset(factory->create(node_config, io_context, outer));
  2196. creating_index = -1;
  2197. node_next_type[new_node_index] = "";
  2199. auto node_impl = node_impls.at(new_node_index);
  2200. notify([&type_str](
  2201. auto &selector) { return selector.type() == type_str; },
  2202. node_impl);
  2203. });
  2204. });
  2205. }
  2206. } else {
  2207. auto node_impl = node_impls.at(size_t(node_index));
  2208. notify([&value_str](
  2209. auto &selector) { return selector.type() == value_str; },
  2210. node_impl);
  2211. }
  2212. } else if (key_str == "name") {
  2213. auto node_impl = node_impls.at(size_t(node_index));
  2214. auto value_str = std::get<std::string>(v);
  2215. notify([&value_str](
  2216. auto &selector) { return selector.name() == value_str; },
  2217. node_impl);
  2218. }
  2219. }
  2220. }
  2221. };
  2223. NodeGraphImpl::NodeGraphImpl(ObservableListPtr nodes,
  2224. boost::asio::io_context &io_context,
  2225. std::chrono::system_clock::time_point system_time,
  2226. std::chrono::steady_clock::time_point steady_time,
  2227. thalamus_grpc::Thalamus::Stub* stub,
  2228. std::vector<SharedLibrary>& extension,
  2229. Vulkan vulkan,
  2230. std::optional<int> thread_policy,
  2231. std::optional<int> thread_priority)
  2232. : impl(new Impl(nodes, io_context, this, system_time, steady_time, stub, extension, vulkan)) {
  2233. impl->nodes->recap();
  2234. impl->thread_pool.start(thread_policy, thread_priority);
  2235. }
  2237. NodeGraphImpl::~NodeGraphImpl() {}
  2239. std::optional<std::string>
  2240. NodeGraphImpl::get_type_name(const std::string &type) {
  2241. auto i = impl->node_factories.find(type);
  2242. if (i != impl->node_factories.end()) {
  2243. return i->second->type_name();
  2244. } else {
  2245. return std::nullopt;
  2246. }
  2247. }
  2249. void NodeGraphImpl::set_service(Service *service) { impl->service = service; }
  2251. Service &NodeGraphImpl::get_service() { return **impl->service; }
  2253. std::weak_ptr<Node> NodeGraphImpl::get_node(const std::string &query_name) {
  2254. thalamus_grpc::NodeSelector selector;
  2255. selector.set_name(query_name);
  2256. return get_node(selector);
  2257. }
  2259. std::weak_ptr<Node>
  2260. NodeGraphImpl::get_node(const thalamus_grpc::NodeSelector &query_name) {
  2261. std::string key;
  2262. std::string query;
  2263. if (!query_name.name().empty()) {
  2264. key = "name";
  2265. query = query_name.name();
  2266. } else {
  2267. key = "type";
  2268. query = query_name.type();
  2269. }
  2270. for (auto i = 0u; i < impl->nodes->size(); ++i) {
  2271. ObservableDictPtr node = impl->nodes->at(i);
  2272. std::string value = node->at(key);
  2273. if (query == value) {
  2274. return std::weak_ptr<Node>(impl->node_impls.at(i));
  2275. }
  2276. }
  2277. return std::weak_ptr<Node>();
  2278. }
  2280. void NodeGraphImpl::get_node(
  2281. const std::string &query_name,
  2282. std::function<void(std::weak_ptr<Node>)> callback) {
  2283. thalamus_grpc::NodeSelector selector;
  2284. selector.set_name(query_name);
  2285. return get_node(selector, callback);
  2286. }
  2288. void NodeGraphImpl::get_node(
  2289. const thalamus_grpc::NodeSelector &query_name,
  2290. std::function<void(std::weak_ptr<Node>)> callback) {
  2291. auto value = get_node(query_name);
  2292. if (!value.lock()) {
  2293. impl->callbacks.emplace_back(query_name, callback);
  2294. } else {
  2295. impl->io_context.post([callback,value] {
  2296. callback(value);
  2297. });
  2298. }
  2299. }
  2301. NodeGraph::NodeConnection NodeGraphImpl::get_node_scoped(
  2302. const std::string &name,
  2303. std::function<void(std::weak_ptr<Node>)> callback) {
  2304. thalamus_grpc::NodeSelector selector;
  2305. selector.set_name(name);
  2306. return get_node_scoped(selector, callback);
  2307. }
  2309. NodeGraph::NodeConnection NodeGraphImpl::get_node_scoped(
  2310. const thalamus_grpc::NodeSelector &selector,
  2311. std::function<void(std::weak_ptr<Node>)> callback) {
  2312. auto value = get_node(selector);
  2313. if (!value.lock()) {
  2314. impl->signals.emplace_back(
  2315. selector, boost::signals2::signal<void(std::weak_ptr<Node>)>());
  2316. boost::signals2::scoped_connection connection(
  2317. impl->signals.back().second.connect(callback));
  2318. return connection;
  2319. } else {
  2320. impl->io_context.post([callback,value] {
  2321. callback(value);
  2322. });
  2323. return NodeConnection();
  2324. }
  2325. }
  2327. std::shared_ptr<grpc::Channel>
  2328. NodeGraphImpl::get_channel(const std::string &url) {
  2329. std::vector<std::string> tokens = absl::StrSplit(url, ':');
  2330. int port;
  2331. bool parsed = absl::SimpleAtoi(tokens.back(), &port);
  2332. if(!parsed) {
  2333. return get_channel(url + ":50050");
  2334. }
  2336. if (!impl->channels.contains(url) || !impl->channels[url].lock()) {
  2337. auto channel = create_grpc_channel(url);
  2338. impl->channels[url] = channel;
  2339. return channel;
  2340. }
  2341. return impl->channels[url].lock();
  2342. }
  2344. thalamus_grpc::Thalamus::Stub*
  2345. NodeGraphImpl::get_thalamus_stub(const std::string &url) {
  2346. if (!impl->stubs.contains(url)) {
  2347. auto channel = get_channel(url);
  2348. auto stub = thalamus_grpc::Thalamus::NewStub(channel);
  2349. impl->stubs[url] = std::move(stub);
  2350. }
  2351. return impl->stubs[url].get();
  2352. }
  2354. std::chrono::system_clock::time_point
  2355. NodeGraphImpl::get_system_clock_at_start() {
  2356. return impl->system_time;
  2357. }
  2359. std::chrono::steady_clock::time_point
  2360. NodeGraphImpl::get_steady_clock_at_start() {
  2361. return impl->steady_time;
  2362. }
  2364. ThreadPool &NodeGraphImpl::get_thread_pool() { return impl->thread_pool; }
  2366. void NodeGraphImpl::dialog(const thalamus_grpc::Dialog &dialog) {
  2367. auto context = std::make_shared<grpc::ClientContext>();
  2368. auto request = std::make_shared<thalamus_grpc::Dialog>(dialog);
  2369. auto response = std::make_shared<thalamus_grpc::Empty>();
  2371. impl->stub->async()->dialog(context.get(), request.get(), response.get(),
  2372. [moved_context=context,moved_request=request,moved_response=response](grpc::Status s) {
  2373. THALAMUS_LOG(info) << "Dialog complete " << s.error_message();
  2374. });
  2375. }
  2377. void NodeGraphImpl::log(const thalamus_grpc::Text & text) {
  2378. (*impl->service)->log_signal(text);
  2379. }
  2381. ObservableDictPtr NodeGraphImpl::get_node_state(Node* node) {
  2382. for(size_t i = 0;i < impl->node_impls.size();++i) {
  2383. if(impl->node_impls[i].get() == node) {
  2384. return impl->node_configs[i];
  2385. }
  2386. }
  2387. THALAMUS_ABORT("Failed to find node.");
  2388. }
  2390. VkDevice NodeGraphImpl::get_vulkan_device() {
  2391. return impl->vulkan.device;
  2392. }
  2394. VkInstance NodeGraphImpl::get_vulkan_instance() {
  2395. return impl->vulkan.instance;
  2396. }
  2398. VkPhysicalDevice NodeGraphImpl::get_vulkan_physical_device() {
  2399. return impl->vulkan.physical_device;
  2400. }
  2402. VkQueue NodeGraphImpl::get_vulkan_queue() {
  2403. return impl->vulkan.queue;
  2404. }
  2406. std::unique_lock<std::mutex> NodeGraphImpl::lock_vulkan_queue() {
  2407. return std::unique_lock<std::mutex>(impl->vulkan_mutex);
  2408. }
  2410. VkCommandPool NodeGraphImpl::create_vulkan_command_pool() {
  2411. VkCommandPoolCreateInfo cp_ci{};
  2412. cp_ci.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
  2413. cp_ci.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
  2414. cp_ci.queueFamilyIndex = impl->vulkan.queue_family_index;
  2415. VkCommandPool result;
  2416. auto success = vkCreateCommandPool(impl->vulkan.device, &cp_ci, nullptr, &result);
  2417. THALAMUS_ASSERT(success == VK_SUCCESS, "vkCreateCommandPool failed");
  2418. return result;
  2419. }
  2421. void NodeGraphImpl::predrop(std::function<void()> ready) {
  2422. auto drop_count = std::make_shared<size_t>(impl->node_impls.size());
  2423. if (*drop_count == 0) {
  2424. ready();
  2425. return;
  2426. }
  2427. for(auto& node : impl->node_impls) {
  2428. node->predrop([ready,drop_count,this] {
  2429. boost::asio::post(impl->io_context, [ready,drop_count] {
  2430. --*drop_count;
  2431. if(*drop_count == 0) {
  2432. ready();
  2433. }
  2434. });
  2435. });
  2436. }
  2437. }
  2439. } // namespace thalamus

node_graph_impl.cpp at commit 4c0bcd7, under GPL-3.0 · at the source

Overview

Authors: Jarl Haggerty1, Qasim Qureshi1, Ellie D Gabriel1, Pedro GLB Borges1, Pierce Davis1, Katie Wingel1, Jerry Cai1, Krishna Sargur2, Min Jae Kim1, Agrita Dubey1, Indie Garwood1, Alex Vaz1, Andrew G Richardson1, Han-Chiao Isaac Chen1,3, Lauren H Hammer2,4, Joshua Gold5, Brian Litt1,2,4, Daniel Yoshor1, Michael Beauchamp1, Casey Halpern1,3, Bijan Pesaran1,2,5, Iahn Cajigas1,2
ORCID iDs: Qasim Qureshi, Ellie D Gabriel, Pedro GLB Borges, Pierce Davis, Andrew G Richardson, Lauren H Hammer, Joshua Gold, Daniel Yoshor, Michael Beauchamp, Iahn Cajigas
  1. Department of Neurosurgery, Perelman School of Medicine, University of Pennsylvania, Philadelphia, PA USA
  2. Department of Bioengineering, University of Pennsylvania, Philadelphia, PA USA
  3. Department of Surgery, Corporal Michael J. Crescenz Veterans Affairs Medical Center, Philadelphia, PA USA
  4. Department of Neurology, University of Pennsylvania, Philadelphia, PA USA
  5. Department of Neuroscience, University of Pennsylvania, Philadelphia, PA USA
Institutions: University of Pennsylvania (United States); Philadelphia VA Medical Center (United States)
Journal: Communications engineering, volume 5, issue 1, article 93
Dates: received 1 October 2024; accepted 11 March 2026; published online 26 March 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s44172-026-00646-z · PMID 41882345 · PMCID PMC13184004 · OpenAlex W7140605488
Open access: gold, a free copy (OpenAlex)
Status: code verified (how the code is found and verified)
Methods: Spectral & time-frequency, Connectivity, Preprocessing, Statistics, Machine learning
Keywords: Biomedical engineering, Physiology, Neuronal physiology
Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: U.S. Department of Health &amp; Human Services | National Institutes of Health (5K12NS129164-02); U.S. Department of Health & Human Services | National Institutes of Health (NIH) (5K12NS129164-02); NINDS NIH HHS (K23 NS138692)
Citations: not cited yet (Europe PMC); 56 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repositories

Its files are read in the Code ↔ Paper reader above, with 7 matches between paragraphs and lines of code.

cajigaslab/Thalamus

License: GPL-3.0
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 4c0bcd7e6b9a9a5b209e97973960d8909a75bc79, 29 September 2026
Languages: Python (128), C++ (77), C/C++ (15), MATLAB (10), Shell (6), Java (2), JavaScript (2), NEURON (1), Go (1)
Size: 568 files, 242 scripts
Software Heritage: not archived
Found in: the text, “Dependency management”
Holds: README, license file, environment (pyproject.toml, requirements-ci.txt, requirements-no-native.txt, requirements-ubuntu-18.04.txt, requirements.txt, docker/ubuntu-18.04.dockerfile, docker/uploader.dockerfile, docker/windows.dockerfile), tests, continuous integration, documentation, 2 notebooks
Not found: CITATION.cff
Tools: NumPy (37 files), Matplotlib (6 files), SciPy (6 files), OpenCV (2 files), pandas (2 files), h5py (1 file), Signal Processing Toolbox (1 file), Pillow (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
244 files
At the source: github.com/cajigaslab/Thalamus

cajigaslab

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: the link answers
Software Heritage: not checked
Found in: “Code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 30 September 2026: the link answers (HTTP 200)
  • 30 September 2026: the link answers (HTTP 200)
At the source: github.com/cajigaslab

Code availability statement

The paper has a code availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s44172-026-00646-z.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 242 scripts, each with its path and the digest of its content;
  • 7 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data availability statement

The paper has a data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

  • no repository, dataset or request procedure was recognized in it

Read it in the paper: doi.org/10.1038/s44172-026-00646-z.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 30 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 22 authors, 3 keywords, 3 funders, 23 references.

Cite

This paper

Haggerty, J., Qureshi, Q., Gabriel, E. D., Borges, P. G., Davis, P., Wingel, K., Cai, J., Sargur, K., Kim, M. J., Dubey, A., Garwood, I., Vaz, A., Richardson, A. G., Chen, H.-C. I., Hammer, L. H., Gold, J., Litt, B., Yoshor, D., Beauchamp, M., . . . Cajigas, I. (2026). Thalamus: a real-time system for synchronized, closed-loop multimodal behavioral and electrophysiological data capture. Communications engineering, 5(1), 93. https://doi.org/10.1038/s44172-026-00646-z

BibTeX

@article{haggerty2026thalamus,
author = {Haggerty, Jarl and Qureshi, Qasim and Gabriel, Ellie D and Borges, Pedro GLB and Davis, Pierce and Wingel, Katie and Cai, Jerry and Sargur, Krishna and Kim, Min Jae and Dubey, Agrita and Garwood, Indie and Vaz, Alex and Richardson, Andrew G and Chen, Han-Chiao Isaac and Hammer, Lauren H and Gold, Joshua and Litt, Brian and Yoshor, Daniel and Beauchamp, Michael and Halpern, Casey and Pesaran, Bijan and Cajigas, Iahn},
title = {{Thalamus: a real-time system for synchronized, closed-loop multimodal behavioral and electrophysiological data capture}},
journal = {Communications engineering},
year = {2026},
month = mar,
volume = {5},
number = {1},
pages = {93},
publisher = {Springer Science+Business Media},
issn = {2731-3395},
doi = {10.1038/s44172-026-00646-z},
url = {https://doi.org/10.1038/s44172-026-00646-z},
pmid = {41882345},
pmcid = {PMC13184004}
}

RIS

TY - JOUR
AU - Haggerty, Jarl
AU - Qureshi, Qasim
AU - Gabriel, Ellie D
AU - Borges, Pedro GLB
AU - Davis, Pierce
AU - Wingel, Katie
AU - Cai, Jerry
AU - Sargur, Krishna
AU - Kim, Min Jae
AU - Dubey, Agrita
AU - Garwood, Indie
AU - Vaz, Alex
AU - Richardson, Andrew G
AU - Chen, Han-Chiao Isaac
AU - Hammer, Lauren H
AU - Gold, Joshua
AU - Litt, Brian
AU - Yoshor, Daniel
AU - Beauchamp, Michael
AU - Halpern, Casey
AU - Pesaran, Bijan
AU - Cajigas, Iahn
TI - Thalamus: a real-time system for synchronized, closed-loop multimodal behavioral and electrophysiological data capture
T2 - Communications engineering
J2 - Commun Eng
PY - 2026
DA - 2026/03/26
VL - 5
IS - 1
SP - 93
SN - 2731-3395
PB - Springer Science+Business Media
DO - 10.1038/s44172-026-00646-z
UR - https://doi.org/10.1038/s44172-026-00646-z
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s44172-026-00646-z",
"type": "article-journal",
"title": "Thalamus: a real-time system for synchronized, closed-loop multimodal behavioral and electrophysiological data capture",
"container-title": "Communications engineering",
"author": [
{
"family": "Haggerty",
"given": "Jarl"
},
{
"family": "Qureshi",
"given": "Qasim"
},
{
"family": "Gabriel",
"given": "Ellie D"
},
{
"family": "Borges",
"given": "Pedro GLB"
},
{
"family": "Davis",
"given": "Pierce"
},
{
"family": "Wingel",
"given": "Katie"
},
{
"family": "Cai",
"given": "Jerry"
},
{
"family": "Sargur",
"given": "Krishna"
},
{
"family": "Kim",
"given": "Min Jae"
},
{
"family": "Dubey",
"given": "Agrita"
},
{
"family": "Garwood",
"given": "Indie"
},
{
"family": "Vaz",
"given": "Alex"
},
{
"family": "Richardson",
"given": "Andrew G"
},
{
"family": "Chen",
"given": "Han-Chiao Isaac"
},
{
"family": "Hammer",
"given": "Lauren H"
},
{
"family": "Gold",
"given": "Joshua"
},
{
"family": "Litt",
"given": "Brian"
},
{
"family": "Yoshor",
"given": "Daniel"
},
{
"family": "Beauchamp",
"given": "Michael"
},
{
"family": "Halpern",
"given": "Casey"
},
{
"family": "Pesaran",
"given": "Bijan"
},
{
"family": "Cajigas",
"given": "Iahn"
}
],
"container-title-short": "Commun Eng",
"volume": "5",
"issue": "1",
"page": "93",
"DOI": "10.1038/s44172-026-00646-z",
"PMID": "41882345",
"PMCID": "PMC13184004",
"ISSN": "2731-3395",
"publisher": "Springer Science+Business Media",
"URL": "https://doi.org/10.1038/s44172-026-00646-z",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
26
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s42003-025-07516-y [code]
Human response times are governed by dual anticipatory processes with distinct neural signatures.
Journal: Communications biology
In common: pandas, SciPy, Matplotlib, 1 other tool, 2 authors
[2] doi:10.1038/s41591-025-04035-5 [code]
Brain activity associated with breakthrough food preoccupation in an individual on tirzepatide.
Journal: Nature medicine
In common: Signal Processing Toolbox, 2 authors
[3] doi:10.1093/braincomms/fcae320 [code]
The sixth sense: how much does interictal intracranial EEG add to determining the focality of epileptic networks?
Journal: Brain communications
In common: pandas, SciPy, Matplotlib, 1 other tool, author Iahn Cajigas
[4] doi:10.1371/journal.pone.0344600 [code]
Robust disease prognosis via diagnostic knowledge preservation: A sequential learning approach.
Journal: PloS one
In common: OpenCV, h5py, Pillow, 4 other tools, 1 reference
[5] doi: [code]
Real-time closed-loop feedback system for mouse mesoscale cortical signal and movement control
Journal: eLife
In common: OpenCV, h5py, Pillow, 4 other tools, 1 reference
[6] doi:10.7554/elife.108663 [code]
The Crunchometer, a low-cost, open-source acoustic analysis of feeding microstructure.
Journal: eLife
In common: OpenCV, h5py, Signal Processing Toolbox, 4 other tools, 1 reference
[7] doi:10.7554/elife.100258 [code]
Normative evidence weighing and accumulation in correlated environments.
Journal: eLife
In common: pandas, SciPy, Matplotlib, 1 other tool, author Joshua I Gold
[8] doi:10.1038/s41598-025-14693-7 [code]
RpiBeh offers a versatile open source solution for rodent behavior tracking and closed loop interventions.
Journal: Scientific reports
In common: OpenCV, h5py, Pillow, 3 other tools, 1 reference
[9] doi:10.1016/j.ynirp.2023.100164 [code]
Neural processing of goal and non-goal-directed movements on the smartphone.
Journal: Neuroimage. Reports
In common: h5py, Signal Processing Toolbox, pandas, 2 other tools, 2 references
[10] doi:10.1038/s41597-023-02614-0 [code]
A comparison of neuroelectrophysiology databases.
Journal: Scientific data
In common: SciPy, NumPy, author Michael Beauchamp

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Add the badge to the code's README

OSCR: the badge of this paper

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown
<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.1038/s44172-026-00646-z.svg)](https://openscicode.org/badge/doi/10.1038/s44172-026-00646-z)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1038/s44172-026-00646-z.svg
   :target: https://openscicode.org/badge/doi/10.1038/s44172-026-00646-z
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1038/s44172-026-00646-z"><img src="https://openscicode.org/badge/doi/10.1038/s44172-026-00646-z.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.