|
|
@@ -0,0 +1,1125 @@
|
|
|
+#import <Cocoa/Cocoa.h>
|
|
|
+#import <ScriptingBridge/ScriptingBridge.h>
|
|
|
+#import "syphon-framework/Syphon.h"
|
|
|
+#include <obs-module.h>
|
|
|
+
|
|
|
+#define LOG(level, message, ...) \
|
|
|
+ blog(level, "%s: " message, obs_source_get_name(s->source), ##__VA_ARGS__)
|
|
|
+
|
|
|
+struct syphon {
|
|
|
+ SYPHON_CLIENT_UNIQUE_CLASS_NAME *client;
|
|
|
+ IOSurfaceRef ref;
|
|
|
+
|
|
|
+ gs_samplerstate_t *sampler;
|
|
|
+ gs_effect_t *effect;
|
|
|
+ gs_vertbuffer_t *vertbuffer;
|
|
|
+ gs_texture_t *tex;
|
|
|
+ uint32_t width, height;
|
|
|
+ bool crop;
|
|
|
+ CGRect crop_rect;
|
|
|
+
|
|
|
+ obs_source_t *source;
|
|
|
+
|
|
|
+ bool active;
|
|
|
+ bool uuid_changed;
|
|
|
+ id new_server_listener;
|
|
|
+ id retire_listener;
|
|
|
+
|
|
|
+ NSString *app_name;
|
|
|
+ NSString *name;
|
|
|
+ NSString *uuid;
|
|
|
+
|
|
|
+ obs_data_t *inject_info;
|
|
|
+ bool inject_active;
|
|
|
+ id launch_listener;
|
|
|
+};
|
|
|
+typedef struct syphon *syphon_t;
|
|
|
+
|
|
|
+static inline void update_properties(syphon_t s)
|
|
|
+{
|
|
|
+ obs_source_update_properties(s->source);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void find_and_inject_target(syphon_t s, NSArray *arr);
|
|
|
+
|
|
|
+@interface OBSSyphonKVObserver : NSObject
|
|
|
+- (void)observeValueForKeyPath:(NSString *)keyPath
|
|
|
+ ofObject:(id)object
|
|
|
+ change:(NSDictionary *)change
|
|
|
+ context:(void *)context;
|
|
|
+@end
|
|
|
+
|
|
|
+static inline void handle_application_launch(syphon_t s, NSArray *new)
|
|
|
+{
|
|
|
+ if (!s->inject_active)
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (!new)
|
|
|
+ return;
|
|
|
+
|
|
|
+ find_and_inject_target(s, new);
|
|
|
+}
|
|
|
+
|
|
|
+@implementation OBSSyphonKVObserver
|
|
|
+- (void)observeValueForKeyPath:(NSString *)keyPath
|
|
|
+ ofObject:(id)object
|
|
|
+ change:(NSDictionary *)change
|
|
|
+ context:(void *)context
|
|
|
+{
|
|
|
+ UNUSED_PARAMETER(keyPath);
|
|
|
+ UNUSED_PARAMETER(object);
|
|
|
+
|
|
|
+ syphon_t s = context;
|
|
|
+ if (!s)
|
|
|
+ return;
|
|
|
+
|
|
|
+ handle_application_launch(s, change[NSKeyValueChangeNewKey]);
|
|
|
+ update_properties(s);
|
|
|
+}
|
|
|
+@end
|
|
|
+
|
|
|
+static const char *syphon_get_name()
|
|
|
+{
|
|
|
+ return "Syphon";
|
|
|
+}
|
|
|
+
|
|
|
+static void stop_client(syphon_t s)
|
|
|
+{
|
|
|
+ obs_enter_graphics();
|
|
|
+
|
|
|
+ if (s->client) {
|
|
|
+ @autoreleasepool {
|
|
|
+ [s->client stop];
|
|
|
+ [s->client release];
|
|
|
+ s->client = nil;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (s->tex) {
|
|
|
+ gs_texture_destroy(s->tex);
|
|
|
+ s->tex = NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (s->ref) {
|
|
|
+ IOSurfaceDecrementUseCount(s->ref);
|
|
|
+ CFRelease(s->ref);
|
|
|
+ s->ref = NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+ s->width = 0;
|
|
|
+ s->height = 0;
|
|
|
+
|
|
|
+ obs_leave_graphics();
|
|
|
+}
|
|
|
+
|
|
|
+static inline NSDictionary *find_by_uuid(NSArray *arr, NSString *uuid)
|
|
|
+{
|
|
|
+ for (NSDictionary *dict in arr) {
|
|
|
+ if ([dict[SyphonServerDescriptionUUIDKey] isEqual:uuid])
|
|
|
+ return dict;
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil;
|
|
|
+}
|
|
|
+
|
|
|
+static inline void check_version(syphon_t s, NSDictionary *desc)
|
|
|
+{
|
|
|
+ extern const NSString *SyphonServerDescriptionDictionaryVersionKey;
|
|
|
+
|
|
|
+ NSNumber *version = desc[SyphonServerDescriptionDictionaryVersionKey];
|
|
|
+ if (!version)
|
|
|
+ return LOG(LOG_WARNING, "Server description does not contain "
|
|
|
+ "VersionKey");
|
|
|
+
|
|
|
+ if (version.unsignedIntValue > 0)
|
|
|
+ LOG(LOG_WARNING, "Got server description version %d, "
|
|
|
+ "expected 0", version.unsignedIntValue);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void check_description(syphon_t s, NSDictionary *desc)
|
|
|
+{
|
|
|
+ extern const NSString *SyphonSurfaceType;
|
|
|
+ extern const NSString *SyphonSurfaceTypeIOSurface;
|
|
|
+ extern const NSString *SyphonServerDescriptionSurfacesKey;
|
|
|
+
|
|
|
+ NSArray *surfaces = desc[SyphonServerDescriptionSurfacesKey];
|
|
|
+ if (!surfaces)
|
|
|
+ return LOG(LOG_WARNING, "Server description does not contain "
|
|
|
+ "SyphonServerDescriptionSurfacesKey");
|
|
|
+
|
|
|
+ if (!surfaces.count)
|
|
|
+ return LOG(LOG_WARNING, "Server description contains empty "
|
|
|
+ "SyphonServerDescriptionSurfacesKey");
|
|
|
+
|
|
|
+ for (NSDictionary *surface in surfaces) {
|
|
|
+ NSString *type = surface[SyphonSurfaceType];
|
|
|
+ if (type && [type isEqual:SyphonSurfaceTypeIOSurface])
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ NSString *surfaces_string = [NSString stringWithFormat:@"%@", surfaces];
|
|
|
+ LOG(LOG_WARNING, "SyphonSurfaces does not contain"
|
|
|
+ "'SyphonSurfaceTypeIOSurface': %s",
|
|
|
+ surfaces_string.UTF8String);
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool update_string(NSString **str, NSString *new)
|
|
|
+{
|
|
|
+ if (!new)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ [*str release];
|
|
|
+ *str = [new retain];
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+static inline void handle_new_frame(syphon_t s,
|
|
|
+ SYPHON_CLIENT_UNIQUE_CLASS_NAME *client)
|
|
|
+{
|
|
|
+ IOSurfaceRef ref = [client IOSurface];
|
|
|
+
|
|
|
+ if (!ref)
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (ref == s->ref) {
|
|
|
+ CFRelease(ref);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ IOSurfaceIncrementUseCount(ref);
|
|
|
+
|
|
|
+ obs_enter_graphics();
|
|
|
+ if (s->ref) {
|
|
|
+ gs_texture_destroy(s->tex);
|
|
|
+ IOSurfaceDecrementUseCount(s->ref);
|
|
|
+ CFRelease(s->ref);
|
|
|
+ }
|
|
|
+
|
|
|
+ s->ref = ref;
|
|
|
+ s->tex = gs_texture_create_from_iosurface(s->ref);
|
|
|
+ s->width = gs_texture_get_width(s->tex);
|
|
|
+ s->height = gs_texture_get_height(s->tex);
|
|
|
+ obs_leave_graphics();
|
|
|
+}
|
|
|
+
|
|
|
+static void create_client(syphon_t s)
|
|
|
+{
|
|
|
+ stop_client(s);
|
|
|
+
|
|
|
+ if (!s->app_name.length && !s->name.length && !s->uuid.length)
|
|
|
+ return;
|
|
|
+
|
|
|
+ SyphonServerDirectory *ssd = [SyphonServerDirectory sharedDirectory];
|
|
|
+ NSArray *servers = [ssd serversMatchingName:s->name
|
|
|
+ appName:s->app_name];
|
|
|
+ if (!servers.count)
|
|
|
+ return;
|
|
|
+
|
|
|
+ NSDictionary *desc = find_by_uuid(servers, s->uuid);
|
|
|
+ if (!desc) {
|
|
|
+ desc = servers[0];
|
|
|
+ if (update_string(&s->uuid,
|
|
|
+ desc[SyphonServerDescriptionUUIDKey]))
|
|
|
+ s->uuid_changed = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ check_version(s, desc);
|
|
|
+ check_description(s, desc);
|
|
|
+
|
|
|
+ @autoreleasepool {
|
|
|
+ s->client = [[SYPHON_CLIENT_UNIQUE_CLASS_NAME alloc]
|
|
|
+ initWithServerDescription:desc
|
|
|
+ options:nil
|
|
|
+ newFrameHandler:^
|
|
|
+ (SYPHON_CLIENT_UNIQUE_CLASS_NAME *client)
|
|
|
+ {
|
|
|
+ handle_new_frame(s, client);
|
|
|
+ }];
|
|
|
+ }
|
|
|
+
|
|
|
+ s->active = true;
|
|
|
+}
|
|
|
+
|
|
|
+static inline void release_settings(syphon_t s)
|
|
|
+{
|
|
|
+ [s->app_name release];
|
|
|
+ [s->name release];
|
|
|
+ [s->uuid release];
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool load_syphon_settings(syphon_t s, obs_data_t *settings)
|
|
|
+{
|
|
|
+ NSString *app_name = @(obs_data_get_string(settings, "app_name"));
|
|
|
+ NSString *name = @(obs_data_get_string(settings, "name"));
|
|
|
+ bool equal_names = [app_name isEqual:s->app_name] &&
|
|
|
+ [name isEqual:s->name];
|
|
|
+ if (s->uuid_changed && equal_names)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ NSString *uuid = @(obs_data_get_string(settings, "uuid"));
|
|
|
+ if ([uuid isEqual:s->uuid] && equal_names)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ release_settings(s);
|
|
|
+ s->app_name = [app_name retain];
|
|
|
+ s->name = [name retain];
|
|
|
+ s->uuid = [uuid retain];
|
|
|
+ s->uuid_changed = false;
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+static inline void update_from_announce(syphon_t s, NSDictionary *info)
|
|
|
+{
|
|
|
+ if (s->active)
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (!info)
|
|
|
+ return;
|
|
|
+
|
|
|
+ NSString *app_name = info[SyphonServerDescriptionAppNameKey];
|
|
|
+ NSString *name = info[SyphonServerDescriptionNameKey];
|
|
|
+ NSString *uuid = info[SyphonServerDescriptionUUIDKey];
|
|
|
+
|
|
|
+ if (![uuid isEqual:s->uuid] &&
|
|
|
+ !([app_name isEqual:s->app_name] && [name isEqual:s->name]))
|
|
|
+ return;
|
|
|
+
|
|
|
+ update_string(&s->app_name, app_name);
|
|
|
+ update_string(&s->name, name);
|
|
|
+ if (update_string(&s->uuid, uuid))
|
|
|
+ s->uuid_changed = true;
|
|
|
+
|
|
|
+ create_client(s);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void handle_announce(syphon_t s, NSNotification *note)
|
|
|
+{
|
|
|
+ if (!note)
|
|
|
+ return;
|
|
|
+
|
|
|
+ update_from_announce(s, note.object);
|
|
|
+ update_properties(s);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void update_from_retire(syphon_t s, NSDictionary *info)
|
|
|
+{
|
|
|
+ if (!info)
|
|
|
+ return;
|
|
|
+
|
|
|
+ NSString *uuid = info[SyphonServerDescriptionUUIDKey];
|
|
|
+ if (!uuid)
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (![uuid isEqual:s->uuid])
|
|
|
+ return;
|
|
|
+
|
|
|
+ s->active = false;
|
|
|
+}
|
|
|
+
|
|
|
+static inline void handle_retire(syphon_t s, NSNotification *note)
|
|
|
+{
|
|
|
+ if (!note)
|
|
|
+ return;
|
|
|
+
|
|
|
+ update_from_retire(s, note.object);
|
|
|
+ update_properties(s);
|
|
|
+}
|
|
|
+
|
|
|
+static inline gs_vertbuffer_t *create_vertbuffer()
|
|
|
+{
|
|
|
+ struct gs_vb_data *vb_data = gs_vbdata_create();
|
|
|
+ vb_data->num = 4;
|
|
|
+ vb_data->points = bzalloc(sizeof(struct vec3) * 4);
|
|
|
+ if (!vb_data->points)
|
|
|
+ return NULL;
|
|
|
+
|
|
|
+ vb_data->num_tex = 1;
|
|
|
+ vb_data->tvarray = bzalloc(sizeof(struct gs_tvertarray));
|
|
|
+ if (!vb_data->tvarray)
|
|
|
+ goto fail_tvarray;
|
|
|
+
|
|
|
+ vb_data->tvarray[0].width = 2;
|
|
|
+ vb_data->tvarray[0].array = bzalloc(sizeof(struct vec2) * 4);
|
|
|
+ if (!vb_data->tvarray[0].array)
|
|
|
+ goto fail_array;
|
|
|
+
|
|
|
+ gs_vertbuffer_t *vbuff = gs_vertexbuffer_create(vb_data, GS_DYNAMIC);
|
|
|
+ if (vbuff)
|
|
|
+ return vbuff;
|
|
|
+
|
|
|
+ bfree(vb_data->tvarray[0].array);
|
|
|
+fail_array:
|
|
|
+ bfree(vb_data->tvarray);
|
|
|
+fail_tvarray:
|
|
|
+ bfree(vb_data->points);
|
|
|
+
|
|
|
+ return NULL;
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool init_obs_graphics_objects(syphon_t s)
|
|
|
+{
|
|
|
+ struct gs_sampler_info info = {
|
|
|
+ .filter = GS_FILTER_LINEAR,
|
|
|
+ .address_u = GS_ADDRESS_CLAMP,
|
|
|
+ .address_v = GS_ADDRESS_CLAMP,
|
|
|
+ .address_w = GS_ADDRESS_CLAMP,
|
|
|
+ .max_anisotropy = 1,
|
|
|
+ };
|
|
|
+
|
|
|
+ obs_enter_graphics();
|
|
|
+ s->sampler = gs_samplerstate_create(&info);
|
|
|
+ s->vertbuffer = create_vertbuffer();
|
|
|
+ obs_leave_graphics();
|
|
|
+
|
|
|
+ s->effect = obs_get_default_rect_effect();
|
|
|
+
|
|
|
+ return s->sampler != NULL && s->vertbuffer != NULL && s->effect != NULL;
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool create_syphon_listeners(syphon_t s)
|
|
|
+{
|
|
|
+ NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
|
|
|
+ s->new_server_listener = [nc
|
|
|
+ addObserverForName:SyphonServerAnnounceNotification
|
|
|
+ object:nil
|
|
|
+ queue:[NSOperationQueue mainQueue]
|
|
|
+ usingBlock:^(NSNotification *note)
|
|
|
+ {
|
|
|
+ handle_announce(s, note);
|
|
|
+ }
|
|
|
+ ];
|
|
|
+
|
|
|
+ s->retire_listener = [nc
|
|
|
+ addObserverForName:SyphonServerRetireNotification
|
|
|
+ object:nil
|
|
|
+ queue:[NSOperationQueue mainQueue]
|
|
|
+ usingBlock:^(NSNotification *note)
|
|
|
+ {
|
|
|
+ handle_retire(s, note);
|
|
|
+ }
|
|
|
+ ];
|
|
|
+
|
|
|
+ return s->new_server_listener != nil && s->retire_listener != nil;
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool create_applications_observer(syphon_t s, NSWorkspace *ws)
|
|
|
+{
|
|
|
+ s->launch_listener = [[OBSSyphonKVObserver alloc] init];
|
|
|
+ if (!s->launch_listener)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ [ws addObserver:s->launch_listener
|
|
|
+ forKeyPath:NSStringFromSelector(@selector(runningApplications))
|
|
|
+ options:NSKeyValueObservingOptionNew
|
|
|
+ context:s];
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+static inline void load_crop(syphon_t s, obs_data_t *settings)
|
|
|
+{
|
|
|
+ s->crop = obs_data_get_bool(settings, "crop");
|
|
|
+
|
|
|
+#define LOAD_CROP(x) \
|
|
|
+ s->crop_rect.x = obs_data_get_double(settings, "crop." #x)
|
|
|
+ LOAD_CROP(origin.x);
|
|
|
+ LOAD_CROP(origin.y);
|
|
|
+ LOAD_CROP(size.width);
|
|
|
+ LOAD_CROP(size.height);
|
|
|
+#undef LOAD_CROP
|
|
|
+}
|
|
|
+
|
|
|
+static inline void syphon_destroy_internal(syphon_t s);
|
|
|
+
|
|
|
+static void *syphon_create_internal(obs_data_t *settings, obs_source_t *source)
|
|
|
+{
|
|
|
+ UNUSED_PARAMETER(source);
|
|
|
+
|
|
|
+ syphon_t s = bzalloc(sizeof(struct syphon));
|
|
|
+ if (!s)
|
|
|
+ return s;
|
|
|
+
|
|
|
+ s->source = source;
|
|
|
+
|
|
|
+ if (!init_obs_graphics_objects(s))
|
|
|
+ goto fail;
|
|
|
+
|
|
|
+ if (!load_syphon_settings(s, settings))
|
|
|
+ goto fail;
|
|
|
+
|
|
|
+ const char *inject_info = obs_data_get_string(settings, "application");
|
|
|
+ s->inject_info = obs_data_create_from_json(inject_info);
|
|
|
+ s->inject_active = obs_data_get_bool(settings, "inject");
|
|
|
+
|
|
|
+ if (!create_syphon_listeners(s))
|
|
|
+ goto fail;
|
|
|
+
|
|
|
+ NSWorkspace *ws = [NSWorkspace sharedWorkspace];
|
|
|
+ if (!create_applications_observer(s, ws))
|
|
|
+ goto fail;
|
|
|
+
|
|
|
+ if (s->inject_active)
|
|
|
+ find_and_inject_target(s, ws.runningApplications);
|
|
|
+
|
|
|
+ create_client(s);
|
|
|
+
|
|
|
+ load_crop(s, settings);
|
|
|
+
|
|
|
+ return s;
|
|
|
+
|
|
|
+fail:
|
|
|
+ syphon_destroy_internal(s);
|
|
|
+ return NULL;
|
|
|
+}
|
|
|
+
|
|
|
+static void *syphon_create(obs_data_t *settings, obs_source_t *source)
|
|
|
+{
|
|
|
+ @autoreleasepool {
|
|
|
+ return syphon_create_internal(settings, source);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static inline void stop_listener(id listener)
|
|
|
+{
|
|
|
+ if (!listener)
|
|
|
+ return;
|
|
|
+
|
|
|
+ NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
|
|
|
+ [nc removeObserver:listener];
|
|
|
+}
|
|
|
+
|
|
|
+static inline void syphon_destroy_internal(syphon_t s)
|
|
|
+{
|
|
|
+ stop_listener(s->new_server_listener);
|
|
|
+ stop_listener(s->retire_listener);
|
|
|
+
|
|
|
+ NSWorkspace *ws = [NSWorkspace sharedWorkspace];
|
|
|
+ [ws removeObserver:s->launch_listener
|
|
|
+ forKeyPath:NSStringFromSelector(@selector(runningApplications))];
|
|
|
+ [s->launch_listener release];
|
|
|
+
|
|
|
+ obs_data_release(s->inject_info);
|
|
|
+
|
|
|
+ release_settings(s);
|
|
|
+
|
|
|
+ obs_enter_graphics();
|
|
|
+ stop_client(s);
|
|
|
+
|
|
|
+ if (s->sampler)
|
|
|
+ gs_samplerstate_destroy(s->sampler);
|
|
|
+ if (s->vertbuffer)
|
|
|
+ gs_vertexbuffer_destroy(s->vertbuffer);
|
|
|
+ obs_leave_graphics();
|
|
|
+
|
|
|
+ bfree(s);
|
|
|
+}
|
|
|
+
|
|
|
+static void syphon_destroy(void *data)
|
|
|
+{
|
|
|
+ @autoreleasepool {
|
|
|
+ syphon_destroy_internal(data);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static inline NSString *get_string(obs_data_t *settings, const char *name)
|
|
|
+{
|
|
|
+ if (!settings)
|
|
|
+ return nil;
|
|
|
+
|
|
|
+ return @(obs_data_get_string(settings, name));
|
|
|
+}
|
|
|
+
|
|
|
+static inline void update_strings_from_context(syphon_t s, obs_data_t *settings,
|
|
|
+ NSString **app, NSString **name, NSString **uuid)
|
|
|
+{
|
|
|
+ if (!s || !s->uuid_changed)
|
|
|
+ return;
|
|
|
+
|
|
|
+ s->uuid_changed = false;
|
|
|
+ *app = s->app_name;
|
|
|
+ *name = s->name;
|
|
|
+ *uuid = s->uuid;
|
|
|
+
|
|
|
+ obs_data_set_string(settings, "app_name", s->app_name.UTF8String);
|
|
|
+ obs_data_set_string(settings, "name", s->name.UTF8String);
|
|
|
+ obs_data_set_string(settings, "uuid", s->uuid.UTF8String);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void add_servers(syphon_t s, obs_property_t *list,
|
|
|
+ obs_data_t *settings)
|
|
|
+{
|
|
|
+ bool found_current = settings == NULL;
|
|
|
+
|
|
|
+ NSString *set_app = get_string(settings, "app_name");
|
|
|
+ NSString *set_name = get_string(settings, "name");
|
|
|
+ NSString *set_uuid = get_string(settings, "uuid");
|
|
|
+
|
|
|
+ update_strings_from_context(s, settings,
|
|
|
+ &set_app, &set_name, &set_uuid);
|
|
|
+
|
|
|
+ obs_property_list_add_string(list, "", "");
|
|
|
+ NSArray *arr = [[SyphonServerDirectory sharedDirectory] servers];
|
|
|
+ for (NSDictionary *server in arr) {
|
|
|
+ NSString *app = server[SyphonServerDescriptionAppNameKey];
|
|
|
+ NSString *name = server[SyphonServerDescriptionNameKey];
|
|
|
+ NSString *uuid = server[SyphonServerDescriptionUUIDKey];
|
|
|
+ NSString *serv = [NSString stringWithFormat:@"[%@] %@",
|
|
|
+ app, name];
|
|
|
+
|
|
|
+ obs_property_list_add_string(list,
|
|
|
+ serv.UTF8String, uuid.UTF8String);
|
|
|
+
|
|
|
+ if (!found_current)
|
|
|
+ found_current = [uuid isEqual:set_uuid];
|
|
|
+ }
|
|
|
+
|
|
|
+ if (found_current || !set_uuid.length || !set_app.length)
|
|
|
+ return;
|
|
|
+
|
|
|
+ NSString *serv = [NSString stringWithFormat:@"[%@] %@",
|
|
|
+ set_app, set_name];
|
|
|
+ size_t idx = obs_property_list_add_string(list,
|
|
|
+ serv.UTF8String, set_uuid.UTF8String);
|
|
|
+ obs_property_list_item_disable(list, idx, true);
|
|
|
+}
|
|
|
+
|
|
|
+static bool servers_changed(obs_properties_t *props, obs_property_t *list,
|
|
|
+ obs_data_t *settings)
|
|
|
+{
|
|
|
+ @autoreleasepool {
|
|
|
+ obs_property_list_clear(list);
|
|
|
+ add_servers(obs_properties_get_param(props), list, settings);
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static inline NSString *get_inject_application_path()
|
|
|
+{
|
|
|
+ static NSString *ident = @"zakk.lol.SyphonInject";
|
|
|
+ NSWorkspace *ws = [NSWorkspace sharedWorkspace];
|
|
|
+ return [ws absolutePathForAppBundleWithIdentifier:ident];
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool is_inject_available_in_lib_dir(NSFileManager *fm, NSURL *url)
|
|
|
+{
|
|
|
+ if (!url.isFileURL)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ for (NSString *path in [fm
|
|
|
+ contentsOfDirectoryAtPath:url.path
|
|
|
+ error:nil]) {
|
|
|
+ NSURL *bundle_url = [url URLByAppendingPathComponent:path];
|
|
|
+ NSBundle *bundle = [NSBundle bundleWithURL:bundle_url];
|
|
|
+ if (!bundle)
|
|
|
+ continue;
|
|
|
+
|
|
|
+ if ([bundle.bundleIdentifier
|
|
|
+ isEqual:@"zakk.lol.SASyphonInjector"])
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool is_inject_available()
|
|
|
+{
|
|
|
+ if (get_inject_application_path())
|
|
|
+ return true;
|
|
|
+
|
|
|
+ NSFileManager *fm = [NSFileManager defaultManager];
|
|
|
+ for (NSURL *url in [fm URLsForDirectory:NSLibraryDirectory
|
|
|
+ inDomains:NSAllDomainsMask]) {
|
|
|
+ NSURL *scripting = [url
|
|
|
+ URLByAppendingPathComponent:@"ScriptingAdditions"
|
|
|
+ isDirectory:true];
|
|
|
+ if (is_inject_available_in_lib_dir(fm, scripting))
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+static inline void launch_syphon_inject_internal()
|
|
|
+{
|
|
|
+ NSString *path = get_inject_application_path();
|
|
|
+ NSWorkspace *ws = [NSWorkspace sharedWorkspace];
|
|
|
+ if (path)
|
|
|
+ [ws launchApplication:path];
|
|
|
+}
|
|
|
+
|
|
|
+static bool launch_syphon_inject(obs_properties_t *props, obs_property_t *prop,
|
|
|
+ void *data)
|
|
|
+{
|
|
|
+ UNUSED_PARAMETER(props);
|
|
|
+ UNUSED_PARAMETER(prop);
|
|
|
+ UNUSED_PARAMETER(data);
|
|
|
+
|
|
|
+ @autoreleasepool {
|
|
|
+ launch_syphon_inject_internal();
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static int describes_app(obs_data_t *info, NSRunningApplication *app)
|
|
|
+{
|
|
|
+ int score = 0;
|
|
|
+ if ([app.localizedName isEqual:get_string(info, "name")])
|
|
|
+ score += 1;
|
|
|
+
|
|
|
+ if ([app.bundleIdentifier isEqual:get_string(info, "bundle")])
|
|
|
+ score += 1;
|
|
|
+
|
|
|
+ if ([app.executableURL isEqual:get_string(info, "executable")])
|
|
|
+ score += 1;
|
|
|
+
|
|
|
+ if (score && app.processIdentifier == obs_data_get_int(info, "pid"))
|
|
|
+ score += 1;
|
|
|
+
|
|
|
+ return score;
|
|
|
+}
|
|
|
+
|
|
|
+static inline void app_to_data(NSRunningApplication *app, obs_data_t *app_data)
|
|
|
+{
|
|
|
+ obs_data_set_string(app_data, "name", app.localizedName.UTF8String);
|
|
|
+ obs_data_set_string(app_data, "bundle",
|
|
|
+ app.bundleIdentifier.UTF8String);
|
|
|
+ obs_data_set_string(app_data, "executable",
|
|
|
+ app.executableURL.fileSystemRepresentation);
|
|
|
+ obs_data_set_int(app_data, "pid", app.processIdentifier);
|
|
|
+}
|
|
|
+
|
|
|
+static void update_inject_list_internal(obs_properties_t *props,
|
|
|
+ obs_property_t *prop, obs_data_t *settings)
|
|
|
+{
|
|
|
+ UNUSED_PARAMETER(props);
|
|
|
+
|
|
|
+ const char *current_str = obs_data_get_string(settings, "application");
|
|
|
+ obs_data_t *current = obs_data_create_from_json(current_str);
|
|
|
+
|
|
|
+ bool current_found = !obs_data_has_user_value(current, "name");
|
|
|
+
|
|
|
+ obs_property_list_clear(prop);
|
|
|
+ obs_property_list_add_string(prop, "", "");
|
|
|
+
|
|
|
+ NSMapTable *candidates = [NSMapTable weakToStrongObjectsMapTable];
|
|
|
+
|
|
|
+ obs_data_t *app_data = obs_data_create();
|
|
|
+ NSWorkspace *ws = [NSWorkspace sharedWorkspace];
|
|
|
+ for (NSRunningApplication *app in ws.runningApplications) {
|
|
|
+ app_to_data(app, app_data);
|
|
|
+
|
|
|
+ obs_property_list_add_string(prop, app.localizedName.UTF8String,
|
|
|
+ obs_data_get_json(app_data));
|
|
|
+
|
|
|
+ int score = describes_app(current, app);
|
|
|
+ if (score) {
|
|
|
+ [candidates setObject:@(score) forKey:app];
|
|
|
+ current_found = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ obs_data_release(app_data);
|
|
|
+
|
|
|
+ if (!current_found) {
|
|
|
+ size_t idx = obs_property_list_add_string(prop,
|
|
|
+ obs_data_get_string(current, "name"),
|
|
|
+ current_str);
|
|
|
+ obs_property_list_item_disable(prop, idx, true);
|
|
|
+
|
|
|
+ } else if (candidates.count > 0) {
|
|
|
+ NSRunningApplication *best_match = nil;
|
|
|
+ NSNumber *best_match_score = @(0);
|
|
|
+
|
|
|
+ for (NSRunningApplication *app in candidates.keyEnumerator) {
|
|
|
+ NSNumber *score = [candidates objectForKey:app];
|
|
|
+ if ([score compare:best_match_score] ==
|
|
|
+ NSOrderedDescending) {
|
|
|
+ best_match = app;
|
|
|
+ best_match_score = score;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ app_to_data(best_match, current);
|
|
|
+ obs_data_set_string(settings, "application",
|
|
|
+ obs_data_get_json(current));
|
|
|
+ }
|
|
|
+
|
|
|
+ obs_data_release(current);
|
|
|
+}
|
|
|
+
|
|
|
+static void toggle_inject_internal(obs_properties_t *props,
|
|
|
+ obs_property_t *prop, obs_data_t *settings)
|
|
|
+{
|
|
|
+ bool enabled = obs_data_get_bool(settings, "inject");
|
|
|
+ obs_property_t *inject_list = obs_properties_get(props, "application");
|
|
|
+
|
|
|
+ bool inject_enabled = obs_property_enabled(prop);
|
|
|
+ obs_property_set_enabled(inject_list, enabled && inject_enabled);
|
|
|
+}
|
|
|
+
|
|
|
+static bool toggle_inject(obs_properties_t *props, obs_property_t *prop,
|
|
|
+ obs_data_t *settings)
|
|
|
+{
|
|
|
+ @autoreleasepool {
|
|
|
+ toggle_inject_internal(props, prop, settings);
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static bool update_inject_list(obs_properties_t *props, obs_property_t *prop,
|
|
|
+ obs_data_t *settings)
|
|
|
+{
|
|
|
+ @autoreleasepool {
|
|
|
+ update_inject_list_internal(props, prop, settings);
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static bool update_crop(obs_properties_t *props, obs_property_t *prop,
|
|
|
+ obs_data_t *settings)
|
|
|
+{
|
|
|
+ bool enabled = obs_data_get_bool(settings, "crop");
|
|
|
+
|
|
|
+#define LOAD_CROP(x) \
|
|
|
+ prop = obs_properties_get(props, "crop." #x); \
|
|
|
+ obs_property_set_enabled(prop, enabled);
|
|
|
+ LOAD_CROP(origin.x);
|
|
|
+ LOAD_CROP(origin.y);
|
|
|
+ LOAD_CROP(size.width);
|
|
|
+ LOAD_CROP(size.height);
|
|
|
+#undef LOAD_CROP
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+static void show_syphon_license_internal(void)
|
|
|
+{
|
|
|
+ char *path = obs_module_file("syphon_license.txt");
|
|
|
+ if (!path)
|
|
|
+ return;
|
|
|
+
|
|
|
+ NSWorkspace *ws = [NSWorkspace sharedWorkspace];
|
|
|
+ [ws openFile:@(path)];
|
|
|
+ bfree(path);
|
|
|
+}
|
|
|
+
|
|
|
+static bool show_syphon_license(obs_properties_t *props, obs_property_t *prop,
|
|
|
+ void *data)
|
|
|
+{
|
|
|
+ UNUSED_PARAMETER(props);
|
|
|
+ UNUSED_PARAMETER(prop);
|
|
|
+ UNUSED_PARAMETER(data);
|
|
|
+
|
|
|
+ @autoreleasepool {
|
|
|
+ show_syphon_license_internal();
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static void syphon_release(void *param)
|
|
|
+{
|
|
|
+ if (!param)
|
|
|
+ return;
|
|
|
+
|
|
|
+ obs_source_release(((syphon_t)param)->source);
|
|
|
+}
|
|
|
+
|
|
|
+static inline obs_properties_t *syphon_properties_internal(syphon_t s)
|
|
|
+{
|
|
|
+ if (s)
|
|
|
+ obs_source_addref(s->source);
|
|
|
+
|
|
|
+ obs_properties_t *props = obs_properties_create_param(s,
|
|
|
+ syphon_release);
|
|
|
+
|
|
|
+ obs_property_t *list = obs_properties_add_list(props,
|
|
|
+ "uuid", obs_module_text("Source"),
|
|
|
+ OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
|
|
|
+ obs_property_set_modified_callback(list, servers_changed);
|
|
|
+
|
|
|
+ obs_property_t *launch = obs_properties_add_button(props,
|
|
|
+ "launch inject", obs_module_text("LaunchSyphonInject"),
|
|
|
+ launch_syphon_inject);
|
|
|
+
|
|
|
+ obs_property_t *inject = obs_properties_add_bool(props,
|
|
|
+ "inject", obs_module_text("Inject"));
|
|
|
+ obs_property_set_modified_callback(inject, toggle_inject);
|
|
|
+
|
|
|
+ obs_property_t *inject_list = obs_properties_add_list(props,
|
|
|
+ "application", obs_module_text("Application"),
|
|
|
+ OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
|
|
|
+ obs_property_set_modified_callback(inject_list, update_inject_list);
|
|
|
+
|
|
|
+ if (!get_inject_application_path())
|
|
|
+ obs_property_set_enabled(launch, false);
|
|
|
+
|
|
|
+ if (!is_inject_available()) {
|
|
|
+ obs_property_set_enabled(inject, false);
|
|
|
+ obs_property_set_enabled(inject_list, false);
|
|
|
+ }
|
|
|
+
|
|
|
+ obs_property_t *crop = obs_properties_add_bool(props, "crop",
|
|
|
+ obs_module_text("Crop"));
|
|
|
+ obs_property_set_modified_callback(crop, update_crop);
|
|
|
+
|
|
|
+#define LOAD_CROP(x) \
|
|
|
+ obs_properties_add_float(props, "crop." #x, \
|
|
|
+ obs_module_text("Crop." #x), 0., 4096.f, .5f);
|
|
|
+ LOAD_CROP(origin.x);
|
|
|
+ LOAD_CROP(origin.y);
|
|
|
+ LOAD_CROP(size.width);
|
|
|
+ LOAD_CROP(size.height);
|
|
|
+#undef LOAD_CROP
|
|
|
+
|
|
|
+ obs_properties_add_button(props, "syphon license",
|
|
|
+ obs_module_text("SyphonLicense"),
|
|
|
+ show_syphon_license);
|
|
|
+
|
|
|
+ return props;
|
|
|
+}
|
|
|
+
|
|
|
+static obs_properties_t *syphon_properties(void *data)
|
|
|
+{
|
|
|
+ @autoreleasepool {
|
|
|
+ return syphon_properties_internal(data);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static inline void syphon_save_internal(syphon_t s, obs_data_t *settings)
|
|
|
+{
|
|
|
+ if (!s->uuid_changed)
|
|
|
+ return;
|
|
|
+
|
|
|
+ obs_data_set_string(settings, "app_name", s->app_name.UTF8String);
|
|
|
+ obs_data_set_string(settings, "name", s->name.UTF8String);
|
|
|
+ obs_data_set_string(settings, "uuid", s->uuid.UTF8String);
|
|
|
+}
|
|
|
+
|
|
|
+static void syphon_save(void *data, obs_data_t *settings)
|
|
|
+{
|
|
|
+ @autoreleasepool {
|
|
|
+ syphon_save_internal(data, settings);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static inline void build_sprite(struct gs_vb_data *data, float fcx, float fcy,
|
|
|
+ float start_u, float end_u, float start_v, float end_v)
|
|
|
+{
|
|
|
+ struct vec2 *tvarray = data->tvarray[0].array;
|
|
|
+
|
|
|
+ vec3_set(data->points+1, fcx, 0.0f, 0.0f);
|
|
|
+ vec3_set(data->points+2, 0.0f, fcy, 0.0f);
|
|
|
+ vec3_set(data->points+3, fcx, fcy, 0.0f);
|
|
|
+ vec2_set(tvarray, start_u, start_v);
|
|
|
+ vec2_set(tvarray+1, end_u, start_v);
|
|
|
+ vec2_set(tvarray+2, start_u, end_v);
|
|
|
+ vec2_set(tvarray+3, end_u, end_v);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void build_sprite_rect(struct gs_vb_data *data,
|
|
|
+ float origin_x, float origin_y, float end_x, float end_y)
|
|
|
+{
|
|
|
+ build_sprite(data, fabs(end_x - origin_x), fabs(end_y - origin_y),
|
|
|
+ origin_x, end_x,
|
|
|
+ origin_y, end_y);
|
|
|
+}
|
|
|
+
|
|
|
+static void syphon_video_tick(void *data, float seconds)
|
|
|
+{
|
|
|
+ UNUSED_PARAMETER(seconds);
|
|
|
+
|
|
|
+ syphon_t s = data;
|
|
|
+ if (!s->tex)
|
|
|
+ return;
|
|
|
+
|
|
|
+ static const CGRect null_crop = { { 0.f } };
|
|
|
+ const CGRect *crop = &null_crop;
|
|
|
+ if (s->crop)
|
|
|
+ crop = &s->crop_rect;
|
|
|
+
|
|
|
+ obs_enter_graphics();
|
|
|
+ build_sprite_rect(gs_vertexbuffer_get_data(s->vertbuffer),
|
|
|
+ crop->origin.x,
|
|
|
+ s->height - crop->origin.y,
|
|
|
+ s->width - crop->size.width,
|
|
|
+ crop->size.height);
|
|
|
+ obs_leave_graphics();
|
|
|
+}
|
|
|
+
|
|
|
+static void syphon_video_render(void *data, gs_effect_t *effect)
|
|
|
+{
|
|
|
+ UNUSED_PARAMETER(effect);
|
|
|
+
|
|
|
+ syphon_t s = data;
|
|
|
+
|
|
|
+ if (!s->tex)
|
|
|
+ return;
|
|
|
+
|
|
|
+ gs_vertexbuffer_flush(s->vertbuffer);
|
|
|
+ gs_load_vertexbuffer(s->vertbuffer);
|
|
|
+ gs_load_indexbuffer(NULL);
|
|
|
+ gs_load_samplerstate(s->sampler, 0);
|
|
|
+ gs_technique_t *tech = gs_effect_get_technique(s->effect, "Draw");
|
|
|
+ gs_effect_set_texture(gs_effect_get_param_by_name(s->effect, "image"),
|
|
|
+ s->tex);
|
|
|
+ gs_technique_begin(tech);
|
|
|
+ gs_technique_begin_pass(tech, 0);
|
|
|
+
|
|
|
+ gs_draw(GS_TRISTRIP, 0, 4);
|
|
|
+
|
|
|
+ gs_technique_end_pass(tech);
|
|
|
+ gs_technique_end(tech);
|
|
|
+}
|
|
|
+
|
|
|
+static uint32_t syphon_get_width(void *data)
|
|
|
+{
|
|
|
+ syphon_t s = (syphon_t)data;
|
|
|
+ if (!s->crop)
|
|
|
+ return s->width;
|
|
|
+ int32_t width = s->width
|
|
|
+ - s->crop_rect.origin.x
|
|
|
+ - s->crop_rect.size.width;
|
|
|
+ return MAX(0, width);
|
|
|
+}
|
|
|
+
|
|
|
+static uint32_t syphon_get_height(void *data)
|
|
|
+{
|
|
|
+ syphon_t s = (syphon_t)data;
|
|
|
+ if (!s->crop)
|
|
|
+ return s->height;
|
|
|
+ int32_t height = s->height
|
|
|
+ - s->crop_rect.origin.y
|
|
|
+ - s->crop_rect.size.height;
|
|
|
+ return MAX(0, height);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void inject_app(syphon_t s, NSRunningApplication *app)
|
|
|
+{
|
|
|
+ SBApplication *sbapp = nil;
|
|
|
+ if (app.processIdentifier != -1)
|
|
|
+ sbapp = [SBApplication
|
|
|
+ applicationWithProcessIdentifier:app.processIdentifier];
|
|
|
+ else if (app.bundleIdentifier)
|
|
|
+ sbapp = [SBApplication
|
|
|
+ applicationWithBundleIdentifier:app.bundleIdentifier];
|
|
|
+
|
|
|
+ if (!sbapp)
|
|
|
+ return LOG(LOG_ERROR, "Could not inject %s",
|
|
|
+ app.localizedName.UTF8String);
|
|
|
+
|
|
|
+ sbapp.timeout = 10*60;
|
|
|
+ sbapp.sendMode = kAEWaitReply;
|
|
|
+ [sbapp sendEvent:'ascr' id:'gdut' parameters:0];
|
|
|
+ sbapp.sendMode = kAENoReply;
|
|
|
+ [sbapp sendEvent:'SASI' id:'injc' parameters:0];
|
|
|
+
|
|
|
+ LOG(LOG_INFO, "Injected '%s' (%d, '%s')",
|
|
|
+ app.localizedName.UTF8String,
|
|
|
+ app.processIdentifier, app.bundleIdentifier.UTF8String);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void find_and_inject_target(syphon_t s, NSArray *arr)
|
|
|
+{
|
|
|
+ for (NSRunningApplication *app in arr) {
|
|
|
+ if (describes_app(s->inject_info, app))
|
|
|
+ inject_app(s, app);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool inject_info_equal(obs_data_t *prev, obs_data_t *new)
|
|
|
+{
|
|
|
+ if (![get_string(prev, "name")
|
|
|
+ isEqual:get_string(new, "name")])
|
|
|
+ return false;
|
|
|
+
|
|
|
+ if (![get_string(prev, "bundle")
|
|
|
+ isEqual:get_string(new, "bundle")])
|
|
|
+ return false;
|
|
|
+
|
|
|
+ if (![get_string(prev, "executable")
|
|
|
+ isEqual:get_string(new, "executable")])
|
|
|
+ return false;
|
|
|
+
|
|
|
+ if (![get_string(prev, "pid")
|
|
|
+ isEqual:get_string(new, "pid")])
|
|
|
+ return false;
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+static inline void update_inject(syphon_t s, obs_data_t *settings)
|
|
|
+{
|
|
|
+ bool try_injecting = s->inject_active;
|
|
|
+ s->inject_active = obs_data_get_bool(settings, "inject");
|
|
|
+ const char *inject_str = obs_data_get_string(settings, "application");
|
|
|
+
|
|
|
+ try_injecting = !try_injecting && s->inject_active;
|
|
|
+
|
|
|
+ obs_data_t *prev = s->inject_info;
|
|
|
+ s->inject_info = obs_data_create_from_json(inject_str);
|
|
|
+ if (!try_injecting)
|
|
|
+ try_injecting = s->inject_active &&
|
|
|
+ !inject_info_equal(prev, s->inject_info);
|
|
|
+ obs_data_release(prev);
|
|
|
+
|
|
|
+ if (!try_injecting)
|
|
|
+ return;
|
|
|
+
|
|
|
+ NSWorkspace *ws = [NSWorkspace sharedWorkspace];
|
|
|
+ find_and_inject_target(s, ws.runningApplications);
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool update_syphon(syphon_t s, obs_data_t *settings)
|
|
|
+{
|
|
|
+ NSArray *arr = [[SyphonServerDirectory sharedDirectory] servers];
|
|
|
+
|
|
|
+ if (!load_syphon_settings(s, settings))
|
|
|
+ return false;
|
|
|
+
|
|
|
+ NSDictionary *dict = find_by_uuid(arr, s->uuid);
|
|
|
+ if (dict) {
|
|
|
+ NSString *app = dict[SyphonServerDescriptionAppNameKey];
|
|
|
+ NSString *name = dict[SyphonServerDescriptionNameKey];
|
|
|
+ obs_data_set_string(settings, "app_name", app.UTF8String);
|
|
|
+ obs_data_set_string(settings, "name", name.UTF8String);
|
|
|
+ load_syphon_settings(s, settings);
|
|
|
+
|
|
|
+ } else if (!dict && !s->uuid.length) {
|
|
|
+ obs_data_set_string(settings, "app_name", "");
|
|
|
+ obs_data_set_string(settings, "name", "");
|
|
|
+ load_syphon_settings(s, settings);
|
|
|
+ }
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+static void syphon_update_internal(syphon_t s, obs_data_t *settings)
|
|
|
+{
|
|
|
+ load_crop(s, settings);
|
|
|
+ update_inject(s, settings);
|
|
|
+ if (update_syphon(s, settings))
|
|
|
+ create_client(s);
|
|
|
+}
|
|
|
+
|
|
|
+static void syphon_update(void *data, obs_data_t *settings)
|
|
|
+{
|
|
|
+ @autoreleasepool {
|
|
|
+ syphon_update_internal(data, settings);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+struct obs_source_info syphon_info = {
|
|
|
+ .id = "syphon-input",
|
|
|
+ .type = OBS_SOURCE_TYPE_INPUT,
|
|
|
+ .output_flags = OBS_SOURCE_VIDEO | OBS_SOURCE_CUSTOM_DRAW,
|
|
|
+ .get_name = syphon_get_name,
|
|
|
+ .create = syphon_create,
|
|
|
+ .destroy = syphon_destroy,
|
|
|
+ .video_render = syphon_video_render,
|
|
|
+ .video_tick = syphon_video_tick,
|
|
|
+ .get_properties = syphon_properties,
|
|
|
+ .get_width = syphon_get_width,
|
|
|
+ .get_height = syphon_get_height,
|
|
|
+ .update = syphon_update,
|
|
|
+ .save = syphon_save,
|
|
|
+};
|
|
|
+
|
Palana