From 2700db9ff94acdbbc1d7604b98e1533e5ce28b41 Mon Sep 17 00:00:00 2001 From: John Boiles Date: Tue, 20 Oct 2020 13:50:06 +0200 Subject: [PATCH] Add virtualcam plugin to OBS codebase MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: lvsti Co-authored-by: Sebastian Beckmann Co-authored-by: Stefan Huber Co-authored-by: Ryohei Ikegami Co-authored-by: Colin Dean Co-authored-by: Wolfgang Ladermann Co-authored-by: Simon Eves Co-authored-by: Colin Nelson Co-authored-by: Yoshimasa Niwa Co-authored-by: Michael Karliner Co-authored-by: Jason Grout Co-authored-by: Alfredo Inostroza Co-authored-by: Daniel Kennett Co-authored-by: Gary Ewan Park Co-authored-by: José Carlos Cieni Júnior --- .github/workflows/main.yml | 3 + CI/full-build-macos.sh | 6 + plugins/CMakeLists.txt | 1 + plugins/mac-virtualcam/CMakeLists.txt | 2 + plugins/mac-virtualcam/data/locale/en-US.ini | 0 .../mac-virtualcam/src/common/MachProtocol.h | 17 + .../src/dal-plugin/CMSampleBufferUtils.h | 22 + .../src/dal-plugin/CMSampleBufferUtils.mm | 187 +++ .../src/dal-plugin/CMakeLists.txt | 108 ++ .../mac-virtualcam/src/dal-plugin/Defines.h | 21 + .../mac-virtualcam/src/dal-plugin/Device.h | 34 + .../mac-virtualcam/src/dal-plugin/Device.mm | 295 ++++ .../mac-virtualcam/src/dal-plugin/Info.plist | 40 + .../mac-virtualcam/src/dal-plugin/Logging.h | 32 + .../src/dal-plugin/MachClient.h | 33 + .../src/dal-plugin/MachClient.mm | 140 ++ .../src/dal-plugin/ObjectStore.h | 62 + .../src/dal-plugin/ObjectStore.mm | 281 ++++ .../mac-virtualcam/src/dal-plugin/PlugIn.h | 51 + .../mac-virtualcam/src/dal-plugin/PlugIn.mm | 255 +++ .../src/dal-plugin/PlugInInterface.h | 23 + .../src/dal-plugin/PlugInInterface.mm | 444 +++++ .../src/dal-plugin/PlugInMain.mm | 37 + .../mac-virtualcam/src/dal-plugin/Stream.h | 48 + .../mac-virtualcam/src/dal-plugin/Stream.mm | 571 +++++++ .../mac-virtualcam/src/dal-plugin/TestCard.h | 14 + .../mac-virtualcam/src/dal-plugin/TestCard.mm | 1452 +++++++++++++++++ .../src/dal-plugin/placeholder.png | Bin 0 -> 314050 bytes .../src/obs-plugin/CMakeLists.txt | 59 + .../mac-virtualcam/src/obs-plugin/Defines.h | 24 + .../src/obs-plugin/MachServer.h | 29 + .../src/obs-plugin/MachServer.mm | 178 ++ .../src/obs-plugin/data/locale/en-US.ini | 5 + .../src/obs-plugin/plugin-main.mm | 208 +++ 34 files changed, 4682 insertions(+) create mode 100644 plugins/mac-virtualcam/CMakeLists.txt create mode 100644 plugins/mac-virtualcam/data/locale/en-US.ini create mode 100644 plugins/mac-virtualcam/src/common/MachProtocol.h create mode 100644 plugins/mac-virtualcam/src/dal-plugin/CMSampleBufferUtils.h create mode 100644 plugins/mac-virtualcam/src/dal-plugin/CMSampleBufferUtils.mm create mode 100644 plugins/mac-virtualcam/src/dal-plugin/CMakeLists.txt create mode 100755 plugins/mac-virtualcam/src/dal-plugin/Defines.h create mode 100644 plugins/mac-virtualcam/src/dal-plugin/Device.h create mode 100644 plugins/mac-virtualcam/src/dal-plugin/Device.mm create mode 100644 plugins/mac-virtualcam/src/dal-plugin/Info.plist create mode 100644 plugins/mac-virtualcam/src/dal-plugin/Logging.h create mode 100644 plugins/mac-virtualcam/src/dal-plugin/MachClient.h create mode 100644 plugins/mac-virtualcam/src/dal-plugin/MachClient.mm create mode 100644 plugins/mac-virtualcam/src/dal-plugin/ObjectStore.h create mode 100644 plugins/mac-virtualcam/src/dal-plugin/ObjectStore.mm create mode 100644 plugins/mac-virtualcam/src/dal-plugin/PlugIn.h create mode 100644 plugins/mac-virtualcam/src/dal-plugin/PlugIn.mm create mode 100644 plugins/mac-virtualcam/src/dal-plugin/PlugInInterface.h create mode 100644 plugins/mac-virtualcam/src/dal-plugin/PlugInInterface.mm create mode 100644 plugins/mac-virtualcam/src/dal-plugin/PlugInMain.mm create mode 100644 plugins/mac-virtualcam/src/dal-plugin/Stream.h create mode 100644 plugins/mac-virtualcam/src/dal-plugin/Stream.mm create mode 100644 plugins/mac-virtualcam/src/dal-plugin/TestCard.h create mode 100644 plugins/mac-virtualcam/src/dal-plugin/TestCard.mm create mode 100644 plugins/mac-virtualcam/src/dal-plugin/placeholder.png create mode 100644 plugins/mac-virtualcam/src/obs-plugin/CMakeLists.txt create mode 100644 plugins/mac-virtualcam/src/obs-plugin/Defines.h create mode 100644 plugins/mac-virtualcam/src/obs-plugin/MachServer.h create mode 100644 plugins/mac-virtualcam/src/obs-plugin/MachServer.mm create mode 100644 plugins/mac-virtualcam/src/obs-plugin/data/locale/en-US.ini create mode 100644 plugins/mac-virtualcam/src/obs-plugin/plugin-main.mm diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 55541b787..a23c50fef 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -215,6 +215,7 @@ jobs: -x ./OBS.app/Contents/PlugIns/mac-decklink.so \ -x ./OBS.app/Contents/PlugIns/mac-syphon.so \ -x ./OBS.app/Contents/PlugIns/mac-vth264.so \ + -x ./OBS.app/Contents/PlugIns/mac-virtualcam.so \ -x ./OBS.app/Contents/PlugIns/obs-browser.so \ -x ./OBS.app/Contents/PlugIns/obs-browser-page \ -x ./OBS.app/Contents/PlugIns/obs-ffmpeg.so \ @@ -266,6 +267,8 @@ jobs: codesign --force --options runtime --sign "${SIGN_IDENTITY:--}" "./OBS.app/Contents/Frameworks/Chromium Embedded Framework.framework/Libraries/libswiftshader_libGLESv2.dylib" codesign --force --options runtime --sign "${SIGN_IDENTITY:--}" --deep "./OBS.app/Contents/Frameworks/Chromium Embedded Framework.framework" + codesign --force --options runtime --deep --sign "${SIGN_IDENTITY:--}" "./OBS.app/Contents/Resources/data/obs-mac-virtualcam.plugin" + codesign --force --options runtime --entitlements "../CI/scripts/macos/app/entitlements.plist" --sign "${SIGN_IDENTITY:--}" --deep ./OBS.app codesign -dvv ./OBS.app diff --git a/CI/full-build-macos.sh b/CI/full-build-macos.sh index 13e4af87f..c63a6a182 100755 --- a/CI/full-build-macos.sh +++ b/CI/full-build-macos.sh @@ -318,6 +318,7 @@ bundle_dylibs() { -x ./OBS.app/Contents/PlugIns/mac-decklink.so \ -x ./OBS.app/Contents/PlugIns/mac-syphon.so \ -x ./OBS.app/Contents/PlugIns/mac-vth264.so \ + -x ./OBS.app/Contents/PlugIns/mac-virtualcam.so \ -x ./OBS.app/Contents/PlugIns/obs-browser.so \ -x ./OBS.app/Contents/PlugIns/obs-browser-page \ -x ./OBS.app/Contents/PlugIns/obs-ffmpeg.so \ @@ -508,6 +509,11 @@ codesign_bundle() { codesign --force --options runtime --sign "${CODESIGN_IDENT}" --deep "./OBS.app/Contents/Frameworks/Chromium Embedded Framework.framework" echo -n "${COLOR_RESET}" + step "Code-sign DAL Plugin..." + echo -n "${COLOR_ORANGE}" + codesign --force --options runtime --deep --sign "${CODESIGN_IDENT}" "./OBS.app/Contents/Resources/data/obs-mac-virtualcam.plugin" + echo -n "${COLOR_RESET}" + step "Code-sign OBS code..." echo -n "${COLOR_ORANGE}" codesign --force --options runtime --entitlements "${CI_SCRIPTS}/app/entitlements.plist" --sign "${CODESIGN_IDENT}" --deep ./OBS.app diff --git a/plugins/CMakeLists.txt b/plugins/CMakeLists.txt index cad1dc788..cf655e475 100644 --- a/plugins/CMakeLists.txt +++ b/plugins/CMakeLists.txt @@ -30,6 +30,7 @@ elseif(APPLE) add_subdirectory(mac-capture) add_subdirectory(mac-vth264) add_subdirectory(mac-syphon) + add_subdirectory(mac-virtualcam) add_subdirectory(decklink/mac) add_subdirectory(vlc-video) add_subdirectory(linux-jack) diff --git a/plugins/mac-virtualcam/CMakeLists.txt b/plugins/mac-virtualcam/CMakeLists.txt new file mode 100644 index 000000000..843c0cb51 --- /dev/null +++ b/plugins/mac-virtualcam/CMakeLists.txt @@ -0,0 +1,2 @@ +add_subdirectory(src/obs-plugin) +add_subdirectory(src/dal-plugin) diff --git a/plugins/mac-virtualcam/data/locale/en-US.ini b/plugins/mac-virtualcam/data/locale/en-US.ini new file mode 100644 index 000000000..e69de29bb diff --git a/plugins/mac-virtualcam/src/common/MachProtocol.h b/plugins/mac-virtualcam/src/common/MachProtocol.h new file mode 100644 index 000000000..54b8d2500 --- /dev/null +++ b/plugins/mac-virtualcam/src/common/MachProtocol.h @@ -0,0 +1,17 @@ +// +// MachProtocol.m +// obs-mac-virtualcam +// +// Created by John Boiles on 5/5/20. +// + +#define MACH_SERVICE_NAME "com.obsproject.obs-mac-virtualcam.server" + +typedef enum { + //! Initial connect message sent from the client to the server to initate a connection + MachMsgIdConnect = 1, + //! Message containing data for a frame + MachMsgIdFrame = 2, + //! Indicates the server is going to stop sending frames + MachMsgIdStop = 3, +} MachMsgId; diff --git a/plugins/mac-virtualcam/src/dal-plugin/CMSampleBufferUtils.h b/plugins/mac-virtualcam/src/dal-plugin/CMSampleBufferUtils.h new file mode 100644 index 000000000..f0c659ac4 --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/CMSampleBufferUtils.h @@ -0,0 +1,22 @@ +// +// CMSampleBufferUtils.h +// dal-plugin +// +// Created by John Boiles on 5/8/20. +// + +#include + +OSStatus CMSampleBufferCreateFromData(NSSize size, + CMSampleTimingInfo timingInfo, + UInt64 sequenceNumber, NSData *data, + CMSampleBufferRef *sampleBuffer); + +OSStatus CMSampleBufferCreateFromDataNoCopy(NSSize size, + CMSampleTimingInfo timingInfo, + UInt64 sequenceNumber, NSData *data, + CMSampleBufferRef *sampleBuffer); + +CMSampleTimingInfo CMSampleTimingInfoForTimestamp(uint64_t timestampNanos, + uint32_t fpsNumerator, + uint32_t fpsDenominator); diff --git a/plugins/mac-virtualcam/src/dal-plugin/CMSampleBufferUtils.mm b/plugins/mac-virtualcam/src/dal-plugin/CMSampleBufferUtils.mm new file mode 100644 index 000000000..9273cc179 --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/CMSampleBufferUtils.mm @@ -0,0 +1,187 @@ +// +// CMSampleBufferUtils.m +// dal-plugin +// +// Created by John Boiles on 5/8/20. +// + +#import "CMSampleBufferUtils.h" + +#include "Logging.h" + +/*! +CMSampleBufferCreateFromData + +Creates a CMSampleBuffer by copying bytes from NSData into a CVPixelBuffer. +*/ +OSStatus CMSampleBufferCreateFromData(NSSize size, + CMSampleTimingInfo timingInfo, + UInt64 sequenceNumber, NSData *data, + CMSampleBufferRef *sampleBuffer) +{ + OSStatus err = noErr; + + // Create an empty pixel buffer + CVPixelBufferRef pixelBuffer; + err = CVPixelBufferCreate(kCFAllocatorDefault, size.width, size.height, + kCVPixelFormatType_422YpCbCr8, nil, + &pixelBuffer); + if (err != noErr) { + DLog(@"CVPixelBufferCreate err %d", err); + return err; + } + + // Generate the video format description from that pixel buffer + CMFormatDescriptionRef format; + err = CMVideoFormatDescriptionCreateForImageBuffer(NULL, pixelBuffer, + &format); + if (err != noErr) { + DLog(@"CMVideoFormatDescriptionCreateForImageBuffer err %d", + err); + return err; + } + + // Copy memory into the pixel buffer + CVPixelBufferLockBaseAddress(pixelBuffer, 0); + uint8_t *dest = + (uint8_t *)CVPixelBufferGetBaseAddressOfPlane(pixelBuffer, 0); + uint8_t *src = (uint8_t *)data.bytes; + + size_t destBytesPerRow = + CVPixelBufferGetBytesPerRowOfPlane(pixelBuffer, 0); + size_t srcBytesPerRow = size.width * 2; + + // Sometimes CVPixelBufferCreate will create a pixelbuffer that's a different + // size than necessary to hold the frame (probably for some optimization reason). + // If that is the case this will do a row-by-row copy into the buffer. + if (destBytesPerRow == srcBytesPerRow) { + memcpy(dest, src, data.length); + } else { + for (int line = 0; line < size.height; line++) { + memcpy(dest, src, srcBytesPerRow); + src += srcBytesPerRow; + dest += destBytesPerRow; + } + } + + CVPixelBufferUnlockBaseAddress(pixelBuffer, 0); + + err = CMIOSampleBufferCreateForImageBuffer(kCFAllocatorDefault, + pixelBuffer, format, + &timingInfo, sequenceNumber, + 0, sampleBuffer); + CFRelease(format); + CFRelease(pixelBuffer); + + if (err != noErr) { + DLog(@"CMIOSampleBufferCreateForImageBuffer err %d", err); + return err; + } + + return noErr; +} + +static void releaseNSData(void *o, void *block, size_t size) +{ + NSData *data = (__bridge_transfer NSData *)o; + data = nil; // Assuming ARC is enabled +} + +// From https://stackoverflow.com/questions/26158253/how-to-create-a-cmblockbufferref-from-nsdata +OSStatus createReadonlyBlockBuffer(CMBlockBufferRef *result, NSData *data) +{ + CMBlockBufferCustomBlockSource blockSource = { + .version = kCMBlockBufferCustomBlockSourceVersion, + .AllocateBlock = NULL, + .FreeBlock = &releaseNSData, + .refCon = (__bridge_retained void *)data, + }; + return CMBlockBufferCreateWithMemoryBlock(NULL, (void *)data.bytes, + data.length, NULL, + &blockSource, 0, data.length, + 0, result); +} + +/*! + CMSampleBufferCreateFromDataNoCopy + + Creates a CMSampleBuffer by using the bytes directly from NSData (without copying them). + Seems to mostly work but does not work at full resolution in OBS for some reason (which prevents loopback testing). + */ +OSStatus CMSampleBufferCreateFromDataNoCopy(NSSize size, + CMSampleTimingInfo timingInfo, + UInt64 sequenceNumber, NSData *data, + CMSampleBufferRef *sampleBuffer) +{ + OSStatus err = noErr; + + CMBlockBufferRef dataBuffer; + createReadonlyBlockBuffer(&dataBuffer, data); + + // Magic format properties snagged from https://github.com/lvsti/CoreMediaIO-DAL-Example/blob/0392cbf27ed33425a1a5bd9f495b2ccec8f20501/Sources/Extras/CoreMediaIO/DeviceAbstractionLayer/Devices/Sample/PlugIn/CMIO_DP_Sample_Stream.cpp#L830 + NSDictionary *extensions = @{ + @"com.apple.cmio.format_extension.video.only_has_i_frames": + @YES, + (__bridge NSString *) + kCMFormatDescriptionExtension_FieldCount: @1, + (__bridge NSString *) + kCMFormatDescriptionExtension_ColorPrimaries: + (__bridge NSString *) + kCMFormatDescriptionColorPrimaries_SMPTE_C, + (__bridge NSString *) + kCMFormatDescriptionExtension_TransferFunction: ( + __bridge NSString *) + kCMFormatDescriptionTransferFunction_ITU_R_709_2, + (__bridge NSString *) + kCMFormatDescriptionExtension_YCbCrMatrix: (__bridge NSString *) + kCMFormatDescriptionYCbCrMatrix_ITU_R_601_4, + (__bridge NSString *) + kCMFormatDescriptionExtension_BytesPerRow: @(size.width * 2), + (__bridge NSString *)kCMFormatDescriptionExtension_FormatName: + @"Component Video - CCIR-601 uyvy", + (__bridge NSString *)kCMFormatDescriptionExtension_Version: @2, + }; + + CMFormatDescriptionRef format; + err = CMVideoFormatDescriptionCreate( + NULL, kCMVideoCodecType_422YpCbCr8, size.width, size.height, + (__bridge CFDictionaryRef)extensions, &format); + if (err != noErr) { + DLog(@"CMVideoFormatDescriptionCreate err %d", err); + return err; + } + + size_t dataSize = data.length; + err = CMIOSampleBufferCreate(kCFAllocatorDefault, dataBuffer, format, 1, + 1, &timingInfo, 1, &dataSize, + sequenceNumber, 0, sampleBuffer); + CFRelease(format); + CFRelease(dataBuffer); + + if (err != noErr) { + DLog(@"CMIOSampleBufferCreate err %d", err); + return err; + } + + return noErr; +} + +CMSampleTimingInfo CMSampleTimingInfoForTimestamp(uint64_t timestampNanos, + uint32_t fpsNumerator, + uint32_t fpsDenominator) +{ + // The timing here is quite important. For frames to be delivered correctly and successfully be recorded by apps + // like QuickTime Player, we need to be accurate in both our timestamps _and_ have a sensible scale. Using large + // timestamps and scales like mach_absolute_time() and NSEC_PER_SEC will work for display, but will error out + // when trying to record. + // + // 600 is a commmon default in Apple's docs https://developer.apple.com/documentation/avfoundation/avmutablemovie/1390622-timescale + CMTimeScale scale = 600; + CMSampleTimingInfo timing; + timing.duration = + CMTimeMake(fpsDenominator * scale, fpsNumerator * scale); + timing.presentationTimeStamp = CMTimeMake( + (timestampNanos / (double)NSEC_PER_SEC) * scale, scale); + timing.decodeTimeStamp = kCMTimeInvalid; + return timing; +} diff --git a/plugins/mac-virtualcam/src/dal-plugin/CMakeLists.txt b/plugins/mac-virtualcam/src/dal-plugin/CMakeLists.txt new file mode 100644 index 000000000..c8bcbe8b5 --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/CMakeLists.txt @@ -0,0 +1,108 @@ +project(mac-dal-plugin) + +find_library(AVFOUNDATION AVFoundation) +find_library(COCOA Cocoa) +find_library(COREFOUNDATION CoreFoundation) +find_library(COREMEDIA CoreMedia) +find_library(COREVIDEO CoreVideo) +find_library(COCOA Cocoa) +find_library(COREMEDIAIO CoreMediaIO) +find_library(IOSURFACE IOSurface) +find_library(IOKIT IOKit) + +# Possible we could remove osme of these +include_directories(${AVFOUNDATION} + ${COCOA} + ${COREFOUNDATION} + ${COREMEDIA} + ${COREVIDEO} + ${COREMEDIAIO} + ${COCOA} + ${IOSURFACE} + ./ + ../common) + +set(mac-dal-plugin_HEADERS + Defines.h + Logging.h + PlugInInterface.h + ObjectStore.h + PlugIn.h + Device.h + Stream.h + CMSampleBufferUtils.h + MachClient.h + TestCard.h + ../common/MachProtocol.h) + +set(mac-dal-plugin_SOURCES + PlugInMain.mm + PlugInInterface.mm + ObjectStore.mm + PlugIn.mm + Device.mm + Stream.mm + CMSampleBufferUtils.mm + MachClient.mm + TestCard.mm) + +add_library(mac-dal-plugin MODULE + ${mac-dal-plugin_SOURCES} + ${mac-dal-plugin_HEADERS}) + +set_target_properties(mac-dal-plugin PROPERTIES + FOLDER "plugins" + BUNDLE TRUE + OUTPUT_NAME "obs-mac-virtualcam" + COMPILE_FLAGS "-std=gnu++14 -stdlib=libc++ -fobjc-arc -fobjc-weak") + +if (XCODE) + set(TARGET_DIR "${CMAKE_CURRENT_BINARY_DIR}/Debug") +else (XCODE) + set(TARGET_DIR "${CMAKE_CURRENT_BINARY_DIR}") +endif (XCODE) + +target_link_libraries(mac-dal-plugin + ${AVFOUNDATION} + ${COCOA} + ${COREFOUNDATION} + ${COREMEDIA} + ${COREVIDEO} + ${COREMEDIAIO} + ${IOSURFACE} + ${IOKIT}) + +add_custom_command(TARGET mac-dal-plugin + POST_BUILD + COMMAND rm -rf ${TARGET_DIR}/obs-mac-virtualcam.plugin || true + COMMAND ${CMAKE_COMMAND} -E copy_directory ${TARGET_DIR}/obs-mac-virtualcam.bundle ${TARGET_DIR}/obs-mac-virtualcam.plugin + COMMENT "Rename bundle to plugin" +) + +# Note: Xcode seems to run a command `builtin-infoPlistUtility` to generate the Info.plist, but I'm +# not sure where to find that binary. If we had access to it, the command would look something like: +# builtin-infoPlistUtility ${PROJECT_SOURCE_DIR}/../common/CoreMediaIO/DeviceAbstractionLayer/Devices/Sample/PlugIn/SampleVCam-Info.plist -producttype com.apple.product-type.bundle -expandbuildsettings -platform macosx -o mac-virtualcam.bundle/Contents/Info.plist +# Instead, just copy in one that was already generated from Xcode. +add_custom_command(TARGET mac-dal-plugin + POST_BUILD + COMMAND cp ${PROJECT_SOURCE_DIR}/Info.plist ${TARGET_DIR}/obs-mac-virtualcam.plugin/Contents/Info.plist + COMMAND mkdir ${TARGET_DIR}/obs-mac-virtualcam.plugin/Contents/Resources + COMMAND cp ${PROJECT_SOURCE_DIR}/placeholder.png ${TARGET_DIR}/obs-mac-virtualcam.plugin/Contents/Resources/placeholder.png + COMMAND /usr/bin/plutil -insert CFBundleVersion -string "${OBS_VERSION}" ${TARGET_DIR}/obs-mac-virtualcam.plugin/Contents/Info.plist + COMMAND /usr/bin/plutil -insert CFBundleShortVersionString -string "${OBS_VERSION}" ${TARGET_DIR}/obs-mac-virtualcam.plugin/Contents/Info.plist + DEPENDS {PROJECT_SOURCE_DIR}/Info.plist + COMMENT "Copy in Info.plist" +) + +add_custom_command(TARGET mac-dal-plugin + POST_BUILD + COMMAND /usr/bin/codesign --force --deep --sign - --timestamp=none ${TARGET_DIR}/obs-mac-virtualcam.plugin + COMMENT "Codesign plugin" +) + +add_custom_command(TARGET mac-dal-plugin + POST_BUILD + COMMAND rm -rf "${OBS_OUTPUT_DIR}/$/data/obs-mac-virtualcam.plugin" || true + COMMAND ${CMAKE_COMMAND} -E copy_directory ${TARGET_DIR}/obs-mac-virtualcam.plugin "${OBS_OUTPUT_DIR}/$/data/obs-mac-virtualcam.plugin" + COMMENT "Copy plugin to destination" +) diff --git a/plugins/mac-virtualcam/src/dal-plugin/Defines.h b/plugins/mac-virtualcam/src/dal-plugin/Defines.h new file mode 100755 index 000000000..1d1705aeb --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/Defines.h @@ -0,0 +1,21 @@ +// +// Defines.h +// obs-mac-virtualcam +// +// Created by John Boiles on 5/27/20. +// +// obs-mac-virtualcam is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 2 of the License, or +// (at your option) any later version. +// +// obs-mac-virtualcam is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with obs-mac-virtualcam. If not, see . + +#define PLUGIN_NAME @"mac-virtualcam" +#define PLUGIN_VERSION @"1.3.0" diff --git a/plugins/mac-virtualcam/src/dal-plugin/Device.h b/plugins/mac-virtualcam/src/dal-plugin/Device.h new file mode 100644 index 000000000..c392638da --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/Device.h @@ -0,0 +1,34 @@ +// +// Device.h +// obs-mac-virtualcam +// +// Created by John Boiles on 4/10/20. +// +// obs-mac-virtualcam is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 2 of the License, or +// (at your option) any later version. +// +// obs-mac-virtualcam is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with obs-mac-virtualcam. If not, see . + +#import + +#import "ObjectStore.h" + +NS_ASSUME_NONNULL_BEGIN + +@interface Device : NSObject + +@property CMIOObjectID objectId; +@property CMIOObjectID pluginId; +@property CMIOObjectID streamId; + +@end + +NS_ASSUME_NONNULL_END diff --git a/plugins/mac-virtualcam/src/dal-plugin/Device.mm b/plugins/mac-virtualcam/src/dal-plugin/Device.mm new file mode 100644 index 000000000..dfa56c300 --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/Device.mm @@ -0,0 +1,295 @@ +// +// Device.mm +// obs-mac-virtualcam +// +// Created by John Boiles on 4/10/20. +// +// obs-mac-virtualcam is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 2 of the License, or +// (at your option) any later version. +// +// obs-mac-virtualcam is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with obs-mac-virtualcam. If not, see . + +#import "Device.h" + +#import +#include + +#import "PlugIn.h" +#import "Logging.h" + +@interface Device () +@property BOOL excludeNonDALAccess; +@property pid_t masterPid; +@end + +@implementation Device + +// Note that the DAL's API calls HasProperty before calling GetPropertyDataSize. This means that it can be assumed that address is valid for the property involved. +- (UInt32)getPropertyDataSizeWithAddress:(CMIOObjectPropertyAddress)address + qualifierDataSize:(UInt32)qualifierDataSize + qualifierData:(nonnull const void *)qualifierData +{ + + switch (address.mSelector) { + case kCMIOObjectPropertyName: + return sizeof(CFStringRef); + case kCMIOObjectPropertyManufacturer: + return sizeof(CFStringRef); + case kCMIOObjectPropertyElementCategoryName: + return sizeof(CFStringRef); + case kCMIOObjectPropertyElementNumberName: + return sizeof(CFStringRef); + case kCMIODevicePropertyPlugIn: + return sizeof(CMIOObjectID); + case kCMIODevicePropertyDeviceUID: + return sizeof(CFStringRef); + case kCMIODevicePropertyModelUID: + return sizeof(CFStringRef); + case kCMIODevicePropertyTransportType: + return sizeof(UInt32); + case kCMIODevicePropertyDeviceIsAlive: + return sizeof(UInt32); + case kCMIODevicePropertyDeviceHasChanged: + return sizeof(UInt32); + case kCMIODevicePropertyDeviceIsRunning: + return sizeof(UInt32); + case kCMIODevicePropertyDeviceIsRunningSomewhere: + return sizeof(UInt32); + case kCMIODevicePropertyDeviceCanBeDefaultDevice: + return sizeof(UInt32); + case kCMIODevicePropertyHogMode: + return sizeof(pid_t); + case kCMIODevicePropertyLatency: + return sizeof(UInt32); + case kCMIODevicePropertyStreams: + // Only one stream + return sizeof(CMIOStreamID) * 1; + case kCMIODevicePropertyStreamConfiguration: + // Only one stream + return sizeof(UInt32) + (sizeof(UInt32) * 1); + case kCMIODevicePropertyExcludeNonDALAccess: + return sizeof(UInt32); + case kCMIODevicePropertyCanProcessAVCCommand: + return sizeof(Boolean); + case kCMIODevicePropertyCanProcessRS422Command: + return sizeof(Boolean); + case kCMIODevicePropertyLinkedCoreAudioDeviceUID: + return sizeof(CFStringRef); + case kCMIODevicePropertyDeviceMaster: + return sizeof(pid_t); + default: + DLog(@"Device unhandled getPropertyDataSizeWithAddress for %@", + [ObjectStore + StringFromPropertySelector:address.mSelector]); + }; + + return 0; +} + +// Note that the DAL's API calls HasProperty before calling GetPropertyData. This means that it can be assumed that address is valid for the property involved. +- (void)getPropertyDataWithAddress:(CMIOObjectPropertyAddress)address + qualifierDataSize:(UInt32)qualifierDataSize + qualifierData:(nonnull const void *)qualifierData + dataSize:(UInt32)dataSize + dataUsed:(nonnull UInt32 *)dataUsed + data:(nonnull void *)data +{ + + switch (address.mSelector) { + case kCMIOObjectPropertyName: + *static_cast(data) = CFSTR("OBS Virtual Camera"); + *dataUsed = sizeof(CFStringRef); + break; + case kCMIOObjectPropertyManufacturer: + *static_cast(data) = CFSTR("John Boiles"); + *dataUsed = sizeof(CFStringRef); + break; + case kCMIOObjectPropertyElementCategoryName: + *static_cast(data) = CFSTR("Virtual Camera"); + *dataUsed = sizeof(CFStringRef); + break; + case kCMIOObjectPropertyElementNumberName: + *static_cast(data) = CFSTR("0001"); + *dataUsed = sizeof(CFStringRef); + break; + case kCMIODevicePropertyPlugIn: + *static_cast(data) = self.pluginId; + *dataUsed = sizeof(CMIOObjectID); + break; + case kCMIODevicePropertyDeviceUID: + *static_cast(data) = + CFSTR("obs-virtual-cam-device"); + *dataUsed = sizeof(CFStringRef); + break; + case kCMIODevicePropertyModelUID: + *static_cast(data) = + CFSTR("obs-virtual-cam-model"); + *dataUsed = sizeof(CFStringRef); + break; + case kCMIODevicePropertyTransportType: + *static_cast(data) = + kIOAudioDeviceTransportTypeBuiltIn; + *dataUsed = sizeof(UInt32); + break; + case kCMIODevicePropertyDeviceIsAlive: + *static_cast(data) = 1; + *dataUsed = sizeof(UInt32); + break; + case kCMIODevicePropertyDeviceHasChanged: + *static_cast(data) = 0; + *dataUsed = sizeof(UInt32); + break; + case kCMIODevicePropertyDeviceIsRunning: + *static_cast(data) = 1; + *dataUsed = sizeof(UInt32); + break; + case kCMIODevicePropertyDeviceIsRunningSomewhere: + *static_cast(data) = 1; + *dataUsed = sizeof(UInt32); + break; + case kCMIODevicePropertyDeviceCanBeDefaultDevice: + *static_cast(data) = 1; + *dataUsed = sizeof(UInt32); + break; + case kCMIODevicePropertyHogMode: + *static_cast(data) = -1; + *dataUsed = sizeof(pid_t); + break; + case kCMIODevicePropertyLatency: + *static_cast(data) = 0; + *dataUsed = sizeof(UInt32); + break; + case kCMIODevicePropertyStreams: + *static_cast(data) = self.streamId; + *dataUsed = sizeof(CMIOObjectID); + break; + case kCMIODevicePropertyStreamConfiguration: + DLog(@"TODO kCMIODevicePropertyStreamConfiguration"); + break; + case kCMIODevicePropertyExcludeNonDALAccess: + *static_cast(data) = self.excludeNonDALAccess ? 1 : 0; + *dataUsed = sizeof(UInt32); + break; + case kCMIODevicePropertyCanProcessAVCCommand: + *static_cast(data) = false; + *dataUsed = sizeof(Boolean); + break; + case kCMIODevicePropertyCanProcessRS422Command: + *static_cast(data) = false; + *dataUsed = sizeof(Boolean); + break; + case kCMIODevicePropertyDeviceMaster: + *static_cast(data) = self.masterPid; + *dataUsed = sizeof(pid_t); + break; + default: + DLog(@"Device unhandled getPropertyDataWithAddress for %@", + [ObjectStore + StringFromPropertySelector:address.mSelector]); + *dataUsed = 0; + break; + }; +} + +- (BOOL)hasPropertyWithAddress:(CMIOObjectPropertyAddress)address +{ + switch (address.mSelector) { + case kCMIOObjectPropertyName: + case kCMIOObjectPropertyManufacturer: + case kCMIOObjectPropertyElementCategoryName: + case kCMIOObjectPropertyElementNumberName: + case kCMIODevicePropertyPlugIn: + case kCMIODevicePropertyDeviceUID: + case kCMIODevicePropertyModelUID: + case kCMIODevicePropertyTransportType: + case kCMIODevicePropertyDeviceIsAlive: + case kCMIODevicePropertyDeviceHasChanged: + case kCMIODevicePropertyDeviceIsRunning: + case kCMIODevicePropertyDeviceIsRunningSomewhere: + case kCMIODevicePropertyDeviceCanBeDefaultDevice: + case kCMIODevicePropertyHogMode: + case kCMIODevicePropertyLatency: + case kCMIODevicePropertyStreams: + case kCMIODevicePropertyExcludeNonDALAccess: + case kCMIODevicePropertyCanProcessAVCCommand: + case kCMIODevicePropertyCanProcessRS422Command: + case kCMIODevicePropertyDeviceMaster: + return true; + case kCMIODevicePropertyStreamConfiguration: + case kCMIODevicePropertyLinkedCoreAudioDeviceUID: + return false; + default: + DLog(@"Device unhandled hasPropertyWithAddress for %@", + [ObjectStore + StringFromPropertySelector:address.mSelector]); + return false; + }; +} + +- (BOOL)isPropertySettableWithAddress:(CMIOObjectPropertyAddress)address +{ + switch (address.mSelector) { + case kCMIOObjectPropertyName: + case kCMIOObjectPropertyManufacturer: + case kCMIOObjectPropertyElementCategoryName: + case kCMIOObjectPropertyElementNumberName: + case kCMIODevicePropertyPlugIn: + case kCMIODevicePropertyDeviceUID: + case kCMIODevicePropertyModelUID: + case kCMIODevicePropertyTransportType: + case kCMIODevicePropertyDeviceIsAlive: + case kCMIODevicePropertyDeviceHasChanged: + case kCMIODevicePropertyDeviceIsRunning: + case kCMIODevicePropertyDeviceIsRunningSomewhere: + case kCMIODevicePropertyDeviceCanBeDefaultDevice: + case kCMIODevicePropertyHogMode: + case kCMIODevicePropertyLatency: + case kCMIODevicePropertyStreams: + case kCMIODevicePropertyStreamConfiguration: + case kCMIODevicePropertyCanProcessAVCCommand: + case kCMIODevicePropertyCanProcessRS422Command: + case kCMIODevicePropertyLinkedCoreAudioDeviceUID: + return false; + case kCMIODevicePropertyExcludeNonDALAccess: + case kCMIODevicePropertyDeviceMaster: + return true; + default: + DLog(@"Device unhandled isPropertySettableWithAddress for %@", + [ObjectStore + StringFromPropertySelector:address.mSelector]); + return false; + }; +} + +- (void)setPropertyDataWithAddress:(CMIOObjectPropertyAddress)address + qualifierDataSize:(UInt32)qualifierDataSize + qualifierData:(nonnull const void *)qualifierData + dataSize:(UInt32)dataSize + data:(nonnull const void *)data +{ + + switch (address.mSelector) { + case kCMIODevicePropertyExcludeNonDALAccess: + self.excludeNonDALAccess = + (*static_cast(data) != 0); + break; + case kCMIODevicePropertyDeviceMaster: + self.masterPid = *static_cast(data); + break; + default: + DLog(@"Device unhandled setPropertyDataWithAddress for %@", + [ObjectStore + StringFromPropertySelector:address.mSelector]); + break; + }; +} + +@end diff --git a/plugins/mac-virtualcam/src/dal-plugin/Info.plist b/plugins/mac-virtualcam/src/dal-plugin/Info.plist new file mode 100644 index 000000000..a731c2fec --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/Info.plist @@ -0,0 +1,40 @@ + + + + + CFBundleDevelopmentRegion + English + CFBundleExecutable + obs-mac-virtualcam + CFBundleIdentifier + com.obsproject.obs-mac-virtualcam.dal-plugin + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + OBS Virtual Camera + CFBundlePackageType + BNDL + CFBundleSupportedPlatforms + + MacOSX + + CFPlugInFactories + + 35FDFF29-BFCF-4644-AB77-B759DE932ABE + PlugInMain + + CFPlugInTypes + + 30010C1C-93BF-11D8-8B5B-000A95AF9C6A + + 35FDFF29-BFCF-4644-AB77-B759DE932ABE + + + LSMinimumSystemVersion + 10.13 + CMIOHardwareAssistantServiceNames + + com.obsproject.obs-mac-virtualcam.server + + + diff --git a/plugins/mac-virtualcam/src/dal-plugin/Logging.h b/plugins/mac-virtualcam/src/dal-plugin/Logging.h new file mode 100644 index 000000000..d64a687d7 --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/Logging.h @@ -0,0 +1,32 @@ +// +// Logging.h +// obs-mac-virtualcam +// +// Created by John Boiles on 4/10/20. +// +// obs-mac-virtualcam is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 2 of the License, or +// (at your option) any later version. +// +// obs-mac-virtualcam is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with obs-mac-virtualcam. If not, see . + +#ifndef Logging_h +#define Logging_h + +#include "Defines.h" + +#define DLog(fmt, ...) NSLog((PLUGIN_NAME @"(DAL): " fmt), ##__VA_ARGS__) +#define DLogFunc(fmt, ...) \ + NSLog((PLUGIN_NAME @"(DAL): %s " fmt), __FUNCTION__, ##__VA_ARGS__) +#define VLog(fmt, ...) +#define VLogFunc(fmt, ...) +#define ELog(fmt, ...) DLog(fmt, ##__VA_ARGS__) + +#endif /* Logging_h */ diff --git a/plugins/mac-virtualcam/src/dal-plugin/MachClient.h b/plugins/mac-virtualcam/src/dal-plugin/MachClient.h new file mode 100644 index 000000000..bb4cef5e1 --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/MachClient.h @@ -0,0 +1,33 @@ +// +// MachClient.h +// dal-plugin +// +// Created by John Boiles on 5/5/20. +// + +#import + +NS_ASSUME_NONNULL_BEGIN + +@protocol MachClientDelegate + +- (void)receivedFrameWithSize:(NSSize)size + timestamp:(uint64_t)timestamp + fpsNumerator:(uint32_t)fpsNumerator + fpsDenominator:(uint32_t)fpsDenominator + frameData:(NSData *)frameData; +- (void)receivedStop; + +@end + +@interface MachClient : NSObject + +@property (nullable, weak) id delegate; + +- (BOOL)isServerAvailable; + +- (BOOL)connectToServer; + +@end + +NS_ASSUME_NONNULL_END diff --git a/plugins/mac-virtualcam/src/dal-plugin/MachClient.mm b/plugins/mac-virtualcam/src/dal-plugin/MachClient.mm new file mode 100644 index 000000000..a90e4ecfb --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/MachClient.mm @@ -0,0 +1,140 @@ +// +// MachClient.m +// dal-plugin +// +// Created by John Boiles on 5/5/20. +// + +#import "MachClient.h" +#import "MachProtocol.h" +#import "Logging.h" + +@interface MachClient () { + NSPort *_receivePort; +} +@end + +@implementation MachClient + +- (void)dealloc +{ + DLogFunc(@""); + _receivePort.delegate = nil; +} + +- (NSPort *)serverPort +{ +// See note in MachServer.mm and don't judge me +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-declarations" + return [[NSMachBootstrapServer sharedInstance] + portForName:@MACH_SERVICE_NAME]; +#pragma clang diagnostic pop +} + +- (BOOL)isServerAvailable +{ + return [self serverPort] != nil; +} + +- (NSPort *)receivePort +{ + if (_receivePort == nil) { + NSPort *receivePort = [NSMachPort port]; + _receivePort = receivePort; + _receivePort.delegate = self; + __weak __typeof(self) weakSelf = self; + dispatch_async( + dispatch_get_global_queue( + DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), + ^{ + NSRunLoop *runLoop = [NSRunLoop currentRunLoop]; + [runLoop addPort:receivePort + forMode:NSDefaultRunLoopMode]; + // weakSelf should become nil when this object gets destroyed + while (weakSelf) { + [[NSRunLoop currentRunLoop] + runUntilDate: + [NSDate dateWithTimeIntervalSinceNow: + 0.1]]; + } + DLog(@"Shutting down receive run loop"); + }); + DLog(@"Initialized mach port %d for receiving", + ((NSMachPort *)_receivePort).machPort); + } + return _receivePort; +} + +- (BOOL)connectToServer +{ + DLogFunc(@""); + + NSPort *sendPort = [self serverPort]; + if (sendPort == nil) { + ELog(@"Unable to connect to server port"); + return NO; + } + + NSPortMessage *message = [[NSPortMessage alloc] + initWithSendPort:sendPort + receivePort:self.receivePort + components:nil]; + message.msgid = MachMsgIdConnect; + + NSDate *timeout = [NSDate dateWithTimeIntervalSinceNow:5.0]; + if (![message sendBeforeDate:timeout]) { + ELog(@"sendBeforeDate failed"); + return NO; + } + + return YES; +} + +- (void)handlePortMessage:(NSPortMessage *)message +{ + VLogFunc(@""); + NSArray *components = message.components; + switch (message.msgid) { + case MachMsgIdConnect: + DLog(@"Received connect response"); + break; + case MachMsgIdFrame: + VLog(@"Received frame message"); + if (components.count >= 6) { + CGFloat width; + [components[0] getBytes:&width length:sizeof(width)]; + CGFloat height; + [components[1] getBytes:&height length:sizeof(height)]; + uint64_t timestamp; + [components[2] getBytes:×tamp + length:sizeof(timestamp)]; + VLog(@"Received frame data: %fx%f (%llu)", width, + height, timestamp); + NSData *frameData = components[3]; + uint32_t fpsNumerator; + [components[4] getBytes:&fpsNumerator + length:sizeof(fpsNumerator)]; + uint32_t fpsDenominator; + [components[5] getBytes:&fpsDenominator + length:sizeof(fpsDenominator)]; + [self.delegate + receivedFrameWithSize:NSMakeSize(width, height) + timestamp:timestamp + fpsNumerator:fpsNumerator + fpsDenominator:fpsDenominator + frameData:frameData]; + } + break; + case MachMsgIdStop: + DLog(@"Received stop message"); + [self.delegate receivedStop]; + break; + default: + ELog(@"Received unexpected response msgid %u", + (unsigned)message.msgid); + break; + } +} + +@end diff --git a/plugins/mac-virtualcam/src/dal-plugin/ObjectStore.h b/plugins/mac-virtualcam/src/dal-plugin/ObjectStore.h new file mode 100644 index 000000000..1b01f4423 --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/ObjectStore.h @@ -0,0 +1,62 @@ +// +// ObjectStore.h +// obs-mac-virtualcam +// +// Created by John Boiles on 4/10/20. +// +// obs-mac-virtualcam is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 2 of the License, or +// (at your option) any later version. +// +// obs-mac-virtualcam is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with obs-mac-virtualcam. If not, see . + +#import +#import + +NS_ASSUME_NONNULL_BEGIN + +@protocol CMIOObject + +- (BOOL)hasPropertyWithAddress:(CMIOObjectPropertyAddress)address; +- (BOOL)isPropertySettableWithAddress:(CMIOObjectPropertyAddress)address; +- (UInt32)getPropertyDataSizeWithAddress:(CMIOObjectPropertyAddress)address + qualifierDataSize:(UInt32)qualifierDataSize + qualifierData:(const void *)qualifierData; +- (void)getPropertyDataWithAddress:(CMIOObjectPropertyAddress)address + qualifierDataSize:(UInt32)qualifierDataSize + qualifierData:(const void *)qualifierData + dataSize:(UInt32)dataSize + dataUsed:(UInt32 *)dataUsed + data:(void *)data; +- (void)setPropertyDataWithAddress:(CMIOObjectPropertyAddress)address + qualifierDataSize:(UInt32)qualifierDataSize + qualifierData:(const void *)qualifierData + dataSize:(UInt32)dataSize + data:(const void *)data; + +@end + +@interface ObjectStore : NSObject + ++ (ObjectStore *)SharedObjectStore; + ++ (NSObject *)GetObjectWithId:(CMIOObjectID)objectId; + ++ (NSString *)StringFromPropertySelector:(CMIOObjectPropertySelector)selector; + ++ (BOOL)IsBridgedTypeForSelector:(CMIOObjectPropertySelector)selector; + +- (NSObject *)getObject:(CMIOObjectID)objectID; + +- (void)setObject:(id)object forObjectId:(CMIOObjectID)objectId; + +@end + +NS_ASSUME_NONNULL_END diff --git a/plugins/mac-virtualcam/src/dal-plugin/ObjectStore.mm b/plugins/mac-virtualcam/src/dal-plugin/ObjectStore.mm new file mode 100644 index 000000000..5c8ed3cd6 --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/ObjectStore.mm @@ -0,0 +1,281 @@ +// +// ObjectStore.mm +// obs-mac-virtualcam +// +// Created by John Boiles on 4/10/20. +// +// obs-mac-virtualcam is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 2 of the License, or +// (at your option) any later version. +// +// obs-mac-virtualcam is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with obs-mac-virtualcam. If not, see . + +#import "ObjectStore.h" + +@interface ObjectStore () +@property NSMutableDictionary *objectMap; +@end + +@implementation ObjectStore + +// 4-byte selectors to string for easy debugging ++ (NSString *)StringFromPropertySelector:(CMIOObjectPropertySelector)selector +{ + switch (selector) { + case kCMIODevicePropertyPlugIn: + return @"kCMIODevicePropertyPlugIn"; + case kCMIODevicePropertyDeviceUID: + return @"kCMIODevicePropertyDeviceUID"; + case kCMIODevicePropertyModelUID: + return @"kCMIODevicePropertyModelUID"; + case kCMIODevicePropertyTransportType: + return @"kCMIODevicePropertyTransportType"; + case kCMIODevicePropertyDeviceIsAlive: + return @"kCMIODevicePropertyDeviceIsAlive"; + case kCMIODevicePropertyDeviceHasChanged: + return @"kCMIODevicePropertyDeviceHasChanged"; + case kCMIODevicePropertyDeviceIsRunning: + return @"kCMIODevicePropertyDeviceIsRunning"; + case kCMIODevicePropertyDeviceIsRunningSomewhere: + return @"kCMIODevicePropertyDeviceIsRunningSomewhere"; + case kCMIODevicePropertyDeviceCanBeDefaultDevice: + return @"kCMIODevicePropertyDeviceCanBeDefaultDevice"; + case kCMIODevicePropertyHogMode: + return @"kCMIODevicePropertyHogMode"; + case kCMIODevicePropertyLatency: + return @"kCMIODevicePropertyLatency"; + case kCMIODevicePropertyStreams: + return @"kCMIODevicePropertyStreams"; + case kCMIODevicePropertyStreamConfiguration: + return @"kCMIODevicePropertyStreamConfiguration"; + case kCMIODevicePropertyDeviceMaster: + return @"kCMIODevicePropertyDeviceMaster"; + case kCMIODevicePropertyExcludeNonDALAccess: + return @"kCMIODevicePropertyExcludeNonDALAccess"; + case kCMIODevicePropertyClientSyncDiscontinuity: + return @"kCMIODevicePropertyClientSyncDiscontinuity"; + case kCMIODevicePropertySMPTETimeCallback: + return @"kCMIODevicePropertySMPTETimeCallback"; + case kCMIODevicePropertyCanProcessAVCCommand: + return @"kCMIODevicePropertyCanProcessAVCCommand"; + case kCMIODevicePropertyAVCDeviceType: + return @"kCMIODevicePropertyAVCDeviceType"; + case kCMIODevicePropertyAVCDeviceSignalMode: + return @"kCMIODevicePropertyAVCDeviceSignalMode"; + case kCMIODevicePropertyCanProcessRS422Command: + return @"kCMIODevicePropertyCanProcessRS422Command"; + case kCMIODevicePropertyLinkedCoreAudioDeviceUID: + return @"kCMIODevicePropertyLinkedCoreAudioDeviceUID"; + case kCMIODevicePropertyVideoDigitizerComponents: + return @"kCMIODevicePropertyVideoDigitizerComponents"; + case kCMIODevicePropertySuspendedByUser: + return @"kCMIODevicePropertySuspendedByUser"; + case kCMIODevicePropertyLinkedAndSyncedCoreAudioDeviceUID: + return @"kCMIODevicePropertyLinkedAndSyncedCoreAudioDeviceUID"; + case kCMIODevicePropertyIIDCInitialUnitSpace: + return @"kCMIODevicePropertyIIDCInitialUnitSpace"; + case kCMIODevicePropertyIIDCCSRData: + return @"kCMIODevicePropertyIIDCCSRData"; + case kCMIODevicePropertyCanSwitchFrameRatesWithoutFrameDrops: + return @"kCMIODevicePropertyCanSwitchFrameRatesWithoutFrameDrops"; + case kCMIODevicePropertyLocation: + return @"kCMIODevicePropertyLocation"; + case kCMIODevicePropertyDeviceHasStreamingError: + return @"kCMIODevicePropertyDeviceHasStreamingError"; + case kCMIODevicePropertyScopeInput: + return @"kCMIODevicePropertyScopeInput"; + case kCMIODevicePropertyScopeOutput: + return @"kCMIODevicePropertyScopeOutput"; + case kCMIODevicePropertyScopePlayThrough: + return @"kCMIODevicePropertyScopePlayThrough"; + case kCMIOObjectPropertyClass: + return @"kCMIOObjectPropertyClass"; + case kCMIOObjectPropertyOwner: + return @"kCMIOObjectPropertyOwner"; + case kCMIOObjectPropertyCreator: + return @"kCMIOObjectPropertyCreator"; + case kCMIOObjectPropertyName: + return @"kCMIOObjectPropertyName"; + case kCMIOObjectPropertyManufacturer: + return @"kCMIOObjectPropertyManufacturer"; + case kCMIOObjectPropertyElementName: + return @"kCMIOObjectPropertyElementName"; + case kCMIOObjectPropertyElementCategoryName: + return @"kCMIOObjectPropertyElementCategoryName"; + case kCMIOObjectPropertyElementNumberName: + return @"kCMIOObjectPropertyElementNumberName"; + case kCMIOObjectPropertyOwnedObjects: + return @"kCMIOObjectPropertyOwnedObjects"; + case kCMIOObjectPropertyListenerAdded: + return @"kCMIOObjectPropertyListenerAdded"; + case kCMIOObjectPropertyListenerRemoved: + return @"kCMIOObjectPropertyListenerRemoved"; + case kCMIOStreamPropertyDirection: + return @"kCMIOStreamPropertyDirection"; + case kCMIOStreamPropertyTerminalType: + return @"kCMIOStreamPropertyTerminalType"; + case kCMIOStreamPropertyStartingChannel: + return @"kCMIOStreamPropertyStartingChannel"; + // Same value as kCMIODevicePropertyLatency + // case kCMIOStreamPropertyLatency: + // return @"kCMIOStreamPropertyLatency"; + case kCMIOStreamPropertyFormatDescription: + return @"kCMIOStreamPropertyFormatDescription"; + case kCMIOStreamPropertyFormatDescriptions: + return @"kCMIOStreamPropertyFormatDescriptions"; + case kCMIOStreamPropertyStillImage: + return @"kCMIOStreamPropertyStillImage"; + case kCMIOStreamPropertyStillImageFormatDescriptions: + return @"kCMIOStreamPropertyStillImageFormatDescriptions"; + case kCMIOStreamPropertyFrameRate: + return @"kCMIOStreamPropertyFrameRate"; + case kCMIOStreamPropertyMinimumFrameRate: + return @"kCMIOStreamPropertyMinimumFrameRate"; + case kCMIOStreamPropertyFrameRates: + return @"kCMIOStreamPropertyFrameRates"; + case kCMIOStreamPropertyFrameRateRanges: + return @"kCMIOStreamPropertyFrameRateRanges"; + case kCMIOStreamPropertyNoDataTimeoutInMSec: + return @"kCMIOStreamPropertyNoDataTimeoutInMSec"; + case kCMIOStreamPropertyDeviceSyncTimeoutInMSec: + return @"kCMIOStreamPropertyDeviceSyncTimeoutInMSec"; + case kCMIOStreamPropertyNoDataEventCount: + return @"kCMIOStreamPropertyNoDataEventCount"; + case kCMIOStreamPropertyOutputBufferUnderrunCount: + return @"kCMIOStreamPropertyOutputBufferUnderrunCount"; + case kCMIOStreamPropertyOutputBufferRepeatCount: + return @"kCMIOStreamPropertyOutputBufferRepeatCount"; + case kCMIOStreamPropertyOutputBufferQueueSize: + return @"kCMIOStreamPropertyOutputBufferQueueSize"; + case kCMIOStreamPropertyOutputBuffersRequiredForStartup: + return @"kCMIOStreamPropertyOutputBuffersRequiredForStartup"; + case kCMIOStreamPropertyOutputBuffersNeededForThrottledPlayback: + return @"kCMIOStreamPropertyOutputBuffersNeededForThrottledPlayback"; + case kCMIOStreamPropertyFirstOutputPresentationTimeStamp: + return @"kCMIOStreamPropertyFirstOutputPresentationTimeStamp"; + case kCMIOStreamPropertyEndOfData: + return @"kCMIOStreamPropertyEndOfData"; + case kCMIOStreamPropertyClock: + return @"kCMIOStreamPropertyClock"; + case kCMIOStreamPropertyCanProcessDeckCommand: + return @"kCMIOStreamPropertyCanProcessDeckCommand"; + case kCMIOStreamPropertyDeck: + return @"kCMIOStreamPropertyDeck"; + case kCMIOStreamPropertyDeckFrameNumber: + return @"kCMIOStreamPropertyDeckFrameNumber"; + case kCMIOStreamPropertyDeckDropness: + return @"kCMIOStreamPropertyDeckDropness"; + case kCMIOStreamPropertyDeckThreaded: + return @"kCMIOStreamPropertyDeckThreaded"; + case kCMIOStreamPropertyDeckLocal: + return @"kCMIOStreamPropertyDeckLocal"; + case kCMIOStreamPropertyDeckCueing: + return @"kCMIOStreamPropertyDeckCueing"; + case kCMIOStreamPropertyInitialPresentationTimeStampForLinkedAndSyncedAudio: + return @"kCMIOStreamPropertyInitialPresentationTimeStampForLinkedAndSyncedAudio"; + case kCMIOStreamPropertyScheduledOutputNotificationProc: + return @"kCMIOStreamPropertyScheduledOutputNotificationProc"; + case kCMIOStreamPropertyPreferredFormatDescription: + return @"kCMIOStreamPropertyPreferredFormatDescription"; + case kCMIOStreamPropertyPreferredFrameRate: + return @"kCMIOStreamPropertyPreferredFrameRate"; + case kCMIOControlPropertyScope: + return @"kCMIOControlPropertyScope"; + case kCMIOControlPropertyElement: + return @"kCMIOControlPropertyElement"; + case kCMIOControlPropertyVariant: + return @"kCMIOControlPropertyVariant"; + case kCMIOHardwarePropertyProcessIsMaster: + return @"kCMIOHardwarePropertyProcessIsMaster"; + case kCMIOHardwarePropertyIsInitingOrExiting: + return @"kCMIOHardwarePropertyIsInitingOrExiting"; + case kCMIOHardwarePropertyDevices: + return @"kCMIOHardwarePropertyDevices"; + case kCMIOHardwarePropertyDefaultInputDevice: + return @"kCMIOHardwarePropertyDefaultInputDevice"; + case kCMIOHardwarePropertyDefaultOutputDevice: + return @"kCMIOHardwarePropertyDefaultOutputDevice"; + case kCMIOHardwarePropertyDeviceForUID: + return @"kCMIOHardwarePropertyDeviceForUID"; + case kCMIOHardwarePropertySleepingIsAllowed: + return @"kCMIOHardwarePropertySleepingIsAllowed"; + case kCMIOHardwarePropertyUnloadingIsAllowed: + return @"kCMIOHardwarePropertyUnloadingIsAllowed"; + case kCMIOHardwarePropertyPlugInForBundleID: + return @"kCMIOHardwarePropertyPlugInForBundleID"; + case kCMIOHardwarePropertyUserSessionIsActiveOrHeadless: + return @"kCMIOHardwarePropertyUserSessionIsActiveOrHeadless"; + case kCMIOHardwarePropertySuspendedBySystem: + return @"kCMIOHardwarePropertySuspendedBySystem"; + case kCMIOHardwarePropertyAllowScreenCaptureDevices: + return @"kCMIOHardwarePropertyAllowScreenCaptureDevices"; + case kCMIOHardwarePropertyAllowWirelessScreenCaptureDevices: + return @"kCMIOHardwarePropertyAllowWirelessScreenCaptureDevices"; + default: + uint8_t *chars = (uint8_t *)&selector; + return [NSString stringWithFormat:@"Unknown selector: %c%c%c%c", + chars[0], chars[1], chars[2], + chars[3]]; + } +} + ++ (BOOL)IsBridgedTypeForSelector:(CMIOObjectPropertySelector)selector +{ + switch (selector) { + case kCMIOObjectPropertyName: + case kCMIOObjectPropertyManufacturer: + case kCMIOObjectPropertyElementName: + case kCMIOObjectPropertyElementCategoryName: + case kCMIOObjectPropertyElementNumberName: + case kCMIODevicePropertyDeviceUID: + case kCMIODevicePropertyModelUID: + case kCMIOStreamPropertyFormatDescriptions: + case kCMIOStreamPropertyFormatDescription: + case kCMIOStreamPropertyClock: + return YES; + default: + return NO; + } +} + ++ (ObjectStore *)SharedObjectStore +{ + static ObjectStore *sObjectStore = nil; + static dispatch_once_t sOnceToken; + dispatch_once(&sOnceToken, ^{ + sObjectStore = [[self alloc] init]; + }); + return sObjectStore; +} + ++ (NSObject *)GetObjectWithId:(CMIOObjectID)objectId +{ + return [[ObjectStore SharedObjectStore] getObject:objectId]; +} + +- (id)init +{ + if (self = [super init]) { + self.objectMap = [[NSMutableDictionary alloc] init]; + } + return self; +} + +- (NSObject *)getObject:(CMIOObjectID)objectID +{ + return self.objectMap[@(objectID)]; +} + +- (void)setObject:(id)object forObjectId:(CMIOObjectID)objectId +{ + self.objectMap[@(objectId)] = object; +} + +@end diff --git a/plugins/mac-virtualcam/src/dal-plugin/PlugIn.h b/plugins/mac-virtualcam/src/dal-plugin/PlugIn.h new file mode 100644 index 000000000..c0d044bbe --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/PlugIn.h @@ -0,0 +1,51 @@ +// +// PlugIn.h +// obs-mac-virtualcam +// +// Created by John Boiles on 4/9/20. +// +// obs-mac-virtualcam is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 2 of the License, or +// (at your option) any later version. +// +// obs-mac-virtualcam is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with obs-mac-virtualcam. If not, see . + +#import +#import + +#import "ObjectStore.h" +#import "MachClient.h" +#import "Stream.h" + +#define kTestCardWidthKey @"obs-mac-virtualcam-test-card-width" +#define kTestCardHeightKey @"obs-mac-virtualcam-test-card-height" +#define kTestCardFPSKey @"obs-mac-virtualcam-test-card-fps" + +NS_ASSUME_NONNULL_BEGIN + +@interface PlugIn : NSObject + +@property CMIOObjectID objectId; +@property (readonly) MachClient *machClient; +@property Stream *stream; + ++ (PlugIn *)SharedPlugIn; + +- (void)initialize; + +- (void)teardown; + +- (void)startStream; + +- (void)stopStream; + +@end + +NS_ASSUME_NONNULL_END diff --git a/plugins/mac-virtualcam/src/dal-plugin/PlugIn.mm b/plugins/mac-virtualcam/src/dal-plugin/PlugIn.mm new file mode 100644 index 000000000..716e3fa62 --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/PlugIn.mm @@ -0,0 +1,255 @@ +// +// PlugIn.mm +// obs-mac-virtualcam +// +// Created by John Boiles on 4/9/20. +// +// obs-mac-virtualcam is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 2 of the License, or +// (at your option) any later version. +// +// obs-mac-virtualcam is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with obs-mac-virtualcam. If not, see . + +#import "PlugIn.h" + +#import + +#import "Logging.h" + +typedef enum { + PlugInStateNotStarted = 0, + PlugInStateWaitingForServer, + PlugInStateReceivingFrames, +} PlugInState; + +@interface PlugIn () { + //! Serial queue for all state changes that need to be concerned with thread safety + dispatch_queue_t _stateQueue; + + //! Repeated timer for driving the mach server re-connection + dispatch_source_t _machConnectTimer; + + //! Timeout timer when we haven't received frames for 5s + dispatch_source_t _timeoutTimer; +} +@property PlugInState state; +@property MachClient *machClient; + +@end + +@implementation PlugIn + ++ (PlugIn *)SharedPlugIn +{ + static PlugIn *sPlugIn = nil; + static dispatch_once_t sOnceToken; + dispatch_once(&sOnceToken, ^{ + sPlugIn = [[self alloc] init]; + }); + return sPlugIn; +} + +- (instancetype)init +{ + if (self = [super init]) { + _stateQueue = dispatch_queue_create( + "com.obsproject.obs-mac-virtualcam.dal.state", + DISPATCH_QUEUE_SERIAL); + + _timeoutTimer = dispatch_source_create( + DISPATCH_SOURCE_TYPE_TIMER, 0, 0, _stateQueue); + __weak __typeof(self) weakSelf = self; + dispatch_source_set_event_handler(_timeoutTimer, ^{ + if (weakSelf.state == PlugInStateReceivingFrames) { + DLog(@"No frames received for 5s, restarting connection"); + [self stopStream]; + [self startStream]; + } + }); + + _machClient = [[MachClient alloc] init]; + _machClient.delegate = self; + + _machConnectTimer = dispatch_source_create( + DISPATCH_SOURCE_TYPE_TIMER, 0, 0, _stateQueue); + dispatch_time_t startTime = dispatch_time(DISPATCH_TIME_NOW, 0); + uint64_t intervalTime = (int64_t)(1 * NSEC_PER_SEC); + dispatch_source_set_timer(_machConnectTimer, startTime, + intervalTime, 0); + dispatch_source_set_event_handler(_machConnectTimer, ^{ + if (![[weakSelf machClient] isServerAvailable]) { + DLog(@"Server is not available"); + } else if (weakSelf.state == + PlugInStateWaitingForServer) { + DLog(@"Attempting connection"); + [[weakSelf machClient] connectToServer]; + } + }); + } + return self; +} + +- (void)startStream +{ + DLogFunc(@""); + dispatch_async(_stateQueue, ^{ + if (_state == PlugInStateNotStarted) { + dispatch_resume(_machConnectTimer); + [self.stream startServingDefaultFrames]; + _state = PlugInStateWaitingForServer; + } + }); +} + +- (void)stopStream +{ + DLogFunc(@""); + dispatch_async(_stateQueue, ^{ + if (_state == PlugInStateWaitingForServer) { + dispatch_suspend(_machConnectTimer); + [self.stream stopServingDefaultFrames]; + } else if (_state == PlugInStateReceivingFrames) { + // TODO: Disconnect from the mach server? + dispatch_suspend(_timeoutTimer); + } + _state = PlugInStateNotStarted; + }); +} + +- (void)initialize +{ +} + +- (void)teardown +{ +} + +#pragma mark - CMIOObject + +- (BOOL)hasPropertyWithAddress:(CMIOObjectPropertyAddress)address +{ + switch (address.mSelector) { + case kCMIOObjectPropertyName: + return true; + default: + DLog(@"PlugIn unhandled hasPropertyWithAddress for %@", + [ObjectStore + StringFromPropertySelector:address.mSelector]); + return false; + }; +} + +- (BOOL)isPropertySettableWithAddress:(CMIOObjectPropertyAddress)address +{ + switch (address.mSelector) { + case kCMIOObjectPropertyName: + return false; + default: + DLog(@"PlugIn unhandled isPropertySettableWithAddress for %@", + [ObjectStore + StringFromPropertySelector:address.mSelector]); + return false; + }; +} + +- (UInt32)getPropertyDataSizeWithAddress:(CMIOObjectPropertyAddress)address + qualifierDataSize:(UInt32)qualifierDataSize + qualifierData:(const void *)qualifierData +{ + switch (address.mSelector) { + case kCMIOObjectPropertyName: + return sizeof(CFStringRef); + default: + DLog(@"PlugIn unhandled getPropertyDataSizeWithAddress for %@", + [ObjectStore + StringFromPropertySelector:address.mSelector]); + return 0; + }; +} + +- (void)getPropertyDataWithAddress:(CMIOObjectPropertyAddress)address + qualifierDataSize:(UInt32)qualifierDataSize + qualifierData:(nonnull const void *)qualifierData + dataSize:(UInt32)dataSize + dataUsed:(nonnull UInt32 *)dataUsed + data:(nonnull void *)data +{ + switch (address.mSelector) { + case kCMIOObjectPropertyName: + *static_cast(data) = + CFSTR("OBS Virtual Camera Plugin"); + *dataUsed = sizeof(CFStringRef); + return; + default: + DLog(@"PlugIn unhandled getPropertyDataWithAddress for %@", + [ObjectStore + StringFromPropertySelector:address.mSelector]); + return; + }; +} + +- (void)setPropertyDataWithAddress:(CMIOObjectPropertyAddress)address + qualifierDataSize:(UInt32)qualifierDataSize + qualifierData:(nonnull const void *)qualifierData + dataSize:(UInt32)dataSize + data:(nonnull const void *)data +{ + DLog(@"PlugIn unhandled setPropertyDataWithAddress for %@", + [ObjectStore StringFromPropertySelector:address.mSelector]); +} + +#pragma mark - MachClientDelegate + +- (void)receivedFrameWithSize:(NSSize)size + timestamp:(uint64_t)timestamp + fpsNumerator:(uint32_t)fpsNumerator + fpsDenominator:(uint32_t)fpsDenominator + frameData:(NSData *)frameData +{ + dispatch_sync(_stateQueue, ^{ + if (_state == PlugInStateWaitingForServer) { + NSUserDefaults *defaults = + [NSUserDefaults standardUserDefaults]; + [defaults setInteger:size.width + forKey:kTestCardWidthKey]; + [defaults setInteger:size.height + forKey:kTestCardHeightKey]; + [defaults setDouble:(double)fpsNumerator / + (double)fpsDenominator + forKey:kTestCardFPSKey]; + + dispatch_suspend(_machConnectTimer); + [self.stream stopServingDefaultFrames]; + dispatch_resume(_timeoutTimer); + _state = PlugInStateReceivingFrames; + } + }); + + // Add 5 more seconds onto the timeout timer + dispatch_source_set_timer( + _timeoutTimer, + dispatch_time(DISPATCH_TIME_NOW, 5.0 * NSEC_PER_SEC), + 5.0 * NSEC_PER_SEC, (1ull * NSEC_PER_SEC) / 10); + + [self.stream queueFrameWithSize:size + timestamp:timestamp + fpsNumerator:fpsNumerator + fpsDenominator:fpsDenominator + frameData:frameData]; +} + +- (void)receivedStop +{ + DLogFunc(@"Restarting connection"); + [self stopStream]; + [self startStream]; +} + +@end diff --git a/plugins/mac-virtualcam/src/dal-plugin/PlugInInterface.h b/plugins/mac-virtualcam/src/dal-plugin/PlugInInterface.h new file mode 100644 index 000000000..54f1fc4fa --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/PlugInInterface.h @@ -0,0 +1,23 @@ +// +// PlugInInterface.h +// obs-mac-virtualcam +// +// Created by John Boiles on 4/9/20. +// +// obs-mac-virtualcam is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 2 of the License, or +// (at your option) any later version. +// +// obs-mac-virtualcam is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with obs-mac-virtualcam. If not, see . + +#import + +// The static singleton of the plugin interface +CMIOHardwarePlugInRef PlugInRef(); diff --git a/plugins/mac-virtualcam/src/dal-plugin/PlugInInterface.mm b/plugins/mac-virtualcam/src/dal-plugin/PlugInInterface.mm new file mode 100644 index 000000000..5f9632136 --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/PlugInInterface.mm @@ -0,0 +1,444 @@ +// +// PlugInInterface.mm +// obs-mac-virtualcam +// +// This file implements the CMIO DAL plugin interface +// +// Created by John Boiles on 4/9/20. +// +// obs-mac-virtualcam is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 2 of the License, or +// (at your option) any later version. +// +// obs-mac-virtualcam is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with obs-mac-virtualcam. If not, see . + +#import "PlugInInterface.h" + +#import + +#import "PlugIn.h" +#import "Device.h" +#import "Stream.h" +#import "Logging.h" + +#pragma mark Plug-In Operations + +static UInt32 sRefCount = 0; + +ULONG HardwarePlugIn_AddRef(CMIOHardwarePlugInRef self) +{ + sRefCount += 1; + DLogFunc(@"sRefCount now = %d", sRefCount); + return sRefCount; +} + +ULONG HardwarePlugIn_Release(CMIOHardwarePlugInRef self) +{ + sRefCount -= 1; + DLogFunc(@"sRefCount now = %d", sRefCount); + return sRefCount; +} + +HRESULT HardwarePlugIn_QueryInterface(CMIOHardwarePlugInRef self, REFIID uuid, + LPVOID *interface) +{ + DLogFunc(@""); + + if (!interface) { + DLogFunc(@"Received an empty interface"); + return E_POINTER; + } + + // Set the returned interface to NULL in case the UUIDs don't match + *interface = NULL; + + // Create a CoreFoundation UUIDRef for the requested interface. + CFUUIDRef cfUuid = CFUUIDCreateFromUUIDBytes(kCFAllocatorDefault, uuid); + CFStringRef uuidString = CFUUIDCreateString(NULL, cfUuid); + CFStringRef hardwarePluginUuid = + CFUUIDCreateString(NULL, kCMIOHardwarePlugInInterfaceID); + + if (CFEqual(uuidString, hardwarePluginUuid)) { + // Return the interface; + sRefCount += 1; + *interface = PlugInRef(); + return kCMIOHardwareNoError; + } else { + DLogFunc(@"ERR Queried for some weird UUID %@", uuidString); + } + + return E_NOINTERFACE; +} + +// I think this is deprecated, seems that HardwarePlugIn_InitializeWithObjectID gets called instead +OSStatus HardwarePlugIn_Initialize(CMIOHardwarePlugInRef self) +{ + DLogFunc(@"ERR self=%p", self); + return kCMIOHardwareUnspecifiedError; +} + +OSStatus HardwarePlugIn_InitializeWithObjectID(CMIOHardwarePlugInRef self, + CMIOObjectID objectID) +{ + DLogFunc(@"self=%p", self); + + OSStatus error = kCMIOHardwareNoError; + + PlugIn *plugIn = [PlugIn SharedPlugIn]; + plugIn.objectId = objectID; + [[ObjectStore SharedObjectStore] setObject:plugIn forObjectId:objectID]; + + Device *device = [[Device alloc] init]; + CMIOObjectID deviceId; + error = CMIOObjectCreate(PlugInRef(), kCMIOObjectSystemObject, + kCMIODeviceClassID, &deviceId); + if (error != noErr) { + DLog(@"CMIOObjectCreate Error %d", error); + return error; + } + device.objectId = deviceId; + device.pluginId = objectID; + [[ObjectStore SharedObjectStore] setObject:device forObjectId:deviceId]; + + Stream *stream = [[Stream alloc] init]; + CMIOObjectID streamId; + error = CMIOObjectCreate(PlugInRef(), deviceId, kCMIOStreamClassID, + &streamId); + if (error != noErr) { + DLog(@"CMIOObjectCreate Error %d", error); + return error; + } + stream.objectId = streamId; + [[ObjectStore SharedObjectStore] setObject:stream forObjectId:streamId]; + device.streamId = streamId; + plugIn.stream = stream; + + // Tell the system about the Device + error = CMIOObjectsPublishedAndDied( + PlugInRef(), kCMIOObjectSystemObject, 1, &deviceId, 0, 0); + if (error != kCMIOHardwareNoError) { + DLog(@"CMIOObjectsPublishedAndDied plugin/device Error %d", + error); + return error; + } + + // Tell the system about the Stream + error = CMIOObjectsPublishedAndDied(PlugInRef(), deviceId, 1, &streamId, + 0, 0); + if (error != kCMIOHardwareNoError) { + DLog(@"CMIOObjectsPublishedAndDied device/stream Error %d", + error); + return error; + } + + return error; +} + +OSStatus HardwarePlugIn_Teardown(CMIOHardwarePlugInRef self) +{ + DLogFunc(@"self=%p", self); + + OSStatus error = kCMIOHardwareNoError; + + PlugIn *plugIn = [PlugIn SharedPlugIn]; + [plugIn teardown]; + + return error; +} + +#pragma mark CMIOObject Operations + +void HardwarePlugIn_ObjectShow(CMIOHardwarePlugInRef self, + CMIOObjectID objectID) +{ + DLogFunc(@"self=%p", self); +} + +Boolean +HardwarePlugIn_ObjectHasProperty(CMIOHardwarePlugInRef self, + CMIOObjectID objectID, + const CMIOObjectPropertyAddress *address) +{ + + NSObject *object = [ObjectStore GetObjectWithId:objectID]; + + if (object == nil) { + DLogFunc(@"ERR nil object"); + return false; + } + + Boolean answer = [object hasPropertyWithAddress:*address]; + + // Disabling Noisy logs + // DLogFunc(@"%@(%d) %@ self=%p hasProperty=%d", NSStringFromClass([object class]), objectID, [ObjectStore StringFromPropertySelector:address->mSelector], self, answer); + + return answer; +} + +OSStatus HardwarePlugIn_ObjectIsPropertySettable( + CMIOHardwarePlugInRef self, CMIOObjectID objectID, + const CMIOObjectPropertyAddress *address, Boolean *isSettable) +{ + + NSObject *object = [ObjectStore GetObjectWithId:objectID]; + + if (object == nil) { + DLogFunc(@"ERR nil object"); + return kCMIOHardwareBadObjectError; + } + + *isSettable = [object isPropertySettableWithAddress:*address]; + + DLogFunc(@"%@(%d) %@ self=%p settable=%d", + NSStringFromClass([object class]), objectID, + [ObjectStore StringFromPropertySelector:address->mSelector], + self, *isSettable); + + return kCMIOHardwareNoError; +} + +OSStatus HardwarePlugIn_ObjectGetPropertyDataSize( + CMIOHardwarePlugInRef self, CMIOObjectID objectID, + const CMIOObjectPropertyAddress *address, UInt32 qualifierDataSize, + const void *qualifierData, UInt32 *dataSize) +{ + + NSObject *object = [ObjectStore GetObjectWithId:objectID]; + + if (object == nil) { + DLogFunc(@"ERR nil object"); + return kCMIOHardwareBadObjectError; + } + + *dataSize = [object getPropertyDataSizeWithAddress:*address + qualifierDataSize:qualifierDataSize + qualifierData:qualifierData]; + + // Disabling Noisy logs + // DLogFunc(@"%@(%d) %@ self=%p size=%d", NSStringFromClass([object class]), objectID, [ObjectStore StringFromPropertySelector:address->mSelector], self, *dataSize); + + return kCMIOHardwareNoError; +} + +OSStatus HardwarePlugIn_ObjectGetPropertyData( + CMIOHardwarePlugInRef self, CMIOObjectID objectID, + const CMIOObjectPropertyAddress *address, UInt32 qualifierDataSize, + const void *qualifierData, UInt32 dataSize, UInt32 *dataUsed, + void *data) +{ + + NSObject *object = [ObjectStore GetObjectWithId:objectID]; + + if (object == nil) { + DLogFunc(@"ERR nil object"); + return kCMIOHardwareBadObjectError; + } + + [object getPropertyDataWithAddress:*address + qualifierDataSize:qualifierDataSize + qualifierData:qualifierData + dataSize:dataSize + dataUsed:dataUsed + data:data]; + + // Disabling Noisy logs + // if ([ObjectStore IsBridgedTypeForSelector:address->mSelector]) { + // id dataObj = (__bridge NSObject *)*static_cast(data); + // DLogFunc(@"%@(%d) %@ self=%p data(id)=%@", NSStringFromClass([object class]), objectID, [ObjectStore StringFromPropertySelector:address->mSelector], self, dataObj); + // } else { + // UInt32 *dataInt = (UInt32 *)data; + // DLogFunc(@"%@(%d) %@ self=%p data(int)=%d", NSStringFromClass([object class]), objectID, [ObjectStore StringFromPropertySelector:address->mSelector], self, *dataInt); + // } + + return kCMIOHardwareNoError; +} + +OSStatus HardwarePlugIn_ObjectSetPropertyData( + CMIOHardwarePlugInRef self, CMIOObjectID objectID, + const CMIOObjectPropertyAddress *address, UInt32 qualifierDataSize, + const void *qualifierData, UInt32 dataSize, const void *data) +{ + + NSObject *object = [ObjectStore GetObjectWithId:objectID]; + + if (object == nil) { + DLogFunc(@"ERR nil object"); + return kCMIOHardwareBadObjectError; + } + + UInt32 *dataInt = (UInt32 *)data; + DLogFunc(@"%@(%d) %@ self=%p data(int)=%d", + NSStringFromClass([object class]), objectID, + [ObjectStore StringFromPropertySelector:address->mSelector], + self, *dataInt); + + [object setPropertyDataWithAddress:*address + qualifierDataSize:qualifierDataSize + qualifierData:qualifierData + dataSize:dataSize + data:data]; + + return kCMIOHardwareNoError; +} + +#pragma mark CMIOStream Operations +OSStatus HardwarePlugIn_StreamCopyBufferQueue( + CMIOHardwarePlugInRef self, CMIOStreamID streamID, + CMIODeviceStreamQueueAlteredProc queueAlteredProc, + void *queueAlteredRefCon, CMSimpleQueueRef *queue) +{ + + Stream *stream = (Stream *)[ObjectStore GetObjectWithId:streamID]; + + if (stream == nil) { + DLogFunc(@"ERR nil object"); + return kCMIOHardwareBadObjectError; + } + + *queue = [stream copyBufferQueueWithAlteredProc:queueAlteredProc + alteredRefCon:queueAlteredRefCon]; + + DLogFunc(@"%@ (id=%d) self=%p queue=%@", stream, streamID, self, + (__bridge NSObject *)*queue); + + return kCMIOHardwareNoError; +} + +#pragma mark CMIODevice Operations +OSStatus HardwarePlugIn_DeviceStartStream(CMIOHardwarePlugInRef self, + CMIODeviceID deviceID, + CMIOStreamID streamID) +{ + DLogFunc(@"self=%p device=%d stream=%d", self, deviceID, streamID); + + Stream *stream = (Stream *)[ObjectStore GetObjectWithId:streamID]; + + if (stream == nil) { + DLogFunc(@"ERR nil object"); + return kCMIOHardwareBadObjectError; + } + + [[PlugIn SharedPlugIn] startStream]; + + return kCMIOHardwareNoError; +} + +OSStatus HardwarePlugIn_DeviceSuspend(CMIOHardwarePlugInRef self, + CMIODeviceID deviceID) +{ + DLogFunc(@"self=%p", self); + return kCMIOHardwareNoError; +} + +OSStatus HardwarePlugIn_DeviceResume(CMIOHardwarePlugInRef self, + CMIODeviceID deviceID) +{ + DLogFunc(@"self=%p", self); + return kCMIOHardwareNoError; +} + +OSStatus HardwarePlugIn_DeviceStopStream(CMIOHardwarePlugInRef self, + CMIODeviceID deviceID, + CMIOStreamID streamID) +{ + DLogFunc(@"self=%p device=%d stream=%d", self, deviceID, streamID); + + Stream *stream = (Stream *)[ObjectStore GetObjectWithId:streamID]; + + if (stream == nil) { + DLogFunc(@"ERR nil object"); + return kCMIOHardwareBadObjectError; + } + + [[PlugIn SharedPlugIn] stopStream]; + + return kCMIOHardwareNoError; +} + +OSStatus +HardwarePlugIn_DeviceProcessAVCCommand(CMIOHardwarePlugInRef self, + CMIODeviceID deviceID, + CMIODeviceAVCCommand *ioAVCCommand) +{ + DLogFunc(@"self=%p", self); + return kCMIOHardwareNoError; +} + +OSStatus +HardwarePlugIn_DeviceProcessRS422Command(CMIOHardwarePlugInRef self, + CMIODeviceID deviceID, + CMIODeviceRS422Command *ioRS422Command) +{ + DLogFunc(@"self=%p", self); + return kCMIOHardwareNoError; +} + +OSStatus HardwarePlugIn_StreamDeckPlay(CMIOHardwarePlugInRef self, + CMIOStreamID streamID) +{ + DLogFunc(@"self=%p", self); + return kCMIOHardwareIllegalOperationError; +} + +OSStatus HardwarePlugIn_StreamDeckStop(CMIOHardwarePlugInRef self, + CMIOStreamID streamID) +{ + DLogFunc(@"self=%p", self); + return kCMIOHardwareIllegalOperationError; +} + +OSStatus HardwarePlugIn_StreamDeckJog(CMIOHardwarePlugInRef self, + CMIOStreamID streamID, SInt32 speed) +{ + DLogFunc(@"self=%p", self); + return kCMIOHardwareIllegalOperationError; +} + +OSStatus HardwarePlugIn_StreamDeckCueTo(CMIOHardwarePlugInRef self, + CMIOStreamID streamID, + Float64 requestedTimecode, + Boolean playOnCue) +{ + DLogFunc(@"self=%p", self); + return kCMIOHardwareIllegalOperationError; +} + +static CMIOHardwarePlugInInterface sInterface = { + // Padding for COM + NULL, + + // IUnknown Routines + (HRESULT (*)(void *, CFUUIDBytes, + void **))HardwarePlugIn_QueryInterface, + (ULONG(*)(void *))HardwarePlugIn_AddRef, + (ULONG(*)(void *))HardwarePlugIn_Release, + + // DAL Plug-In Routines + HardwarePlugIn_Initialize, HardwarePlugIn_InitializeWithObjectID, + HardwarePlugIn_Teardown, HardwarePlugIn_ObjectShow, + HardwarePlugIn_ObjectHasProperty, + HardwarePlugIn_ObjectIsPropertySettable, + HardwarePlugIn_ObjectGetPropertyDataSize, + HardwarePlugIn_ObjectGetPropertyData, + HardwarePlugIn_ObjectSetPropertyData, HardwarePlugIn_DeviceSuspend, + HardwarePlugIn_DeviceResume, HardwarePlugIn_DeviceStartStream, + HardwarePlugIn_DeviceStopStream, HardwarePlugIn_DeviceProcessAVCCommand, + HardwarePlugIn_DeviceProcessRS422Command, + HardwarePlugIn_StreamCopyBufferQueue, HardwarePlugIn_StreamDeckPlay, + HardwarePlugIn_StreamDeckStop, HardwarePlugIn_StreamDeckJog, + HardwarePlugIn_StreamDeckCueTo}; + +static CMIOHardwarePlugInInterface *sInterfacePtr = &sInterface; +static CMIOHardwarePlugInRef sPlugInRef = &sInterfacePtr; + +CMIOHardwarePlugInRef PlugInRef() +{ + return sPlugInRef; +} diff --git a/plugins/mac-virtualcam/src/dal-plugin/PlugInMain.mm b/plugins/mac-virtualcam/src/dal-plugin/PlugInMain.mm new file mode 100644 index 000000000..45a13f418 --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/PlugInMain.mm @@ -0,0 +1,37 @@ +// +// PlugInMain.mm +// obs-mac-virtualcam +// +// Created by John Boiles on 4/9/20. +// +// obs-mac-virtualcam is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 2 of the License, or +// (at your option) any later version. +// +// obs-mac-virtualcam is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with obs-mac-virtualcam. If not, see . + +#import + +#import "PlugInInterface.h" +#import "Logging.h" +#import "Defines.h" + +//! PlugInMain is the entrypoint for the plugin +extern "C" { +void *PlugInMain(CFAllocatorRef allocator, CFUUIDRef requestedTypeUUID) +{ + DLogFunc(@"version=%@", PLUGIN_VERSION); + if (!CFEqual(requestedTypeUUID, kCMIOHardwarePlugInTypeID)) { + return 0; + } + + return PlugInRef(); +} +} diff --git a/plugins/mac-virtualcam/src/dal-plugin/Stream.h b/plugins/mac-virtualcam/src/dal-plugin/Stream.h new file mode 100644 index 000000000..53d12115c --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/Stream.h @@ -0,0 +1,48 @@ +// +// Stream.h +// obs-mac-virtualcam +// +// Created by John Boiles on 4/10/20. +// +// obs-mac-virtualcam is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 2 of the License, or +// (at your option) any later version. +// +// obs-mac-virtualcam is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with obs-mac-virtualcam. If not, see . + +#import + +#import "ObjectStore.h" + +NS_ASSUME_NONNULL_BEGIN + +@interface Stream : NSObject + +@property CMIOStreamID objectId; + +- (instancetype _Nonnull)init; + +- (CMSimpleQueueRef)copyBufferQueueWithAlteredProc: + (CMIODeviceStreamQueueAlteredProc)alteredProc + alteredRefCon:(void *)alteredRefCon; + +- (void)startServingDefaultFrames; + +- (void)stopServingDefaultFrames; + +- (void)queueFrameWithSize:(NSSize)size + timestamp:(uint64_t)timestamp + fpsNumerator:(uint32_t)fpsNumerator + fpsDenominator:(uint32_t)fpsDenominator + frameData:(NSData *)frameData; + +@end + +NS_ASSUME_NONNULL_END diff --git a/plugins/mac-virtualcam/src/dal-plugin/Stream.mm b/plugins/mac-virtualcam/src/dal-plugin/Stream.mm new file mode 100644 index 000000000..1c6dc5540 --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/Stream.mm @@ -0,0 +1,571 @@ +// +// Stream.mm +// obs-mac-virtualcam +// +// Created by John Boiles on 4/10/20. +// +// obs-mac-virtualcam is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 2 of the License, or +// (at your option) any later version. +// +// obs-mac-virtualcam is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with obs-mac-virtualcam. If not, see . + +#import "Stream.h" + +#import +#import +#include + +#import "Logging.h" +#import "CMSampleBufferUtils.h" +#import "TestCard.h" +#import "PlugIn.h" + +@interface Stream () { + CMSimpleQueueRef _queue; + CFTypeRef _clock; + NSImage *_testCardImage; + dispatch_source_t _frameDispatchSource; + NSSize _testCardSize; + Float64 _fps; +} + +@property CMIODeviceStreamQueueAlteredProc alteredProc; +@property void *alteredRefCon; +@property (readonly) CMSimpleQueueRef queue; +@property (readonly) CFTypeRef clock; +@property UInt64 sequenceNumber; +@property (readonly) NSImage *testCardImage; +@property (readonly) NSSize testCardSize; +@property (readonly) Float64 fps; + +@end + +@implementation Stream + +#define DEFAULT_FPS 30.0 +#define DEFAULT_WIDTH 1280 +#define DEFAULT_HEIGHT 720 + +- (instancetype _Nonnull)init +{ + self = [super init]; + if (self) { + _frameDispatchSource = dispatch_source_create( + DISPATCH_SOURCE_TYPE_TIMER, 0, 0, + dispatch_get_global_queue( + DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)); + __weak __typeof(self) wself = self; + dispatch_source_set_event_handler(_frameDispatchSource, ^{ + [wself fillFrame]; + }); + } + return self; +} + +- (void)dealloc +{ + DLog(@"Stream Dealloc"); + CMIOStreamClockInvalidate(_clock); + CFRelease(_clock); + _clock = NULL; + CFRelease(_queue); + _queue = NULL; + dispatch_suspend(_frameDispatchSource); +} + +- (void)startServingDefaultFrames +{ + DLogFunc(@""); + _testCardImage = nil; + _testCardSize = NSZeroSize; + _fps = 0; + dispatch_time_t startTime = dispatch_time(DISPATCH_TIME_NOW, 0); + uint64_t intervalTime = (int64_t)(NSEC_PER_SEC / self.fps); + dispatch_source_set_timer(_frameDispatchSource, startTime, intervalTime, + 0); + dispatch_resume(_frameDispatchSource); +} + +- (void)stopServingDefaultFrames +{ + DLogFunc(@""); + dispatch_suspend(_frameDispatchSource); +} + +- (CMSimpleQueueRef)queue +{ + if (_queue == NULL) { + // Allocate a one-second long queue, which we can use our FPS constant for. + OSStatus err = CMSimpleQueueCreate(kCFAllocatorDefault, + self.fps, &_queue); + if (err != noErr) { + DLog(@"Err %d in CMSimpleQueueCreate", err); + } + } + return _queue; +} + +- (CFTypeRef)clock +{ + if (_clock == NULL) { + OSStatus err = CMIOStreamClockCreate( + kCFAllocatorDefault, + CFSTR("obs-mac-virtualcam::Stream::clock"), + (__bridge void *)self, CMTimeMake(1, 10), 100, 10, + &_clock); + if (err != noErr) { + DLog(@"Error %d from CMIOStreamClockCreate", err); + } + } + return _clock; +} + +- (NSSize)testCardSize +{ + if (NSEqualSizes(_testCardSize, NSZeroSize)) { + NSUserDefaults *defaults = + [NSUserDefaults standardUserDefaults]; + int width = [[defaults objectForKey:kTestCardWidthKey] + integerValue]; + int height = [[defaults objectForKey:kTestCardHeightKey] + integerValue]; + if (width == 0 || height == 0) { + _testCardSize = + NSMakeSize(DEFAULT_WIDTH, DEFAULT_HEIGHT); + } else { + _testCardSize = NSMakeSize(width, height); + } + } + return _testCardSize; +} + +- (Float64)fps +{ + if (_fps == 0) { + NSUserDefaults *defaults = + [NSUserDefaults standardUserDefaults]; + double fps = + [[defaults objectForKey:kTestCardFPSKey] doubleValue]; + if (fps == 0) { + _fps = DEFAULT_FPS; + } else { + _fps = fps; + } + } + return _fps; +} + +- (NSImage *)testCardImage +{ + if (_testCardImage == nil) { + NSString *bundlePath = + [[NSBundle bundleForClass:[Stream class]] bundlePath]; + NSString *placeHolderPath = [bundlePath + stringByAppendingString: + @"/Contents/Resources/placeholder.png"]; + NSImage *placeholderImage = [[NSImage alloc] + initWithContentsOfFile:placeHolderPath]; + + NSBitmapImageRep *rep = [[NSBitmapImageRep alloc] + initWithBitmapDataPlanes:NULL + pixelsWide:self.testCardSize.width + pixelsHigh:self.testCardSize.height + bitsPerSample:8 + samplesPerPixel:4 + hasAlpha:YES + isPlanar:NO + colorSpaceName:NSCalibratedRGBColorSpace + bytesPerRow:0 + bitsPerPixel:0]; + rep.size = self.testCardSize; + + float hScale = + placeholderImage.size.width / self.testCardSize.width; + float vScale = + placeholderImage.size.height / self.testCardSize.height; + + float scaling = fmax(hScale, vScale); + + float newWidth = placeholderImage.size.width / scaling; + float newHeight = placeholderImage.size.height / scaling; + + float leftOffset = (self.testCardSize.width - newWidth) / 2; + float topOffset = (self.testCardSize.height - newHeight) / 2; + + [NSGraphicsContext saveGraphicsState]; + [NSGraphicsContext + setCurrentContext: + [NSGraphicsContext + graphicsContextWithBitmapImageRep:rep]]; + + NSColor *backgroundColor = [NSColor blackColor]; + [backgroundColor set]; + NSRectFill(NSMakeRect(0, 0, self.testCardSize.width, + self.testCardSize.height)); + + [placeholderImage drawInRect:NSMakeRect(leftOffset, topOffset, + newWidth, newHeight) + fromRect:NSZeroRect + operation:NSCompositingOperationCopy + fraction:1.0]; + [NSGraphicsContext restoreGraphicsState]; + + NSImage *testCardImage = + [[NSImage alloc] initWithSize:self.testCardSize]; + [testCardImage addRepresentation:rep]; + + _testCardImage = testCardImage; + } + return _testCardImage; +} + +- (CMSimpleQueueRef)copyBufferQueueWithAlteredProc: + (CMIODeviceStreamQueueAlteredProc)alteredProc + alteredRefCon:(void *)alteredRefCon +{ + self.alteredProc = alteredProc; + self.alteredRefCon = alteredRefCon; + + // Retain this since it's a copy operation + CFRetain(self.queue); + + return self.queue; +} + +- (CVPixelBufferRef)createPixelBufferWithTestAnimation +{ + int width = self.testCardSize.width; + int height = self.testCardSize.height; + + NSDictionary *options = [NSDictionary + dictionaryWithObjectsAndKeys: + [NSNumber numberWithBool:YES], + kCVPixelBufferCGImageCompatibilityKey, + [NSNumber numberWithBool:YES], + kCVPixelBufferCGBitmapContextCompatibilityKey, nil]; + CVPixelBufferRef pxbuffer = NULL; + CVReturn status = CVPixelBufferCreate(kCFAllocatorDefault, width, + height, kCVPixelFormatType_32ARGB, + (__bridge CFDictionaryRef)options, + &pxbuffer); + + NSParameterAssert(status == kCVReturnSuccess && pxbuffer != NULL); + + CVPixelBufferLockBaseAddress(pxbuffer, 0); + void *pxdata = CVPixelBufferGetBaseAddressOfPlane(pxbuffer, 0); + NSParameterAssert(pxdata != NULL); + + CGColorSpaceRef rgbColorSpace = CGColorSpaceCreateDeviceRGB(); + CGContextRef context = CGBitmapContextCreate( + pxdata, width, height, 8, + CVPixelBufferGetBytesPerRowOfPlane(pxbuffer, 0), rgbColorSpace, + kCGImageAlphaPremultipliedFirst | kCGImageByteOrder32Big); + NSParameterAssert(context); + + NSGraphicsContext *nsContext = [NSGraphicsContext + graphicsContextWithCGContext:context + flipped:NO]; + [NSGraphicsContext setCurrentContext:nsContext]; + + NSRect rect = NSMakeRect(0, 0, self.testCardImage.size.width, + self.testCardImage.size.height); + CGImageRef image = [self.testCardImage CGImageForProposedRect:&rect + context:nsContext + hints:nil]; + CGContextDrawImage(context, + CGRectMake(0, 0, CGImageGetWidth(image), + CGImageGetHeight(image)), + image); + + // DrawDialWithFrame( + // NSMakeRect(0, 0, width, height), + // (int(self.fps) - self.sequenceNumber % int(self.fps)) * 360 / + // int(self.fps)); + + CGContextRelease(context); + + CVPixelBufferUnlockBaseAddress(pxbuffer, 0); + + return pxbuffer; +} + +- (void)fillFrame +{ + if (CMSimpleQueueGetFullness(self.queue) >= 1.0) { + DLog(@"Queue is full, bailing out"); + return; + } + + CVPixelBufferRef pixelBuffer = + [self createPixelBufferWithTestAnimation]; + + uint64_t hostTime = mach_absolute_time(); + CMSampleTimingInfo timingInfo = + CMSampleTimingInfoForTimestamp(hostTime, self.fps, 1); + + OSStatus err = CMIOStreamClockPostTimingEvent( + timingInfo.presentationTimeStamp, hostTime, true, self.clock); + if (err != noErr) { + DLog(@"CMIOStreamClockPostTimingEvent err %d", err); + } + + CMFormatDescriptionRef format; + CMVideoFormatDescriptionCreateForImageBuffer(kCFAllocatorDefault, + pixelBuffer, &format); + + self.sequenceNumber = CMIOGetNextSequenceNumber(self.sequenceNumber); + + CMSampleBufferRef buffer; + err = CMIOSampleBufferCreateForImageBuffer( + kCFAllocatorDefault, pixelBuffer, format, &timingInfo, + self.sequenceNumber, kCMIOSampleBufferNoDiscontinuities, + &buffer); + CFRelease(pixelBuffer); + CFRelease(format); + if (err != noErr) { + DLog(@"CMIOSampleBufferCreateForImageBuffer err %d", err); + } + + CMSimpleQueueEnqueue(self.queue, buffer); + + // Inform the clients that the queue has been altered + if (self.alteredProc != NULL) { + (self.alteredProc)(self.objectId, buffer, self.alteredRefCon); + } +} + +- (void)queueFrameWithSize:(NSSize)size + timestamp:(uint64_t)timestamp + fpsNumerator:(uint32_t)fpsNumerator + fpsDenominator:(uint32_t)fpsDenominator + frameData:(NSData *)frameData +{ + if (CMSimpleQueueGetFullness(self.queue) >= 1.0) { + DLog(@"Queue is full, bailing out"); + return; + } + OSStatus err = noErr; + + CMSampleTimingInfo timingInfo = CMSampleTimingInfoForTimestamp( + timestamp, fpsNumerator, fpsDenominator); + + err = CMIOStreamClockPostTimingEvent(timingInfo.presentationTimeStamp, + mach_absolute_time(), true, + self.clock); + if (err != noErr) { + DLog(@"CMIOStreamClockPostTimingEvent err %d", err); + } + + self.sequenceNumber = CMIOGetNextSequenceNumber(self.sequenceNumber); + + CMSampleBufferRef sampleBuffer; + CMSampleBufferCreateFromData(size, timingInfo, self.sequenceNumber, + frameData, &sampleBuffer); + CMSimpleQueueEnqueue(self.queue, sampleBuffer); + + // Inform the clients that the queue has been altered + if (self.alteredProc != NULL) { + (self.alteredProc)(self.objectId, sampleBuffer, + self.alteredRefCon); + } +} + +- (CMVideoFormatDescriptionRef)getFormatDescription +{ + CMVideoFormatDescriptionRef formatDescription; + OSStatus err = CMVideoFormatDescriptionCreate( + kCFAllocatorDefault, kCMVideoCodecType_422YpCbCr8, + self.testCardSize.width, self.testCardSize.height, NULL, + &formatDescription); + if (err != noErr) { + DLog(@"Error %d from CMVideoFormatDescriptionCreate", err); + } + return formatDescription; +} + +#pragma mark - CMIOObject + +- (UInt32)getPropertyDataSizeWithAddress:(CMIOObjectPropertyAddress)address + qualifierDataSize:(UInt32)qualifierDataSize + qualifierData:(nonnull const void *)qualifierData +{ + switch (address.mSelector) { + case kCMIOStreamPropertyInitialPresentationTimeStampForLinkedAndSyncedAudio: + return sizeof(CMTime); + case kCMIOStreamPropertyOutputBuffersNeededForThrottledPlayback: + return sizeof(UInt32); + case kCMIOObjectPropertyName: + return sizeof(CFStringRef); + case kCMIOObjectPropertyManufacturer: + return sizeof(CFStringRef); + case kCMIOObjectPropertyElementName: + return sizeof(CFStringRef); + case kCMIOObjectPropertyElementCategoryName: + return sizeof(CFStringRef); + case kCMIOObjectPropertyElementNumberName: + return sizeof(CFStringRef); + case kCMIOStreamPropertyDirection: + return sizeof(UInt32); + case kCMIOStreamPropertyTerminalType: + return sizeof(UInt32); + case kCMIOStreamPropertyStartingChannel: + return sizeof(UInt32); + case kCMIOStreamPropertyLatency: + return sizeof(UInt32); + case kCMIOStreamPropertyFormatDescriptions: + return sizeof(CFArrayRef); + case kCMIOStreamPropertyFormatDescription: + return sizeof(CMFormatDescriptionRef); + case kCMIOStreamPropertyFrameRateRanges: + return sizeof(AudioValueRange); + case kCMIOStreamPropertyFrameRate: + case kCMIOStreamPropertyFrameRates: + return sizeof(Float64); + case kCMIOStreamPropertyMinimumFrameRate: + return sizeof(Float64); + case kCMIOStreamPropertyClock: + return sizeof(CFTypeRef); + default: + DLog(@"Stream unhandled getPropertyDataSizeWithAddress for %@", + [ObjectStore + StringFromPropertySelector:address.mSelector]); + return 0; + }; +} + +- (void)getPropertyDataWithAddress:(CMIOObjectPropertyAddress)address + qualifierDataSize:(UInt32)qualifierDataSize + qualifierData:(nonnull const void *)qualifierData + dataSize:(UInt32)dataSize + dataUsed:(nonnull UInt32 *)dataUsed + data:(nonnull void *)data +{ + switch (address.mSelector) { + case kCMIOObjectPropertyName: + *static_cast(data) = CFSTR("OBS Virtual Camera"); + *dataUsed = sizeof(CFStringRef); + break; + case kCMIOObjectPropertyElementName: + *static_cast(data) = + CFSTR("OBS Virtual Camera Stream Element"); + *dataUsed = sizeof(CFStringRef); + break; + case kCMIOObjectPropertyManufacturer: + case kCMIOObjectPropertyElementCategoryName: + case kCMIOObjectPropertyElementNumberName: + case kCMIOStreamPropertyTerminalType: + case kCMIOStreamPropertyStartingChannel: + case kCMIOStreamPropertyLatency: + case kCMIOStreamPropertyInitialPresentationTimeStampForLinkedAndSyncedAudio: + case kCMIOStreamPropertyOutputBuffersNeededForThrottledPlayback: + break; + case kCMIOStreamPropertyDirection: + *static_cast(data) = 1; + *dataUsed = sizeof(UInt32); + break; + case kCMIOStreamPropertyFormatDescriptions: + *static_cast( + data) = (__bridge_retained CFArrayRef)[NSArray + arrayWithObject:(__bridge_transfer NSObject *) + [self getFormatDescription]]; + *dataUsed = sizeof(CFArrayRef); + break; + case kCMIOStreamPropertyFormatDescription: + *static_cast(data) = + [self getFormatDescription]; + *dataUsed = sizeof(CMVideoFormatDescriptionRef); + break; + case kCMIOStreamPropertyFrameRateRanges: + AudioValueRange range; + range.mMinimum = self.fps; + range.mMaximum = self.fps; + *static_cast(data) = range; + *dataUsed = sizeof(AudioValueRange); + break; + case kCMIOStreamPropertyFrameRate: + case kCMIOStreamPropertyFrameRates: + *static_cast(data) = self.fps; + *dataUsed = sizeof(Float64); + break; + case kCMIOStreamPropertyMinimumFrameRate: + *static_cast(data) = self.fps; + *dataUsed = sizeof(Float64); + break; + case kCMIOStreamPropertyClock: + *static_cast(data) = self.clock; + // This one was incredibly tricky and cost me many hours to find. It seems that DAL expects + // the clock to be retained when returned. It's unclear why, and that seems inconsistent + // with other properties that don't have the same behavior. But this is what Apple's sample + // code does. + // https://github.com/lvsti/CoreMediaIO-DAL-Example/blob/0392cb/Sources/Extras/CoreMediaIO/DeviceAbstractionLayer/Devices/DP/Properties/CMIO_DP_Property_Clock.cpp#L75 + CFRetain(*static_cast(data)); + *dataUsed = sizeof(CFTypeRef); + break; + default: + DLog(@"Stream unhandled getPropertyDataWithAddress for %@", + [ObjectStore + StringFromPropertySelector:address.mSelector]); + *dataUsed = 0; + }; +} + +- (BOOL)hasPropertyWithAddress:(CMIOObjectPropertyAddress)address +{ + switch (address.mSelector) { + case kCMIOObjectPropertyName: + case kCMIOObjectPropertyElementName: + case kCMIOStreamPropertyFormatDescriptions: + case kCMIOStreamPropertyFormatDescription: + case kCMIOStreamPropertyFrameRateRanges: + case kCMIOStreamPropertyFrameRate: + case kCMIOStreamPropertyFrameRates: + case kCMIOStreamPropertyMinimumFrameRate: + case kCMIOStreamPropertyClock: + return true; + case kCMIOObjectPropertyManufacturer: + case kCMIOObjectPropertyElementCategoryName: + case kCMIOObjectPropertyElementNumberName: + case kCMIOStreamPropertyDirection: + case kCMIOStreamPropertyTerminalType: + case kCMIOStreamPropertyStartingChannel: + case kCMIOStreamPropertyLatency: + case kCMIOStreamPropertyInitialPresentationTimeStampForLinkedAndSyncedAudio: + case kCMIOStreamPropertyOutputBuffersNeededForThrottledPlayback: + DLog(@"TODO: %@", + [ObjectStore + StringFromPropertySelector:address.mSelector]); + return false; + default: + DLog(@"Stream unhandled hasPropertyWithAddress for %@", + [ObjectStore + StringFromPropertySelector:address.mSelector]); + return false; + }; +} + +- (BOOL)isPropertySettableWithAddress:(CMIOObjectPropertyAddress)address +{ + DLog(@"Stream unhandled isPropertySettableWithAddress for %@", + [ObjectStore StringFromPropertySelector:address.mSelector]); + return false; +} + +- (void)setPropertyDataWithAddress:(CMIOObjectPropertyAddress)address + qualifierDataSize:(UInt32)qualifierDataSize + qualifierData:(nonnull const void *)qualifierData + dataSize:(UInt32)dataSize + data:(nonnull const void *)data +{ + DLog(@"Stream unhandled setPropertyDataWithAddress for %@", + [ObjectStore StringFromPropertySelector:address.mSelector]); +} + +@end diff --git a/plugins/mac-virtualcam/src/dal-plugin/TestCard.h b/plugins/mac-virtualcam/src/dal-plugin/TestCard.h new file mode 100644 index 000000000..1f9a4c333 --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/TestCard.h @@ -0,0 +1,14 @@ +// +// TestCard.h +// dal-plugin +// +// Created by John Boiles on 5/8/20. +// + +#import +#import + +void DrawTestCardWithFrame(CGContextRef context, NSRect frame); +void DrawDialWithFrame(NSRect frame, CGFloat rotation); + +NSImage *ImageOfTestCardWithSize(NSSize imageSize); diff --git a/plugins/mac-virtualcam/src/dal-plugin/TestCard.mm b/plugins/mac-virtualcam/src/dal-plugin/TestCard.mm new file mode 100644 index 000000000..b7f0e77b1 --- /dev/null +++ b/plugins/mac-virtualcam/src/dal-plugin/TestCard.mm @@ -0,0 +1,1452 @@ +// +// TestCard.m +// dal-plugin +// +// Created by John Boiles on 5/8/20. +// + +#import "TestCard.h" + +#import +#import "Defines.h" + +// This code was generated by Trial version of PaintCode, therefore cannot be used for commercial purposes. +// http://www.paintcodeapp.com + +void DrawTestCardWithFrame(CGContextRef context, NSRect frame) +{ + if (context == NULL) { + context = NSGraphicsContext.currentContext.CGContext; + } + + BOOL showText = (frame.size.width >= 1280 && frame.size.height >= 720); + + CGFloat centerWidth = floor(frame.size.width * 0.70840 - 0.25) - + floor(frame.size.width * 0.29199 - 0.25); + NSRect center = NSMakeRect( + NSMinX(frame) + floor(frame.size.width * 0.29199 - 0.25) + 0.75, + NSMinY(frame) + floor((frame.size.height - centerWidth) / 2), + centerWidth, centerWidth); + NSString *versionText = PLUGIN_VERSION; + + // Paste in PaintCode code below + + //// Color Declarations + NSColor *fillColor = [NSColor colorWithRed:0.125 + green:0.176 + blue:0.435 + alpha:1]; + NSColor *fillColor2 = [NSColor colorWithRed:0.086 + green:0.141 + blue:0.345 + alpha:1]; + NSColor *fillColor3 = [NSColor colorWithRed:0.047 + green:0.086 + blue:0.2 + alpha:1]; + NSColor *strokeColor = [NSColor colorWithRed:1 green:1 blue:1 alpha:1]; + NSColor *fillColor4 = [NSColor colorWithRed:0 + green:0 + blue:0 + alpha:0.62]; + NSColor *fillColor5 = [NSColor colorWithRed:0.188 + green:0.18 + blue:0.192 + alpha:1]; + NSColor *fillColor6 = [NSColor colorWithRed:0.769 + green:0.761 + blue:0.769 + alpha:1]; + NSColor *textForeground = [NSColor colorWithRed:1 + green:1 + blue:1 + alpha:1]; + NSColor *fillColor7 = [NSColor colorWithRed:1 green:1 blue:1 alpha:1]; + NSColor *fillColor8 = [NSColor colorWithRed:0 + green:0 + blue:0.753 + alpha:1]; + NSColor *fillColor9 = [NSColor colorWithRed:0 + green:0.753 + blue:0 + alpha:1]; + NSColor *fillColor10 = [NSColor colorWithRed:0.753 + green:0 + blue:0 + alpha:1]; + + //// Subframes + NSRect background = NSMakeRect(NSMinX(frame), NSMinY(frame), + frame.size.width, frame.size.height); + // NSRect center = NSMakeRect(NSMinX(frame) + floor(frame.size.width * 0.29199 - 0.25) + 0.75, NSMinY(frame) + floor(frame.size.height * 0.12917 + 0.5), floor(frame.size.width * 0.70840 - 0.25) - floor(frame.size.width * 0.29199 - 0.25), floor(frame.size.height * 0.86944 + 0.5) - floor(frame.size.height * 0.12917 + 0.5)); + NSRect regularText = NSMakeRect( + NSMinX(frame) + + floor((frame.size.width - 274.23) * 0.04061 - 0.34) + + 0.84, + NSMinY(frame) + + floor((frame.size.height - 352.53) * 0.42711 - 0.45) + + 0.95, + 274.23, 352.53); + NSRect rGB = NSMakeRect( + NSMinX(frame), NSMinY(frame) - 0.98, + floor((frame.size.width) * 0.03223 + 0.24) + 0.26, + floor((frame.size.height + 0.98) * 0.02185 - 1.25) + 1.75); + NSRect topRight = NSMakeRect(NSMinX(frame) + frame.size.width - 93.46, + NSMinY(frame) + 0.04, 93.42, 93.52); + NSRect bottomLeft = NSMakeRect( + NSMinX(frame), NSMinY(frame) + frame.size.height - 93.55, 93.42, + 93.51); + + //// Background + { + //// Rectangle Drawing + NSBezierPath *rectanglePath = [NSBezierPath + bezierPathWithRect: + NSMakeRect( + NSMinX(background) + + floor(background.size.width * + 0.00000 + + 0.5), + NSMinY(background) + + floor(background.size.height * + 0.00000 + + 0.5), + floor(background.size.width * 1.00000 + + 0.5) - + floor(background.size.width * + 0.00000 + + 0.5), + floor(background.size.height * 0.24874 + + 0.41) - + floor(background.size.height * + 0.00000 + + 0.5) + + 0.09)]; + [fillColor setFill]; + [rectanglePath fill]; + + //// Rectangle 2 Drawing + NSBezierPath *rectangle2Path = [NSBezierPath + bezierPathWithRect: + NSMakeRect( + NSMinX(background) + + floor(background.size.width * + 0.00000 + + 0.5), + NSMinY(background) + + floor(background.size.height * + 0.24874 + + 0.41) + + 0.09, + floor(background.size.width * 1.00000 + + 0.5) - + floor(background.size.width * + 0.00000 + + 0.5), + floor(background.size.height * 1.00000 + + 0.5) - + floor(background.size.height * + 0.24874 + + 0.41) - + 0.09)]; + [fillColor setFill]; + [rectangle2Path fill]; + + //// Bezier Drawing + NSBezierPath *bezierPath = [NSBezierPath bezierPath]; + [bezierPath + moveToPoint:NSMakePoint( + NSMinX(background) + + 1.00000 * background.size + .width, + NSMinY(background) + + 0.49645 * background.size + .height)]; + [bezierPath + curveToPoint:NSMakePoint( + NSMinX(background) + + 0.71753 * background.size + .width, + NSMinY(background) + + 0.62275 * background.size + .height) + controlPoint1:NSMakePoint( + NSMinX(background) + + 1.00000 * background.size + .width, + NSMinY(background) + + 0.48916 * background.size + .height) + controlPoint2:NSMakePoint( + NSMinX(background) + + 0.71753 * background.size + .width, + NSMinY(background) + + 0.62275 * + background.size + .height)]; + [bezierPath + curveToPoint:NSMakePoint( + NSMinX(background) + + 0.00000 * background.size + .width, + NSMinY(background) + + 0.28446 * background.size + .height) + controlPoint1:NSMakePoint( + NSMinX(background) + + 0.71753 * background.size + .width, + NSMinY(background) + + 0.62275 * background.size + .height) + controlPoint2:NSMakePoint( + NSMinX(background) + + 0.15141 * background.size + .width, + NSMinY(background) + + 0.36204 * + background.size + .height)]; + [bezierPath + lineToPoint:NSMakePoint( + NSMinX(background) + + 0.00000 * background.size + .width, + NSMinY(background) + + 0.24823 * background.size + .height)]; + [bezierPath + lineToPoint:NSMakePoint( + NSMinX(background) + + 1.00000 * background.size + .width, + NSMinY(background) + + 0.24823 * background.size + .height)]; + [bezierPath + lineToPoint:NSMakePoint( + NSMinX(background) + + 1.00000 * background.size + .width, + NSMinY(background) + + 0.49645 * background.size + .height)]; + [bezierPath closePath]; + [fillColor2 setFill]; + [bezierPath fill]; + + //// Bezier 2 Drawing + NSBezierPath *bezier2Path = [NSBezierPath bezierPath]; + [bezier2Path + moveToPoint:NSMakePoint( + NSMinX(background) + + 1.00000 * background.size + .width, + NSMinY(background) + + 0.49645 * background.size + .height)]; + [bezier2Path + lineToPoint:NSMakePoint( + NSMinX(background) + + 1.00000 * background.size + .width, + NSMinY(background) + + 1.00000 * background.size + .height)]; + [bezier2Path + lineToPoint:NSMakePoint( + NSMinX(background) + + 0.00000 * background.size + .width, + NSMinY(background) + + 1.00000 * background.size + .height)]; + [bezier2Path + lineToPoint:NSMakePoint( + NSMinX(background) + + 0.00000 * background.size + .width, + NSMinY(background) + + 0.78019 * background.size + .height)]; + [bezier2Path + lineToPoint:NSMakePoint( + NSMinX(background) + + 1.00000 * background.size + .width, + NSMinY(background) + + 0.49645 * background.size + .height)]; + [bezier2Path closePath]; + [fillColor3 setFill]; + [bezier2Path fill]; + } + + //// Center + { + //// Oval Drawing + NSBezierPath *ovalPath = [NSBezierPath + bezierPathWithOvalInRect: + NSMakeRect(NSMinX(center) + + floor(center.size.width * + 0.00000 + + 0.5), + NSMinY(center) + + floor(center.size.height * + 0.00000 + + 0.5), + floor(center.size.width * 1.00000 + + 0.5) - + floor(center.size.width * + 0.00000 + + 0.5), + floor(center.size.height * 1.00000 + + 0.5) - + floor(center.size.height * + 0.00000 + + 0.5))]; + [fillColor4 setFill]; + [ovalPath fill]; + [strokeColor setStroke]; + ovalPath.lineWidth = 2; + [ovalPath stroke]; + + //// Rectangle 3 Drawing + NSBezierPath *rectangle3Path = [NSBezierPath + bezierPathWithRect: + NSMakeRect(NSMinX(center) + + floor(center.size.width * + 0.15572 + + 0.5), + NSMinY(center) + + floor(center.size.height * + 0.15572 + + 0.5), + floor(center.size.width * 0.84428 + + 0.5) - + floor(center.size.width * + 0.15572 + + 0.5), + floor(center.size.height * 0.84428 + + 0.5) - + floor(center.size.height * + 0.15572 + + 0.5))]; + [strokeColor setStroke]; + rectangle3Path.lineWidth = 2; + [rectangle3Path stroke]; + + //// Oval 2 Drawing + NSBezierPath *oval2Path = [NSBezierPath + bezierPathWithOvalInRect: + NSMakeRect(NSMinX(center) + + floor(center.size.width * + 0.37715 + + 0.48) + + 0.02, + NSMinY(center) + + floor(center.size.height * + 0.37715 + + 0.48) + + 0.02, + floor(center.size.width * 0.62285 - + 0.48) - + floor(center.size.width * + 0.37715 + + 0.48) + + 0.96, + floor(center.size.height * 0.62285 - + 0.48) - + floor(center.size.height * + 0.37715 + + 0.48) + + 0.96)]; + [fillColor5 setFill]; + [oval2Path fill]; + [strokeColor setStroke]; + oval2Path.lineWidth = 3.47; + [oval2Path stroke]; + + //// Bezier 3 Drawing + NSBezierPath *bezier3Path = [NSBezierPath bezierPath]; + [bezier3Path + moveToPoint:NSMakePoint( + NSMinX(center) + + 0.43774 * center.size.width, + NSMinY(center) + + 0.43569 * + center.size.height)]; + [bezier3Path + lineToPoint:NSMakePoint( + NSMinX(center) + + 0.43777 * center.size.width, + NSMinY(center) + + 0.43553 * + center.size.height)]; + [bezier3Path + curveToPoint:NSMakePoint( + NSMinX(center) + + 0.47053 * + center.size.width, + NSMinY(center) + + 0.39283 * + center.size.height) + controlPoint1:NSMakePoint( + NSMinX(center) + + 0.44169 * + center.size.width, + NSMinY(center) + + 0.41708 * + center.size.height) + controlPoint2:NSMakePoint( + NSMinX(center) + + 0.45373 * + center.size.width, + NSMinY(center) + + 0.40139 * + center.size + .height)]; + [bezier3Path + curveToPoint:NSMakePoint( + NSMinX(center) + + 0.46134 * + center.size.width, + NSMinY(center) + + 0.40126 * + center.size.height) + controlPoint1:NSMakePoint( + NSMinX(center) + + 0.46749 * + center.size.width, + NSMinY(center) + + 0.39584 * + center.size.height) + controlPoint2:NSMakePoint( + NSMinX(center) + + 0.46401 * + center.size.width, + NSMinY(center) + + 0.39809 * + center.size + .height)]; + [bezier3Path + lineToPoint:NSMakePoint( + NSMinX(center) + + 0.46106 * center.size.width, + NSMinY(center) + + 0.40157 * + center.size.height)]; + [bezier3Path + curveToPoint:NSMakePoint( + NSMinX(center) + + 0.44863 * + center.size.width, + NSMinY(center) + + 0.44638 * + center.size.height) + controlPoint1:NSMakePoint( + NSMinX(center) + + 0.45011 * + center.size.width, + NSMinY(center) + + 0.41373 * + center.size.height) + controlPoint2:NSMakePoint( + NSMinX(center) + + 0.44551 * + center.size.width, + NSMinY(center) + + 0.43032 * + center.size + .height)]; + [bezier3Path + curveToPoint:NSMakePoint( + NSMinX(center) + + 0.49915 * + center.size.width, + NSMinY(center) + + 0.48885 * + center.size.height) + controlPoint1:NSMakePoint( + NSMinX(center) + + 0.45226 * + center.size.width, + NSMinY(center) + + 0.46965 * + center.size.height) + controlPoint2:NSMakePoint( + NSMinX(center) + + 0.47476 * + center.size.width, + NSMinY(center) + + 0.48919 * + center.size + .height)]; + [bezier3Path + curveToPoint:NSMakePoint( + NSMinX(center) + + 0.54568 * + center.size.width, + NSMinY(center) + + 0.46244 * + center.size.height) + controlPoint1:NSMakePoint( + NSMinX(center) + + 0.51803 * + center.size.width, + NSMinY(center) + + 0.48969 * + center.size.height) + controlPoint2:NSMakePoint( + NSMinX(center) + + 0.53644 * + center.size.width, + NSMinY(center) + + 0.47885 * + center.size + .height)]; + [bezier3Path + lineToPoint:NSMakePoint( + NSMinX(center) + + 0.54557 * center.size.width, + NSMinY(center) + + 0.46243 * + center.size.height)]; + [bezier3Path + curveToPoint:NSMakePoint( + NSMinX(center) + + 0.59607 * + center.size.width, + NSMinY(center) + + 0.48985 * + center.size.height) + controlPoint1:NSMakePoint( + NSMinX(center) + + 0.56578 * + center.size.width, + NSMinY(center) + + 0.46314 * + center.size.height) + controlPoint2:NSMakePoint( + NSMinX(center) + + 0.58447 * + center.size.width, + NSMinY(center) + + 0.47329 * + center.size + .height)]; + [bezier3Path + curveToPoint:NSMakePoint( + NSMinX(center) + + 0.60657 * + center.size.width, + NSMinY(center) + + 0.51871 * + center.size.height) + controlPoint1:NSMakePoint( + NSMinX(center) + + 0.60175 * + center.size.width, + NSMinY(center) + + 0.49825 * + center.size.height) + controlPoint2:NSMakePoint( + NSMinX(center) + + 0.60626 * + center.size.width, + NSMinY(center) + + 0.50827 * + center.size + .height)]; + [bezier3Path + lineToPoint:NSMakePoint( + NSMinX(center) + + 0.60649 * center.size.width, + NSMinY(center) + + 0.51837 * + center.size.height)]; + [bezier3Path + curveToPoint:NSMakePoint( + NSMinX(center) + + 0.58067 * + center.size.width, + NSMinY(center) + + 0.48533 * + center.size.height) + controlPoint1:NSMakePoint( + NSMinX(center) + + 0.60272 * + center.size.width, + NSMinY(center) + + 0.50431 * + center.size.height) + controlPoint2:NSMakePoint( + NSMinX(center) + + 0.59340 * + center.size.width, + NSMinY(center) + + 0.49239 * + center.size + .height)]; + [bezier3Path + lineToPoint:NSMakePoint( + NSMinX(center) + + 0.58087 * center.size.width, + NSMinY(center) + + 0.48544 * + center.size.height)]; + [bezier3Path + curveToPoint:NSMakePoint( + NSMinX(center) + + 0.50993 * + center.size.width, + NSMinY(center) + + 0.50579 * + center.size.height) + controlPoint1:NSMakePoint( + NSMinX(center) + + 0.55566 * + center.size.width, + NSMinY(center) + + 0.47147 * + center.size.height) + controlPoint2:NSMakePoint( + NSMinX(center) + + 0.52390 * + center.size.width, + NSMinY(center) + + 0.48058 * + center.size + .height)]; + [bezier3Path + curveToPoint:NSMakePoint( + NSMinX(center) + + 0.50541 * + center.size.width, + NSMinY(center) + + 0.51670 * + center.size.height) + controlPoint1:NSMakePoint( + NSMinX(center) + + 0.50801 * + center.size.width, + NSMinY(center) + + 0.50924 * + center.size.height) + controlPoint2:NSMakePoint( + NSMinX(center) + + 0.50649 * + center.size.width, + NSMinY(center) + + 0.51291 * + center.size + .height)]; + [bezier3Path + lineToPoint:NSMakePoint( + NSMinX(center) + + 0.50550 * center.size.width, + NSMinY(center) + + 0.51637 * + center.size.height)]; + [bezier3Path + curveToPoint:NSMakePoint( + NSMinX(center) + + 0.50977 * + center.size.width, + NSMinY(center) + + 0.55699 * + center.size.height) + controlPoint1:NSMakePoint( + NSMinX(center) + + 0.50161 * + center.size.width, + NSMinY(center) + + 0.52995 * + center.size.height) + controlPoint2:NSMakePoint( + NSMinX(center) + + 0.50314 * + center.size.width, + NSMinY(center) + + 0.54451 * + center.size + .height)]; + [bezier3Path + lineToPoint:NSMakePoint( + NSMinX(center) + + 0.50940 * center.size.width, + NSMinY(center) + + 0.55691 * + center.size.height)]; + [bezier3Path + curveToPoint:NSMakePoint( + NSMinX(center) + + 0.46769 * + center.size.width, + NSMinY(center) + + 0.58611 * + center.size.height) + controlPoint1:NSMakePoint( + NSMinX(center) + + 0.50026 * + center.size.width, + NSMinY(center) + + 0.57211 * + center.size.height) + controlPoint2:NSMakePoint( + NSMinX(center) + + 0.48510 * + center.size.width, + NSMinY(center) + + 0.58273 * + center.size + .height)]; + [bezier3Path + curveToPoint:NSMakePoint( + NSMinX(center) + + 0.42781 * + center.size.width, + NSMinY(center) + + 0.58115 * + center.size.height) + controlPoint1:NSMakePoint( + NSMinX(center) + + 0.45419 * + center.size.width, + NSMinY(center) + + 0.58894 * + center.size.height) + controlPoint2:NSMakePoint( + NSMinX(center) + + 0.44020 * + center.size.width, + NSMinY(center) + + 0.58679 * + center.size + .height)]; + [bezier3Path + curveToPoint:NSMakePoint( + NSMinX(center) + + 0.46195 * + center.size.width, + NSMinY(center) + + 0.58102 * + center.size.height) + controlPoint1:NSMakePoint( + NSMinX(center) + + 0.43890 * + center.size.width, + NSMinY(center) + + 0.58437 * + center.size.height) + controlPoint2:NSMakePoint( + NSMinX(center) + + 0.45094 * + center.size.width, + NSMinY(center) + + 0.58490 * + center.size + .height)]; + [bezier3Path + lineToPoint:NSMakePoint( + NSMinX(center) + + 0.46219 * center.size.width, + NSMinY(center) + + 0.58094 * + center.size.height)]; + [bezier3Path + curveToPoint:NSMakePoint( + NSMinX(center) + + 0.49448 * + center.size.width, + NSMinY(center) + + 0.54921 * + center.size.height) + controlPoint1:NSMakePoint( + NSMinX(center) + + 0.47719 * + center.size.width, + NSMinY(center) + + 0.57578 * + center.size.height) + controlPoint2:NSMakePoint( + NSMinX(center) + + 0.48905 * + center.size.width, + NSMinY(center) + + 0.56412 * + center.size + .height)]; + [bezier3Path + curveToPoint:NSMakePoint( + NSMinX(center) + + 0.48799 * + center.size.width, + NSMinY(center) + + 0.50104 * + center.size.height) + controlPoint1:NSMakePoint( + NSMinX(center) + + 0.50027 * + center.size.width, + NSMinY(center) + + 0.53367 * + center.size.height) + controlPoint2:NSMakePoint( + NSMinX(center) + + 0.49801 * + center.size.width, + NSMinY(center) + + 0.51472 * + center.size + .height)]; + [bezier3Path + lineToPoint:NSMakePoint( + NSMinX(center) + + 0.48819 * center.size.width, + NSMinY(center) + + 0.50132 * + center.size.height)]; + [bezier3Path + curveToPoint:NSMakePoint( + NSMinX(center) + + 0.45603 * + center.size.width, + NSMinY(center) + + 0.48003 * + center.size.height) + controlPoint1:NSMakePoint( + NSMinX(center) + + 0.48055 * + center.size.width, + NSMinY(center) + + 0.49041 * + center.size.height) + controlPoint2:NSMakePoint( + NSMinX(center) + + 0.46906 * + center.size.width, + NSMinY(center) + + 0.48280 * + center.size + .height)]; + [bezier3Path + curveToPoint:NSMakePoint( + NSMinX(center) + + 0.44359 * + center.size.width, + NSMinY(center) + + 0.47857 * + center.size.height) + controlPoint1:NSMakePoint( + NSMinX(center) + + 0.45180 * + center.size.width, + NSMinY(center) + + 0.47927 * + center.size.height) + controlPoint2:NSMakePoint( + NSMinX(center) + + 0.44769 * + center.size.width, + NSMinY(center) + + 0.47895 * + center.size + .height)]; + [bezier3Path + curveToPoint:NSMakePoint( + NSMinX(center) + + 0.43794 * + center.size.width, + NSMinY(center) + + 0.43581 * + center.size.height) + controlPoint1:NSMakePoint( + NSMinX(center) + + 0.43705 * + center.size.width, + NSMinY(center) + + 0.46540 * + center.size.height) + controlPoint2:NSMakePoint( + NSMinX(center) + + 0.43465 * + center.size.width, + NSMinY(center) + + 0.45011 * + center.size + .height)]; + [bezier3Path + lineToPoint:NSMakePoint( + NSMinX(center) + + 0.43774 * center.size.width, + NSMinY(center) + + 0.43569 * + center.size.height)]; + [bezier3Path closePath]; + [fillColor6 setFill]; + [bezier3Path fill]; + } + + if (showText) { + //// MirroredText + { + [NSGraphicsContext saveGraphicsState]; + CGContextTranslateCTM( + context, + NSMinX(frame) + 0.96057 * frame.size.width, + NSMinY(frame) + 0.42824 * frame.size.height); + CGContextScaleCTM(context, -1, 1); + + //// Label Drawing + NSRect labelRect = + NSMakeRect(-0.15, -30.85, 264.59, 40); + NSMutableParagraphStyle *labelStyle = + [[NSMutableParagraphStyle alloc] init]; + labelStyle.alignment = NSTextAlignmentLeft; + NSDictionary *labelFontAttributes = @{ + NSFontAttributeName: + [NSFont fontWithName:@"Helvetica-Bold" + size:32], + NSForegroundColorAttributeName: textForeground, + NSParagraphStyleAttributeName: labelStyle + }; + + [@"OBS Virtual Cam " + drawInRect:NSOffsetRect(labelRect, 0, 0) + withAttributes:labelFontAttributes]; + + //// Label 2 Drawing + NSRect label2Rect = NSMakeRect(-0.15, 7.75, 264.68, 40); + NSMutableParagraphStyle *label2Style = + [[NSMutableParagraphStyle alloc] init]; + label2Style.alignment = NSTextAlignmentLeft; + NSDictionary *label2FontAttributes = @{ + NSFontAttributeName: + [NSFont fontWithName:@"Helvetica-Bold" + size:32], + NSForegroundColorAttributeName: textForeground, + NSParagraphStyleAttributeName: label2Style + }; + + [@"is inactive." + drawInRect:NSOffsetRect(label2Rect, 0, 0) + withAttributes:label2FontAttributes]; + + //// Label 3 Drawing + NSRect label3Rect = + NSMakeRect(-0.15, 84.95, 245.51, 39); + NSMutableParagraphStyle *label3Style = + [[NSMutableParagraphStyle alloc] init]; + label3Style.alignment = NSTextAlignmentLeft; + NSDictionary *label3FontAttributes = @{ + NSFontAttributeName: + [NSFont fontWithName:@"Helvetica-Bold" + size:32], + NSForegroundColorAttributeName: textForeground, + NSParagraphStyleAttributeName: label3Style + }; + + [@"Choose Tools > " + drawInRect:NSOffsetRect(label3Rect, 0, 0) + withAttributes:label3FontAttributes]; + + //// Label 4 Drawing + NSRect label4Rect = + NSMakeRect(-0.15, 123.55, 269.53, 39); + NSMutableParagraphStyle *label4Style = + [[NSMutableParagraphStyle alloc] init]; + label4Style.alignment = NSTextAlignmentLeft; + NSDictionary *label4FontAttributes = @{ + NSFontAttributeName: + [NSFont fontWithName:@"Helvetica-Bold" + size:32], + NSForegroundColorAttributeName: textForeground, + NSParagraphStyleAttributeName: label4Style + }; + + [@"Start Virtual " + drawInRect:NSOffsetRect(label4Rect, 0, 0) + withAttributes:label4FontAttributes]; + + //// Label 5 Drawing + NSRect label5Rect = + NSMakeRect(-0.15, 162.15, 126.45, 39); + NSMutableParagraphStyle *label5Style = + [[NSMutableParagraphStyle alloc] init]; + label5Style.alignment = NSTextAlignmentLeft; + NSDictionary *label5FontAttributes = @{ + NSFontAttributeName: + [NSFont fontWithName:@"Helvetica-Bold" + size:32], + NSForegroundColorAttributeName: textForeground, + NSParagraphStyleAttributeName: label5Style + }; + + [@"Camera." drawInRect:NSOffsetRect(label5Rect, 0, 0) + withAttributes:label5FontAttributes]; + + //// Label 6 Drawing + NSRect label6Rect = + NSMakeRect(-0.15, -152.38, 296.53, 81); + NSMutableParagraphStyle *label6Style = + [[NSMutableParagraphStyle alloc] init]; + label6Style.alignment = NSTextAlignmentLeft; + NSDictionary *label6FontAttributes = @{ + NSFontAttributeName: + [NSFont fontWithName:@"Helvetica-Bold" + size:66], + NSForegroundColorAttributeName: textForeground, + NSParagraphStyleAttributeName: label6Style + }; + + [@"Mirrored" drawInRect:NSOffsetRect(label6Rect, 0, 0) + withAttributes:label6FontAttributes]; + + [NSGraphicsContext restoreGraphicsState]; + } + + //// RegularText + { + //// Label 7 Drawing + NSRect label7Rect = NSMakeRect( + NSMinX(regularText) + 4.7, + NSMinY(regularText) + 121.53, 264.59, 40); + NSMutableParagraphStyle *label7Style = + [[NSMutableParagraphStyle alloc] init]; + label7Style.alignment = NSTextAlignmentLeft; + NSDictionary *label7FontAttributes = @{ + NSFontAttributeName: + [NSFont fontWithName:@"Helvetica-Bold" + size:32], + NSForegroundColorAttributeName: textForeground, + NSParagraphStyleAttributeName: label7Style + }; + + [@"OBS Virtual Cam " + drawInRect:NSOffsetRect(label7Rect, 0, 0) + withAttributes:label7FontAttributes]; + + //// Label 8 Drawing + NSRect label8Rect = NSMakeRect( + NSMinX(regularText) + 4.7, + NSMinY(regularText) + 160.13, 269.46, 39); + NSMutableParagraphStyle *label8Style = + [[NSMutableParagraphStyle alloc] init]; + label8Style.alignment = NSTextAlignmentLeft; + NSDictionary *label8FontAttributes = @{ + NSFontAttributeName: + [NSFont fontWithName:@"Helvetica-Bold" + size:32], + NSForegroundColorAttributeName: textForeground, + NSParagraphStyleAttributeName: label8Style + }; + + [@"is inactive." + drawInRect:NSOffsetRect(label8Rect, 0, 0) + withAttributes:label8FontAttributes]; + + //// Label 9 Drawing + NSRect label9Rect = NSMakeRect( + NSMinX(regularText) + 4.7, + NSMinY(regularText) + 236.33, 245.51, 39); + NSMutableParagraphStyle *label9Style = + [[NSMutableParagraphStyle alloc] init]; + label9Style.alignment = NSTextAlignmentLeft; + NSDictionary *label9FontAttributes = @{ + NSFontAttributeName: + [NSFont fontWithName:@"Helvetica-Bold" + size:32], + NSForegroundColorAttributeName: textForeground, + NSParagraphStyleAttributeName: label9Style + }; + + [@"Choose Tools > " + drawInRect:NSOffsetRect(label9Rect, 0, 0) + withAttributes:label9FontAttributes]; + + //// Label 10 Drawing + NSRect label10Rect = NSMakeRect( + NSMinX(regularText) + 4.7, + NSMinY(regularText) + 274.93, 269.53, 39); + NSMutableParagraphStyle *label10Style = + [[NSMutableParagraphStyle alloc] init]; + label10Style.alignment = NSTextAlignmentLeft; + NSDictionary *label10FontAttributes = @{ + NSFontAttributeName: + [NSFont fontWithName:@"Helvetica-Bold" + size:32], + NSForegroundColorAttributeName: textForeground, + NSParagraphStyleAttributeName: label10Style + }; + + [@"Start Virtual " + drawInRect:NSOffsetRect(label10Rect, 0, 0) + withAttributes:label10FontAttributes]; + + //// Label 11 Drawing + NSRect label11Rect = NSMakeRect( + NSMinX(regularText) + 4.7, + NSMinY(regularText) + 313.53, 126.45, 39); + NSMutableParagraphStyle *label11Style = + [[NSMutableParagraphStyle alloc] init]; + label11Style.alignment = NSTextAlignmentLeft; + NSDictionary *label11FontAttributes = @{ + NSFontAttributeName: + [NSFont fontWithName:@"Helvetica-Bold" + size:32], + NSForegroundColorAttributeName: textForeground, + NSParagraphStyleAttributeName: label11Style + }; + + [@"Camera." drawInRect:NSOffsetRect(label11Rect, 0, 0) + withAttributes:label11FontAttributes]; + + //// Label 12 Drawing + NSRect label12Rect = NSMakeRect(NSMinX(regularText), + NSMinY(regularText), + 248.31, 81); + NSMutableParagraphStyle *label12Style = + [[NSMutableParagraphStyle alloc] init]; + label12Style.alignment = NSTextAlignmentLeft; + NSDictionary *label12FontAttributes = @{ + NSFontAttributeName: + [NSFont fontWithName:@"Helvetica-Bold" + size:66], + NSForegroundColorAttributeName: textForeground, + NSParagraphStyleAttributeName: label12Style + }; + + [@"Regular" drawInRect:NSOffsetRect(label12Rect, 0, 0) + withAttributes:label12FontAttributes]; + } + } + + //// RGB + { + //// Blue Drawing + NSBezierPath *bluePath = [NSBezierPath + bezierPathWithRect: + NSMakeRect( + NSMinX(rGB) + + floor(rGB.size.width * 0.67475 - + 0.34) + + 0.84, + NSMinY(rGB) + floor(rGB.size.height * + 0.00000 + + 0.5), + floor(rGB.size.width * 1.00000 + 0.24) - + floor(rGB.size.width * 0.67475 - + 0.34) - + 0.58, + floor(rGB.size.height * 1.00000 - 0.25) - + floor(rGB.size.height * 0.00000 + + 0.5) + + 0.75)]; + [fillColor8 setFill]; + [bluePath fill]; + + //// Green Drawing + NSBezierPath *greenPath = [NSBezierPath + bezierPathWithRect: + NSMakeRect( + NSMinX(rGB) + + floor(rGB.size.width * 0.32525 + + 0.08) + + 0.42, + NSMinY(rGB) + floor(rGB.size.height * + 0.00000 + + 0.5), + floor(rGB.size.width * 0.67475 - 0.34) - + floor(rGB.size.width * 0.32525 + + 0.08) + + 0.42, + floor(rGB.size.height * 1.00000 - 0.25) - + floor(rGB.size.height * 0.00000 + + 0.5) + + 0.75)]; + [fillColor9 setFill]; + [greenPath fill]; + + //// Red Drawing + NSBezierPath *redPath = [NSBezierPath + bezierPathWithRect: + NSMakeRect( + NSMinX(rGB) + + floor(rGB.size.width * 0.00000 + + 0.5), + NSMinY(rGB) + floor(rGB.size.height * + 0.00000 + + 0.5), + floor(rGB.size.width * 0.32525 + 0.08) - + floor(rGB.size.width * 0.00000 + + 0.5) + + 0.42, + floor(rGB.size.height * 1.00000 - 0.25) - + floor(rGB.size.height * 0.00000 + + 0.5) + + 0.75)]; + [fillColor10 setFill]; + [redPath fill]; + } + + //// TopRight + { + //// Bezier 7 Drawing + NSBezierPath *bezier7Path = [NSBezierPath bezierPath]; + [bezier7Path moveToPoint:NSMakePoint(NSMinX(topRight) + 31.28, + NSMinY(topRight) + 54.38)]; + [bezier7Path + curveToPoint:NSMakePoint(NSMinX(topRight) + 23.82, + NSMinY(topRight) + 61.91) + controlPoint1:NSMakePoint(NSMinX(topRight) + 26.23, + NSMinY(topRight) + 55.91) + controlPoint2:NSMakePoint(NSMinX(topRight) + 25.34, + NSMinY(topRight) + 56.81)]; + [bezier7Path lineToPoint:NSMakePoint(NSMinX(topRight), + NSMinY(topRight) + 61.91)]; + [bezier7Path lineToPoint:NSMakePoint(NSMinX(topRight) + 30.91, + NSMinY(topRight))]; + [bezier7Path lineToPoint:NSMakePoint(NSMinX(topRight) + 31.28, + NSMinY(topRight) + 0.08)]; + [bezier7Path lineToPoint:NSMakePoint(NSMinX(topRight) + 31.28, + NSMinY(topRight) + 54.38)]; + [bezier7Path closePath]; + [fillColor7 setFill]; + [bezier7Path fill]; + + //// Bezier 8 Drawing + NSBezierPath *bezier8Path = [NSBezierPath bezierPath]; + [bezier8Path moveToPoint:NSMakePoint(NSMinX(topRight) + 93.42, + NSMinY(topRight) + 62.55)]; + [bezier8Path lineToPoint:NSMakePoint(NSMinX(topRight) + 31.61, + NSMinY(topRight) + 93.52)]; + [bezier8Path lineToPoint:NSMakePoint(NSMinX(topRight) + 31.61, + NSMinY(topRight) + 69.52)]; + [bezier8Path + curveToPoint:NSMakePoint(NSMinX(topRight) + 38.98, + NSMinY(topRight) + 62.1) + controlPoint1:NSMakePoint(NSMinX(topRight) + 35.92, + NSMinY(topRight) + 68.97) + controlPoint2:NSMakePoint(NSMinX(topRight) + 38.42, + NSMinY(topRight) + 66.47)]; + [bezier8Path lineToPoint:NSMakePoint(NSMinX(topRight) + 93.28, + NSMinY(topRight) + 62.1)]; + [bezier8Path lineToPoint:NSMakePoint(NSMinX(topRight) + 93.42, + NSMinY(topRight) + 62.55)]; + [bezier8Path closePath]; + [fillColor7 setFill]; + [bezier8Path fill]; + + //// Bezier 9 Drawing + NSBezierPath *bezier9Path = [NSBezierPath bezierPath]; + [bezier9Path moveToPoint:NSMakePoint(NSMinX(topRight) + 31.54, + NSMinY(topRight) + 65.21)]; + [bezier9Path + curveToPoint:NSMakePoint(NSMinX(topRight) + 28.38, + NSMinY(topRight) + 62.07) + controlPoint1:NSMakePoint(NSMinX(topRight) + 29.66, + NSMinY(topRight) + 64.99) + controlPoint2:NSMakePoint(NSMinX(topRight) + 28.39, + NSMinY(topRight) + 64.01)]; + [bezier9Path lineToPoint:NSMakePoint(NSMinX(topRight) + 28.38, + NSMinY(topRight) + 62.05)]; + [bezier9Path + curveToPoint:NSMakePoint(NSMinX(topRight) + 31.52, + NSMinY(topRight) + 59) + controlPoint1:NSMakePoint(NSMinX(topRight) + 28.41, + NSMinY(topRight) + 60.34) + controlPoint2:NSMakePoint(NSMinX(topRight) + 29.82, + NSMinY(topRight) + 58.97)]; + [bezier9Path + curveToPoint:NSMakePoint(NSMinX(topRight) + 34.56, + NSMinY(topRight) + 61.94) + controlPoint1:NSMakePoint(NSMinX(topRight) + 33.15, + NSMinY(topRight) + 59.03) + controlPoint2:NSMakePoint(NSMinX(topRight) + 34.47, + NSMinY(topRight) + 60.31)]; + [bezier9Path + curveToPoint:NSMakePoint(NSMinX(topRight) + 31.54, + NSMinY(topRight) + 65.21) + controlPoint1:NSMakePoint(NSMinX(topRight) + 34.65, + NSMinY(topRight) + 63.82) + controlPoint2:NSMakePoint(NSMinX(topRight) + 33.42, + NSMinY(topRight) + 64.86)]; + [bezier9Path closePath]; + [fillColor7 setFill]; + [bezier9Path fill]; + } + + //// BottomLeft + { + //// Bezier 4 Drawing + NSBezierPath *bezier4Path = [NSBezierPath bezierPath]; + [bezier4Path + moveToPoint:NSMakePoint(NSMinX(bottomLeft) + 62.14, + NSMinY(bottomLeft) + 39.13)]; + [bezier4Path + curveToPoint:NSMakePoint(NSMinX(bottomLeft) + 69.6, + NSMinY(bottomLeft) + 31.6) + controlPoint1:NSMakePoint(NSMinX(bottomLeft) + 67.18, + NSMinY(bottomLeft) + 37.6) + controlPoint2:NSMakePoint(NSMinX(bottomLeft) + 68.08, + NSMinY(bottomLeft) + 36.71)]; + [bezier4Path + lineToPoint:NSMakePoint(NSMinX(bottomLeft) + 93.42, + NSMinY(bottomLeft) + 31.6)]; + [bezier4Path + lineToPoint:NSMakePoint(NSMinX(bottomLeft) + 62.51, + NSMinY(bottomLeft) + 93.51)]; + [bezier4Path + lineToPoint:NSMakePoint(NSMinX(bottomLeft) + 62.14, + NSMinY(bottomLeft) + 93.43)]; + [bezier4Path + lineToPoint:NSMakePoint(NSMinX(bottomLeft) + 62.14, + NSMinY(bottomLeft) + 39.13)]; + [bezier4Path closePath]; + [fillColor7 setFill]; + [bezier4Path fill]; + + //// Bezier 5 Drawing + NSBezierPath *bezier5Path = [NSBezierPath bezierPath]; + [bezier5Path + moveToPoint:NSMakePoint(NSMinX(bottomLeft), + NSMinY(bottomLeft) + 30.96)]; + [bezier5Path lineToPoint:NSMakePoint(NSMinX(bottomLeft) + 61.81, + NSMinY(bottomLeft))]; + [bezier5Path + lineToPoint:NSMakePoint(NSMinX(bottomLeft) + 61.81, + NSMinY(bottomLeft) + 24.02)]; + [bezier5Path + curveToPoint:NSMakePoint(NSMinX(bottomLeft) + 54.44, + NSMinY(bottomLeft) + 31.44) + controlPoint1:NSMakePoint(NSMinX(bottomLeft) + 57.49, + NSMinY(bottomLeft) + 24.57) + controlPoint2:NSMakePoint(NSMinX(bottomLeft) + 54.99, + NSMinY(bottomLeft) + 27.07)]; + [bezier5Path + lineToPoint:NSMakePoint(NSMinX(bottomLeft) + 0.14, + NSMinY(bottomLeft) + 31.44)]; + [bezier5Path + lineToPoint:NSMakePoint(NSMinX(bottomLeft), + NSMinY(bottomLeft) + 30.96)]; + [bezier5Path closePath]; + [fillColor7 setFill]; + [bezier5Path fill]; + + //// Bezier 6 Drawing + NSBezierPath *bezier6Path = [NSBezierPath bezierPath]; + [bezier6Path + moveToPoint:NSMakePoint(NSMinX(bottomLeft) + 61.88, + NSMinY(bottomLeft) + 28.3)]; + [bezier6Path + curveToPoint:NSMakePoint(NSMinX(bottomLeft) + 65.04, + NSMinY(bottomLeft) + 31.45) + controlPoint1:NSMakePoint(NSMinX(bottomLeft) + 63.75, + NSMinY(bottomLeft) + 28.53) + controlPoint2:NSMakePoint(NSMinX(bottomLeft) + 65.03, + NSMinY(bottomLeft) + 29.51)]; + [bezier6Path + lineToPoint:NSMakePoint(NSMinX(bottomLeft) + 65.04, + NSMinY(bottomLeft) + 31.47)]; + [bezier6Path + curveToPoint:NSMakePoint(NSMinX(bottomLeft) + 61.89, + NSMinY(bottomLeft) + 34.52) + controlPoint1:NSMakePoint(NSMinX(bottomLeft) + 65.01, + NSMinY(bottomLeft) + 33.18) + controlPoint2:NSMakePoint(NSMinX(bottomLeft) + 63.6, + NSMinY(bottomLeft) + 34.55)]; + [bezier6Path + curveToPoint:NSMakePoint(NSMinX(bottomLeft) + 58.86, + NSMinY(bottomLeft) + 31.58) + controlPoint1:NSMakePoint(NSMinX(bottomLeft) + 60.27, + NSMinY(bottomLeft) + 34.49) + controlPoint2:NSMakePoint(NSMinX(bottomLeft) + 58.95, + NSMinY(bottomLeft) + 33.21)]; + [bezier6Path + curveToPoint:NSMakePoint(NSMinX(bottomLeft) + 61.88, + NSMinY(bottomLeft) + 28.3) + controlPoint1:NSMakePoint(NSMinX(bottomLeft) + 58.77, + NSMinY(bottomLeft) + 29.7) + controlPoint2:NSMakePoint(NSMinX(bottomLeft) + 60, + NSMinY(bottomLeft) + 28.66)]; + [bezier6Path closePath]; + [fillColor7 setFill]; + [bezier6Path fill]; + } + + //// Text Drawing + NSRect textRect = NSMakeRect( + NSMinX(frame) + floor(frame.size.width * 0.42422 + 0.5), + NSMinY(frame) + frame.size.height - 20, + floor(frame.size.width * 0.57656 + 0.5) - + floor(frame.size.width * 0.42422 + 0.5), + 21); + NSMutableParagraphStyle *textStyle = + [[NSMutableParagraphStyle alloc] init]; + textStyle.alignment = NSTextAlignmentCenter; + NSDictionary *textFontAttributes = @{ + NSFontAttributeName: [NSFont systemFontOfSize:14], + NSForegroundColorAttributeName: fillColor6, + NSParagraphStyleAttributeName: textStyle + }; + + CGFloat textTextHeight = + [versionText + boundingRectWithSize:textRect.size + options:NSStringDrawingUsesLineFragmentOrigin + attributes:textFontAttributes] + .size.height; + NSRect textTextRect = NSMakeRect( + NSMinX(textRect), + NSMinY(textRect) + (textRect.size.height - textTextHeight) / 2, + textRect.size.width, textTextHeight); + [NSGraphicsContext saveGraphicsState]; + NSRectClip(textRect); + [versionText drawInRect:NSOffsetRect(textTextRect, 0, -0.5) + withAttributes:textFontAttributes]; + [NSGraphicsContext restoreGraphicsState]; +} + +void DrawDialWithFrame(NSRect frame, CGFloat rotation) +{ + //// General Declarations + CGContextRef context = NSGraphicsContext.currentContext.CGContext; + + //// Oval 3 Drawing + NSBezierPath *oval3Path = [NSBezierPath + bezierPathWithOvalInRect:NSMakeRect( + NSMinX(frame) + + frame.size.width - 133, + NSMinY(frame) + 30, 98, 98)]; + [NSColor.grayColor setFill]; + [oval3Path fill]; + + //// Bezier 10 Drawing + [NSGraphicsContext saveGraphicsState]; + CGContextTranslateCTM(context, NSMaxX(frame) - 83.5, + NSMinY(frame) + 79.5); + CGContextRotateCTM(context, rotation * M_PI / 180); + + NSBezierPath *bezier10Path = [NSBezierPath bezierPath]; + [bezier10Path moveToPoint:NSMakePoint(-0, -0)]; + [bezier10Path lineToPoint:NSMakePoint(-0, 48)]; + [NSColor.blackColor setStroke]; + bezier10Path.lineWidth = 2; + [bezier10Path stroke]; + + [NSGraphicsContext restoreGraphicsState]; +} + +NSImage *ImageOfTestCardWithSize(NSSize imageSize) +{ + return [NSImage imageWithSize:imageSize + flipped:YES + drawingHandler:^(__unused NSRect dstRect) { + DrawTestCardWithFrame( + nil, NSMakeRect(0, 0, imageSize.width, + imageSize.height)); + return YES; + }]; +} diff --git a/plugins/mac-virtualcam/src/dal-plugin/placeholder.png b/plugins/mac-virtualcam/src/dal-plugin/placeholder.png new file mode 100644 index 0000000000000000000000000000000000000000..70721300311cd30610ede698e13acb74fcedab4f GIT binary patch literal 314050 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 z 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%0DwJ4=QFmBD9Ta}GtZ@BZ;~N`9tLc;`-KqE)&7YA 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

M!G9stD#tXYGG%qa~5An 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

$(N`8LqA-*aPFOX8>dj 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 DS?I. + +#define PLUGIN_NAME "mac-virtualcam" +#define PLUGIN_VERSION "1.3.0" + +#define blog(level, msg, ...) \ + blog(level, "[" PLUGIN_NAME "] " msg, ##__VA_ARGS__) diff --git a/plugins/mac-virtualcam/src/obs-plugin/MachServer.h b/plugins/mac-virtualcam/src/obs-plugin/MachServer.h new file mode 100644 index 000000000..0f21f091f --- /dev/null +++ b/plugins/mac-virtualcam/src/obs-plugin/MachServer.h @@ -0,0 +1,29 @@ +// +// MachServer.h +// obs-mac-virtualcam +// +// Created by John Boiles on 5/5/20. +// + +#import + +NS_ASSUME_NONNULL_BEGIN + +@interface MachServer : NSObject + +- (void)run; + +/*! + Will eventually be used for sending frames to all connected clients + */ +- (void)sendFrameWithSize:(NSSize)size + timestamp:(uint64_t)timestamp + fpsNumerator:(uint32_t)fpsNumerator + fpsDenominator:(uint32_t)fpsDenominator + frameBytes:(uint8_t *)frameBytes; + +- (void)stop; + +@end + +NS_ASSUME_NONNULL_END diff --git a/plugins/mac-virtualcam/src/obs-plugin/MachServer.mm b/plugins/mac-virtualcam/src/obs-plugin/MachServer.mm new file mode 100644 index 000000000..4529f4c35 --- /dev/null +++ b/plugins/mac-virtualcam/src/obs-plugin/MachServer.mm @@ -0,0 +1,178 @@ +// +// MachServer.m +// mac-virtualcam +// +// Created by John Boiles on 5/5/20. +// + +#import "MachServer.h" +#import +#include +#include "MachProtocol.h" +#include "Defines.h" + +@interface MachServer () +@property NSPort *port; +@property NSMutableSet *clientPorts; +@property NSRunLoop *runLoop; +@end + +@implementation MachServer + +- (id)init +{ + if (self = [super init]) { + self.clientPorts = [[NSMutableSet alloc] init]; + } + return self; +} + +- (void)dealloc +{ + blog(LOG_DEBUG, "tearing down MachServer"); + [self.runLoop removePort:self.port forMode:NSDefaultRunLoopMode]; + [self.port invalidate]; + self.port.delegate = nil; +} + +- (void)run +{ + if (self.port != nil) { + blog(LOG_DEBUG, "mach server already running!"); + return; + } + +// It's a bummer this is deprecated. The replacement, NSXPCConnection, seems to require +// an assistant process that lives inside the .app bundle. This would be more modern, but adds +// complexity and I think makes it impossible to just run the `obs` binary from the commandline. +// So let's stick with NSMachBootstrapServer at least until it fully goes away. +// At that point we can decide between NSXPCConnection and using the CoreFoundation versions of +// these APIs (which are, interestingly, not deprecated) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-declarations" + self.port = [[NSMachBootstrapServer sharedInstance] + servicePortWithName:@MACH_SERVICE_NAME]; +#pragma clang diagnostic pop + if (self.port == nil) { + // This probably means another instance is running. + blog(LOG_ERROR, "Unable to open mach server port."); + return; + } + + self.port.delegate = self; + + self.runLoop = [NSRunLoop currentRunLoop]; + [self.runLoop addPort:self.port forMode:NSDefaultRunLoopMode]; + + blog(LOG_DEBUG, "mach server running!"); +} + +- (void)handlePortMessage:(NSPortMessage *)message +{ + switch (message.msgid) { + case MachMsgIdConnect: + if (message.sendPort != nil) { + blog(LOG_DEBUG, + "mach server received connect message from port %d!", + ((NSMachPort *)message.sendPort).machPort); + [self.clientPorts addObject:message.sendPort]; + } + break; + default: + blog(LOG_ERROR, "Unexpected mach message ID %u", + (unsigned)message.msgid); + break; + } +} + +- (void)sendMessageToClientsWithMsgId:(uint32_t)msgId + components:(nullable NSArray *)components +{ + if ([self.clientPorts count] <= 0) { + return; + } + + NSMutableSet *removedPorts = [NSMutableSet set]; + + for (NSPort *port in self.clientPorts) { + @try { + NSPortMessage *message = [[NSPortMessage alloc] + initWithSendPort:port + receivePort:nil + components:components]; + message.msgid = msgId; + if (![message + sendBeforeDate: + [NSDate dateWithTimeIntervalSinceNow: + 1.0]]) { + blog(LOG_DEBUG, + "failed to send message to %d, removing it from the clients!", + ((NSMachPort *)port).machPort); + [removedPorts addObject:port]; + } + } @catch (NSException *exception) { + blog(LOG_DEBUG, + "failed to send message (exception) to %d, removing it from the clients!", + ((NSMachPort *)port).machPort); + [removedPorts addObject:port]; + } + } + + // Remove dead ports if necessary + [self.clientPorts minusSet:removedPorts]; +} + +- (void)sendFrameWithSize:(NSSize)size + timestamp:(uint64_t)timestamp + fpsNumerator:(uint32_t)fpsNumerator + fpsDenominator:(uint32_t)fpsDenominator + frameBytes:(uint8_t *)frameBytes +{ + if ([self.clientPorts count] <= 0) { + return; + } + + @autoreleasepool { + CGFloat width = size.width; + NSData *widthData = [NSData dataWithBytes:&width + length:sizeof(width)]; + CGFloat height = size.height; + NSData *heightData = [NSData dataWithBytes:&height + length:sizeof(height)]; + NSData *timestampData = [NSData + dataWithBytes:×tamp + length:sizeof(timestamp)]; + NSData *fpsNumeratorData = [NSData + dataWithBytes:&fpsNumerator + length:sizeof(fpsNumerator)]; + NSData *fpsDenominatorData = [NSData + dataWithBytes:&fpsDenominator + length:sizeof(fpsDenominator)]; + + // NOTE: I'm not totally sure about the safety of dataWithBytesNoCopy in this context. + // Seems like there could potentially be an issue if the frameBuffer went away before the + // mach message finished sending. But it seems to be working and avoids a memory copy. Alternately + // we could do something like + // NSData *frameData = [NSData dataWithBytes:(void *)frameBytes length:size.width * size.height * 2]; + NSData *frameData = [NSData + dataWithBytesNoCopy:(void *)frameBytes + length:size.width * size.height * 2 + freeWhenDone:NO]; + [self sendMessageToClientsWithMsgId:MachMsgIdFrame + components:@[ + widthData, heightData, + timestampData, frameData, + fpsNumeratorData, + fpsDenominatorData + ]]; + } +} + +- (void)stop +{ + blog(LOG_DEBUG, "sending stop message to %lu clients", + self.clientPorts.count); + [self sendMessageToClientsWithMsgId:MachMsgIdStop components:nil]; +} + +@end diff --git a/plugins/mac-virtualcam/src/obs-plugin/data/locale/en-US.ini b/plugins/mac-virtualcam/src/obs-plugin/data/locale/en-US.ini new file mode 100644 index 000000000..4ac071612 --- /dev/null +++ b/plugins/mac-virtualcam/src/obs-plugin/data/locale/en-US.ini @@ -0,0 +1,5 @@ +UnsupportedResolution_Title="Unsupported resolution" +UnsupportedResolution_Main="Your output resolution not supported. Please use one of the following:" +VirtualCamera_Start="Start Virtual Camera" +VirtualCamera_Stop="Stop Virtual Camera" +Plugin_Name="macOS Virtual Webcam" diff --git a/plugins/mac-virtualcam/src/obs-plugin/plugin-main.mm b/plugins/mac-virtualcam/src/obs-plugin/plugin-main.mm new file mode 100644 index 000000000..2542b6048 --- /dev/null +++ b/plugins/mac-virtualcam/src/obs-plugin/plugin-main.mm @@ -0,0 +1,208 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "MachServer.h" +#include "Defines.h" + +OBS_DECLARE_MODULE() +OBS_MODULE_USE_DEFAULT_LOCALE("mac-virtualcam", "en-US") +MODULE_EXPORT const char *obs_module_description(void) +{ + return "macOS virtual webcam output"; +} + +obs_output_t *outputRef; +obs_video_info videoInfo; +static MachServer *sMachServer; + +static bool check_dal_plugin() +{ + NSFileManager *fileManager = [NSFileManager defaultManager]; + + NSString *dalPluginDestinationPath = + @"/Library/CoreMediaIO/Plug-Ins/DAL/"; + NSString *dalPluginFileName = [dalPluginDestinationPath + stringByAppendingString:@"obs-mac-virtualcam.plugin"]; + + BOOL dalPluginInstalled = + [fileManager fileExistsAtPath:dalPluginFileName]; + BOOL dalPluginUpdateNeeded = NO; + + if (dalPluginInstalled) { + NSString *dalPluginPlistPath = [dalPluginFileName + stringByAppendingString:@"/Contents/Info.plist"]; + NSDictionary *dalPluginInfoPlist = [NSDictionary + dictionaryWithContentsOfURL: + [NSURL fileURLWithPath:dalPluginPlistPath] + error:nil]; + NSString *dalPluginVersion = [dalPluginInfoPlist + valueForKey:@"CFBundleShortVersionString"]; + const char *obsVersion = obs_get_version_string(); + + if (![dalPluginVersion isEqualToString:@(obsVersion)]) { + dalPluginUpdateNeeded = YES; + } + } else { + dalPluginUpdateNeeded = YES; + } + + if (dalPluginUpdateNeeded) { + NSString *dalPluginSourcePath; + NSRunningApplication *app = + [NSRunningApplication currentApplication]; + + if ([app bundleIdentifier] != nil) { + NSURL *bundleURL = [app bundleURL]; + NSString *pluginPath = + @"Contents/Resources/data/obs-mac-virtualcam.plugin"; + + NSURL *pluginUrl = [bundleURL + URLByAppendingPathComponent:pluginPath]; + dalPluginSourcePath = [pluginUrl path]; + } else { + dalPluginSourcePath = [[[[app executableURL] + URLByAppendingPathComponent: + @"../data/obs-mac-virtualcam.plugin"] + path] + stringByReplacingOccurrencesOfString:@"obs/" + withString:@""]; + } + + if ([fileManager fileExistsAtPath:dalPluginSourcePath]) { + NSString *copyCmd = [NSString + stringWithFormat: + @"do shell script \"cp -R '%@' '%@'\" with administrator privileges", + dalPluginSourcePath, + dalPluginDestinationPath]; + + NSDictionary *errorDict; + NSAppleEventDescriptor *returnDescriptor = NULL; + NSAppleScript *scriptObject = + [[NSAppleScript alloc] initWithSource:copyCmd]; + returnDescriptor = + [scriptObject executeAndReturnError:&errorDict]; + if (errorDict != nil) { + const char *errorMessage = [[errorDict + objectForKey:@"NSAppleScriptErrorMessage"] + UTF8String]; + blog(LOG_INFO, + "[macOS] VirtualCam DAL Plugin Installation status: %s", + errorMessage); + return false; + } + } else { + blog(LOG_INFO, + "[macOS] VirtualCam DAL Plugin not shipped with OBS"); + return false; + } + } + return true; +} + +static const char *virtualcam_output_get_name(void *type_data) +{ + (void)type_data; + return obs_module_text("macOS Virtual Webcam"); +} + +// This is a dummy pointer so we have something to return from virtualcam_output_create +static void *data = &data; + +static void *virtualcam_output_create(obs_data_t *settings, + obs_output_t *output) +{ + outputRef = output; + + blog(LOG_DEBUG, "output_create"); + sMachServer = [[MachServer alloc] init]; + return data; +} + +static void virtualcam_output_destroy(void *data) +{ + blog(LOG_DEBUG, "output_destroy"); + sMachServer = nil; +} + +static bool virtualcam_output_start(void *data) +{ + bool hasDalPlugin = check_dal_plugin(); + + if (!hasDalPlugin) { + return false; + } + + blog(LOG_DEBUG, "output_start"); + + [sMachServer run]; + + obs_get_video_info(&videoInfo); + + struct video_scale_info conversion = {}; + conversion.format = VIDEO_FORMAT_UYVY; + conversion.width = videoInfo.output_width; + conversion.height = videoInfo.output_height; + obs_output_set_video_conversion(outputRef, &conversion); + if (!obs_output_begin_data_capture(outputRef, 0)) { + return false; + } + + return true; +} + +static void virtualcam_output_stop(void *data, uint64_t ts) +{ + blog(LOG_DEBUG, "output_stop"); + obs_output_end_data_capture(outputRef); + [sMachServer stop]; +} + +static void virtualcam_output_raw_video(void *data, struct video_data *frame) +{ + uint8_t *outData = frame->data[0]; + if (frame->linesize[0] != (videoInfo.output_width * 2)) { + blog(LOG_ERROR, + "unexpected frame->linesize (expected:%d actual:%d)", + (videoInfo.output_width * 2), frame->linesize[0]); + } + + CGFloat width = videoInfo.output_width; + CGFloat height = videoInfo.output_height; + + [sMachServer sendFrameWithSize:NSMakeSize(width, height) + timestamp:frame->timestamp + fpsNumerator:videoInfo.fps_num + fpsDenominator:videoInfo.fps_den + frameBytes:outData]; +} + +struct obs_output_info virtualcam_output_info = { + .id = "virtualcam_output", + .flags = OBS_OUTPUT_VIDEO, + .get_name = virtualcam_output_get_name, + .create = virtualcam_output_create, + .destroy = virtualcam_output_destroy, + .start = virtualcam_output_start, + .stop = virtualcam_output_stop, + .raw_video = virtualcam_output_raw_video, +}; + +bool obs_module_load(void) +{ + blog(LOG_INFO, "version=%s", PLUGIN_VERSION); + + obs_register_output(&virtualcam_output_info); + + obs_data_t *obs_settings = obs_data_create(); + obs_data_set_bool(obs_settings, "vcamEnabled", true); + obs_apply_private_data(obs_settings); + obs_data_release(obs_settings); + + return true; +}