close #12 Add support for NDI SDK 5.1.1

src/main.cpp

@@ -7,7 +7,7 @@ namespace py = pybind11;
 
 PYBIND11_MODULE(NDIlib, m) {
 
-  m.doc() = "NDI Plugin";
+  m.doc() = "NDI SDK for Python";
 
   // Processing.NDI.structs
   py::enum_<NDIlib_frame_type_e>(m, "FrameType", py::arithmetic())
@@ -275,16 +275,30 @@ PYBIND11_MODULE(NDIlib, m) {
             self.p_extra_ips = strs[&self].c_str();
           });
 
-  m.def("find_create_v2", &NDIlib_find_create_v2,
+  m.def(
+      "find_create_v2",
+      [](const NDIlib_find_create_t *p_create_settings) {
+        auto instance = NDIlib_find_create_v2(p_create_settings);
+        return py::capsule(instance);
+      },
       py::arg("create_settings") = nullptr);
 
-  m.def("find_destroy", &NDIlib_find_destroy, py::arg("instance"));
+  m.def(
+      "find_destroy",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_find_instance_type *>(p_instance.get_pointer());
+        NDIlib_find_destroy(instance);
+      },
+      py::arg("instance"));
 
   m.def(
       "find_get_current_sources",
-      [](NDIlib_find_instance_t p_instance) {
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_find_instance_type *>(p_instance.get_pointer());
         uint32_t count = 0;
-        auto sources = NDIlib_find_get_current_sources(p_instance, &count);
+        auto sources = NDIlib_find_get_current_sources(instance, &count);
         py::list out;
         for (uint32_t i = 0; i < count; ++i)
           out.append(sources + i);
@@ -292,7 +306,13 @@ PYBIND11_MODULE(NDIlib, m) {
       },
       py::arg("instance"));
 
-  m.def("find_wait_for_sources", &NDIlib_find_wait_for_sources,
+  m.def(
+      "find_wait_for_sources",
+      [](py::capsule p_instance, uint32_t timeout_in_ms) {
+        auto instance =
+            static_cast<NDIlib_find_instance_type *>(p_instance.get_pointer());
+        return NDIlib_find_wait_for_sources(instance, timeout_in_ms);
+      },
       py::arg("instance"), py::arg("timeout_in_ms"));
 
   // Processing.NDI.Recv
@@ -367,22 +387,41 @@ PYBIND11_MODULE(NDIlib, m) {
       .def_readwrite("audio_frames", &NDIlib_recv_queue_t::audio_frames)
       .def_readwrite("metadata_frames", &NDIlib_recv_queue_t::metadata_frames);
 
-  m.def("recv_create_v3", &NDIlib_recv_create_v3,
+  m.def(
-        py::arg("instance") = nullptr);
+      "recv_create_v3",
+      [](const NDIlib_recv_create_v3_t *p_create_settings) {
+        auto instance = NDIlib_recv_create_v3(p_create_settings);
+        return py::capsule(instance);
+      },
+      py::arg("create_settings") = nullptr);
 
-  m.def("recv_destroy", &NDIlib_recv_destroy, py::arg("instance"));
+  m.def(
+      "recv_destroy",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        NDIlib_recv_destroy(instance);
+      },
+      py::arg("instance"));
 
-  m.def("recv_connect", &NDIlib_recv_connect, py::arg("instance"),
+  m.def(
-        py::arg("source") = nullptr);
+      "recv_connect",
+      [](py::capsule p_instance, const NDIlib_source_t *p_src) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        NDIlib_recv_connect(instance, p_src);
+      },
+      py::arg("instance"), py::arg("source") = nullptr);
 
   m.def(
       "recv_capture_v2",
-      [](NDIlib_recv_instance_t p_instance, uint32_t timeout_in_ms) {
+      [](py::capsule p_instance, uint32_t timeout_in_ms) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
         NDIlib_video_frame_v2_t video_frame;
         NDIlib_audio_frame_v2_t audio_frame;
         NDIlib_metadata_frame_t metadata_frame;
-        auto type =
+        auto type = NDIlib_recv_capture_v2(instance, &video_frame, &audio_frame,
-            NDIlib_recv_capture_v2(p_instance, &video_frame, &audio_frame,
                                            &metadata_frame, timeout_in_ms);
         return std::tuple<NDIlib_frame_type_e, NDIlib_video_frame_v2_t,
                           NDIlib_audio_frame_v2_t, NDIlib_metadata_frame_t>(
@@ -392,12 +431,13 @@ PYBIND11_MODULE(NDIlib, m) {
 
   m.def(
       "recv_capture_v3",
-      [](NDIlib_recv_instance_t p_instance, uint32_t timeout_in_ms) {
+      [](py::capsule p_instance, uint32_t timeout_in_ms) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
         NDIlib_video_frame_v2_t video_frame;
         NDIlib_audio_frame_v3_t audio_frame;
         NDIlib_metadata_frame_t metadata_frame;
-        auto type =
+        auto type = NDIlib_recv_capture_v3(instance, &video_frame, &audio_frame,
-            NDIlib_recv_capture_v3(p_instance, &video_frame, &audio_frame,
                                            &metadata_frame, timeout_in_ms);
         return std::tuple<NDIlib_frame_type_e, NDIlib_video_frame_v2_t,
                           NDIlib_audio_frame_v3_t, NDIlib_metadata_frame_t>(
@@ -405,117 +445,364 @@ PYBIND11_MODULE(NDIlib, m) {
       },
       py::arg("instance"), py::arg("timeout_in_ms"));
 
-  m.def("recv_free_video_v2", &NDIlib_recv_free_video_v2, py::arg("instance"),
+  m.def(
-        py::arg("video_data"));
+      "recv_free_video_v2",
+      [](py::capsule p_instance, const NDIlib_video_frame_v2_t *p_video_data) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        NDIlib_recv_free_video_v2(instance, p_video_data);
+      },
+      py::arg("instance"), py::arg("video_data") = nullptr);
 
-  m.def("recv_free_audio_v2", &NDIlib_recv_free_audio_v2, py::arg("instance"),
+  m.def(
-        py::arg("audio_data"));
+      "recv_free_audio_v2",
+      [](py::capsule p_instance, const NDIlib_audio_frame_v2_t *p_audio_data) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        NDIlib_recv_free_audio_v2(instance, p_audio_data);
+      },
+      py::arg("instance"), py::arg("audio_data") = nullptr);
 
-  m.def("recv_free_audio_v3", &NDIlib_recv_free_audio_v3, py::arg("instance"),
+  m.def(
-        py::arg("audio_data"));
+      "recv_free_audio_v3",
+      [](py::capsule p_instance, const NDIlib_audio_frame_v3_t *p_audio_data) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        NDIlib_recv_free_audio_v3(instance, p_audio_data);
+      },
+      py::arg("instance"), py::arg("audio_data") = nullptr);
 
-  m.def("recv_free_metadata", &NDIlib_recv_free_metadata, py::arg("instance"),
+  m.def(
-        py::arg("metadata"));
+      "recv_free_metadata",
+      [](py::capsule p_instance, const NDIlib_metadata_frame_t *p_metadata) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        NDIlib_recv_free_metadata(instance, p_metadata);
+      },
+      py::arg("instance"), py::arg("metadata") = nullptr);
 
-  m.def("recv_free_string", &NDIlib_recv_free_string, py::arg("instance"),
+  m.def(
-        py::arg("string"));
+      "recv_free_string",
+      [](py::capsule p_instance, const char *p_string) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        NDIlib_recv_free_string(instance, p_string);
+      },
+      py::arg("instance"), py::arg("string") = nullptr);
 
-  m.def("recv_send_metadata", &NDIlib_recv_send_metadata, py::arg("instance"),
+  m.def(
-        py::arg("metadata_frame"));
+      "recv_send_metadata",
+      [](py::capsule p_instance, const NDIlib_metadata_frame_t *p_metadata) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_send_metadata(instance, p_metadata);
+      },
+      py::arg("instance"), py::arg("metadata_frame"));
 
-  m.def("recv_set_tally", &NDIlib_recv_set_tally, py::arg("instance"),
+  m.def(
-        py::arg("tally"));
+      "recv_set_tally",
+      [](py::capsule p_instance, const NDIlib_tally_t *p_tally) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_set_tally(instance, p_tally);
+      },
+      py::arg("instance"), py::arg("tally"));
 
-  m.def("recv_get_performance", &NDIlib_recv_get_performance,
+  m.def(
-        py::arg("instance"), py::arg("total"), py::arg("dropped"));
+      "recv_get_performance",
-
+      [](py::capsule p_instance) {
-  m.def("recv_get_queue", &NDIlib_recv_get_queue, py::arg("instance"),
+        auto instance =
-        py::arg("total"));
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
-
+        NDIlib_recv_performance_t total;
-  m.def("recv_clear_connection_metadata",
+        NDIlib_recv_performance_t dropped;
-        &NDIlib_recv_clear_connection_metadata, py::arg("instance"));
+        NDIlib_recv_get_performance(instance, &total, &dropped);
-
+        return std::tuple<NDIlib_recv_performance_t, NDIlib_recv_performance_t>(
-  m.def("recv_add_connection_metadata", &NDIlib_recv_add_connection_metadata,
+            total, dropped);
-        py::arg("instance"), py::arg("metadata"));
+      },
-
-  m.def("recv_get_no_connections", &NDIlib_recv_get_no_connections,
       py::arg("instance"));
 
-  m.def("recv_get_web_control", &NDIlib_recv_get_web_control,
+  m.def(
+      "recv_get_queue",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        NDIlib_recv_queue_t total;
+        NDIlib_recv_get_queue(instance, &total);
+        return total;
+      },
+      py::arg("instance"));
+
+  m.def(
+      "recv_clear_connection_metadata",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        NDIlib_recv_clear_connection_metadata(instance);
+      },
+      py::arg("instance"));
+
+  m.def(
+      "recv_add_connection_metadata",
+      [](py::capsule p_instance, const NDIlib_metadata_frame_t *p_metadata) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        NDIlib_recv_add_connection_metadata(instance, p_metadata);
+      },
+      py::arg("instance"), py::arg("metadata"));
+
+  m.def(
+      "recv_get_no_connections",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_get_no_connections(instance);
+      },
+      py::arg("instance"));
+
+  m.def(
+      "recv_get_web_control",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        auto str = NDIlib_recv_get_web_control(instance);
+        auto ustr = PyUnicode_DecodeLocale(str, nullptr);
+        return py::reinterpret_steal<py::str>(ustr);
+      },
       py::arg("instance"));
 
   // Processing.NDI.Recv.ex
