jp9000
/
obs-studio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Apply clang-format to objective c code

master
Colin Edwards 2019-07-09 13:29:39 -05:00
parent 617086b040
commit ad85a9fa25
14 changed files with 1103 additions and 1133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.clang-format
View File

@ -1,6 +1,5 @@
# please use clang-format version 8 or later # please use clang-format version 8 or later
Language: Cpp
Standard: Cpp11 Standard: Cpp11
AccessModifierOffset: -8 AccessModifierOffset: -8
AlignAfterOpenBracket: Align AlignAfterOpenBracket: Align
@ -104,3 +103,5 @@ TabWidth: 8
#TypenameMacros: # requires clang-format 9 #TypenameMacros: # requires clang-format 9
# - 'DARRAY' # - 'DARRAY'
UseTab: ForContinuationAndIndentation UseTab: ForContinuationAndIndentation
---
Language: ObjC

20
UI/platform-osx.mm
View File

@ -58,7 +58,7 @@ bool InitApplicationBundle()
throw "Could not change working directory to " throw "Could not change working directory to "
"bundle path"; "bundle path";
} catch (const char* error) { } catch (const char *error) {
blog(LOG_ERROR, "InitBundle: %s", error); blog(LOG_ERROR, "InitBundle: %s", error);
return false; return false;
} }
@ -77,7 +77,7 @@ string GetDefaultVideoSavePath()
appropriateForURL:nil appropriateForURL:nil
create:true create:true
error:nil]; error:nil];
if (!url) if (!url)
return getenv("HOME"); return getenv("HOME");
@ -97,7 +97,7 @@ vector<string> GetPreferredLocales()
return locale.first; return locale.first;
if (!lang_match.size() && if (!lang_match.size() &&
locale.first.substr(0, 2) == lang.substr(0, 2)) locale.first.substr(0, 2) == lang.substr(0, 2))
lang_match = locale.first; lang_match = locale.first;
} }
@ -150,12 +150,13 @@ void EnableOSXVSync(bool enable)
if (!initialized) { if (!initialized) {
void *quartzCore = dlopen("/System/Library/Frameworks/" void *quartzCore = dlopen("/System/Library/Frameworks/"
"QuartzCore.framework/QuartzCore", RTLD_LAZY); "QuartzCore.framework/QuartzCore",
RTLD_LAZY);
if (quartzCore) { if (quartzCore) {
set_debug_options = (set_int_t)dlsym(quartzCore, set_debug_options = (set_int_t)dlsym(
"CGSSetDebugOptions"); quartzCore, "CGSSetDebugOptions");
deferred_updates = (set_int_t)dlsym(quartzCore, deferred_updates = (set_int_t)dlsym(
"CGSDeferredUpdates"); quartzCore, "CGSDeferredUpdates");
valid = set_debug_options && deferred_updates; valid = set_debug_options && deferred_updates;
} }
@ -174,5 +175,6 @@ void EnableOSXDockIcon(bool enable)
if (enable) if (enable)
[NSApp setActivationPolicy:NSApplicationActivationPolicyRegular]; [NSApp setActivationPolicy:NSApplicationActivationPolicyRegular];
else else
[NSApp setActivationPolicy:NSApplicationActivationPolicyProhibited]; [NSApp setActivationPolicy:
NSApplicationActivationPolicyProhibited];
} }

25
UI/sparkle-updater.mm
View File

@ -6,15 +6,13 @@ static inline bool equali(NSString *a, NSString *b)
return a && b && [a caseInsensitiveCompare:b] == NSOrderedSame; return a && b && [a caseInsensitiveCompare:b] == NSOrderedSame;
} }
@interface OBSSparkleUpdateDelegate : @interface OBSSparkleUpdateDelegate
NSObject<SUUpdaterDelegate, SUVersionComparison> : NSObject <SUUpdaterDelegate, SUVersionComparison> {
{
} }
@property (nonatomic) bool updateToUndeployed; @property (nonatomic) bool updateToUndeployed;
@end @end
@implementation OBSSparkleUpdateDelegate @implementation OBSSparkleUpdateDelegate {
{
} }
@synthesize updateToUndeployed; @synthesize updateToUndeployed;
@ -50,11 +48,11 @@ static inline bool equali(NSString *a, NSString *b)
item = mpkg; item = mpkg;
NSMutableDictionary *dict = [NSMutableDictionary NSMutableDictionary *dict = [NSMutableDictionary
dictionaryWithDictionary:item.propertiesDictionary]; dictionaryWithDictionary:item.propertiesDictionary];
NSString *build = [host objectForInfoDictionaryKey:@"CFBundleVersion"]; NSString *build = [host objectForInfoDictionaryKey:@"CFBundleVersion"];
NSString *url = dict[@"sparkle:releaseNotesLink"]; NSString *url = dict[@"sparkle:releaseNotesLink"];
dict[@"sparkle:releaseNotesLink"] = [url stringByAppendingFormat:@"#%@", dict[@"sparkle:releaseNotesLink"] =
build]; [url stringByAppendingFormat:@"#%@", build];
return [[SUAppcastItem alloc] initWithDictionary:dict]; return [[SUAppcastItem alloc] initWithDictionary:dict];
} }
@ -62,9 +60,9 @@ static inline bool equali(NSString *a, NSString *b)
- (SUAppcastItem *)bestValidUpdateInAppcast:(SUAppcast *)appcast - (SUAppcastItem *)bestValidUpdateInAppcast:(SUAppcast *)appcast
forUpdater:(SUUpdater *)updater forUpdater:(SUUpdater *)updater
{ {
SUAppcastItem *selected = SUAppcastItem *selected = [self
[self bestValidUpdateWithDeltasInAppcast:appcast bestValidUpdateWithDeltasInAppcast:appcast
forUpdater:updater]; forUpdater:updater];
NSBundle *host = updater.hostBundle; NSBundle *host = updater.hostBundle;
NSString *build = [host objectForInfoDictionaryKey:@"CFBundleVersion"]; NSString *build = [host objectForInfoDictionaryKey:@"CFBundleVersion"];
@ -91,8 +89,8 @@ static inline bool equali(NSString *a, NSString *b)
return NSOrderedSame; return NSOrderedSame;
} }
- (id <SUVersionComparison>) - (id<SUVersionComparison>)versionComparatorForUpdater:(SUUpdater *)__unused
versionComparatorForUpdater:(SUUpdater *)__unused updater updater
{ {
return self; return self;
} }
@ -141,4 +139,3 @@ void trigger_sparkle_update()
{ {
[updater checkForUpdates:nil]; [updater checkForUpdates:nil];
} }

119
libobs-opengl/gl-cocoa.m
View File

