Merge pull request #11 from cansik/data-sharing

Added data-sharing methods and examples

Author: jlai

.gitignore

@@ -11,6 +11,7 @@ VS2019/Release
 VS2019/x64
 VS2019/Win32
 src/SpoutGL/*.dll
+.idea
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

README.md

@@ -4,7 +4,7 @@ SpoutGL for Python
 An unofficial Python wrapper for [Spout](https://leadedge.github.io/) using [pybind11](https://github.com/pybind/pybind11)
 
 Key features compared to some previous wrappers:
-- Covers more of the SpoutGL API, including sendImage/receiveImage and setFrameSync/waitFrameSync
+- Covers more of the SpoutGL API, including sendImage/receiveImage, setFrameSync/waitFrameSync and data sharing
 - pybind11 instead of Boost Python which should make it easier to build for multiple Python versions
 - pip/wheel support for Python 3.7+ on both 64-bit and 32-bit Windows
 - No external dependencies

examples/data/receiver.py

@@ -0,0 +1,39 @@
+import numpy as np
+
+import SpoutGL
+from OpenGL import GL
+from itertools import repeat
+import array
+
+SENDER_NAME = "SpoutGL-test"
+
+with SpoutGL.SpoutReceiver() as receiver:
+    receiver.setReceiverName(SENDER_NAME)
+
+    buffer = None
+    shared_memory = None
+
+    while True:
+        result = receiver.receiveImage(buffer, GL.GL_RGBA, False, 0)
+
+        if receiver.isUpdated():
+            width = receiver.getSenderWidth()
+            height = receiver.getSenderHeight()
+            buffer = array.array('B', repeat(0, width * height * 4))
+
+        if buffer and result and not SpoutGL.helpers.isBufferEmpty(buffer):
+            print("Got bytes", bytes(buffer[0:64]), "...")
+
+        # Wait until the next frame is ready
+        # Wait time is in milliseconds; note that 0 will return immediately
+        receiver.waitFrameSync(SENDER_NAME, 10000)
+        print("sync received")
+
+        if shared_memory is None:
+            memory_length = receiver.getMemoryBufferSize(SENDER_NAME)
+            shared_memory = array.array('B', repeat(0, memory_length))
+
+        result = receiver.readMemoryBuffer(SENDER_NAME, shared_memory, len(shared_memory))
+        if result:
+            message = bytes(shared_memory).decode().split("\x00")[0]
+            print(message)

examples/data/sender.py

@@ -0,0 +1,40 @@
+import SpoutGL
+from itertools import islice, cycle
+import time
+from OpenGL import GL
+from random import randint
+
+TARGET_FPS = 1
+SEND_WIDTH = 256
+SEND_HEIGHT = 256
+SENDER_NAME = "SpoutGL-test"
+
+def randcolor():
+    return randint(0, 255)
+
+with SpoutGL.SpoutSender() as sender:
+    sender.setSenderName(SENDER_NAME)
+
+    # create shared memory buffer
+    sender.createMemoryBuffer(SENDER_NAME, 256)
+
+    while True:
+        # Generating bytes in Python is very slow; ideally you should pass in a buffer obtained elsewhere
+        # or re-use an already allocated array instead of allocating one on the fly
+        pixels = bytes(islice(cycle([randcolor(), randcolor(), randcolor(), 255]), SEND_WIDTH * SEND_HEIGHT * 3))
+
+        result = sender.sendImage(pixels, SEND_WIDTH, SEND_HEIGHT, GL.GL_RGB, False, 0)
+        print("Send result", result)
+
+        # add data to buffer
+        data = "hello world".encode()
+        sender.writeMemoryBuffer(SENDER_NAME, data, len(data))
+
+        # Indicate that a frame is ready to read
+        sender.setFrameSync(SENDER_NAME)
+        
+        # Wait for next send attempt
+        time.sleep(1./TARGET_FPS)
+
+    # cleanup shared buffer
+    sender.deleteMemoryBuffer(SENDER_NAME)

setup.py

@@ -10,7 +10,7 @@
 
 import sys
 
-__version__ = "0.0.2"
+__version__ = "0.0.3"
 
 is_64bits = sys.maxsize > 2**32
 

src/PySpoutGL.cpp

@@ -117,6 +117,12 @@ PYBIND11_MODULE(_spoutgl, m) {
         .def("waitFrameSync", &SpoutSender::WaitFrameSync, py::call_guard<py::gil_scoped_release>())
         .def("getCPU", &SpoutSender::GetCPU)
         .def("getGLDX", &SpoutSender::GetGLDX)
+
+        // data sharing
+        .def("createMemoryBuffer", &SpoutSender::CreateMemoryBuffer)
+        .def("writeMemoryBuffer", &SpoutSender::WriteMemoryBuffer)
+        .def("deleteMemoryBuffer", &SpoutSender::DeleteMemoryBuffer)
+        .def("getMemoryBufferSize", &SpoutSender::GetMemoryBufferSize)
    );
 
     addCommonDefs(py::class_<SpoutReceiver>(m, "SpoutReceiver")
@@ -169,6 +175,27 @@ PYBIND11_MODULE(_spoutgl, m) {
         .def("getSenderFrame", &SpoutReceiver::GetSenderFrame)
         .def("setFrameSync", &SpoutReceiver::SetFrameSync)
         .def("waitFrameSync", &SpoutReceiver::WaitFrameSync, py::arg("senderName"), py::arg("timeout") = 0, py::call_guard<py::gil_scoped_release>())
+
+        // data-sharing
+        .def("readMemoryBuffer", [](SpoutReceiver& receiver, const char *name, std::optional<py::buffer> buffer, int length) {
+            if (!buffer.has_value()) {
+                // Buffer cannot be None
+                throw pybind11::type_error("Must provide a buffer");
+            }
+
+            py::buffer_info bufferInfo(buffer->request());
+
+            if (bufferInfo.size * bufferInfo.itemsize < length) {
+                throw pybind11::buffer_error("Buffer not large enough");
+            }
+
+            if (!PyBuffer_IsContiguous(bufferInfo.view(), 'C')) {
+                throw pybind11::buffer_error("Buffer must be contiguous");
+            }
+
+            return receiver.ReadMemoryBuffer(name, static_cast<char*>(bufferInfo.ptr), length);
+        })
+        .def("getMemoryBufferSize", &SpoutReceiver::GetMemoryBufferSize)
     );
 
     auto enums = m.def_submodule("enums", "Re-export of supported OpenGL format enums as integers");