-  m.def("recv_ptz_is_supported", &NDIlib_recv_ptz_is_supported,
+  m.def(
+      "recv_ptz_is_supported",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_ptz_is_supported(instance);
+      },
       py::arg("instance"));
 
-  m.def("recv_recording_is_supported", &NDIlib_recv_recording_is_supported,
+  m.def(
+      "recv_recording_is_supported",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_recording_is_supported(instance);
+      },
       py::arg("instance"));
 
-  m.def("recv_ptz_zoom", &NDIlib_recv_ptz_zoom, py::arg("instance"),
+  m.def(
-        py::arg("zoom_value"));
+      "recv_ptz_zoom",
+      [](py::capsule p_instance, const float zoom_value) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_ptz_zoom(instance, zoom_value);
+      },
+      py::arg("instance"), py::arg("zoom_value"));
 
-  m.def("recv_ptz_zoom_speed", &NDIlib_recv_ptz_zoom_speed, py::arg("instance"),
+  m.def(
-        py::arg("zoom_speed"));
+      "recv_ptz_zoom_speed",
+      [](py::capsule p_instance, const float zoom_speed) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_ptz_zoom_speed(instance, zoom_speed);
+      },
+      py::arg("instance"), py::arg("zoom_speed"));
 
-  m.def("recv_ptz_pan_tilt", &NDIlib_recv_ptz_pan_tilt, py::arg("instance"),
+  m.def(
-        py::arg("pan_value"), py::arg("tilt_value"));
+      "recv_ptz_pan_tilt",
+      [](py::capsule p_instance, const float pan_value,
+         const float tilt_value) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_ptz_pan_tilt(instance, pan_value, tilt_value);
+      },
+      py::arg("instance"), py::arg("pan_value"), py::arg("tilt_value"));
 