@ -21,10 +21,8 @@
#import <Cocoa/Cocoa.h> #import <Cocoa/Cocoa.h>
#import <AppKit/AppKit.h> #import <AppKit/AppKit.h>
//#include "util/darray.h" //#include "util/darray.h"
struct gl_windowinfo { struct gl_windowinfo {
NSView *view; NSView *view;
}; };
@ -37,9 +35,15 @@ static NSOpenGLContext *gl_context_create(void)
{ {
unsigned attrib_count = 0; unsigned attrib_count = 0;
#define ADD_ATTR(x) \ #define ADD_ATTR(x) \
{ attributes[attrib_count++] = (NSOpenGLPixelFormatAttribute)x; } { \
#define ADD_ATTR2(x, y) { ADD_ATTR(x); ADD_ATTR(y); } attributes[attrib_count++] = (NSOpenGLPixelFormatAttribute)x; \
}
#define ADD_ATTR2(x, y) \
{ \
ADD_ATTR(x); \
ADD_ATTR(y); \
}
NSOpenGLPixelFormatAttribute attributes[40]; NSOpenGLPixelFormatAttribute attributes[40];
@ -52,7 +56,7 @@ static NSOpenGLContext *gl_context_create(void)
NSOpenGLPixelFormat *pf; NSOpenGLPixelFormat *pf;
pf = [[NSOpenGLPixelFormat alloc] initWithAttributes:attributes]; pf = [[NSOpenGLPixelFormat alloc] initWithAttributes:attributes];
if(!pf) { if (!pf) {
blog(LOG_ERROR, "Failed to create pixel format"); blog(LOG_ERROR, "Failed to create pixel format");
return NULL; return NULL;
} }
@ -60,7 +64,7 @@ static NSOpenGLContext *gl_context_create(void)
NSOpenGLContext *context; NSOpenGLContext *context;
context = [[NSOpenGLContext alloc] initWithFormat:pf shareContext:nil]; context = [[NSOpenGLContext alloc] initWithFormat:pf shareContext:nil];
[pf release]; [pf release];
if(!context) { if (!context) {
blog(LOG_ERROR, "Failed to create context"); blog(LOG_ERROR, "Failed to create context");
return NULL; return NULL;
} }
@ -98,7 +102,7 @@ fail:
void gl_platform_destroy(struct gl_platform *platform) void gl_platform_destroy(struct gl_platform *platform)
{ {
if(!platform) if (!platform)
return; return;
[platform->context release]; [platform->context release];
@ -121,10 +125,10 @@ void gl_platform_cleanup_swapchain(struct gs_swap_chain *swap)
struct gl_windowinfo *gl_windowinfo_create(const struct gs_init_data *info) struct gl_windowinfo *gl_windowinfo_create(const struct gs_init_data *info)
{ {
if(!info) if (!info)
return NULL; return NULL;
if(!info->window.view) if (!info->window.view)
return NULL; return NULL;
struct gl_windowinfo *wi = bzalloc(sizeof(struct gl_windowinfo)); struct gl_windowinfo *wi = bzalloc(sizeof(struct gl_windowinfo));
@ -137,7 +141,7 @@ struct gl_windowinfo *gl_windowinfo_create(const struct gs_init_data *info)
void gl_windowinfo_destroy(struct gl_windowinfo *wi) void gl_windowinfo_destroy(struct gl_windowinfo *wi)
{ {
if(!wi) if (!wi)
return; return;
wi->view = nil; wi->view = nil;
@ -163,7 +167,7 @@ void device_leave_context(gs_device_t *device)
void device_load_swapchain(gs_device_t *device, gs_swapchain_t *swap) void device_load_swapchain(gs_device_t *device, gs_swapchain_t *swap)
{ {
if(device->cur_swap == swap) if (device->cur_swap == swap)
return; return;
device->cur_swap = swap; device->cur_swap = swap;
@ -180,14 +184,16 @@ void device_present(gs_device_t *device)
} }
void gl_getclientsize(const struct gs_swap_chain *swap, uint32_t *width, void gl_getclientsize(const struct gs_swap_chain *swap, uint32_t *width,
uint32_t *height) uint32_t *height)
{ {
if(width) *width = swap->info.cx; if (width)
if(height) *height = swap->info.cy; *width = swap->info.cx;
if (height)
*height = swap->info.cy;
} }
gs_texture_t *device_texture_create_from_iosurface(gs_device_t *device, gs_texture_t *device_texture_create_from_iosurface(gs_device_t *device,
void *iosurf) void *iosurf)
{ {
IOSurfaceRef ref = (IOSurfaceRef)iosurf; IOSurfaceRef ref = (IOSurfaceRef)iosurf;
struct gs_texture_2d *tex = bzalloc(sizeof(struct gs_texture_2d)); struct gs_texture_2d *tex = bzalloc(sizeof(struct gs_texture_2d));
@ -195,23 +201,23 @@ gs_texture_t *device_texture_create_from_iosurface(gs_device_t *device,
OSType pf = IOSurfaceGetPixelFormat(ref); OSType pf = IOSurfaceGetPixelFormat(ref);
if (pf != 'BGRA') if (pf != 'BGRA')
blog(LOG_ERROR, "Unexpected pixel format: %d (%c%c%c%c)", pf, blog(LOG_ERROR, "Unexpected pixel format: %d (%c%c%c%c)", pf,
pf >> 24, pf >> 16, pf >> 8, pf); pf >> 24, pf >> 16, pf >> 8, pf);
const enum gs_color_format color_format = GS_BGRA; const enum gs_color_format color_format = GS_BGRA;
tex->base.device = device; tex->base.device = device;
tex->base.type = GS_TEXTURE_2D; tex->base.type = GS_TEXTURE_2D;
tex->base.format = GS_BGRA; tex->base.format = GS_BGRA;
tex->base.levels = 1; tex->base.levels = 1;
tex->base.gl_format = convert_gs_format(color_format); tex->base.gl_format = convert_gs_format(color_format);
tex->base.gl_internal_format = convert_gs_internal_format(color_format); tex->base.gl_internal_format = convert_gs_internal_format(color_format);
tex->base.gl_type = GL_UNSIGNED_INT_8_8_8_8_REV; tex->base.gl_type = GL_UNSIGNED_INT_8_8_8_8_REV;
tex->base.gl_target = GL_TEXTURE_RECTANGLE; tex->base.gl_target = GL_TEXTURE_RECTANGLE;
tex->base.is_dynamic = false; tex->base.is_dynamic = false;
tex->base.is_render_target = false; tex->base.is_render_target = false;
tex->base.gen_mipmaps = false; tex->base.gen_mipmaps = false;
tex->width = IOSurfaceGetWidth(ref); tex->width = IOSurfaceGetWidth(ref);
tex->height = IOSurfaceGetHeight(ref); tex->height = IOSurfaceGetHeight(ref);
if (!gl_gen_textures(1, &tex->base.texture)) if (!gl_gen_textures(1, &tex->base.texture))
goto fail; goto fail;
@ -220,34 +226,30 @@ gs_texture_t *device_texture_create_from_iosurface(gs_device_t *device,
goto fail; goto fail;
CGLError err = CGLTexImageIOSurface2D( CGLError err = CGLTexImageIOSurface2D(
[[NSOpenGLContext currentContext] CGLContextObj], [[NSOpenGLContext currentContext] CGLContextObj],
tex->base.gl_target, tex->base.gl_target, tex->base.gl_internal_format, tex->width,
tex->base.gl_internal_format, tex->height, tex->base.gl_format, tex->base.gl_type, ref, 0);
tex->width, tex->height,
tex->base.gl_format, if (err != kCGLNoError) {
tex->base.gl_type, blog(LOG_ERROR,
ref, 0); "CGLTexImageIOSurface2D: %u, %s"
" (device_texture_create_from_iosurface)",
if(err != kCGLNoError) { err, CGLErrorString(err));
blog(LOG_ERROR, "CGLTexImageIOSurface2D: %u, %s"
" (device_texture_create_from_iosurface)",
err, CGLErrorString(err));
gl_success("CGLTexImageIOSurface2D"); gl_success("CGLTexImageIOSurface2D");
goto fail; goto fail;
} }
if (!gl_tex_param_i(tex->base.gl_target, if (!gl_tex_param_i(tex->base.gl_target, GL_TEXTURE_MAX_LEVEL, 0))
GL_TEXTURE_MAX_LEVEL, 0))
goto fail; goto fail;
if (!gl_bind_texture(tex->base.gl_target, 0)) if (!gl_bind_texture(tex->base.gl_target, 0))
goto fail; goto fail;
return (gs_texture_t*)tex; return (gs_texture_t *)tex;
fail: fail:
gs_texture_destroy((gs_texture_t*)tex); gs_texture_destroy((gs_texture_t *)tex);
blog(LOG_ERROR, "device_texture_create_from_iosurface (GL) failed"); blog(LOG_ERROR, "device_texture_create_from_iosurface (GL) failed");
return NULL; return NULL;
} }
@ -260,34 +262,31 @@ bool gs_texture_rebind_iosurface(gs_texture_t *texture, void *iosurf)
if (!iosurf) if (!iosurf)
return false; return false;
struct gs_texture_2d *tex = (struct gs_texture_2d*)texture; struct gs_texture_2d *tex = (struct gs_texture_2d *)texture;
IOSurfaceRef ref = (IOSurfaceRef)iosurf; IOSurfaceRef ref = (IOSurfaceRef)iosurf;
OSType pf = IOSurfaceGetPixelFormat(ref); OSType pf = IOSurfaceGetPixelFormat(ref);
if (pf != 'BGRA') if (pf != 'BGRA')
blog(LOG_ERROR, "Unexpected pixel format: %d (%c%c%c%c)", pf, blog(LOG_ERROR, "Unexpected pixel format: %d (%c%c%c%c)", pf,
pf >> 24, pf >> 16, pf >> 8, pf); pf >> 24, pf >> 16, pf >> 8, pf);
if (tex->width != IOSurfaceGetWidth(ref) || if (tex->width != IOSurfaceGetWidth(ref) ||
tex->height != IOSurfaceGetHeight(ref)) tex->height != IOSurfaceGetHeight(ref))
return false; return false;
if (!gl_bind_texture(tex->base.gl_target, tex->base.texture)) if (!gl_bind_texture(tex->base.gl_target, tex->base.texture))
return false; return false;
CGLError err = CGLTexImageIOSurface2D( CGLError err = CGLTexImageIOSurface2D(
[[NSOpenGLContext currentContext] CGLContextObj], [[NSOpenGLContext currentContext] CGLContextObj],
tex->base.gl_target, tex->base.gl_target, tex->base.gl_internal_format, tex->width,
tex->base.gl_internal_format, tex->height, tex->base.gl_format, tex->base.gl_type, ref, 0);
tex->width, tex->height,
tex->base.gl_format, if (err != kCGLNoError) {
tex->base.gl_type, blog(LOG_ERROR,
ref, 0); "CGLTexImageIOSurface2D: %u, %s"
" (gs_texture_rebind_iosurface)",
if(err != kCGLNoError) { err, CGLErrorString(err));
blog(LOG_ERROR, "CGLTexImageIOSurface2D: %u, %s"
" (gs_texture_rebind_iosurface)",
err, CGLErrorString(err));
gl_success("CGLTexImageIOSurface2D"); gl_success("CGLTexImageIOSurface2D");
return false; return false;

2
libobs/obs-module.h
View File

@ -129,7 +129,7 @@ MODULE_EXPORT void obs_module_free_locale(void);
void obs_module_free_locale(void) \ void obs_module_free_locale(void) \
{ \ { \
text_lookup_destroy(obs_module_lookup); \ text_lookup_destroy(obs_module_lookup); \
obs_module_lookup = NULL; \ obs_module_lookup = NULL; \
} }
/** Helper function for looking up locale if default locale handler was used */ /** Helper function for looking up locale if default locale handler was used */

113
libobs/util/platform-cocoa.m
View File

@ -54,7 +54,8 @@ static double ns_time_compute_factor()
static uint64_t ns_time_full() static uint64_t ns_time_full()
{ {
static double factor = 0.; static double factor = 0.;
if (factor == 0.) factor = ns_time_compute_factor(); if (factor == 0.)
factor = ns_time_compute_factor();
return (uint64_t)(mach_absolute_time() * factor); return (uint64_t)(mach_absolute_time() * factor);
} }
@ -72,18 +73,19 @@ static time_func ns_time_select_func()
uint64_t os_gettime_ns(void) uint64_t os_gettime_ns(void)
{ {
static time_func f = NULL; static time_func f = NULL;
if (!f) f = ns_time_select_func(); if (!f)
f = ns_time_select_func();
return f(); return f();
} }
/* gets the location [domain mask]/Library/Application Support/[name] */ /* gets the location [domain mask]/Library/Application Support/[name] */
static int os_get_path_internal(char *dst, size_t size, const char *name, static int os_get_path_internal(char *dst, size_t size, const char *name,
NSSearchPathDomainMask domainMask) NSSearchPathDomainMask domainMask)
{ {
NSArray *paths = NSSearchPathForDirectoriesInDomains( NSArray *paths = NSSearchPathForDirectoriesInDomains(
NSApplicationSupportDirectory, domainMask, YES); NSApplicationSupportDirectory, domainMask, YES);
if([paths count] == 0) if ([paths count] == 0)
bcrash("Could not get home directory (platform-cocoa)"); bcrash("Could not get home directory (platform-cocoa)");
NSString *application_support = paths[0]; NSString *application_support = paths[0];
@ -96,12 +98,12 @@ static int os_get_path_internal(char *dst, size_t size, const char *name,
} }
static char *os_get_path_ptr_internal(const char *name, static char *os_get_path_ptr_internal(const char *name,
NSSearchPathDomainMask domainMask) NSSearchPathDomainMask domainMask)
{ {
NSArray *paths = NSSearchPathForDirectoriesInDomains( NSArray *paths = NSSearchPathForDirectoriesInDomains(
NSApplicationSupportDirectory, domainMask, YES); NSApplicationSupportDirectory, domainMask, YES);
if([paths count] == 0) if ([paths count] == 0)
bcrash("Could not get home directory (platform-cocoa)"); bcrash("Could not get home directory (platform-cocoa)");
NSString *application_support = paths[0]; NSString *application_support = paths[0];
@ -109,7 +111,7 @@ static char *os_get_path_ptr_internal(const char *name,
NSUInteger len = [application_support NSUInteger len = [application_support
lengthOfBytesUsingEncoding:NSUTF8StringEncoding]; lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
char *path_ptr = bmalloc(len+1); char *path_ptr = bmalloc(len + 1);
path_ptr[len] = 0; path_ptr[len] = 0;
@ -174,47 +176,47 @@ char *os_get_executable_path_ptr(const char *name)
struct os_cpu_usage_info { struct os_cpu_usage_info {
int64_t last_cpu_time; int64_t last_cpu_time;
int64_t last_sys_time; int64_t last_sys_time;
int core_count; int core_count;
}; };
static inline void add_time_value(time_value_t *dst, time_value_t *a, static inline void add_time_value(time_value_t *dst, time_value_t *a,
time_value_t *b) time_value_t *b)
{ {
dst->microseconds = a->microseconds + b->microseconds; dst->microseconds = a->microseconds + b->microseconds;
dst->seconds = a->seconds + b->seconds; dst->seconds = a->seconds + b->seconds;
if (dst->microseconds >= 1000000) { if (dst->microseconds >= 1000000) {
dst->seconds += dst->microseconds / 1000000; dst->seconds += dst->microseconds / 1000000;
dst->microseconds %= 1000000; dst->microseconds %= 1000000;
} }
} }
static bool get_time_info(int64_t *cpu_time, int64_t *sys_time) static bool get_time_info(int64_t *cpu_time, int64_t *sys_time)
{ {
mach_port_t task = mach_task_self(); mach_port_t task = mach_task_self();
struct task_thread_times_info thread_data; struct task_thread_times_info thread_data;
struct task_basic_info_64 task_data; struct task_basic_info_64 task_data;
mach_msg_type_number_t count; mach_msg_type_number_t count;
kern_return_t kern_ret; kern_return_t kern_ret;
time_value_t cur_time; time_value_t cur_time;
*cpu_time = 0; *cpu_time = 0;
*sys_time = 0; *sys_time = 0;
count = TASK_THREAD_TIMES_INFO_COUNT; count = TASK_THREAD_TIMES_INFO_COUNT;
kern_ret = task_info(task, TASK_THREAD_TIMES_INFO, kern_ret = task_info(task, TASK_THREAD_TIMES_INFO,
(task_info_t)&thread_data, &count); (task_info_t)&thread_data, &count);
if (kern_ret != KERN_SUCCESS) if (kern_ret != KERN_SUCCESS)
return false; return false;
count = TASK_BASIC_INFO_64_COUNT; count = TASK_BASIC_INFO_64_COUNT;
kern_ret = task_info(task, TASK_BASIC_INFO_64, kern_ret = task_info(task, TASK_BASIC_INFO_64, (task_info_t)&task_data,
(task_info_t)&task_data, &count); &count);
if (kern_ret != KERN_SUCCESS) if (kern_ret != KERN_SUCCESS)
return false; return false;
add_time_value(&cur_time, &thread_data.user_time, add_time_value(&cur_time, &thread_data.user_time,
&thread_data.system_time); &thread_data.system_time);
add_time_value(&cur_time, &cur_time, &task_data.user_time); add_time_value(&cur_time, &cur_time, &task_data.user_time);
add_time_value(&cur_time, &cur_time, &task_data.system_time); add_time_value(&cur_time, &cur_time, &task_data.system_time);
@ -238,7 +240,7 @@ os_cpu_usage_info_t *os_cpu_usage_info_start(void)
double os_cpu_usage_info_query(os_cpu_usage_info_t *info) double os_cpu_usage_info_query(os_cpu_usage_info_t *info)
{ {
int64_t sys_time, cpu_time; int64_t sys_time, cpu_time;
int64_t sys_time_delta, cpu_time_delta; int64_t sys_time_delta, cpu_time_delta;
if (!info || !get_time_info(&cpu_time, &sys_time)) if (!info || !get_time_info(&cpu_time, &sys_time))
@ -254,7 +256,7 @@ double os_cpu_usage_info_query(os_cpu_usage_info_t *info)
info->last_cpu_time = cpu_time; info->last_cpu_time = cpu_time;
return (double)sys_time_delta * 100.0 / (double)cpu_time_delta / return (double)sys_time_delta * 100.0 / (double)cpu_time_delta /
(double)info->core_count; (double)info->core_count;
} }
void os_cpu_usage_info_destroy(os_cpu_usage_info_t *info) void os_cpu_usage_info_destroy(os_cpu_usage_info_t *info)
@ -272,7 +274,7 @@ os_performance_token_t *os_request_high_performance(const char *reason)
return nil; return nil;
//taken from http://stackoverflow.com/a/20100906 //taken from http://stackoverflow.com/a/20100906
id activity = [pi beginActivityWithOptions:0x00FFFFFF id activity = [pi beginActivityWithOptions:0x00FFFFFF
reason:@(reason)]; reason:@(reason)];
return CFBridgingRetain(activity); return CFBridgingRetain(activity);
@ -302,11 +304,11 @@ os_inhibit_t *os_inhibit_sleep_create(const char *reason)
{ {
struct os_inhibit_info *info = bzalloc(sizeof(*info)); struct os_inhibit_info *info = bzalloc(sizeof(*info));
if (!reason) if (!reason)
info->reason = CFStringCreateWithCString(kCFAllocatorDefault, info->reason = CFStringCreateWithCString(
reason, kCFStringEncodingUTF8); kCFAllocatorDefault, reason, kCFStringEncodingUTF8);
else else
info->reason = CFStringCreateCopy(kCFAllocatorDefault, info->reason =
CFSTR("")); CFStringCreateCopy(kCFAllocatorDefault, CFSTR(""));
return info; return info;
} }
@ -321,12 +323,11 @@ bool os_inhibit_sleep_set_active(os_inhibit_t *info, bool active)
return false; return false;
if (active) { if (active) {
IOPMAssertionDeclareUserActivity(info->reason, IOPMAssertionDeclareUserActivity(
kIOPMUserActiveLocal, &info->user_id); info->reason, kIOPMUserActiveLocal, &info->user_id);
success = IOPMAssertionCreateWithName( success = IOPMAssertionCreateWithName(
kIOPMAssertionTypeNoDisplaySleep, kIOPMAssertionTypeNoDisplaySleep, kIOPMAssertionLevelOn,
kIOPMAssertionLevelOn, info->reason, info->reason, &info->sleep_id);
&info->sleep_id);
if (success != kIOReturnSuccess) { if (success != kIOReturnSuccess) {
blog(LOG_WARNING, "Failed to disable sleep"); blog(LOG_WARNING, "Failed to disable sleep");
@ -361,16 +362,16 @@ static void os_get_cores_internal(void)
core_count_initialized = true; core_count_initialized = true;
size_t size; size_t size;
int ret; int ret;
size = sizeof(physical_cores); size = sizeof(physical_cores);
ret = sysctlbyname("machdep.cpu.core_count", &physical_cores, ret = sysctlbyname("machdep.cpu.core_count", &physical_cores, &size,
&size, NULL, 0); NULL, 0);
if (ret != 0) if (ret != 0)
return; return;
ret = sysctlbyname("machdep.cpu.thread_count", &logical_cores, ret = sysctlbyname("machdep.cpu.thread_count", &logical_cores, &size,
&size, NULL, 0); NULL, 0);
} }
int os_get_physical_cores(void) int os_get_physical_cores(void)
@ -390,8 +391,8 @@ int os_get_logical_cores(void)
static inline bool os_get_sys_memory_usage_internal(vm_statistics_t vmstat) static inline bool os_get_sys_memory_usage_internal(vm_statistics_t vmstat)
{ {
mach_msg_type_number_t out_count = HOST_VM_INFO_COUNT; mach_msg_type_number_t out_count = HOST_VM_INFO_COUNT;
if (host_statistics(mach_host_self(), HOST_VM_INFO, if (host_statistics(mach_host_self(), HOST_VM_INFO, (host_info_t)vmstat,
(host_info_t)vmstat, &out_count) != KERN_SUCCESS) &out_count) != KERN_SUCCESS)
return false; return false;
return true; return true;
} }
@ -409,8 +410,8 @@ uint64_t os_get_sys_free_size(void)
typedef task_basic_info_data_t mach_task_basic_info_data_t; typedef task_basic_info_data_t mach_task_basic_info_data_t;
#endif #endif
static inline bool os_get_proc_memory_usage_internal( static inline bool
mach_task_basic_info_data_t *taskinfo) os_get_proc_memory_usage_internal(mach_task_basic_info_data_t *taskinfo)
{ {
#ifdef MACH_TASK_BASIC_INFO #ifdef MACH_TASK_BASIC_INFO
const task_flavor_t flavor = MACH_TASK_BASIC_INFO; const task_flavor_t flavor = MACH_TASK_BASIC_INFO;
@ -419,8 +420,8 @@ static inline bool os_get_proc_memory_usage_internal(
const task_flavor_t flavor = TASK_BASIC_INFO; const task_flavor_t flavor = TASK_BASIC_INFO;
mach_msg_type_number_t out_count = TASK_BASIC_INFO_COUNT; mach_msg_type_number_t out_count = TASK_BASIC_INFO_COUNT;
#endif #endif
if (task_info(mach_task_self(), flavor, if (task_info(mach_task_self(), flavor, (task_info_t)taskinfo,
(task_info_t)taskinfo, &out_count) != KERN_SUCCESS) &out_count) != KERN_SUCCESS)
return false; return false;
return true; return true;
} }
@ -432,7 +433,7 @@ bool os_get_proc_memory_usage(os_proc_memory_usage_t *usage)
return false; return false;
usage->resident_size = taskinfo.resident_size; usage->resident_size = taskinfo.resident_size;
usage->virtual_size = taskinfo.virtual_size; usage->virtual_size = taskinfo.virtual_size;
return true; return true;
} }
@ -461,8 +462,8 @@ char *cfstr_copy_cstr(CFStringRef cfstring, CFStringEncoding cfstring_encoding)
return NULL; return NULL;
// Try the quick way to obtain the buffer // Try the quick way to obtain the buffer
const char *tmp_buffer = CFStringGetCStringPtr(cfstring, const char *tmp_buffer =
cfstring_encoding); CFStringGetCStringPtr(cfstring, cfstring_encoding);
if (tmp_buffer != NULL) if (tmp_buffer != NULL)
return bstrdup(tmp_buffer); return bstrdup(tmp_buffer);
@ -486,8 +487,8 @@ char *cfstr_copy_cstr(CFStringRef cfstring, CFStringEncoding cfstring_encoding)
} }
// Copy CFString in requested encoding to buffer // Copy CFString in requested encoding to buffer
Boolean success = Boolean success = CFStringGetCString(cfstring, buffer, max_size,
CFStringGetCString(cfstring, buffer, max_size, cfstring_encoding); cfstring_encoding);
if (!success) { if (!success) {
bfree(buffer); bfree(buffer);
@ -500,15 +501,15 @@ char *cfstr_copy_cstr(CFStringRef cfstring, CFStringEncoding cfstring_encoding)
* Returns true on success or false on failure. * Returns true on success or false on failure.
* In case of failure, the dstr capacity but not size is changed. * In case of failure, the dstr capacity but not size is changed.
*/ */
bool cfstr_copy_dstr(CFStringRef cfstring, bool cfstr_copy_dstr(CFStringRef cfstring, CFStringEncoding cfstring_encoding,
CFStringEncoding cfstring_encoding, struct dstr *str) struct dstr *str)
{ {
if (!cfstring) if (!cfstring)
return false; return false;
// Try the quick way to obtain the buffer // Try the quick way to obtain the buffer
const char *tmp_buffer = CFStringGetCStringPtr(cfstring, const char *tmp_buffer =
cfstring_encoding); CFStringGetCStringPtr(cfstring, cfstring_encoding);
if (tmp_buffer != NULL) { if (tmp_buffer != NULL) {
dstr_copy(str, tmp_buffer); dstr_copy(str, tmp_buffer);
@ -530,8 +531,8 @@ bool cfstr_copy_dstr(CFStringRef cfstring,
dstr_ensure_capacity(str, max_size); dstr_ensure_capacity(str, max_size);
// Copy CFString in requested encoding to dstr buffer // Copy CFString in requested encoding to dstr buffer
Boolean success = CFStringGetCString( Boolean success = CFStringGetCString(cfstring, str->array, max_size,
cfstring, str->array, max_size, cfstring_encoding); cfstring_encoding);
if (success) if (success)
dstr_resize(str, max_size); dstr_resize(str, max_size);

981
plugins/mac-avcapture/av-capture.mm
View File

File diff suppressed because it is too large Load Diff

212
plugins/mac-capture/mac-display-capture.m
View File

@ -120,16 +120,15 @@ static inline void update_window_params(struct display_capture *dc)
if (!requires_window(dc->crop)) if (!requires_window(dc->crop))
return; return;
NSArray *arr = (NSArray*)CGWindowListCopyWindowInfo( NSArray *arr = (NSArray *)CGWindowListCopyWindowInfo(
kCGWindowListOptionIncludingWindow, kCGWindowListOptionIncludingWindow, dc->window.window_id);
dc->window.window_id);
if (arr.count) { if (arr.count) {
NSDictionary *dict = arr[0]; NSDictionary *dict = arr[0];
NSDictionary *ref = dict[(NSString*)kCGWindowBounds]; NSDictionary *ref = dict[(NSString *)kCGWindowBounds];
CGRectMakeWithDictionaryRepresentation((CFDictionaryRef)ref, CGRectMakeWithDictionaryRepresentation((CFDictionaryRef)ref,
&dc->window_rect); &dc->window_rect);
dc->on_screen = dict[(NSString*)kCGWindowIsOnscreen] != nil; dc->on_screen = dict[(NSString *)kCGWindowIsOnscreen] != nil;
dc->window_rect = dc->window_rect =
[dc->screen convertRectToBacking:dc->window_rect]; [dc->screen convertRectToBacking:dc->window_rect];
@ -144,8 +143,10 @@ static inline void update_window_params(struct display_capture *dc)
} }
static inline void display_stream_update(struct display_capture *dc, static inline void display_stream_update(struct display_capture *dc,
CGDisplayStreamFrameStatus status, uint64_t display_time, CGDisplayStreamFrameStatus status,
IOSurfaceRef frame_surface, CGDisplayStreamUpdateRef update_ref) uint64_t display_time,
IOSurfaceRef frame_surface,
CGDisplayStreamUpdateRef update_ref)
{ {
UNUSED_PARAMETER(display_time); UNUSED_PARAMETER(display_time);
UNUSED_PARAMETER(update_ref); UNUSED_PARAMETER(update_ref);
@ -176,8 +177,7 @@ static inline void display_stream_update(struct display_capture *dc,
size_t dropped_frames = CGDisplayStreamUpdateGetDropCount(update_ref); size_t dropped_frames = CGDisplayStreamUpdateGetDropCount(update_ref);
if (dropped_frames > 0) if (dropped_frames > 0)
blog(LOG_INFO, "%s: Dropped %zu frames", blog(LOG_INFO, "%s: Dropped %zu frames",
obs_source_get_name(dc->source), obs_source_get_name(dc->source), dropped_frames);
dropped_frames);
} }
static bool init_display_stream(struct display_capture *dc) static bool init_display_stream(struct display_capture *dc)
@ -192,38 +192,34 @@ static bool init_display_stream(struct display_capture *dc)
NSNumber *screen_num = dc->screen.deviceDescription[@"NSScreenNumber"]; NSNumber *screen_num = dc->screen.deviceDescription[@"NSScreenNumber"];
CGDirectDisplayID disp_id = (CGDirectDisplayID)screen_num.pointerValue; CGDirectDisplayID disp_id = (CGDirectDisplayID)screen_num.pointerValue;
NSDictionary *rect_dict = CFBridgingRelease( NSDictionary *rect_dict =
CGRectCreateDictionaryRepresentation( CFBridgingRelease(CGRectCreateDictionaryRepresentation(
CGRectMake(0, 0, CGRectMake(0, 0, dc->screen.frame.size.width,
dc->screen.frame.size.width, dc->screen.frame.size.height)));
dc->screen.frame.size.height)));
CFBooleanRef show_cursor_cf = CFBooleanRef show_cursor_cf = dc->hide_cursor ? kCFBooleanFalse
dc->hide_cursor ? kCFBooleanFalse : kCFBooleanTrue; : kCFBooleanTrue;
NSDictionary *dict = @{ NSDictionary *dict = @{
(__bridge NSString*)kCGDisplayStreamSourceRect: rect_dict, (__bridge NSString *)kCGDisplayStreamSourceRect: rect_dict,
(__bridge NSString*)kCGDisplayStreamQueueDepth: @5, (__bridge NSString *)kCGDisplayStreamQueueDepth: @5,
(__bridge NSString*)kCGDisplayStreamShowCursor: (__bridge NSString *)
(id)show_cursor_cf, kCGDisplayStreamShowCursor: (id)show_cursor_cf,
}; };
os_event_init(&dc->disp_finished, OS_EVENT_TYPE_MANUAL); os_event_init(&dc->disp_finished, OS_EVENT_TYPE_MANUAL);
const CGSize *size = &dc->frame.size; const CGSize *size = &dc->frame.size;
dc->disp = CGDisplayStreamCreateWithDispatchQueue(disp_id, dc->disp = CGDisplayStreamCreateWithDispatchQueue(
size->width, size->height, 'BGRA', disp_id, size->width, size->height, 'BGRA',
(__bridge CFDictionaryRef)dict, (__bridge CFDictionaryRef)dict,
dispatch_queue_create(NULL, NULL), dispatch_queue_create(NULL, NULL),
^(CGDisplayStreamFrameStatus status, ^(CGDisplayStreamFrameStatus status, uint64_t displayTime,
uint64_t displayTime, IOSurfaceRef frameSurface,
IOSurfaceRef frameSurface, CGDisplayStreamUpdateRef updateRef) {
CGDisplayStreamUpdateRef updateRef) display_stream_update(dc, status, displayTime,
{ frameSurface, updateRef);
display_stream_update(dc, status, displayTime, });
frameSurface, updateRef);
}
);
return !CGDisplayStreamStart(dc->disp); return !CGDisplayStreamStart(dc->disp);
} }
@ -252,8 +248,7 @@ bool init_vertbuf(struct display_capture *dc)
void load_crop(struct display_capture *dc, obs_data_t *settings); void load_crop(struct display_capture *dc, obs_data_t *settings);
static void *display_capture_create(obs_data_t *settings, static void *display_capture_create(obs_data_t *settings, obs_source_t *source)
obs_source_t *source)
{ {
UNUSED_PARAMETER(source); UNUSED_PARAMETER(source);
UNUSED_PARAMETER(settings); UNUSED_PARAMETER(settings);
@ -303,25 +298,24 @@ fail:
} }
static void build_sprite(struct gs_vb_data *data, float fcx, float fcy, static void build_sprite(struct gs_vb_data *data, float fcx, float fcy,
float start_u, float end_u, float start_v, float end_v) float start_u, float end_u, float start_v, float end_v)
{ {
struct vec2 *tvarray = data->tvarray[0].array; struct vec2 *tvarray = data->tvarray[0].array;
vec3_set(data->points+1, fcx, 0.0f, 0.0f); vec3_set(data->points + 1, fcx, 0.0f, 0.0f);
vec3_set(data->points+2, 0.0f, fcy, 0.0f); vec3_set(data->points + 2, 0.0f, fcy, 0.0f);
vec3_set(data->points+3, fcx, fcy, 0.0f); vec3_set(data->points + 3, fcx, fcy, 0.0f);
vec2_set(tvarray, start_u, start_v); vec2_set(tvarray, start_u, start_v);
vec2_set(tvarray+1, end_u, start_v); vec2_set(tvarray + 1, end_u, start_v);
vec2_set(tvarray+2, start_u, end_v); vec2_set(tvarray + 2, start_u, end_v);
vec2_set(tvarray+3, end_u, end_v); vec2_set(tvarray + 3, end_u, end_v);
} }
static inline void build_sprite_rect(struct gs_vb_data *data, static inline void build_sprite_rect(struct gs_vb_data *data, float origin_x,
float origin_x, float origin_y, float end_x, float end_y) float origin_y, float end_x, float end_y)
{ {
build_sprite(data, fabs(end_x - origin_x), fabs(end_y - origin_y), build_sprite(data, fabs(end_x - origin_x), fabs(end_y - origin_y),
origin_x, end_x, origin_x, end_x, origin_y, end_y);
origin_y, end_y);
} }
static void display_capture_video_tick(void *data, float seconds) static void display_capture_video_tick(void *data, float seconds)
@ -348,8 +342,8 @@ static void display_capture_video_tick(void *data, float seconds)
if (requires_window(dc->crop) && !dc->on_screen) if (requires_window(dc->crop) && !dc->on_screen)
goto cleanup; goto cleanup;
CGPoint origin = { 0.f }; CGPoint origin = {0.f};
CGPoint end = { 0.f }; CGPoint end = {0.f};
switch (dc->crop) { switch (dc->crop) {
float x, y; float x, y;
@ -379,10 +373,9 @@ static void display_capture_video_tick(void *data, float seconds)
break; break;
} }
obs_enter_graphics(); obs_enter_graphics();
build_sprite_rect(gs_vertexbuffer_get_data(dc->vertbuf), build_sprite_rect(gs_vertexbuffer_get_data(dc->vertbuf), origin.x,
origin.x, origin.y, end.x, end.y); origin.y, end.x, end.y);
if (dc->tex) if (dc->tex)
gs_texture_rebind_iosurface(dc->tex, dc->prev); gs_texture_rebind_iosurface(dc->tex, dc->prev);
@ -412,7 +405,7 @@ static void display_capture_video_render(void *data, gs_effect_t *effect)
gs_load_samplerstate(dc->sampler, 0); gs_load_samplerstate(dc->sampler, 0);
gs_technique_t *tech = gs_effect_get_technique(dc->effect, "Draw"); gs_technique_t *tech = gs_effect_get_technique(dc->effect, "Draw");
gs_effect_set_texture(gs_effect_get_param_by_name(dc->effect, "image"), gs_effect_set_texture(gs_effect_get_param_by_name(dc->effect, "image"),
dc->tex); dc->tex);
gs_technique_begin(tech); gs_technique_begin(tech);
gs_technique_begin_pass(tech, 0); gs_technique_begin_pass(tech, 0);
@ -428,9 +421,9 @@ static const char *display_capture_getname(void *unused)
return obs_module_text("DisplayCapture"); return obs_module_text("DisplayCapture");
} }
#define CROPPED_LENGTH(rect, origin_, length) \ #define CROPPED_LENGTH(rect, origin_, length) \
fabs((rect ## .size. ## length - dc->crop_rect.size. ## length) - \ fabs((rect##.size.##length - dc->crop_rect.size.##length) - \
(rect ## .origin. ## origin_ + dc->crop_rect.origin. ## origin_)) (rect##.origin.##origin_ + dc->crop_rect.origin.##origin_))
static uint32_t display_capture_getwidth(void *data) static uint32_t display_capture_getwidth(void *data)
{ {
@ -502,20 +495,20 @@ void load_crop(struct display_capture *dc, obs_data_t *settings)
#define CROP_VAR_NAME(var, mode) (mode "." #var) #define CROP_VAR_NAME(var, mode) (mode "." #var)
#define LOAD_CROP_VAR(var, mode) \ #define LOAD_CROP_VAR(var, mode) \
dc->crop_rect.var = obs_data_get_double(settings, \ dc->crop_rect.var = \
CROP_VAR_NAME(var, mode)); obs_data_get_double(settings, CROP_VAR_NAME(var, mode));
switch (dc->crop) { switch (dc->crop) {
case CROP_MANUAL: case CROP_MANUAL:
LOAD_CROP_VAR(origin.x, "manual"); LOAD_CROP_VAR(origin.x, "manual");
LOAD_CROP_VAR(origin.y, "manual"); LOAD_CROP_VAR(origin.y, "manual");
LOAD_CROP_VAR(size.width, "manual"); LOAD_CROP_VAR(size.width, "manual");
LOAD_CROP_VAR(size.height, "manual"); LOAD_CROP_VAR(size.height, "manual");
break; break;
case CROP_TO_WINDOW_AND_MANUAL: case CROP_TO_WINDOW_AND_MANUAL:
LOAD_CROP_VAR(origin.x, "window"); LOAD_CROP_VAR(origin.x, "window");
LOAD_CROP_VAR(origin.y, "window"); LOAD_CROP_VAR(origin.y, "window");
LOAD_CROP_VAR(size.width, "window"); LOAD_CROP_VAR(size.width, "window");
LOAD_CROP_VAR(size.height, "window"); LOAD_CROP_VAR(size.height, "window");
break; break;
@ -552,7 +545,7 @@ static void display_capture_update(void *data, obs_data_t *settings)
} }
static bool switch_crop_mode(obs_properties_t *props, obs_property_t *p, static bool switch_crop_mode(obs_properties_t *props, obs_property_t *p,
obs_data_t *settings) obs_data_t *settings)
{ {
UNUSED_PARAMETER(p); UNUSED_PARAMETER(p);
@ -561,20 +554,20 @@ static bool switch_crop_mode(obs_properties_t *props, obs_property_t *p,
const char *name; const char *name;
bool visible; bool visible;
#define LOAD_CROP_VAR(var, mode) \ #define LOAD_CROP_VAR(var, mode) \
name = CROP_VAR_NAME(var, mode); \ name = CROP_VAR_NAME(var, mode); \
obs_property_set_visible(obs_properties_get(props, name), visible); obs_property_set_visible(obs_properties_get(props, name), visible);
visible = crop == CROP_MANUAL; visible = crop == CROP_MANUAL;
LOAD_CROP_VAR(origin.x, "manual"); LOAD_CROP_VAR(origin.x, "manual");
LOAD_CROP_VAR(origin.y, "manual"); LOAD_CROP_VAR(origin.y, "manual");
LOAD_CROP_VAR(size.width, "manual"); LOAD_CROP_VAR(size.width, "manual");
LOAD_CROP_VAR(size.height, "manual"); LOAD_CROP_VAR(size.height, "manual");
visible = crop == CROP_TO_WINDOW_AND_MANUAL; visible = crop == CROP_TO_WINDOW_AND_MANUAL;
LOAD_CROP_VAR(origin.x, "window"); LOAD_CROP_VAR(origin.x, "window");
LOAD_CROP_VAR(origin.y, "window"); LOAD_CROP_VAR(origin.y, "window");
LOAD_CROP_VAR(size.width, "window"); LOAD_CROP_VAR(size.width, "window");
LOAD_CROP_VAR(size.height, "window"); LOAD_CROP_VAR(size.height, "window");
#undef LOAD_CROP_VAR #undef LOAD_CROP_VAR
@ -582,15 +575,12 @@ static bool switch_crop_mode(obs_properties_t *props, obs_property_t *p,
return true; return true;
} }
static const char *crop_names[] = { static const char *crop_names[] = {"CropMode.None", "CropMode.Manual",
"CropMode.None", "CropMode.ToWindow",
"CropMode.Manual", "CropMode.ToWindowAndManual"};
"CropMode.ToWindow",
"CropMode.ToWindowAndManual"
};
#ifndef COUNTOF #ifndef COUNTOF
#define COUNTOF(x) (sizeof(x)/sizeof(x[0])) #define COUNTOF(x) (sizeof(x) / sizeof(x[0]))
#endif #endif
static obs_properties_t *display_capture_properties(void *unused) static obs_properties_t *display_capture_properties(void *unused)
{ {
@ -598,9 +588,9 @@ static obs_properties_t *display_capture_properties(void *unused)
obs_properties_t *props = obs_properties_create(); obs_properties_t *props = obs_properties_create();
obs_property_t *list = obs_properties_add_list(props, obs_property_t *list = obs_properties_add_list(
"display", obs_module_text("DisplayCapture.Display"), props, "display", obs_module_text("DisplayCapture.Display"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT); OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
for (unsigned i = 0; i < [NSScreen screens].count; i++) { for (unsigned i = 0; i < [NSScreen screens].count; i++) {
char buf[10]; char buf[10];
@ -609,11 +599,11 @@ static obs_properties_t *display_capture_properties(void *unused)
} }
obs_properties_add_bool(props, "show_cursor", obs_properties_add_bool(props, "show_cursor",
obs_module_text("DisplayCapture.ShowCursor")); obs_module_text("DisplayCapture.ShowCursor"));
obs_property_t *crop = obs_properties_add_list(props, "crop_mode", obs_property_t *crop = obs_properties_add_list(
obs_module_text("CropMode"), props, "crop_mode", obs_module_text("CropMode"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT); OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
obs_property_set_modified_callback(crop, switch_crop_mode); obs_property_set_modified_callback(crop, switch_crop_mode);
for (unsigned i = 0; i < COUNTOF(crop_names); i++) { for (unsigned i = 0; i < COUNTOF(crop_names); i++) {
@ -627,22 +617,22 @@ static obs_properties_t *display_capture_properties(void *unused)
obs_property_t *p; obs_property_t *p;
const char *name; const char *name;
float min; float min;
#define LOAD_CROP_VAR(var, mode) \ #define LOAD_CROP_VAR(var, mode) \
name = CROP_VAR_NAME(var, mode); \ name = CROP_VAR_NAME(var, mode); \
p = obs_properties_add_float(props, name, \ p = obs_properties_add_float( \
obs_module_text("Crop."#var), min, 4096.f, .5f); \ props, name, obs_module_text("Crop." #var), min, 4096.f, .5f); \
obs_property_set_visible(p, false); obs_property_set_visible(p, false);
min = 0.f; min = 0.f;
LOAD_CROP_VAR(origin.x, "manual"); LOAD_CROP_VAR(origin.x, "manual");
LOAD_CROP_VAR(origin.y, "manual"); LOAD_CROP_VAR(origin.y, "manual");
LOAD_CROP_VAR(size.width, "manual"); LOAD_CROP_VAR(size.width, "manual");
LOAD_CROP_VAR(size.height, "manual"); LOAD_CROP_VAR(size.height, "manual");
min = -4096.f; min = -4096.f;
LOAD_CROP_VAR(origin.x, "window"); LOAD_CROP_VAR(origin.x, "window");
LOAD_CROP_VAR(origin.y, "window"); LOAD_CROP_VAR(origin.y, "window");
LOAD_CROP_VAR(size.width, "window"); LOAD_CROP_VAR(size.width, "window");
LOAD_CROP_VAR(size.height, "window"); LOAD_CROP_VAR(size.height, "window");
#undef LOAD_CROP_VAR #undef LOAD_CROP_VAR
@ -650,22 +640,22 @@ static obs_properties_t *display_capture_properties(void *unused)
} }
struct obs_source_info display_capture_info = { struct obs_source_info display_capture_info = {
.id = "display_capture", .id = "display_capture",
.type = OBS_SOURCE_TYPE_INPUT, .type = OBS_SOURCE_TYPE_INPUT,
.get_name = display_capture_getname, .get_name = display_capture_getname,
.create = display_capture_create, .create = display_capture_create,
.destroy = display_capture_destroy, .destroy = display_capture_destroy,
.output_flags = OBS_SOURCE_VIDEO | OBS_SOURCE_CUSTOM_DRAW | .output_flags = OBS_SOURCE_VIDEO | OBS_SOURCE_CUSTOM_DRAW |
OBS_SOURCE_DO_NOT_DUPLICATE, OBS_SOURCE_DO_NOT_DUPLICATE,
.video_tick = display_capture_video_tick, .video_tick = display_capture_video_tick,
.video_render = display_capture_video_render, .video_render = display_capture_video_render,
.get_width = display_capture_getwidth, .get_width = display_capture_getwidth,
.get_height = display_capture_getheight, .get_height = display_capture_getheight,
.get_defaults = display_capture_defaults, .get_defaults = display_capture_defaults,
.get_properties = display_capture_properties, .get_properties = display_capture_properties,
.update = display_capture_update, .update = display_capture_update,
}; };

89
plugins/mac-capture/mac-window-capture.m
View File

@ -21,61 +21,59 @@ struct window_capture {
DARRAY(uint8_t) buffer; DARRAY(uint8_t) buffer;
pthread_t capture_thread; pthread_t capture_thread;
os_event_t *capture_event; os_event_t *capture_event;
os_event_t *stop_event; os_event_t *stop_event;
}; };
static CGImageRef get_image(struct window_capture *wc) static CGImageRef get_image(struct window_capture *wc)
{ {
NSArray *arr = (NSArray*)CGWindowListCreate( NSArray *arr = (NSArray *)CGWindowListCreate(
kCGWindowListOptionIncludingWindow, kCGWindowListOptionIncludingWindow, wc->window.window_id);
wc->window.window_id);
[arr autorelease]; [arr autorelease];
if (arr.count) if (arr.count)
return CGWindowListCreateImage(CGRectNull, return CGWindowListCreateImage(
kCGWindowListOptionIncludingWindow, CGRectNull, kCGWindowListOptionIncludingWindow,
wc->window.window_id, wc->image_option); wc->window.window_id, wc->image_option);
if (!find_window(&wc->window, NULL, false)) if (!find_window(&wc->window, NULL, false))
return NULL; return NULL;
return CGWindowListCreateImage(CGRectNull, return CGWindowListCreateImage(CGRectNull,
kCGWindowListOptionIncludingWindow, kCGWindowListOptionIncludingWindow,
wc->window.window_id, wc->image_option); wc->window.window_id, wc->image_option);
} }
static inline void capture_frame(struct window_capture *wc) static inline void capture_frame(struct window_capture *wc)
{ {
uint64_t ts = os_gettime_ns(); uint64_t ts = os_gettime_ns();
CGImageRef img = get_image(wc); CGImageRef img = get_image(wc);
if (!img) if (!img)
return; return;
size_t width = CGImageGetWidth(img); size_t width = CGImageGetWidth(img);
size_t height = CGImageGetHeight(img); size_t height = CGImageGetHeight(img);
CGRect rect = {{0, 0}, {width, height}}; CGRect rect = {{0, 0}, {width, height}};
da_reserve(wc->buffer, width * height * 4); da_reserve(wc->buffer, width * height * 4);
uint8_t *data = wc->buffer.array; uint8_t *data = wc->buffer.array;
CGContextRef cg_context = CGBitmapContextCreate(data, width, height, CGContextRef cg_context = CGBitmapContextCreate(
8, width * 4, wc->color_space, data, width, height, 8, width * 4, wc->color_space,
kCGBitmapByteOrder32Host | kCGBitmapByteOrder32Host | kCGImageAlphaPremultipliedFirst);
kCGImageAlphaPremultipliedFirst);
CGContextSetBlendMode(cg_context, kCGBlendModeCopy); CGContextSetBlendMode(cg_context, kCGBlendModeCopy);
CGContextDrawImage(cg_context, rect, img); CGContextDrawImage(cg_context, rect, img);
CGContextRelease(cg_context); CGContextRelease(cg_context);
CGImageRelease(img); CGImageRelease(img);
struct obs_source_frame frame = { struct obs_source_frame frame = {
.format = VIDEO_FORMAT_BGRA, .format = VIDEO_FORMAT_BGRA,
.width = width, .width = width,
.height = height, .height = height,
.data[0] = data, .data[0] = data,
.linesize[0] = width * 4, .linesize[0] = width * 4,
.timestamp = ts, .timestamp = ts,
}; };
obs_source_output_video(wc->source, &frame); obs_source_output_video(wc->source, &frame);
@ -99,7 +97,7 @@ static void *capture_thread(void *data)
} }
static inline void *window_capture_create_internal(obs_data_t *settings, static inline void *window_capture_create_internal(obs_data_t *settings,
obs_source_t *source) obs_source_t *source)
{ {
struct window_capture *wc = bzalloc(sizeof(struct window_capture)); struct window_capture *wc = bzalloc(sizeof(struct window_capture));
@ -111,8 +109,9 @@ static inline void *window_capture_create_internal(obs_data_t *settings,
init_window(&wc->window, settings); init_window(&wc->window, settings);
wc->image_option = obs_data_get_bool(settings, "show_shadow") ? wc->image_option = obs_data_get_bool(settings, "show_shadow")
kCGWindowImageDefault : kCGWindowImageBoundsIgnoreFraming; ? kCGWindowImageDefault
: kCGWindowImageBoundsIgnoreFraming;
os_event_init(&wc->capture_event, OS_EVENT_TYPE_AUTO); os_event_init(&wc->capture_event, OS_EVENT_TYPE_AUTO);
os_event_init(&wc->stop_event, OS_EVENT_TYPE_MANUAL); os_event_init(&wc->stop_event, OS_EVENT_TYPE_MANUAL);
@ -135,7 +134,7 @@ static void window_capture_destroy(void *data)
os_event_signal(cap->stop_event); os_event_signal(cap->stop_event);
os_event_signal(cap->capture_event); os_event_signal(cap->capture_event);
pthread_join(cap->capture_thread, NULL); pthread_join(cap->capture_thread, NULL);
CGColorSpaceRelease(cap->color_space); CGColorSpaceRelease(cap->color_space);
@ -165,26 +164,28 @@ static obs_properties_t *window_capture_properties(void *unused)
add_window_properties(props); add_window_properties(props);
obs_properties_add_bool(props, "show_shadow", obs_properties_add_bool(props, "show_shadow",
obs_module_text("WindowCapture.ShowShadow")); obs_module_text("WindowCapture.ShowShadow"));
return props; return props;
} }
static inline void window_capture_update_internal(struct window_capture *wc, static inline void window_capture_update_internal(struct window_capture *wc,
obs_data_t *settings) obs_data_t *settings)
{ {
wc->image_option = obs_data_get_bool(settings, "show_shadow") ? wc->image_option = obs_data_get_bool(settings, "show_shadow")
kCGWindowImageDefault : kCGWindowImageBoundsIgnoreFraming; ? kCGWindowImageDefault
: kCGWindowImageBoundsIgnoreFraming;
update_window(&wc->window, settings); update_window(&wc->window, settings);
if (wc->window.window_name.length) { if (wc->window.window_name.length) {
blog(LOG_INFO, "[window-capture: '%s'] update settings:\n" blog(LOG_INFO,
"\twindow: %s\n" "[window-capture: '%s'] update settings:\n"
"\towner: %s", "\twindow: %s\n"
obs_source_get_name(wc->source), "\towner: %s",
[wc->window.window_name UTF8String], obs_source_get_name(wc->source),
[wc->window.owner_name UTF8String]); [wc->window.window_name UTF8String],
[wc->window.owner_name UTF8String]);
} }
} }
@ -202,7 +203,7 @@ static const char *window_capture_getname(void *unused)
} }
static inline void window_capture_tick_internal(struct window_capture *wc, static inline void window_capture_tick_internal(struct window_capture *wc,
float seconds) float seconds)
{ {
UNUSED_PARAMETER(seconds); UNUSED_PARAMETER(seconds);
os_event_signal(wc->capture_event); os_event_signal(wc->capture_event);
@ -221,17 +222,17 @@ static void window_capture_tick(void *data, float seconds)
} }
struct obs_source_info window_capture_info = { struct obs_source_info window_capture_info = {
.id = "window_capture", .id = "window_capture",
.type = OBS_SOURCE_TYPE_INPUT, .type = OBS_SOURCE_TYPE_INPUT,
.get_name = window_capture_getname, .get_name = window_capture_getname,
.create = window_capture_create, .create = window_capture_create,
.destroy = window_capture_destroy, .destroy = window_capture_destroy,
.output_flags = OBS_SOURCE_ASYNC_VIDEO, .output_flags = OBS_SOURCE_ASYNC_VIDEO,
.video_tick = window_capture_tick, .video_tick = window_capture_tick,
.get_defaults = window_capture_defaults, .get_defaults = window_capture_defaults,
.get_properties = window_capture_properties, .get_properties = window_capture_properties,
.update = window_capture_update, .update = window_capture_update,
}; };

6
plugins/mac-capture/window-utils.h
View File

@ -5,11 +5,11 @@
#include <obs-module.h> #include <obs-module.h>
struct cocoa_window { struct cocoa_window {
CGWindowID window_id; CGWindowID window_id;
pthread_mutex_t name_lock; pthread_mutex_t name_lock;
NSString *owner_name; NSString *owner_name;
NSString *window_name; NSString *window_name;
uint64_t next_search_time; uint64_t next_search_time;
}; };

94
plugins/mac-capture/window-utils.m
View File

@ -2,13 +2,12 @@
#include <util/platform.h> #include <util/platform.h>
#define WINDOW_NAME ((NSString*)kCGWindowName) #define WINDOW_NAME ((NSString *)kCGWindowName)
#define WINDOW_NUMBER ((NSString*)kCGWindowNumber) #define WINDOW_NUMBER ((NSString *)kCGWindowNumber)
#define OWNER_NAME ((NSString*)kCGWindowOwnerName) #define OWNER_NAME ((NSString *)kCGWindowOwnerName)
#define OWNER_PID ((NSNumber*)kCGWindowOwnerPID) #define OWNER_PID ((NSNumber *)kCGWindowOwnerPID)
static NSComparator win_info_cmp = ^(NSDictionary *o1, NSDictionary *o2) static NSComparator win_info_cmp = ^(NSDictionary *o1, NSDictionary *o2) {
{
NSComparisonResult res = [o1[OWNER_NAME] compare:o2[OWNER_NAME]]; NSComparisonResult res = [o1[OWNER_NAME] compare:o2[OWNER_NAME]];
if (res != NSOrderedSame) if (res != NSOrderedSame)
return res; return res;
@ -26,9 +25,8 @@ static NSComparator win_info_cmp = ^(NSDictionary *o1, NSDictionary *o2)
NSArray *enumerate_windows(void) NSArray *enumerate_windows(void)
{ {
NSArray *arr = (NSArray*)CGWindowListCopyWindowInfo( NSArray *arr = (NSArray *)CGWindowListCopyWindowInfo(
kCGWindowListOptionOnScreenOnly, kCGWindowListOptionOnScreenOnly, kCGNullWindowID);
kCGNullWindowID);
[arr autorelease]; [arr autorelease];
@ -60,8 +58,8 @@ bool find_window(cocoa_window_t cw, obs_data_t *settings, bool force)
pthread_mutex_unlock(&cw->name_lock); pthread_mutex_unlock(&cw->name_lock);
NSNumber *window_id = (NSNumber*)dict[WINDOW_NUMBER]; NSNumber *window_id = (NSNumber *)dict[WINDOW_NUMBER];
cw->window_id = window_id.intValue; cw->window_id = window_id.intValue;
obs_data_set_int(settings, "window", cw->window_id); obs_data_set_int(settings, "window", cw->window_id);
return true; return true;
@ -76,9 +74,9 @@ void init_window(cocoa_window_t cw, obs_data_t *settings)
{ {
pthread_mutex_init(&cw->name_lock, NULL); pthread_mutex_init(&cw->name_lock, NULL);
cw->owner_name = @(obs_data_get_string(settings, "owner_name")); cw->owner_name = @(obs_data_get_string(settings, "owner_name"));
cw->window_name = @(obs_data_get_string(settings, "window_name")); cw->window_name = @(obs_data_get_string(settings, "window_name"));
[cw->owner_name retain]; [cw->owner_name retain];
[cw->window_name retain]; [cw->window_name retain];
find_window(cw, settings, true); find_window(cw, settings, true);
} }
@ -86,22 +84,22 @@ void init_window(cocoa_window_t cw, obs_data_t *settings)
void destroy_window(cocoa_window_t cw) void destroy_window(cocoa_window_t cw)
{ {
pthread_mutex_destroy(&cw->name_lock); pthread_mutex_destroy(&cw->name_lock);
[cw->owner_name release]; [cw->owner_name release];
[cw->window_name release]; [cw->window_name release];
} }
void update_window(cocoa_window_t cw, obs_data_t *settings) void update_window(cocoa_window_t cw, obs_data_t *settings)
{ {
pthread_mutex_lock(&cw->name_lock); pthread_mutex_lock(&cw->name_lock);
[cw->owner_name release]; [cw->owner_name release];
[cw->window_name release]; [cw->window_name release];
cw->owner_name = @(obs_data_get_string(settings, "owner_name")); cw->owner_name = @(obs_data_get_string(settings, "owner_name"));
cw->window_name = @(obs_data_get_string(settings, "window_name")); cw->window_name = @(obs_data_get_string(settings, "window_name"));
[cw->owner_name retain]; [cw->owner_name retain];
[cw->window_name retain]; [cw->window_name retain];
pthread_mutex_unlock(&cw->name_lock); pthread_mutex_unlock(&cw->name_lock);
cw->window_id = obs_data_get_int(settings, "window"); cw->window_id = obs_data_get_int(settings, "window");
} }
static inline const char *make_name(NSString *owner, NSString *name) static inline const char *make_name(NSString *owner, NSString *name)
@ -116,7 +114,7 @@ static inline const char *make_name(NSString *owner, NSString *name)
static inline NSDictionary *find_window_dict(NSArray *arr, int window_id) static inline NSDictionary *find_window_dict(NSArray *arr, int window_id)
{ {
for (NSDictionary *dict in arr) { for (NSDictionary *dict in arr) {
NSNumber *wid = (NSNumber*)dict[WINDOW_NUMBER]; NSNumber *wid = (NSNumber *)dict[WINDOW_NUMBER];
if (wid.intValue == window_id) if (wid.intValue == window_id)
return dict; return dict;
} }
@ -125,12 +123,11 @@ static inline NSDictionary *find_window_dict(NSArray *arr, int window_id)
} }
static inline bool window_changed_internal(obs_property_t *p, static inline bool window_changed_internal(obs_property_t *p,
obs_data_t *settings) obs_data_t *settings)
{ {
int window_id = obs_data_get_int(settings, "window"); int window_id = obs_data_get_int(settings, "window");
NSString *window_owner = @(obs_data_get_string(settings, "owner_name")); NSString *window_owner = @(obs_data_get_string(settings, "owner_name"));
NSString *window_name = NSString *window_name = @(obs_data_get_string(settings, "window_name"));
@(obs_data_get_string(settings, "window_name"));
NSDictionary *win_info = @{ NSDictionary *win_info = @{
OWNER_NAME: window_owner, OWNER_NAME: window_owner,
@ -147,39 +144,38 @@ static inline bool window_changed_internal(obs_property_t *p,
obs_property_list_clear(p); obs_property_list_clear(p);
for (NSDictionary *dict in arr) { for (NSDictionary *dict in arr) {
NSString *owner = (NSString*)dict[OWNER_NAME]; NSString *owner = (NSString *)dict[OWNER_NAME];
NSString *name = (NSString*)dict[WINDOW_NAME]; NSString *name = (NSString *)dict[WINDOW_NAME];
NSNumber *wid = (NSNumber*)dict[WINDOW_NUMBER]; NSNumber *wid = (NSNumber *)dict[WINDOW_NUMBER];
if (!window_added && if (!window_added &&
win_info_cmp(win_info, dict) == NSOrderedAscending) { win_info_cmp(win_info, dict) == NSOrderedAscending) {
window_added = true; window_added = true;
size_t idx = obs_property_list_add_int(p, size_t idx = obs_property_list_add_int(
make_name(window_owner, window_name), p, make_name(window_owner, window_name),
window_id); window_id);
obs_property_list_item_disable(p, idx, true); obs_property_list_item_disable(p, idx, true);
} }
if (!show_empty_names && !name.length && if (!show_empty_names && !name.length &&
window_id != wid.intValue) window_id != wid.intValue)
continue; continue;
obs_property_list_add_int(p, make_name(owner, name), obs_property_list_add_int(p, make_name(owner, name),
wid.intValue); wid.intValue);
} }
if (!window_added) { if (!window_added) {
size_t idx = obs_property_list_add_int(p, size_t idx = obs_property_list_add_int(
make_name(window_owner, window_name), p, make_name(window_owner, window_name), window_id);
window_id);
obs_property_list_item_disable(p, idx, true); obs_property_list_item_disable(p, idx, true);
} }
if (!window_found) if (!window_found)
return true; return true;
NSString *owner = (NSString*)cur[OWNER_NAME]; NSString *owner = (NSString *)cur[OWNER_NAME];
NSString *window = (NSString*)cur[WINDOW_NAME]; NSString *window = (NSString *)cur[WINDOW_NAME];
obs_data_set_string(settings, "owner_name", owner.UTF8String); obs_data_set_string(settings, "owner_name", owner.UTF8String);
obs_data_set_string(settings, "window_name", window.UTF8String); obs_data_set_string(settings, "window_name", window.UTF8String);
@ -188,7 +184,7 @@ static inline bool window_changed_internal(obs_property_t *p,
} }
static bool window_changed(obs_properties_t *props, obs_property_t *p, static bool window_changed(obs_properties_t *props, obs_property_t *p,
obs_data_t *settings) obs_data_t *settings)
{ {
UNUSED_PARAMETER(props); UNUSED_PARAMETER(props);
@ -198,12 +194,12 @@ static bool window_changed(obs_properties_t *props, obs_property_t *p,
} }
static bool toggle_empty_names(obs_properties_t *props, obs_property_t *p, static bool toggle_empty_names(obs_properties_t *props, obs_property_t *p,
obs_data_t *settings) obs_data_t *settings)
{ {
UNUSED_PARAMETER(p); UNUSED_PARAMETER(p);
return window_changed(props, obs_properties_get(props, "window"), return window_changed(props, obs_properties_get(props, "window"),
settings); settings);
} }
void window_defaults(obs_data_t *settings) void window_defaults(obs_data_t *settings)
@ -214,20 +210,20 @@ void window_defaults(obs_data_t *settings)
void add_window_properties(obs_properties_t *props) void add_window_properties(obs_properties_t *props)
{ {
obs_property_t *window_list = obs_properties_add_list(props, obs_property_t *window_list = obs_properties_add_list(
"window", obs_module_text("WindowUtils.Window"), props, "window", obs_module_text("WindowUtils.Window"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT); OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
obs_property_set_modified_callback(window_list, window_changed); obs_property_set_modified_callback(window_list, window_changed);
obs_property_t *empty = obs_properties_add_bool(props, obs_property_t *empty = obs_properties_add_bool(
"show_empty_names", props, "show_empty_names",
obs_module_text("WindowUtils.ShowEmptyNames")); obs_module_text("WindowUtils.ShowEmptyNames"));
obs_property_set_modified_callback(empty, toggle_empty_names); obs_property_set_modified_callback(empty, toggle_empty_names);
} }
void show_window_properties(obs_properties_t *props, bool show) void show_window_properties(obs_properties_t *props, bool show)
{ {
obs_property_set_visible(obs_properties_get(props, "window"), show); obs_property_set_visible(obs_properties_get(props, "window"), show);
obs_property_set_visible( obs_property_set_visible(obs_properties_get(props, "show_empty_names"),
obs_properties_get(props, "show_empty_names"), show); show);
} }

453
plugins/mac-syphon/syphon.m
View File

@ -3,40 +3,41 @@
#import "syphon-framework/Syphon.h" #import "syphon-framework/Syphon.h"
#include <obs-module.h> #include <obs-module.h>
#define LOG(level, message, ...) \ #define LOG(level, message, ...) \
blog(level, "%s: " message, obs_source_get_name(s->source), ##__VA_ARGS__) blog(level, "%s: " message, obs_source_get_name(s->source), \
##__VA_ARGS__)
struct syphon { struct syphon {
SYPHON_CLIENT_UNIQUE_CLASS_NAME *client; SYPHON_CLIENT_UNIQUE_CLASS_NAME *client;
IOSurfaceRef ref; IOSurfaceRef ref;
gs_samplerstate_t *sampler; gs_samplerstate_t *sampler;
gs_effect_t *effect; gs_effect_t *effect;
gs_vertbuffer_t *vertbuffer; gs_vertbuffer_t *vertbuffer;
gs_texture_t *tex; gs_texture_t *tex;
uint32_t width, height; uint32_t width, height;
bool crop; bool crop;
CGRect crop_rect; CGRect crop_rect;
bool allow_transparency; bool allow_transparency;
obs_source_t *source; obs_source_t *source;
bool active; bool active;
bool uuid_changed; bool uuid_changed;
id new_server_listener; id new_server_listener;
id retire_listener; id retire_listener;
NSString *app_name; NSString *app_name;
NSString *name; NSString *name;
NSString *uuid; NSString *uuid;
obs_data_t *inject_info; obs_data_t *inject_info;
NSString *inject_app; NSString *inject_app;
NSString *inject_uuid; NSString *inject_uuid;
bool inject_active; bool inject_active;
id launch_listener; id launch_listener;
bool inject_server_found; bool inject_server_found;
float inject_wait_time; float inject_wait_time;
}; };
typedef struct syphon *syphon_t; typedef struct syphon *syphon_t;
@ -55,9 +56,9 @@ static inline void find_and_inject_target(syphon_t s, NSArray *arr, bool retry);
@interface OBSSyphonKVObserver : NSObject @interface OBSSyphonKVObserver : NSObject
- (void)observeValueForKeyPath:(NSString *)keyPath - (void)observeValueForKeyPath:(NSString *)keyPath
ofObject:(id)object ofObject:(id)object
change:(NSDictionary *)change change:(NSDictionary *)change
context:(void *)context; context:(void *)context;
@end @end
static inline void handle_application_launch(syphon_t s, NSArray *new) static inline void handle_application_launch(syphon_t s, NSArray *new)
@ -73,9 +74,9 @@ static inline void handle_application_launch(syphon_t s, NSArray *new)
@implementation OBSSyphonKVObserver @implementation OBSSyphonKVObserver
- (void)observeValueForKeyPath:(NSString *)keyPath - (void)observeValueForKeyPath:(NSString *)keyPath
ofObject:(id)object ofObject:(id)object
change:(NSDictionary *)change change:(NSDictionary *)change
context:(void *)context context:(void *)context
{ {
UNUSED_PARAMETER(keyPath); UNUSED_PARAMETER(keyPath);
UNUSED_PARAMETER(object); UNUSED_PARAMETER(object);
@ -117,7 +118,7 @@ static void stop_client(syphon_t s)
s->ref = NULL; s->ref = NULL;
} }
s->width = 0; s->width = 0;
s->height = 0; s->height = 0;
obs_leave_graphics(); obs_leave_graphics();
@ -143,8 +144,10 @@ static inline void check_version(syphon_t s, NSDictionary *desc)
"VersionKey"); "VersionKey");
if (version.unsignedIntValue > 0) if (version.unsignedIntValue > 0)
LOG(LOG_WARNING, "Got server description version %d, " LOG(LOG_WARNING,
"expected 0", version.unsignedIntValue); "Got server description version %d, "
"expected 0",
version.unsignedIntValue);
} }
static inline void check_description(syphon_t s, NSDictionary *desc) static inline void check_description(syphon_t s, NSDictionary *desc)
@ -169,9 +172,10 @@ static inline void check_description(syphon_t s, NSDictionary *desc)
} }
NSString *surfaces_string = [NSString stringWithFormat:@"%@", surfaces]; NSString *surfaces_string = [NSString stringWithFormat:@"%@", surfaces];
LOG(LOG_WARNING, "SyphonSurfaces does not contain" LOG(LOG_WARNING,
"'SyphonSurfaceTypeIOSurface': %s", "SyphonSurfaces does not contain"
surfaces_string.UTF8String); "'SyphonSurfaceTypeIOSurface': %s",
surfaces_string.UTF8String);
} }
static inline bool update_string(NSString **str, NSString *new) static inline bool update_string(NSString **str, NSString *new)
@ -185,7 +189,7 @@ static inline bool update_string(NSString **str, NSString *new)
} }
static inline void handle_new_frame(syphon_t s, static inline void handle_new_frame(syphon_t s,
SYPHON_CLIENT_UNIQUE_CLASS_NAME *client) SYPHON_CLIENT_UNIQUE_CLASS_NAME *client)
{ {
IOSurfaceRef ref = [client IOSurface]; IOSurfaceRef ref = [client IOSurface];
@ -206,9 +210,9 @@ static inline void handle_new_frame(syphon_t s,
CFRelease(s->ref); CFRelease(s->ref);
} }
s->ref = ref; s->ref = ref;
s->tex = gs_texture_create_from_iosurface(s->ref); s->tex = gs_texture_create_from_iosurface(s->ref);
s->width = gs_texture_get_width(s->tex); s->width = gs_texture_get_width(s->tex);
s->height = gs_texture_get_height(s->tex); s->height = gs_texture_get_height(s->tex);
obs_leave_graphics(); obs_leave_graphics();
} }
@ -230,7 +234,7 @@ static void create_client(syphon_t s)
if (!desc) { if (!desc) {
desc = servers[0]; desc = servers[0];
if (update_string(&s->uuid, if (update_string(&s->uuid,
desc[SyphonServerDescriptionUUIDKey])) desc[SyphonServerDescriptionUUIDKey]))
s->uuid_changed = true; s->uuid_changed = true;
} }
@ -241,11 +245,11 @@ static void create_client(syphon_t s)
s->client = [[SYPHON_CLIENT_UNIQUE_CLASS_NAME alloc] s->client = [[SYPHON_CLIENT_UNIQUE_CLASS_NAME alloc]
initWithServerDescription:desc initWithServerDescription:desc
options:nil options:nil
newFrameHandler:^ newFrameHandler:^(
(SYPHON_CLIENT_UNIQUE_CLASS_NAME *client) SYPHON_CLIENT_UNIQUE_CLASS_NAME
{ *client) {
handle_new_frame(s, client); handle_new_frame(s, client);
}]; }];
} }
s->active = true; s->active = true;
@ -254,27 +258,27 @@ static void create_client(syphon_t s)
static inline void release_settings(syphon_t s) static inline void release_settings(syphon_t s)
{ {
[s->app_name release]; [s->app_name release];
[s->name release]; [s->name release];
[s->uuid release]; [s->uuid release];
} }
static inline bool load_syphon_settings(syphon_t s, obs_data_t *settings) static inline bool load_syphon_settings(syphon_t s, obs_data_t *settings)
{ {
NSString *app_name = @(obs_data_get_string(settings, "app_name")); NSString *app_name = @(obs_data_get_string(settings, "app_name"));
NSString *name = @(obs_data_get_string(settings, "name")); NSString *name = @(obs_data_get_string(settings, "name"));
bool equal_names = [app_name isEqual:s->app_name] && bool equal_names = [app_name isEqual:s->app_name] &&
[name isEqual:s->name]; [name isEqual:s->name];
if (s->uuid_changed && equal_names) if (s->uuid_changed && equal_names)
return false; return false;
NSString *uuid = @(obs_data_get_string(settings, "uuid")); NSString *uuid = @(obs_data_get_string(settings, "uuid"));
if ([uuid isEqual:s->uuid] && equal_names) if ([uuid isEqual:s->uuid] && equal_names)
return false; return false;
release_settings(s); release_settings(s);
s->app_name = [app_name retain]; s->app_name = [app_name retain];
s->name = [name retain]; s->name = [name retain];
s->uuid = [uuid retain]; s->uuid = [uuid retain];
s->uuid_changed = false; s->uuid_changed = false;
return true; return true;
} }
@ -288,15 +292,15 @@ static inline void update_from_announce(syphon_t s, NSDictionary *info)
return; return;
NSString *app_name = info[SyphonServerDescriptionAppNameKey]; NSString *app_name = info[SyphonServerDescriptionAppNameKey];
NSString *name = info[SyphonServerDescriptionNameKey]; NSString *name = info[SyphonServerDescriptionNameKey];
NSString *uuid = info[SyphonServerDescriptionUUIDKey]; NSString *uuid = info[SyphonServerDescriptionUUIDKey];
if (![uuid isEqual:s->uuid] && if (![uuid isEqual:s->uuid] &&
!([app_name isEqual:s->app_name] && [name isEqual:s->name])) !([app_name isEqual:s->app_name] && [name isEqual:s->name]))
return; return;
update_string(&s->app_name, app_name); update_string(&s->app_name, app_name);
update_string(&s->name, name); update_string(&s->name, name);
if (update_string(&s->uuid, uuid)) if (update_string(&s->uuid, uuid))
s->uuid_changed = true; s->uuid_changed = true;
@ -304,27 +308,28 @@ static inline void update_from_announce(syphon_t s, NSDictionary *info)
} }
static inline void update_inject_state(syphon_t s, NSDictionary *info, static inline void update_inject_state(syphon_t s, NSDictionary *info,
bool announce) bool announce)
{ {
if (!info) if (!info)
return; return;
NSString *app_name = info[SyphonServerDescriptionAppNameKey]; NSString *app_name = info[SyphonServerDescriptionAppNameKey];
NSString *name = info[SyphonServerDescriptionNameKey]; NSString *name = info[SyphonServerDescriptionNameKey];
NSString *uuid = info[SyphonServerDescriptionUUIDKey]; NSString *uuid = info[SyphonServerDescriptionUUIDKey];
if (![uuid isEqual:s->inject_uuid] && if (![uuid isEqual:s->inject_uuid] &&
(![app_name isEqual:s->inject_app] (![app_name isEqual:s->inject_app] ||
|| ![name isEqual:@"InjectedSyphon"])) ![name isEqual:@"InjectedSyphon"]))
return; return;
if (!(s->inject_server_found = announce)) { if (!(s->inject_server_found = announce)) {
s->inject_wait_time = 0.f; s->inject_wait_time = 0.f;
objc_release(&s->inject_uuid); objc_release(&s->inject_uuid);
LOG(LOG_INFO, "Injected server retired: " LOG(LOG_INFO,
"[%s] InjectedSyphon (%s)", "Injected server retired: "
s->inject_app.UTF8String, uuid.UTF8String); "[%s] InjectedSyphon (%s)",
s->inject_app.UTF8String, uuid.UTF8String);
return; return;
} }
@ -333,8 +338,7 @@ static inline void update_inject_state(syphon_t s, NSDictionary *info,
s->inject_uuid = [uuid retain]; s->inject_uuid = [uuid retain];
LOG(LOG_INFO, "Injected server found: [%s] %s (%s)", LOG(LOG_INFO, "Injected server found: [%s] %s (%s)",
app_name.UTF8String, name.UTF8String, app_name.UTF8String, name.UTF8String, uuid.UTF8String);
uuid.UTF8String);
} }
static inline void handle_announce(syphon_t s, NSNotification *note) static inline void handle_announce(syphon_t s, NSNotification *note)
@ -406,15 +410,15 @@ fail_tvarray:
static inline bool init_obs_graphics_objects(syphon_t s) static inline bool init_obs_graphics_objects(syphon_t s)
{ {
struct gs_sampler_info info = { struct gs_sampler_info info = {
.filter = GS_FILTER_LINEAR, .filter = GS_FILTER_LINEAR,
.address_u = GS_ADDRESS_CLAMP, .address_u = GS_ADDRESS_CLAMP,
.address_v = GS_ADDRESS_CLAMP, .address_v = GS_ADDRESS_CLAMP,
.address_w = GS_ADDRESS_CLAMP, .address_w = GS_ADDRESS_CLAMP,
.max_anisotropy = 1, .max_anisotropy = 1,
}; };
obs_enter_graphics(); obs_enter_graphics();
s->sampler = gs_samplerstate_create(&info); s->sampler = gs_samplerstate_create(&info);
s->vertbuffer = create_vertbuffer(); s->vertbuffer = create_vertbuffer();
obs_leave_graphics(); obs_leave_graphics();
@ -426,25 +430,21 @@ static inline bool init_obs_graphics_objects(syphon_t s)
static inline bool create_syphon_listeners(syphon_t s) static inline bool create_syphon_listeners(syphon_t s)
{ {
NSNotificationCenter *nc = [NSNotificationCenter defaultCenter]; NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
s->new_server_listener = [nc s->new_server_listener = [nc
addObserverForName:SyphonServerAnnounceNotification addObserverForName:SyphonServerAnnounceNotification
object:nil object:nil
queue:[NSOperationQueue mainQueue] queue:[NSOperationQueue mainQueue]
usingBlock:^(NSNotification *note) usingBlock:^(NSNotification *note) {
{ handle_announce(s, note);
handle_announce(s, note); }];
}
];
s->retire_listener = [nc s->retire_listener = [nc
addObserverForName:SyphonServerRetireNotification addObserverForName:SyphonServerRetireNotification
object:nil object:nil
queue:[NSOperationQueue mainQueue] queue:[NSOperationQueue mainQueue]
usingBlock:^(NSNotification *note) usingBlock:^(NSNotification *note) {
{ handle_retire(s, note);
handle_retire(s, note); }];
}
];
return s->new_server_listener != nil && s->retire_listener != nil; return s->new_server_listener != nil && s->retire_listener != nil;
} }
@ -456,9 +456,9 @@ static inline bool create_applications_observer(syphon_t s, NSWorkspace *ws)
return false; return false;
[ws addObserver:s->launch_listener [ws addObserver:s->launch_listener
forKeyPath:NSStringFromSelector(@selector(runningApplications)) forKeyPath:NSStringFromSelector(@selector(runningApplications))
options:NSKeyValueObservingOptionNew options:NSKeyValueObservingOptionNew
context:s]; context:s];
return true; return true;
} }
@ -467,8 +467,7 @@ static inline void load_crop(syphon_t s, obs_data_t *settings)
{ {
s->crop = obs_data_get_bool(settings, "crop"); s->crop = obs_data_get_bool(settings, "crop");
#define LOAD_CROP(x) \ #define LOAD_CROP(x) s->crop_rect.x = obs_data_get_double(settings, "crop." #x)
s->crop_rect.x = obs_data_get_double(settings, "crop." #x)
LOAD_CROP(origin.x); LOAD_CROP(origin.x);
LOAD_CROP(origin.y); LOAD_CROP(origin.y);
LOAD_CROP(size.width); LOAD_CROP(size.width);
@ -486,7 +485,7 @@ static void *syphon_create_internal(obs_data_t *settings, obs_source_t *source)
if (!s) if (!s)
return s; return s;
s->source = source; s->source = source;
if (!init_obs_graphics_objects(s)) if (!init_obs_graphics_objects(s))
goto fail; goto fail;
@ -495,9 +494,9 @@ static void *syphon_create_internal(obs_data_t *settings, obs_source_t *source)
goto fail; goto fail;
const char *inject_info = obs_data_get_string(settings, "application"); const char *inject_info = obs_data_get_string(settings, "application");
s->inject_info = obs_data_create_from_json(inject_info); s->inject_info = obs_data_create_from_json(inject_info);
s->inject_active = obs_data_get_bool(settings, "inject"); s->inject_active = obs_data_get_bool(settings, "inject");
s->inject_app = @(obs_data_get_string(s->inject_info, "name")); s->inject_app = @(obs_data_get_string(s->inject_info, "name"));
if (s->inject_app) if (s->inject_app)
[s->inject_app retain]; [s->inject_app retain];
@ -516,8 +515,8 @@ static void *syphon_create_internal(obs_data_t *settings, obs_source_t *source)
load_crop(s, settings); load_crop(s, settings);
s->allow_transparency = obs_data_get_bool(settings, s->allow_transparency =
"allow_transparency"); obs_data_get_bool(settings, "allow_transparency");
return s; return s;
@ -549,7 +548,8 @@ static inline void syphon_destroy_internal(syphon_t s)
NSWorkspace *ws = [NSWorkspace sharedWorkspace]; NSWorkspace *ws = [NSWorkspace sharedWorkspace];
[ws removeObserver:s->launch_listener [ws removeObserver:s->launch_listener
forKeyPath:NSStringFromSelector(@selector(runningApplications))]; forKeyPath:NSStringFromSelector(@selector
(runningApplications))];
objc_release(&s->launch_listener); objc_release(&s->launch_listener);
objc_release(&s->inject_app); objc_release(&s->inject_app);
@ -561,7 +561,7 @@ static inline void syphon_destroy_internal(syphon_t s)
obs_enter_graphics(); obs_enter_graphics();
stop_client(s); stop_client(s);
if (s->sampler) if (s->sampler)
gs_samplerstate_destroy(s->sampler); gs_samplerstate_destroy(s->sampler);
if (s->vertbuffer) if (s->vertbuffer)
@ -587,44 +587,45 @@ static inline NSString *get_string(obs_data_t *settings, const char *name)
} }
static inline void update_strings_from_context(syphon_t s, obs_data_t *settings, static inline void update_strings_from_context(syphon_t s, obs_data_t *settings,
NSString **app, NSString **name, NSString **uuid) NSString **app, NSString **name,
NSString **uuid)
{ {
if (!s || !s->uuid_changed) if (!s || !s->uuid_changed)
return; return;
s->uuid_changed = false; s->uuid_changed = false;
*app = s->app_name; *app = s->app_name;
*name = s->name; *name = s->name;
*uuid = s->uuid; *uuid = s->uuid;
obs_data_set_string(settings, "app_name", s->app_name.UTF8String); 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, "name", s->name.UTF8String);
obs_data_set_string(settings, "uuid", s->uuid.UTF8String); obs_data_set_string(settings, "uuid", s->uuid.UTF8String);
} }
static inline void add_servers(syphon_t s, obs_property_t *list, static inline void add_servers(syphon_t s, obs_property_t *list,
obs_data_t *settings) obs_data_t *settings)
{ {
bool found_current = settings == NULL; bool found_current = settings == NULL;
NSString *set_app = get_string(settings, "app_name"); NSString *set_app = get_string(settings, "app_name");
NSString *set_name = get_string(settings, "name"); NSString *set_name = get_string(settings, "name");
NSString *set_uuid = get_string(settings, "uuid"); NSString *set_uuid = get_string(settings, "uuid");
update_strings_from_context(s, settings, update_strings_from_context(s, settings, &set_app, &set_name,
&set_app, &set_name, &set_uuid); &set_uuid);
obs_property_list_add_string(list, "", ""); obs_property_list_add_string(list, "", "");
NSArray *arr = [[SyphonServerDirectory sharedDirectory] servers]; NSArray *arr = [[SyphonServerDirectory sharedDirectory] servers];
for (NSDictionary *server in arr) { for (NSDictionary *server in arr) {
NSString *app = server[SyphonServerDescriptionAppNameKey]; NSString *app = server[SyphonServerDescriptionAppNameKey];
NSString *name = server[SyphonServerDescriptionNameKey]; NSString *name = server[SyphonServerDescriptionNameKey];
NSString *uuid = server[SyphonServerDescriptionUUIDKey]; NSString *uuid = server[SyphonServerDescriptionUUIDKey];
NSString *serv = [NSString stringWithFormat:@"[%@] %@", NSString *serv =
app, name]; [NSString stringWithFormat:@"[%@] %@", app, name];
obs_property_list_add_string(list, obs_property_list_add_string(list, serv.UTF8String,
serv.UTF8String, uuid.UTF8String); uuid.UTF8String);
if (!found_current) if (!found_current)
found_current = [uuid isEqual:set_uuid]; found_current = [uuid isEqual:set_uuid];
@ -633,15 +634,15 @@ static inline void add_servers(syphon_t s, obs_property_t *list,
if (found_current || !set_uuid.length || !set_app.length) if (found_current || !set_uuid.length || !set_app.length)
return; return;
NSString *serv = [NSString stringWithFormat:@"[%@] %@", NSString *serv =
set_app, set_name]; [NSString stringWithFormat:@"[%@] %@", set_app, set_name];
size_t idx = obs_property_list_add_string(list, size_t idx = obs_property_list_add_string(list, serv.UTF8String,
serv.UTF8String, set_uuid.UTF8String); set_uuid.UTF8String);
obs_property_list_item_disable(list, idx, true); obs_property_list_item_disable(list, idx, true);
} }
static bool servers_changed(obs_properties_t *props, obs_property_t *list, static bool servers_changed(obs_properties_t *props, obs_property_t *list,
obs_data_t *settings) obs_data_t *settings)
{ {
@autoreleasepool { @autoreleasepool {
obs_property_list_clear(list); obs_property_list_clear(list);
@ -662,16 +663,15 @@ static inline bool is_inject_available_in_lib_dir(NSFileManager *fm, NSURL *url)
if (!url.isFileURL) if (!url.isFileURL)
return false; return false;
for (NSString *path in [fm for (NSString *path in [fm contentsOfDirectoryAtPath:url.path
contentsOfDirectoryAtPath:url.path error:nil]) {
error:nil]) {
NSURL *bundle_url = [url URLByAppendingPathComponent:path]; NSURL *bundle_url = [url URLByAppendingPathComponent:path];
NSBundle *bundle = [NSBundle bundleWithURL:bundle_url]; NSBundle *bundle = [NSBundle bundleWithURL:bundle_url];
if (!bundle) if (!bundle)
continue; continue;
if ([bundle.bundleIdentifier if ([bundle.bundleIdentifier
isEqual:@"zakk.lol.SASyphonInjector"]) isEqual:@"zakk.lol.SASyphonInjector"])
return true; return true;
} }
@ -705,7 +705,7 @@ static inline void launch_syphon_inject_internal()
} }
static bool launch_syphon_inject(obs_properties_t *props, obs_property_t *prop, static bool launch_syphon_inject(obs_properties_t *props, obs_property_t *prop,
void *data) void *data)
{ {
UNUSED_PARAMETER(props); UNUSED_PARAMETER(props);
UNUSED_PARAMETER(prop); UNUSED_PARAMETER(prop);
@ -720,13 +720,13 @@ static bool launch_syphon_inject(obs_properties_t *props, obs_property_t *prop,
static int describes_app(obs_data_t *info, NSRunningApplication *app) static int describes_app(obs_data_t *info, NSRunningApplication *app)
{ {
int score = 0; int score = 0;
if ([app.localizedName isEqual:get_string(info, "name")]) if ([app.localizedName isEqual:get_string(info, "name")])
score += 2; score += 2;
if ([app.bundleIdentifier isEqual:get_string(info, "bundle")]) if ([app.bundleIdentifier isEqual:get_string(info, "bundle")])
score += 2; score += 2;
if ([app.executableURL isEqual:get_string(info, "executable")]) if ([app.executableURL isEqual:get_string(info, "executable")])
score += 2; score += 2;
if (score && app.processIdentifier == obs_data_get_int(info, "pid")) if (score && app.processIdentifier == obs_data_get_int(info, "pid"))
@ -739,10 +739,10 @@ 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, "name", app.localizedName.UTF8String);
obs_data_set_string(app_data, "bundle", obs_data_set_string(app_data, "bundle",
app.bundleIdentifier.UTF8String); app.bundleIdentifier.UTF8String);
// Until we drop 10.8, use path.fileSystemRepsentation // Until we drop 10.8, use path.fileSystemRepsentation
obs_data_set_string(app_data, "executable", obs_data_set_string(app_data, "executable",
app.executableURL.path.fileSystemRepresentation); app.executableURL.path.fileSystemRepresentation);
obs_data_set_int(app_data, "pid", app.processIdentifier); obs_data_set_int(app_data, "pid", app.processIdentifier);
} }
@ -760,8 +760,9 @@ static inline NSDictionary *get_duplicate_names(NSArray *apps)
} }
static inline size_t add_app(obs_property_t *prop, NSDictionary *duplicates, static inline size_t add_app(obs_property_t *prop, NSDictionary *duplicates,
NSString *name, const char *bundle, const char *json_data, NSString *name, const char *bundle,
bool is_duplicate, pid_t pid) const char *json_data, bool is_duplicate,
pid_t pid)
{ {
if (!is_duplicate) { if (!is_duplicate) {
NSNumber *val = duplicates[name]; NSNumber *val = duplicates[name];
@ -769,20 +770,21 @@ static inline size_t add_app(obs_property_t *prop, NSDictionary *duplicates,
} }
if (is_duplicate) if (is_duplicate)
name = [NSString stringWithFormat:@"%@ (%s: %d)", name = [NSString
name, bundle, pid]; stringWithFormat:@"%@ (%s: %d)", name, bundle, pid];
return obs_property_list_add_string(prop, name.UTF8String, json_data); return obs_property_list_add_string(prop, name.UTF8String, json_data);
} }
static void update_inject_list_internal(obs_properties_t *props, static void update_inject_list_internal(obs_properties_t *props,
obs_property_t *prop, obs_data_t *settings) obs_property_t *prop,
obs_data_t *settings)
{ {
UNUSED_PARAMETER(props); UNUSED_PARAMETER(props);
const char *current_str = obs_data_get_string(settings, "application"); const char *current_str = obs_data_get_string(settings, "application");
obs_data_t *current = obs_data_create_from_json(current_str); obs_data_t *current = obs_data_create_from_json(current_str);
NSString *current_name = @(obs_data_get_string(current, "name")); NSString *current_name = @(obs_data_get_string(current, "name"));
bool current_found = !obs_data_has_user_value(current, "name"); bool current_found = !obs_data_has_user_value(current, "name");
@ -790,10 +792,10 @@ static void update_inject_list_internal(obs_properties_t *props,
obs_property_list_add_string(prop, "", ""); obs_property_list_add_string(prop, "", "");
NSWorkspace *ws = [NSWorkspace sharedWorkspace]; NSWorkspace *ws = [NSWorkspace sharedWorkspace];
NSArray *apps = ws.runningApplications; NSArray *apps = ws.runningApplications;
NSDictionary *duplicates = get_duplicate_names(apps); NSDictionary *duplicates = get_duplicate_names(apps);
NSMapTable *candidates = [NSMapTable weakToStrongObjectsMapTable]; NSMapTable *candidates = [NSMapTable weakToStrongObjectsMapTable];
obs_data_t *app_data = obs_data_create(); obs_data_t *app_data = obs_data_create();
for (NSRunningApplication *app in apps) { for (NSRunningApplication *app in apps) {
@ -801,11 +803,10 @@ static void update_inject_list_internal(obs_properties_t *props,
int score = describes_app(current, app); int score = describes_app(current, app);
NSString *name = app.localizedName; NSString *name = app.localizedName;
add_app(prop, duplicates, name, add_app(prop, duplicates, name, app.bundleIdentifier.UTF8String,
app.bundleIdentifier.UTF8String, obs_data_get_json(app_data),
obs_data_get_json(app_data), [name isEqual:current_name] && score < 4,
[name isEqual:current_name] && score < 4, app.processIdentifier);
app.processIdentifier);
if (score >= 4) { if (score >= 4) {
[candidates setObject:@(score) forKey:app]; [candidates setObject:@(score) forKey:app];
@ -816,10 +817,10 @@ static void update_inject_list_internal(obs_properties_t *props,
if (!current_found) { if (!current_found) {
size_t idx = add_app(prop, duplicates, current_name, size_t idx = add_app(prop, duplicates, current_name,
obs_data_get_string(current, "bundle"), obs_data_get_string(current, "bundle"),
current_str, current_str,
duplicates[current_name] != nil, duplicates[current_name] != nil,
obs_data_get_int(current, "pid")); obs_data_get_int(current, "pid"));
obs_property_list_item_disable(prop, idx, true); obs_property_list_item_disable(prop, idx, true);
} else if (candidates.count > 0) { } else if (candidates.count > 0) {
@ -829,7 +830,7 @@ static void update_inject_list_internal(obs_properties_t *props,
for (NSRunningApplication *app in candidates.keyEnumerator) { for (NSRunningApplication *app in candidates.keyEnumerator) {
NSNumber *score = [candidates objectForKey:app]; NSNumber *score = [candidates objectForKey:app];
if ([score compare:best_match_score] == if ([score compare:best_match_score] ==
NSOrderedDescending) { NSOrderedDescending) {
best_match = app; best_match = app;
best_match_score = score; best_match_score = score;
} }
@ -839,7 +840,7 @@ static void update_inject_list_internal(obs_properties_t *props,
if (best_match_score.intValue >= 4) { if (best_match_score.intValue >= 4) {
app_to_data(best_match, current); app_to_data(best_match, current);
obs_data_set_string(settings, "application", obs_data_set_string(settings, "application",
obs_data_get_json(current)); obs_data_get_json(current));
} }
} }
@ -847,7 +848,7 @@ static void update_inject_list_internal(obs_properties_t *props,
} }
static void toggle_inject_internal(obs_properties_t *props, static void toggle_inject_internal(obs_properties_t *props,
obs_property_t *prop, obs_data_t *settings) obs_property_t *prop, obs_data_t *settings)
{ {
bool enabled = obs_data_get_bool(settings, "inject"); bool enabled = obs_data_get_bool(settings, "inject");
obs_property_t *inject_list = obs_properties_get(props, "application"); obs_property_t *inject_list = obs_properties_get(props, "application");
@ -857,7 +858,7 @@ static void toggle_inject_internal(obs_properties_t *props,
} }
static bool toggle_inject(obs_properties_t *props, obs_property_t *prop, static bool toggle_inject(obs_properties_t *props, obs_property_t *prop,
obs_data_t *settings) obs_data_t *settings)
{ {
@autoreleasepool { @autoreleasepool {
toggle_inject_internal(props, prop, settings); toggle_inject_internal(props, prop, settings);
@ -866,7 +867,7 @@ static bool toggle_inject(obs_properties_t *props, obs_property_t *prop,
} }
static bool update_inject_list(obs_properties_t *props, obs_property_t *prop, static bool update_inject_list(obs_properties_t *props, obs_property_t *prop,
obs_data_t *settings) obs_data_t *settings)
{ {
@autoreleasepool { @autoreleasepool {
update_inject_list_internal(props, prop, settings); update_inject_list_internal(props, prop, settings);
@ -875,11 +876,11 @@ static bool update_inject_list(obs_properties_t *props, obs_property_t *prop,
} }
static bool update_crop(obs_properties_t *props, obs_property_t *prop, static bool update_crop(obs_properties_t *props, obs_property_t *prop,
obs_data_t *settings) obs_data_t *settings)
{ {
bool enabled = obs_data_get_bool(settings, "crop"); bool enabled = obs_data_get_bool(settings, "crop");
#define LOAD_CROP(x) \ #define LOAD_CROP(x) \
prop = obs_properties_get(props, "crop." #x); \ prop = obs_properties_get(props, "crop." #x); \
obs_property_set_enabled(prop, enabled); obs_property_set_enabled(prop, enabled);
LOAD_CROP(origin.x); LOAD_CROP(origin.x);
@ -903,7 +904,7 @@ static void show_syphon_license_internal(void)
} }
static bool show_syphon_license(obs_properties_t *props, obs_property_t *prop, static bool show_syphon_license(obs_properties_t *props, obs_property_t *prop,
void *data) void *data)
{ {
UNUSED_PARAMETER(props); UNUSED_PARAMETER(props);
UNUSED_PARAMETER(prop); UNUSED_PARAMETER(prop);
@ -928,28 +929,28 @@ static inline obs_properties_t *syphon_properties_internal(syphon_t s)
if (s) if (s)
obs_source_addref(s->source); obs_source_addref(s->source);
obs_properties_t *props = obs_properties_create_param(s, obs_properties_t *props =
syphon_release); obs_properties_create_param(s, syphon_release);
obs_property_t *list = obs_properties_add_list(props, obs_property_t *list = obs_properties_add_list(
"uuid", obs_module_text("Source"), props, "uuid", obs_module_text("Source"), OBS_COMBO_TYPE_LIST,
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING); OBS_COMBO_FORMAT_STRING);
obs_property_set_modified_callback(list, servers_changed); obs_property_set_modified_callback(list, servers_changed);
obs_properties_add_bool(props, "allow_transparency", obs_properties_add_bool(props, "allow_transparency",
obs_module_text("AllowTransparency")); obs_module_text("AllowTransparency"));
obs_property_t *launch = obs_properties_add_button(props, obs_property_t *launch = obs_properties_add_button(
"launch inject", obs_module_text("LaunchSyphonInject"), props, "launch inject", obs_module_text("LaunchSyphonInject"),
launch_syphon_inject); launch_syphon_inject);
obs_property_t *inject = obs_properties_add_bool(props, obs_property_t *inject = obs_properties_add_bool(
"inject", obs_module_text("Inject")); props, "inject", obs_module_text("Inject"));
obs_property_set_modified_callback(inject, toggle_inject); obs_property_set_modified_callback(inject, toggle_inject);
obs_property_t *inject_list = obs_properties_add_list(props, obs_property_t *inject_list = obs_properties_add_list(
"application", obs_module_text("Application"), props, "application", obs_module_text("Application"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING); OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
obs_property_set_modified_callback(inject_list, update_inject_list); obs_property_set_modified_callback(inject_list, update_inject_list);
if (!get_inject_application_path()) if (!get_inject_application_path())
@ -960,13 +961,14 @@ static inline obs_properties_t *syphon_properties_internal(syphon_t s)
obs_property_set_enabled(inject_list, false); obs_property_set_enabled(inject_list, false);
} }
obs_property_t *crop = obs_properties_add_bool(props, "crop", obs_property_t *crop =
obs_module_text("Crop")); obs_properties_add_bool(props, "crop", obs_module_text("Crop"));
obs_property_set_modified_callback(crop, update_crop); obs_property_set_modified_callback(crop, update_crop);
#define LOAD_CROP(x) \ #define LOAD_CROP(x) \
obs_properties_add_float(props, "crop." #x, \ obs_properties_add_float(props, "crop." #x, \
obs_module_text("Crop." #x), 0., 4096.f, .5f); obs_module_text("Crop." #x), 0., 4096.f, \
.5f);
LOAD_CROP(origin.x); LOAD_CROP(origin.x);
LOAD_CROP(origin.y); LOAD_CROP(origin.y);
LOAD_CROP(size.width); LOAD_CROP(size.width);
@ -974,8 +976,8 @@ static inline obs_properties_t *syphon_properties_internal(syphon_t s)
#undef LOAD_CROP #undef LOAD_CROP
obs_properties_add_button(props, "syphon license", obs_properties_add_button(props, "syphon license",
obs_module_text("SyphonLicense"), obs_module_text("SyphonLicense"),
show_syphon_license); show_syphon_license);
return props; return props;
} }
@ -993,8 +995,8 @@ static inline void syphon_save_internal(syphon_t s, obs_data_t *settings)
return; return;
obs_data_set_string(settings, "app_name", s->app_name.UTF8String); 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, "name", s->name.UTF8String);
obs_data_set_string(settings, "uuid", s->uuid.UTF8String); obs_data_set_string(settings, "uuid", s->uuid.UTF8String);
} }
static void syphon_save(void *data, obs_data_t *settings) static void syphon_save(void *data, obs_data_t *settings)
@ -1005,25 +1007,25 @@ static void syphon_save(void *data, obs_data_t *settings)
} }
static inline void build_sprite(struct gs_vb_data *data, float fcx, float fcy, 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) float start_u, float end_u, float start_v,
float end_v)
{ {
struct vec2 *tvarray = data->tvarray[0].array; struct vec2 *tvarray = data->tvarray[0].array;
vec3_set(data->points+1, fcx, 0.0f, 0.0f); vec3_set(data->points + 1, fcx, 0.0f, 0.0f);
vec3_set(data->points+2, 0.0f, fcy, 0.0f); vec3_set(data->points + 2, 0.0f, fcy, 0.0f);
vec3_set(data->points+3, fcx, fcy, 0.0f); vec3_set(data->points + 3, fcx, fcy, 0.0f);
vec2_set(tvarray, start_u, start_v); vec2_set(tvarray, start_u, start_v);
vec2_set(tvarray+1, end_u, start_v); vec2_set(tvarray + 1, end_u, start_v);
vec2_set(tvarray+2, start_u, end_v); vec2_set(tvarray + 2, start_u, end_v);
vec2_set(tvarray+3, end_u, end_v); vec2_set(tvarray + 3, end_u, end_v);
} }
static inline void build_sprite_rect(struct gs_vb_data *data, static inline void build_sprite_rect(struct gs_vb_data *data, float origin_x,
float origin_x, float origin_y, float end_x, float end_y) float origin_y, float end_x, float end_y)
{ {
build_sprite(data, fabs(end_x - origin_x), fabs(end_y - origin_y), build_sprite(data, fabs(end_x - origin_x), fabs(end_y - origin_y),
origin_x, end_x, origin_x, end_x, origin_y, end_y);
origin_y, end_y);
} }
static inline void tick_inject_state(syphon_t s, float seconds) static inline void tick_inject_state(syphon_t s, float seconds)
@ -1050,17 +1052,15 @@ static void syphon_video_tick(void *data, float seconds)
if (!s->tex) if (!s->tex)
return; return;
static const CGRect null_crop = { { 0.f } }; static const CGRect null_crop = {{0.f}};
const CGRect *crop = &null_crop; const CGRect *crop = &null_crop;
if (s->crop) if (s->crop)
crop = &s->crop_rect; crop = &s->crop_rect;
obs_enter_graphics(); obs_enter_graphics();
build_sprite_rect(gs_vertexbuffer_get_data(s->vertbuffer), build_sprite_rect(gs_vertexbuffer_get_data(s->vertbuffer),
crop->origin.x, crop->origin.x, s->height - crop->origin.y,
s->height - crop->origin.y, s->width - crop->size.width, crop->size.height);
s->width - crop->size.width,
crop->size.height);
obs_leave_graphics(); obs_leave_graphics();
} }
@ -1085,7 +1085,7 @@ static void syphon_video_render(void *data, gs_effect_t *effect)
gs_load_samplerstate(s->sampler, 0); gs_load_samplerstate(s->sampler, 0);
gs_technique_t *tech = gs_effect_get_technique(s->effect, "Draw"); gs_technique_t *tech = gs_effect_get_technique(s->effect, "Draw");
gs_effect_set_texture(gs_effect_get_param_by_name(s->effect, "image"), gs_effect_set_texture(gs_effect_get_param_by_name(s->effect, "image"),
s->tex); s->tex);
gs_technique_begin(tech); gs_technique_begin(tech);
gs_technique_begin_pass(tech, 0); gs_technique_begin_pass(tech, 0);
@ -1105,9 +1105,8 @@ static uint32_t syphon_get_width(void *data)
syphon_t s = (syphon_t)data; syphon_t s = (syphon_t)data;
if (!s->crop) if (!s->crop)
return s->width; return s->width;
int32_t width = s->width int32_t width =
- s->crop_rect.origin.x s->width - s->crop_rect.origin.x - s->crop_rect.size.width;
- s->crop_rect.size.width;
return MAX(0, width); return MAX(0, width);
} }
@ -1116,9 +1115,8 @@ static uint32_t syphon_get_height(void *data)
syphon_t s = (syphon_t)data; syphon_t s = (syphon_t)data;
if (!s->crop) if (!s->crop)
return s->height; return s->height;
int32_t height = s->height int32_t height =
- s->crop_rect.origin.y s->height - s->crop_rect.origin.y - s->crop_rect.size.height;
- s->crop_rect.size.height;
return MAX(0, height); return MAX(0, height);
} }
@ -1134,9 +1132,9 @@ static inline void inject_app(syphon_t s, NSRunningApplication *app, bool retry)
if (!sbapp) if (!sbapp)
return LOG(LOG_ERROR, "Could not inject %s", return LOG(LOG_ERROR, "Could not inject %s",
app.localizedName.UTF8String); app.localizedName.UTF8String);
sbapp.timeout = 10*60; sbapp.timeout = 10 * 60;
sbapp.sendMode = kAEWaitReply; sbapp.sendMode = kAEWaitReply;
[sbapp sendEvent:'ascr' id:'gdut' parameters:0]; [sbapp sendEvent:'ascr' id:'gdut' parameters:0];
sbapp.sendMode = kAENoReply; sbapp.sendMode = kAENoReply;
@ -1145,9 +1143,8 @@ static inline void inject_app(syphon_t s, NSRunningApplication *app, bool retry)
if (retry) if (retry)
return; return;
LOG(LOG_INFO, "Injected '%s' (%d, '%s')", LOG(LOG_INFO, "Injected '%s' (%d, '%s')", app.localizedName.UTF8String,
app.localizedName.UTF8String, app.processIdentifier, app.bundleIdentifier.UTF8String);
app.processIdentifier, app.bundleIdentifier.UTF8String);
} }
static inline void find_and_inject_target(syphon_t s, NSArray *arr, bool retry) static inline void find_and_inject_target(syphon_t s, NSArray *arr, bool retry)
@ -1174,20 +1171,17 @@ static inline void find_and_inject_target(syphon_t s, NSArray *arr, bool retry)
static inline bool inject_info_equal(obs_data_t *prev, obs_data_t *new) static inline bool inject_info_equal(obs_data_t *prev, obs_data_t *new)
{ {
if (![get_string(prev, "name") if (![get_string(prev, "name") isEqual:get_string(new, "name")])
isEqual:get_string(new, "name")])
return false; return false;
if (![get_string(prev, "bundle") if (![get_string(prev, "bundle") isEqual:get_string(new, "bundle")])
isEqual:get_string(new, "bundle")])
return false; return false;
if (![get_string(prev, "executable") if (![get_string(prev, "executable")
isEqual:get_string(new, "executable")]) isEqual:get_string(new, "executable")])
return false; return false;
if (![get_string(prev, "pid") if (![get_string(prev, "pid") isEqual:get_string(new, "pid")])
isEqual:get_string(new, "pid")])
return false; return false;
return true; return true;
@ -1195,15 +1189,15 @@ static inline bool inject_info_equal(obs_data_t *prev, obs_data_t *new)
static inline void update_inject(syphon_t s, obs_data_t *settings) static inline void update_inject(syphon_t s, obs_data_t *settings)
{ {
bool try_injecting = s->inject_active; bool try_injecting = s->inject_active;
s->inject_active = obs_data_get_bool(settings, "inject"); s->inject_active = obs_data_get_bool(settings, "inject");
const char *inject_str = obs_data_get_string(settings, "application"); const char *inject_str = obs_data_get_string(settings, "application");
try_injecting = !try_injecting && s->inject_active; try_injecting = !try_injecting && s->inject_active;
obs_data_t *prev = s->inject_info; obs_data_t *prev = s->inject_info;
s->inject_info = obs_data_create_from_json(inject_str); s->inject_info = obs_data_create_from_json(inject_str);
NSString *prev_app = s->inject_app; NSString *prev_app = s->inject_app;
s->inject_app = [@(obs_data_get_string(s->inject_info, "name")) retain]; s->inject_app = [@(obs_data_get_string(s->inject_info, "name")) retain];
[prev_app release]; [prev_app release];
@ -1216,10 +1210,10 @@ static inline void update_inject(syphon_t s, obs_data_t *settings)
s->inject_server_found = false; s->inject_server_found = false;
for (NSDictionary *server in servers) for (NSDictionary *server in servers)
update_inject_state(s, server, true); update_inject_state(s, server, true);
if (!try_injecting) if (!try_injecting)
try_injecting = s->inject_active && try_injecting = s->inject_active &&
!inject_info_equal(prev, s->inject_info); !inject_info_equal(prev, s->inject_info);
obs_data_release(prev); obs_data_release(prev);
@ -1239,15 +1233,15 @@ static inline bool update_syphon(syphon_t s, obs_data_t *settings)
NSDictionary *dict = find_by_uuid(arr, s->uuid); NSDictionary *dict = find_by_uuid(arr, s->uuid);
if (dict) { if (dict) {
NSString *app = dict[SyphonServerDescriptionAppNameKey]; NSString *app = dict[SyphonServerDescriptionAppNameKey];
NSString *name = dict[SyphonServerDescriptionNameKey]; NSString *name = dict[SyphonServerDescriptionNameKey];
obs_data_set_string(settings, "app_name", app.UTF8String); obs_data_set_string(settings, "app_name", app.UTF8String);
obs_data_set_string(settings, "name", name.UTF8String); obs_data_set_string(settings, "name", name.UTF8String);
load_syphon_settings(s, settings); load_syphon_settings(s, settings);
} else if (!dict && !s->uuid.length) { } else if (!dict && !s->uuid.length) {
obs_data_set_string(settings, "app_name", ""); obs_data_set_string(settings, "app_name", "");
obs_data_set_string(settings, "name", ""); obs_data_set_string(settings, "name", "");
load_syphon_settings(s, settings); load_syphon_settings(s, settings);
} }
@ -1256,8 +1250,8 @@ static inline bool update_syphon(syphon_t s, obs_data_t *settings)
static void syphon_update_internal(syphon_t s, obs_data_t *settings) static void syphon_update_internal(syphon_t s, obs_data_t *settings)
{ {
s->allow_transparency = obs_data_get_bool(settings, s->allow_transparency =
"allow_transparency"); obs_data_get_bool(settings, "allow_transparency");
load_crop(s, settings); load_crop(s, settings);
update_inject(s, settings); update_inject(s, settings);
@ -1273,19 +1267,18 @@ static void syphon_update(void *data, obs_data_t *settings)
} }
struct obs_source_info syphon_info = { struct obs_source_info syphon_info = {
.id = "syphon-input", .id = "syphon-input",
.type = OBS_SOURCE_TYPE_INPUT, .type = OBS_SOURCE_TYPE_INPUT,
.output_flags = OBS_SOURCE_VIDEO | OBS_SOURCE_CUSTOM_DRAW | .output_flags = OBS_SOURCE_VIDEO | OBS_SOURCE_CUSTOM_DRAW |
OBS_SOURCE_DO_NOT_DUPLICATE, OBS_SOURCE_DO_NOT_DUPLICATE,
.get_name = syphon_get_name, .get_name = syphon_get_name,
.create = syphon_create, .create = syphon_create,
.destroy = syphon_destroy, .destroy = syphon_destroy,
.video_render = syphon_video_render, .video_render = syphon_video_render,
.video_tick = syphon_video_tick, .video_tick = syphon_video_tick,
.get_properties = syphon_properties, .get_properties = syphon_properties,
.get_width = syphon_get_width, .get_width = syphon_get_width,
.get_height = syphon_get_height, .get_height = syphon_get_height,
.update = syphon_update, .update = syphon_update,
.save = syphon_save, .save = syphon_save,
}; };

34
plugins/text-freetype2/find-font-cocoa.m
View File

@ -30,12 +30,12 @@ static void add_path_fonts(NSFileManager *file_manager, NSString *path)
files = [file_manager contentsOfDirectoryAtPath:path error:nil]; files = [file_manager contentsOfDirectoryAtPath:path error:nil];
for (NSString *file in files) { for (NSString *file in files) {
NSString *full_path = [path stringByAppendingPathComponent:file]; NSString *full_path =
[path stringByAppendingPathComponent:file];
BOOL is_dir = FALSE; BOOL is_dir = FALSE;
bool folder_exists = [file_manager bool folder_exists = [file_manager fileExistsAtPath:full_path
fileExistsAtPath:full_path isDirectory:&is_dir];
isDirectory:&is_dir];
if (folder_exists && is_dir) { if (folder_exists && is_dir) {
add_path_fonts(file_manager, full_path); add_path_fonts(file_manager, full_path);
@ -50,7 +50,7 @@ void load_os_font_list(void)
@autoreleasepool { @autoreleasepool {
BOOL is_dir; BOOL is_dir;
NSArray *paths = NSSearchPathForDirectoriesInDomains( NSArray *paths = NSSearchPathForDirectoriesInDomains(
NSLibraryDirectory, NSAllDomainsMask, true); NSLibraryDirectory, NSAllDomainsMask, true);
for (NSString *path in paths) { for (NSString *path in paths) {
NSFileManager *file_manager = NSFileManager *file_manager =
@ -59,8 +59,8 @@ void load_os_font_list(void)
[path stringByAppendingPathComponent:@"Fonts"]; [path stringByAppendingPathComponent:@"Fonts"];
bool folder_exists = [file_manager bool folder_exists = [file_manager
fileExistsAtPath:font_path fileExistsAtPath:font_path
isDirectory:&is_dir]; isDirectory:&is_dir];
if (folder_exists && is_dir) if (folder_exists && is_dir)
add_path_fonts(file_manager, font_path); add_path_fonts(file_manager, font_path);
@ -78,17 +78,19 @@ static uint32_t add_font_checksum(uint32_t checksum, const char *path)
} }
static uint32_t add_font_checksum_path(uint32_t checksum, static uint32_t add_font_checksum_path(uint32_t checksum,
NSFileManager *file_manager, NSString *path) NSFileManager *file_manager,
NSString *path)
{ {
NSArray *files = NULL; NSArray *files = NULL;
files = [file_manager contentsOfDirectoryAtPath:path error:nil]; files = [file_manager contentsOfDirectoryAtPath:path error:nil];
for (NSString *file in files) { for (NSString *file in files) {
NSString *full_path = [path stringByAppendingPathComponent:file]; NSString *full_path =
[path stringByAppendingPathComponent:file];
checksum = add_font_checksum(checksum, checksum = add_font_checksum(
full_path.fileSystemRepresentation); checksum, full_path.fileSystemRepresentation);
} }
return checksum; return checksum;
@ -101,7 +103,7 @@ uint32_t get_font_checksum(void)
@autoreleasepool { @autoreleasepool {
BOOL is_dir; BOOL is_dir;
NSArray *paths = NSSearchPathForDirectoriesInDomains( NSArray *paths = NSSearchPathForDirectoriesInDomains(
NSLibraryDirectory, NSAllDomainsMask, true); NSLibraryDirectory, NSAllDomainsMask, true);
for (NSString *path in paths) { for (NSString *path in paths) {
NSFileManager *file_manager = NSFileManager *file_manager =
@ -110,12 +112,12 @@ uint32_t get_font_checksum(void)
[path stringByAppendingPathComponent:@"Fonts"]; [path stringByAppendingPathComponent:@"Fonts"];
bool folder_exists = [file_manager bool folder_exists = [file_manager
fileExistsAtPath:font_path fileExistsAtPath:font_path
isDirectory:&is_dir]; isDirectory:&is_dir];
if (folder_exists && is_dir) if (folder_exists && is_dir)
checksum = add_font_checksum_path(checksum, checksum = add_font_checksum_path(
file_manager, font_path); checksum, file_manager, font_path);
} }
} }

85
test/osx/test.mm
View File

@ -16,24 +16,23 @@ static const int cy = 600;
/* --------------------------------------------------- */ /* --------------------------------------------------- */
template <typename T, typename D_T, D_T D> template<typename T, typename D_T, D_T D>
struct OBSUniqueHandle : std::unique_ptr<T, std::function<D_T>> struct OBSUniqueHandle : std::unique_ptr<T, std::function<D_T>> {
{
using base = std::unique_ptr<T, std::function<D_T>>; using base = std::unique_ptr<T, std::function<D_T>>;
explicit OBSUniqueHandle(T *obj=nullptr) : base(obj, D) {} explicit OBSUniqueHandle(T *obj = nullptr) : base(obj, D) {}
operator T*() { return base::get(); } operator T *() { return base::get(); }
}; };
#define DECLARE_DELETER(x) decltype(x), x #define DECLARE_DELETER(x) decltype(x), x
using SourceContext = OBSUniqueHandle<obs_source, using SourceContext =
DECLARE_DELETER(obs_source_release)>; OBSUniqueHandle<obs_source, DECLARE_DELETER(obs_source_release)>;
using SceneContext = OBSUniqueHandle<obs_scene, using SceneContext =
DECLARE_DELETER(obs_scene_release)>; OBSUniqueHandle<obs_scene, DECLARE_DELETER(obs_scene_release)>;
using DisplayContext = OBSUniqueHandle<obs_display, using DisplayContext =
DECLARE_DELETER(obs_display_destroy)>; OBSUniqueHandle<obs_display, DECLARE_DELETER(obs_display_destroy)>;
#undef DECLARE_DELETER #undef DECLARE_DELETER
@ -45,15 +44,15 @@ static void CreateOBS()
throw "Couldn't create OBS"; throw "Couldn't create OBS";
struct obs_video_info ovi; struct obs_video_info ovi;
ovi.adapter = 0; ovi.adapter = 0;
ovi.fps_num = 30000; ovi.fps_num = 30000;
ovi.fps_den = 1001; ovi.fps_den = 1001;
ovi.graphics_module = DL_OPENGL; ovi.graphics_module = DL_OPENGL;
ovi.output_format = VIDEO_FORMAT_RGBA; ovi.output_format = VIDEO_FORMAT_RGBA;
ovi.base_width = cx; ovi.base_width = cx;
ovi.base_height = cy; ovi.base_height = cy;
ovi.output_width = cx; ovi.output_width = cx;
ovi.output_height = cy; ovi.output_height = cy;
if (obs_reset_video(&ovi) != 0) if (obs_reset_video(&ovi) != 0)
throw "Couldn't initialize video"; throw "Couldn't initialize video";
@ -61,12 +60,12 @@ static void CreateOBS()
static DisplayContext CreateDisplay(NSView *view) static DisplayContext CreateDisplay(NSView *view)
{ {
gs_init_data info = {}; gs_init_data info = {};
info.cx = cx; info.cx = cx;
info.cy = cy; info.cy = cy;
info.format = GS_RGBA; info.format = GS_RGBA;
info.zsformat = GS_ZS_NONE; info.zsformat = GS_ZS_NONE;
info.window.view = view; info.window.view = view;
return DisplayContext{obs_display_create(&info)}; return DisplayContext{obs_display_create(&info)};
} }
@ -79,8 +78,8 @@ static SceneContext SetupScene()
/* ------------------------------------------------------ */ /* ------------------------------------------------------ */
/* create source */ /* create source */
SourceContext source{obs_source_create("random", "a test source", SourceContext source{
nullptr, nullptr)}; obs_source_create("random", "a test source", nullptr, nullptr)};
if (!source) if (!source)
throw "Couldn't create random test source"; throw "Couldn't create random test source";
@ -99,20 +98,19 @@ static SceneContext SetupScene()
return scene; return scene;
} }
@interface OBSTest : NSObject<NSApplicationDelegate, NSWindowDelegate> @interface OBSTest : NSObject <NSApplicationDelegate, NSWindowDelegate> {
{
NSWindow *win; NSWindow *win;
NSView *view; NSView *view;
DisplayContext display; DisplayContext display;
SceneContext scene; SceneContext scene;
} }
- (void)applicationDidFinishLaunching:(NSNotification*)notification; - (void)applicationDidFinishLaunching:(NSNotification *)notification;
- (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication*)app; - (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication *)app;
- (void)windowWillClose:(NSNotification*)notification; - (void)windowWillClose:(NSNotification *)notification;
@end @end
@implementation OBSTest @implementation OBSTest
- (void)applicationDidFinishLaunching:(NSNotification*)notification - (void)applicationDidFinishLaunching:(NSNotification *)notification
{ {
UNUSED_PARAMETER(notification); UNUSED_PARAMETER(notification);
@ -120,9 +118,10 @@ static SceneContext SetupScene()
NSRect content_rect = NSMakeRect(0, 0, cx, cy); NSRect content_rect = NSMakeRect(0, 0, cx, cy);
win = [[NSWindow alloc] win = [[NSWindow alloc]
initWithContentRect:content_rect initWithContentRect:content_rect
styleMask:NSTitledWindowMask | NSClosableWindowMask styleMask:NSTitledWindowMask |
backing:NSBackingStoreBuffered NSClosableWindowMask
defer:NO]; backing:NSBackingStoreBuffered
defer:NO];
if (!win) if (!win)
throw "Could not create window"; throw "Could not create window";
@ -144,10 +143,12 @@ static SceneContext SetupScene()
scene = SetupScene(); scene = SetupScene();
obs_display_add_draw_callback(display.get(), obs_display_add_draw_callback(
[](void *, uint32_t, uint32_t) { display.get(),
obs_render_main_texture(); [](void *, uint32_t, uint32_t) {
}, nullptr); obs_render_main_texture();
},
nullptr);
} catch (char const *error) { } catch (char const *error) {
NSLog(@"%s\n", error); NSLog(@"%s\n", error);
@ -156,14 +157,14 @@ static SceneContext SetupScene()
} }
} }
- (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication*)app - (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication *)app
{ {
UNUSED_PARAMETER(app); UNUSED_PARAMETER(app);
return YES; return YES;
} }
- (void)windowWillClose:(NSNotification*)notification - (void)windowWillClose:(NSNotification *)notification
{ {
UNUSED_PARAMETER(notification); UNUSED_PARAMETER(notification);