syphon.server

  1from abc import ABC, abstractmethod
  2from typing import Tuple, Optional, Any
  3
  4import Cocoa
  5import Metal
  6import objc
  7from OpenGL.GL import *
  8
  9from syphon.types import Texture, Region, Size
 10from syphon.utils import opengl
 11
 12
 13class BaseSyphonServer(ABC):
 14    """
 15    Abstract base class for Syphon servers.
 16
 17    Attributes:
 18    - name (str): The name of the Syphon server.
 19    """
 20
 21    def __init__(self, name: str):
 22        """
 23        Initialize a BaseSyphonServer.
 24
 25        Parameters:
 26        - name (str): The name of the Syphon server.
 27        """
 28        self.name = name
 29
 30    @abstractmethod
 31    def publish_frame_texture(self,
 32                              texture: Texture,
 33                              region: Optional[Region] = None,
 34                              size: Optional[Size] = None,
 35                              is_flipped: bool = False):
 36        """
 37        Publish a frame with the given texture.
 38
 39        Parameters:
 40        - texture (Texture): The texture to publish.
 41        - region (Region, optional): The region of the texture to publish. Defaults to None.
 42        - size (Size, optional): The size of the texture. Defaults to None.
 43        - is_flipped (bool, optional): If True, the frame is flipped. Defaults to False.
 44        """
 45        pass
 46
 47    @abstractmethod
 48    def publish(self):
 49        """
 50        Publish the frame.
 51        """
 52        pass
 53
 54    @abstractmethod
 55    def stop(self):
 56        """
 57        Stop the Syphon server.
 58        """
 59        pass
 60
 61    @property
 62    @abstractmethod
 63    def has_clients(self) -> bool:
 64        """
 65        Check if the Syphon server has clients.
 66
 67        Returns:
 68        - bool: True if there are clients, False otherwise.
 69        """
 70        pass
 71
 72    @abstractmethod
 73    def _get_texture_size(self, texture: Texture) -> Size:
 74        """
 75        Get the size of the texture.
 76
 77        Parameters:
 78        - texture (Texture): The texture.
 79
 80        Returns:
 81        - Size: The size of the texture.
 82        """
 83        pass
 84
 85    def _prepare_region_and_size(self,
 86                                 texture: Texture,
 87                                 region: Optional[Region] = None,
 88                                 size: Optional[Size] = None) -> Tuple[Region, Size]:
 89        """
 90        Prepare the region and size for publishing.
 91
 92        Parameters:
 93        - texture (Texture): The texture to publish.
 94        - region (Region, optional): The region of the texture to publish. Defaults to None.
 95        - size (Size, optional): The size of the texture. Defaults to None.
 96
 97        Returns:
 98        - Tuple[Region, Size]: The prepared region and size.
 99        """