-  m.def("recv_ptz_pan_tilt_speed", &NDIlib_recv_ptz_pan_tilt_speed,
+  m.def(
+      "recv_ptz_pan_tilt_speed",
+      [](py::capsule p_instance, const float pan_speed,
+         const float tilt_speed) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_ptz_pan_tilt_speed(instance, pan_speed, tilt_speed);
+      },
       py::arg("instance"), py::arg("pan_speed"), py::arg("tilt_speed"));
 
-  m.def("recv_ptz_store_preset", &NDIlib_recv_ptz_store_preset,
+  m.def(
+      "recv_ptz_store_preset",
+      [](py::capsule p_instance, const int preset_no) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_ptz_store_preset(instance, preset_no);
+      },
       py::arg("instance"), py::arg("preset_no"));
 
-  m.def("recv_ptz_recall_preset", &NDIlib_recv_ptz_recall_preset,
+  m.def(
+      "recv_ptz_recall_preset",
+      [](py::capsule p_instance, const int preset_no, const float speed) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_ptz_recall_preset(instance, preset_no, speed);
+      },
       py::arg("instance"), py::arg("preset_no"), py::arg("speed"));
 
-  m.def("recv_ptz_auto_focus", &NDIlib_recv_ptz_auto_focus,
+  m.def(
+      "recv_ptz_auto_focus",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_ptz_auto_focus(instance);
+      },
       py::arg("instance"));
 
-  m.def("recv_ptz_focus", &NDIlib_recv_ptz_focus, py::arg("instance"),
+  m.def(
-        py::arg("focus_value"));
+      "recv_ptz_focus",
+      [](py::capsule p_instance, const float focus_value) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_ptz_focus(instance, focus_value);
+      },
+      py::arg("instance"), py::arg("focus_value"));
 
-  m.def("recv_ptz_focus_speed", &NDIlib_recv_ptz_focus_speed,
+  m.def(
+      "recv_ptz_focus_speed",
+      [](py::capsule p_instance, const float focus_speed) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_ptz_focus_speed(instance, focus_speed);
+      },
       py::arg("instance"), py::arg("focus_speed"));
 
-  m.def("recv_ptz_white_balance_auto", &NDIlib_recv_ptz_white_balance_auto,
+  m.def(
+      "recv_ptz_white_balance_auto",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_ptz_white_balance_auto(instance);
+      },
       py::arg("instance"));
 
-  m.def("recv_ptz_white_balance_indoor", &NDIlib_recv_ptz_white_balance_indoor,
+  m.def(
+      "recv_ptz_white_balance_indoor",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_ptz_white_balance_indoor(instance);
+      },
       py::arg("instance"));
 
-  m.def("recv_ptz_white_balance_outdoor",
+  m.def(
-        &NDIlib_recv_ptz_white_balance_outdoor, py::arg("instance"));
+      "recv_ptz_white_balance_outdoor",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_ptz_white_balance_outdoor(instance);
+      },
+      py::arg("instance"));
 
-  m.def("recv_ptz_white_balance_oneshot",
+  m.def(
-        &NDIlib_recv_ptz_white_balance_oneshot, py::arg("instance"));
+      "recv_ptz_white_balance_oneshot",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_ptz_white_balance_oneshot(instance);
+      },
+      py::arg("instance"));
 
-  m.def("recv_ptz_white_balance_manual", &NDIlib_recv_ptz_white_balance_manual,
+  m.def(
+      "recv_ptz_white_balance_manual",
+      [](py::capsule p_instance, const float red, const float blue) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_ptz_white_balance_manual(instance, red, blue);
+      },
       py::arg("instance"), py::arg("red"), py::arg("blue"));
 
-  m.def("recv_ptz_exposure_auto", &NDIlib_recv_ptz_exposure_auto,
+  m.def(
+      "recv_ptz_exposure_auto",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_ptz_exposure_auto(instance);
+      },
       py::arg("instance"));
 
-  m.def("recv_ptz_exposure_manual", &NDIlib_recv_ptz_exposure_manual,
+  m.def(
+      "recv_ptz_exposure_manual",
+      [](py::capsule p_instance, const float exposure_level) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_ptz_exposure_manual(instance, exposure_level);
+      },
       py::arg("instance"), py::arg("exposure_level"));
 
-  m.def("recv_recording_start", &NDIlib_recv_recording_start,
+  m.def(
+      "recv_ptz_exposure_manual_v2",
+      [](py::capsule p_instance, const float iris, const float gain,
+         const float shutter_speed) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_ptz_exposure_manual_v2(instance, iris, gain,
+                                                  shutter_speed);
+      },
+      py::arg("instance"), py::arg("iris"), py::arg("gain"),
+      py::arg("shutter_speed"));
+
+  m.def(
+      "recv_recording_start",
+      [](py::capsule p_instance, const char *p_filename_hint) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_recording_start(instance, p_filename_hint);
+      },
       py::arg("instance"), py::arg("filename_hint"));
 
-  m.def("recv_recording_stop", &NDIlib_recv_recording_stop,
+  m.def(
+      "recv_recording_stop",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_recording_stop(instance);
+      },
       py::arg("instance"));
 
-  m.def("recv_recording_set_audio_level",
+  m.def(
-        &NDIlib_recv_recording_set_audio_level, py::arg("instance"),
+      "recv_recording_set_audio_level",
-        py::arg("level_dB"));
+      [](py::capsule p_instance, const float level_dB) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_recording_set_audio_level(instance, level_dB);
+      },
+      py::arg("instance"), py::arg("level_dB"));
 
-  m.def("recv_recording_is_recording", &NDIlib_recv_recording_is_recording,
+  m.def(
+      "recv_recording_is_recording",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_recording_is_recording(instance);
+      },
       py::arg("instance"));
 
-  m.def("recv_recording_get_filename", &NDIlib_recv_recording_get_filename,
+  m.def(
+      "recv_recording_get_filename",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        auto str = NDIlib_recv_recording_get_filename(instance);
+        auto ustr = PyUnicode_DecodeLocale(str, nullptr);
+        return py::reinterpret_steal<py::str>(ustr);
+      },
       py::arg("instance"));
 
-  m.def("recv_recording_get_error", &NDIlib_recv_recording_get_error,
+  m.def(
+      "recv_recording_get_error",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        auto str = NDIlib_recv_recording_get_error(instance);
+        auto ustr = PyUnicode_DecodeLocale(str, nullptr);
+        return py::reinterpret_steal<py::str>(ustr);
+      },
       py::arg("instance"));
 
   py::class_<NDIlib_recv_recording_time_t>(m, "RecvRecordingTime")