100        size = self._get_texture_size(texture) if size is None else size
101        if region is None:
102            region = (0, 0, *size)
103        return region, size
104
105
106class SyphonMetalServer(BaseSyphonServer):
107    """
108    Syphon server for Metal-based rendering.
109
110    Attributes:
111    - name (str): The name of the Syphon server.
112    - device (Any): The Metal device.
113    - command_queue (Any): The Metal command queue.
114    - context (Any): The Syphon-Metal context.
115    """
116
117    def __init__(self,
118                 name: str,
119                 device: Optional[Any] = None,
120                 command_queue: Optional[Any] = None):
121        """
122        Initialize a SyphonMetalServer.
123
124        Parameters:
125        - name (str): The name of the Syphon server.
126        - device (Any, optional): The Metal device. If None, the default system device will be used.
127        - command_queue (Any, optional): The Metal command queue. If None, a new command queue will be created.
128        """
129        super().__init__(name)
130
131        self.device = device
132        self.command_queue = command_queue
133
134        # setup device
135        if self.device is None:
136            self.device = Metal.MTLCreateSystemDefaultDevice()
137
138        # setup command queue
139        if self.command_queue is None:
140            self.command_queue = self.device.newCommandQueue()
141
142        # setup syphon-metal context
143        SyphonMetalServerObjC = objc.lookUpClass("SyphonMetalServer")
144        self.context = SyphonMetalServerObjC.alloc().initWithName_device_options_(name, self.device, None)
145
146    def publish_frame_texture(self,
147                              texture: Texture,
148                              region: Optional[Region] = None,
149                              size: Optional[Size] = None,
150                              is_flipped: bool = False,
151                              command_buffer: Optional[Any] = None,
152                              auto_commit: bool = True):
153        """
154        Publish a frame with the given Metal texture.
155
156        Parameters:
157        - texture (Texture): The Metal texture to publish.
158        - region (Region, optional): The region of the texture to publish. Defaults to None.
159        - size (Size, optional): The size of the texture. Defaults to None.
160        - is_flipped (bool, optional): If True, the frame is flipped. Defaults to False.
161        - command_buffer (Any, optional): The Metal command buffer. If None, a new command buffer will be created.
162        - auto_commit (bool, optional): If True, the command buffer is committed automatically. Defaults to True.
163        """
164        # create ns-region
165        region, _ = self._prepare_region_and_size(texture, region, size)
166        ns_region = Cocoa.NSRect((region[0], region[1]), (region[2], region[3]))
167
168        # prepare command buffer if necessary
169        if command_buffer is None:
170            command_buffer = self.command_queue.commandBuffer()
171
172        # publish actual texture
173        self.context.publishFrameTexture_onCommandBuffer_imageRegion_flipped_(texture,
174                                                                              command_buffer,
175                                                                              ns_region,
176                                                                              is_flipped)
177        # commit command buffer
178        if auto_commit:
179            command_buffer.commitAndWaitUntilSubmitted()
180
181    def publish(self):
182        """
183        Publish the frame.
184        """
185        self.context.publish()
186
187    def stop(self):
188        """
189        Stop the SyphonMetalServer.
190        """
191        self.context.stop()
192
193    @property
194    def has_clients(self) -> bool:
195        """
196        Check if the SyphonMetalServer has clients.
197
198        Returns:
199        - bool: True if there are clients, False otherwise.
200        """
201        return self.context.hasClients()
202
203    def _get_texture_size(self, texture: Texture) -> Tuple[int, int]:
204        """
205        Get the size of the Metal texture.
206
207        Parameters:
208        - texture (Texture): The Metal texture.
209
210        Returns:
211        - Tuple[int, int]: The size of the texture.
212        """
213        return texture.width(), texture.height()
214
215
216class SyphonOpenGLServer(BaseSyphonServer):
217    """
218    Syphon server for OpenGL-based rendering.
219
220    Attributes:
221    - name (str): The name of the Syphon server.
222    - cgl_context_obj (Any): The CGL context object.
223    - context (Any): The Syphon-OpenGL context.
224    """
225
226    def __init__(self, name: str, cgl_context_obj: Optional[Any] = None):
227        """
228        Initialize a SyphonOpenGLServer.
229
230        Parameters:
231        - name (str): The name of the Syphon server.
232        - cgl_context_obj (Any, optional): The CGL context object. If None, the current context will be used.
233        """
234        super().__init__(name)
235
236        # store CGL context object
237        self.cgl_context_obj = opengl.get_current_cgl_context_obj() if cgl_context_obj is None else cgl_context_obj
238
239        # create syphon gl server
240        SyphonOpenGLServerObjC = objc.lookUpClass("SyphonOpenGLServer")
241        self.context = SyphonOpenGLServerObjC.alloc().initWithName_context_options_(name, self.cgl_context_obj, None)
242
243    def publish_frame_texture(self,
244                              texture: GLint,
245                              region: Optional[Region] = None,
246                              size: Optional[Size] = None,
247                              is_flipped: bool = False,
248                              target: GLenum = GL_TEXTURE_2D):
249        """
250        Publish a frame with the given OpenGL texture.
251
252        Parameters:
253        - texture (GLint): The OpenGL texture to publish.
254        - region (Region, optional): The region of the texture to publish. Defaults to None.
255        - size (Size, optional): The size of the texture. Defaults to None.
256        - is_flipped (bool, optional): If True, the frame is flipped. Defaults to False.
257        - target (GLenum, optional): The OpenGL texture target. Defaults to GL_TEXTURE_2D.
258        """
259        # create ns-region
260        region, size = self._prepare_region_and_size(texture, region, size)
261        ns_region = Cocoa.NSRect((region[0], region[1]), (region[2], region[3]))
262        ns_size = Cocoa.NSSize(size[0], size[1])
263
264        self.context.publishFrameTexture_textureTarget_imageRegion_textureDimensions_flipped_(texture, target,
265                                                                                              ns_region,
266                                                                                              ns_size, is_flipped)
267
268    def publish(self):
269        """
270        Publish the frame.
271        """
272        self.context.publish()
273
274    def stop(self):
275        """
276        Stop the SyphonOpenGLServer.
277        """
278        self.context.stop()
279
280    @property
281    def has_clients(self) -> bool:
282        """
283        Check if the SyphonOpenGLServer has clients.
284
285        Returns:
286        - bool: True if there are clients, False otherwise.
287        """
288        return self.context.hasClients()
289
290    def _get_texture_size(self, texture: Texture) -> Size:
291        """
292        Get the size of the OpenGL texture.
293
294        Parameters:
295        - texture (Texture): The OpenGL texture.
296
297        Returns:
298        - Size: The size of the texture.
299        """
300        glBindTexture(GL_TEXTURE_2D, texture)
301
302        width = GLint()
303        height = GLint()
304
305        glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, width)
306        glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, height)
307
308        glBindTexture(GL_TEXTURE_2D, 0)
309
310        return int(width.value), int(height.value)