@@ -524,7 +811,13 @@ PYBIND11_MODULE(NDIlib, m) {
       .def_readwrite("start_time", &NDIlib_recv_recording_time_t::start_time)
       .def_readwrite("last_time", &NDIlib_recv_recording_time_t::last_time);
 
-  m.def("recv_recording_get_times", &NDIlib_recv_recording_get_times,
+  m.def(
+      "recv_recording_get_times",
+      [](py::capsule p_instance, NDIlib_recv_recording_time_t *p_times) {
+        auto instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        return NDIlib_recv_recording_get_times(instance, p_times);
+      },
       py::arg("instance"), py::arg("times"));
 
   // Processing.NDI.Send
@@ -557,48 +850,140 @@ PYBIND11_MODULE(NDIlib, m) {
       .def_readwrite("clock_video", &NDIlib_send_create_t::clock_video)
       .def_readwrite("clock_audio", &NDIlib_send_create_t::clock_audio);
 
-  m.def("send_create", &NDIlib_send_create,
+  m.def(
+      "send_create",
+      [](const NDIlib_send_create_t *p_create_settings) {
+        auto instance = NDIlib_send_create(p_create_settings);
+        return py::capsule(instance);
+      },
       py::arg("create_settings") = nullptr);
 
-  m.def("send_destroy", &NDIlib_send_destroy, py::arg("instance"));
+  m.def(
+      "send_destroy",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_send_instance_type *>(p_instance.get_pointer());
+        NDIlib_send_destroy(instance);
+      },
+      py::arg("instance"));
 
-  m.def("send_send_video_v2", &NDIlib_send_send_video_v2, py::arg("instance"),
+  m.def(
-        py::arg("video_data"));
+      "send_send_video_v2",
-
+      [](py::capsule p_instance, const NDIlib_video_frame_v2_t *p_video_data) {
-  m.def("send_send_video_async_v2", &NDIlib_send_send_video_async_v2,
+        auto instance =
+            static_cast<NDIlib_send_instance_type *>(p_instance.get_pointer());
+        NDIlib_send_send_video_v2(instance, p_video_data);
+      },
       py::arg("instance"), py::arg("video_data"));
 
-  m.def("send_send_audio_v2", &NDIlib_send_send_audio_v2, py::arg("instance"),
+  m.def(
-        py::arg("audio_data"));
+      "send_send_video_async_v2",
+      [](py::capsule p_instance, const NDIlib_video_frame_v2_t *p_video_data) {
+        auto instance =
+            static_cast<NDIlib_send_instance_type *>(p_instance.get_pointer());
+        NDIlib_send_send_video_async_v2(instance, p_video_data);
+      },
+      py::arg("instance"), py::arg("video_data"));
 
-  m.def("send_send_audio_v3", &NDIlib_send_send_audio_v3, py::arg("instance"),
+  m.def(
-        py::arg("audio_data"));
+      "send_send_audio_v2",
+      [](py::capsule p_instance, const NDIlib_audio_frame_v2_t *p_audio_data) {
+        auto instance =
+            static_cast<NDIlib_send_instance_type *>(p_instance.get_pointer());
+        NDIlib_send_send_audio_v2(instance, p_audio_data);
+      },
+      py::arg("instance"), py::arg("audio_data"));
 
-  m.def("send_send_metadata", &NDIlib_send_send_metadata, py::arg("instance"),
+  m.def(
-        py::arg("metadata"));
+      "send_send_audio_v3",
+      [](py::capsule p_instance, const NDIlib_audio_frame_v3_t *p_audio_data) {
+        auto instance =
+            static_cast<NDIlib_send_instance_type *>(p_instance.get_pointer());
+        NDIlib_send_send_audio_v3(instance, p_audio_data);
+      },
+      py::arg("instance"), py::arg("audio_data"));
 
-  m.def("send_capture", &NDIlib_send_capture, py::arg("instance"),
+  m.def(
-        py::arg("metadata"), py::arg("timeout_in_ms"));
+      "send_send_metadata",
-
+      [](py::capsule p_instance, const NDIlib_metadata_frame_t *p_metadata) {
-  m.def("send_free_metadata", &NDIlib_send_free_metadata, py::arg("instance"),
+        auto instance =
-        py::arg("metadata"));
+            static_cast<NDIlib_send_instance_type *>(p_instance.get_pointer());
-
+        NDIlib_send_send_metadata(instance, p_metadata);
-  m.def("send_get_tally", &NDIlib_send_get_tally, py::arg("instance"),
+      },
-        py::arg("tally"), py::arg("timeout_in_ms"));
-
-  m.def("send_get_no_connections", &NDIlib_send_get_no_connections,
-        py::arg("instance"), py::arg("timeout_in_ms"));
-
-  m.def("send_clear_connection_metadata",
-        &NDIlib_send_clear_connection_metadata, py::arg("instance"));
-
-  m.def("send_add_connection_metadata", &NDIlib_send_add_connection_metadata,
       py::arg("instance"), py::arg("metadata"));
 
-  m.def("send_set_failover", &NDIlib_send_set_failover, py::arg("instance"),
+  m.def(
-        py::arg("failover_source"));
+      "send_capture",
+      [](py::capsule p_instance, NDIlib_metadata_frame_t *p_metadata,
+         uint32_t timeout_in_ms) {
+        auto instance =
+            static_cast<NDIlib_send_instance_type *>(p_instance.get_pointer());
+        NDIlib_send_capture(instance, p_metadata, timeout_in_ms);
+      },
+      py::arg("instance"), py::arg("metadata"), py::arg("timeout_in_ms"));
 
-  m.def("send_get_source_name", &NDIlib_send_get_source_name,
+  m.def(
+      "send_free_metadata",
+      [](py::capsule p_instance, const NDIlib_metadata_frame_t *p_metadata) {
+        auto instance =
+            static_cast<NDIlib_send_instance_type *>(p_instance.get_pointer());
+        NDIlib_send_free_metadata(instance, p_metadata);
+      },
+      py::arg("instance"), py::arg("metadata"));
+
+  m.def(
+      "send_get_tally",
+      [](py::capsule p_instance, NDIlib_tally_t *p_tally,
+         uint32_t timeout_in_ms) {
+        auto instance =
+            static_cast<NDIlib_send_instance_type *>(p_instance.get_pointer());
+        return NDIlib_send_get_tally(instance, p_tally, timeout_in_ms);
+      },
+      py::arg("instance"), py::arg("tally"), py::arg("timeout_in_ms"));
+
+  m.def(
+      "send_get_no_connections",
+      [](py::capsule p_instance, uint32_t timeout_in_ms) {
+        auto instance =
+            static_cast<NDIlib_send_instance_type *>(p_instance.get_pointer());
+        return NDIlib_send_get_no_connections(instance, timeout_in_ms);
+      },
+      py::arg("instance"), py::arg("timeout_in_ms"));
+
+  m.def(
+      "send_clear_connection_metadata",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_send_instance_type *>(p_instance.get_pointer());
+        NDIlib_send_clear_connection_metadata(instance);
+      },
+      py::arg("instance"));
+
+  m.def(
+      "send_add_connection_metadata",
+      [](py::capsule p_instance, const NDIlib_metadata_frame_t *p_metadata) {
+        auto instance =
+            static_cast<NDIlib_send_instance_type *>(p_instance.get_pointer());
+        NDIlib_send_add_connection_metadata(instance, p_metadata);
+      },
+      py::arg("instance"), py::arg("metadata"));
+
+  m.def(
+      "send_set_failover",
+      [](py::capsule p_instance, const NDIlib_source_t *p_failover_source) {
+        auto instance =
+            static_cast<NDIlib_send_instance_type *>(p_instance.get_pointer());
+        NDIlib_send_set_failover(instance, p_failover_source);
+      },
+      py::arg("instance"), py::arg("failover_source"));
+
+  m.def(
+      "send_get_source_name",
+      [](py::capsule p_instance) {
+        auto instance =
+            static_cast<NDIlib_send_instance_type *>(p_instance.get_pointer());
+        return NDIlib_send_get_source_name(instance);
+      },
       py::arg("instance"));
 
   // Processing.NDI.Routing
@@ -612,7 +997,8 @@ PYBIND11_MODULE(NDIlib, m) {
             return py::reinterpret_steal<py::str>(ustr);
           },
           [](NDIlib_routing_create_t &self, const char *name) {
-            static std::unordered_map<NDIlib_routing_create_t *, std::string> strs;
+            static std::unordered_map<NDIlib_routing_create_t *, std::string>
+                strs;
             strs[&self] = py::str(name);
             self.p_ndi_name = strs[&self].c_str();
           })
@@ -623,19 +1009,64 @@ PYBIND11_MODULE(NDIlib, m) {
             return py::reinterpret_steal<py::str>(ustr);
           },
           [](NDIlib_routing_create_t &self, const std::string &groups) {
-            static std::unordered_map<NDIlib_routing_create_t *, std::string> strs;
+            static std::unordered_map<NDIlib_routing_create_t *, std::string>
+                strs;
             strs[&self] = py::str(groups);
             self.p_groups = strs[&self].c_str();
           });
 
-  m.def("routing_create", &NDIlib_routing_create, py::arg("create_settings"));
+  m.def(
+      "routing_create",
+      [](const NDIlib_routing_create_t *p_create_settings) {
+        auto instance = NDIlib_routing_create(p_create_settings);
+        return py::capsule(instance);
+      },
+      py::arg("create_settings"));
 
-  m.def("routing_destroy", &NDIlib_routing_destroy, py::arg("instance"));
+  m.def(
+      "routing_destroy",
+      [](py::capsule p_instance) {
+        auto instance = static_cast<NDIlib_routing_instance_type *>(
+            p_instance.get_pointer());
+        NDIlib_routing_destroy(instance);
+      },
+      py::arg("instance"));
 
-  m.def("routing_change", &NDIlib_routing_change, py::arg("instance"),
+  m.def(
-        py::arg("source"));
+      "routing_change",
+      [](py::capsule p_instance, const NDIlib_source_t *p_source) {
+        auto instance = static_cast<NDIlib_routing_instance_type *>(
+            p_instance.get_pointer());
+        return NDIlib_routing_change(instance, p_source);
+      },
+      py::arg("instance"), py::arg("source"));
 
-  m.def("routing_clear", &NDIlib_routing_clear, py::arg("instance"));
+  m.def(
+      "routing_clear",
+      [](py::capsule p_instance) {
+        auto instance = static_cast<NDIlib_routing_instance_type *>(
+            p_instance.get_pointer());
+        NDIlib_routing_clear(instance);
+      },
+      py::arg("instance"));
+
+  m.def(
+      "routing_get_no_connections",
+      [](py::capsule p_instance, uint32_t timeout_in_ms) {
+        auto instance = static_cast<NDIlib_routing_instance_type *>(
+            p_instance.get_pointer());
+        return NDIlib_routing_get_no_connections(instance, timeout_in_ms);
+      },
+      py::arg("instance"), py::arg("timeout_in_ms"));
+
+  m.def(
+      "routing_get_source_name(",
+      [](py::capsule p_instance) {
+        auto instance = static_cast<NDIlib_routing_instance_type *>(
+            p_instance.get_pointer());
+        return NDIlib_routing_get_source_name(instance);
+      },
+      py::arg("instance"));
 
   // Processing.NDI.utilities
   py::class_<NDIlib_audio_frame_interleaved_16s_t>(m,
@@ -693,17 +1124,35 @@ PYBIND11_MODULE(NDIlib, m) {
                      &NDIlib_audio_frame_interleaved_32f_t::timecode)
       .def_readwrite("data", &NDIlib_audio_frame_interleaved_32f_t::p_data);
 
-  m.def("util_send_send_audio_interleaved_16s",
+  m.def(
-        &NDIlib_util_send_send_audio_interleaved_16s, py::arg("instance"),
+      "util_send_send_audio_interleaved_16s",
-        py::arg("audio_data"));
+      [](py::capsule p_instance,
+         const NDIlib_audio_frame_interleaved_16s_t *p_audio_data) {
+        auto instance =
+            static_cast<NDIlib_send_instance_type *>(p_instance.get_pointer());
+        NDIlib_util_send_send_audio_interleaved_16s(instance, p_audio_data);
+      },
+      py::arg("instance"), py::arg("audio_data"));
 
-  m.def("util_send_send_audio_interleaved_32s",
+  m.def(
-        &NDIlib_util_send_send_audio_interleaved_32s, py::arg("instance"),
+      "util_send_send_audio_interleaved_32s",
-        py::arg("audio_data"));
+      [](py::capsule p_instance,
+         const NDIlib_audio_frame_interleaved_32s_t *p_audio_data) {
+        auto instance =
+            static_cast<NDIlib_send_instance_type *>(p_instance.get_pointer());
+        NDIlib_util_send_send_audio_interleaved_32s(instance, p_audio_data);
+      },
+      py::arg("instance"), py::arg("audio_data"));
 
-  m.def("util_send_send_audio_interleaved_32f",
+  m.def(
-        &NDIlib_util_send_send_audio_interleaved_32f, py::arg("instance"),
+      "util_send_send_audio_interleaved_32f",
-        py::arg("audio_data"));
+      [](py::capsule p_instance,
+         const NDIlib_audio_frame_interleaved_32f_t *p_audio_data) {
+        auto instance =
+            static_cast<NDIlib_send_instance_type *>(p_instance.get_pointer());
+        NDIlib_util_send_send_audio_interleaved_32f(instance, p_audio_data);
+      },
+      py::arg("instance"), py::arg("audio_data"));
 
   m.def("util_audio_to_interleaved_16s_v2",
         &NDIlib_util_audio_to_interleaved_16s_v2, py::arg("src"),
@@ -739,31 +1188,93 @@ PYBIND11_MODULE(NDIlib, m) {
   // TODO
 
   // Processing.NDI.FrameSync
-  m.def("framesync_create", &NDIlib_framesync_create, py::arg("receiver"));
+  m.def(
+      "framesync_create",
+      [](py::capsule p_instance) {
+        auto recv_instance =
+            static_cast<NDIlib_recv_instance_type *>(p_instance.get_pointer());
+        auto instance = NDIlib_framesync_create(recv_instance);
+        return py::capsule(instance);
+      },
+      py::arg("receiver"));
 
-  m.def("framesync_destroy", &NDIlib_framesync_destroy, py::arg("instance"));
+  m.def(
-
+      "framesync_destroy",
-  m.def("framesync_capture_audio", &NDIlib_framesync_capture_audio,
+      [](py::capsule p_instance) {
-        py::arg("instance"), py::arg("audio_data"), py::arg("sample_rate"),
+        auto instance = static_cast<NDIlib_framesync_instance_type *>(
-        py::arg("no_channels"), py::arg("no_samples"));
+            p_instance.get_pointer());
-
+        NDIlib_framesync_destroy(instance);
-  m.def("framesync_capture_audio_v2", &NDIlib_framesync_capture_audio_v2,
+      },
-        py::arg("instance"), py::arg("audio_data"), py::arg("sample_rate"),
-        py::arg("no_channels"), py::arg("no_samples"));
-
-  m.def("framesync_free_audio", &NDIlib_framesync_free_audio,
-        py::arg("instance"), py::arg("audio_data"));
-
-  m.def("framesync_free_audio_v2", &NDIlib_framesync_free_audio_v2,
-        py::arg("instance"), py::arg("audio_data"));
-
-  m.def("framesync_audio_queue_depth", &NDIlib_framesync_audio_queue_depth,
       py::arg("instance"));
 
-  m.def("framesync_capture_video", &NDIlib_framesync_capture_video,
+  m.def(
+      "framesync_capture_audio",
+      [](py::capsule p_instance, NDIlib_audio_frame_v2_t *p_audio_data,
+         int sample_rate, int no_channels, int no_samples) {
+        auto instance = static_cast<NDIlib_framesync_instance_type *>(
+            p_instance.get_pointer());
+        NDIlib_framesync_capture_audio(instance, p_audio_data, sample_rate,
+                                       no_channels, no_samples);
+      },
+      py::arg("instance"), py::arg("audio_data"), py::arg("sample_rate"),
+      py::arg("no_channels"), py::arg("no_samples"));
+
+  m.def(
+      "framesync_capture_audio_v2",
+      [](py::capsule p_instance, NDIlib_audio_frame_v3_t *p_audio_data,
+         int sample_rate, int no_channels, int no_samples) {
+        auto instance = static_cast<NDIlib_framesync_instance_type *>(
+            p_instance.get_pointer());
+        NDIlib_framesync_capture_audio_v2(instance, p_audio_data, sample_rate,
+                                          no_channels, no_samples);
+      },
+      py::arg("instance"), py::arg("audio_data"), py::arg("sample_rate"),
+      py::arg("no_channels"), py::arg("no_samples"));
+
+  m.def(
+      "framesync_free_audio",
+      [](py::capsule p_instance, NDIlib_audio_frame_v2_t *p_audio_data) {
+        auto instance = static_cast<NDIlib_framesync_instance_type *>(
+            p_instance.get_pointer());
+        NDIlib_framesync_free_audio(instance, p_audio_data);
+      },
+      py::arg("instance"), py::arg("audio_data"));
+
+  m.def(
+      "framesync_free_audio_v2",
+      [](py::capsule p_instance, NDIlib_audio_frame_v3_t *p_audio_data) {
+        auto instance = static_cast<NDIlib_framesync_instance_type *>(
+            p_instance.get_pointer());
+        NDIlib_framesync_free_audio_v2(instance, p_audio_data);
+      },
+      py::arg("instance"), py::arg("audio_data"));
+
+  m.def(
+      "framesync_audio_queue_depth",
+      [](py::capsule p_instance) {
+        auto instance = static_cast<NDIlib_framesync_instance_type *>(
+            p_instance.get_pointer());
+        return NDIlib_framesync_audio_queue_depth(instance);
+      },
+      py::arg("instance"));
+
+  m.def(
+      "framesync_capture_video",
+      [](py::capsule p_instance, NDIlib_video_frame_v2_t *p_video_data,
+         NDIlib_frame_format_type_e field_type) {
+        auto instance = static_cast<NDIlib_framesync_instance_type *>(
+            p_instance.get_pointer());
+        NDIlib_framesync_capture_video(instance, p_video_data, field_type);
+      },
       py::arg("instance"), py::arg("video_data"),
       py::arg("field_type") = NDIlib_frame_format_type_progressive);
 
-  m.def("framesync_free_video", &NDIlib_framesync_free_video,
+  m.def(
+      "framesync_free_video",
+      [](py::capsule p_instance, NDIlib_video_frame_v2_t *p_video_data) {
+        auto instance = static_cast<NDIlib_framesync_instance_type *>(
+            p_instance.get_pointer());
+        NDIlib_framesync_free_video(instance, p_video_data);
+      },
       py::arg("instance"), py::arg("video_data"));
 }