@0biwank/screen-capture 1.0.1 → 2.0.1

package/src/CameraCapturer.mm

@@ -0,0 +1,154 @@
+#import <AVFoundation/AVFoundation.h>
+#import <CoreMedia/CoreMedia.h>
+#include "CameraCapturer.h"
+#include <iostream>
+
+/**
+ * CameraDelegate
+ * --------------
+ * Internal ObjC class to receive frames from AVCaptureVideoDataOutput.
+ */
+@interface CameraDelegate : NSObject <AVCaptureVideoDataOutputSampleBufferDelegate> {
+    CameraFrameCallback _callback;
+}
+- (void)setCallback:(CameraFrameCallback)cb;
+@end
+
+@implementation CameraDelegate
+- (void)setCallback:(CameraFrameCallback)cb {
+    _callback = cb;
+}
+
+- (void)captureOutput:(AVCaptureOutput *)output
+    didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
+           fromConnection:(AVCaptureConnection *)connection {
+    if (_callback) {
+        _callback(static_cast<void*>(sampleBuffer));
+    }
+}
+@end
+
+CameraCapturer::CameraCapturer() : m_session(nullptr), m_delegate(nullptr) {}
+
+CameraCapturer::~CameraCapturer() {
+    stop();
+}
+
+std::vector<CameraDevice> CameraCapturer::listDevices() {
+    std::vector<CameraDevice> result;
+    
+    // Modern API for listing video devices
+    AVCaptureDeviceDiscoverySession *discoverySession = [AVCaptureDeviceDiscoverySession
+        discoverySessionWithDeviceTypes:@[AVCaptureDeviceTypeBuiltInWideAngleCamera, AVCaptureDeviceTypeExternal]
+                              mediaType:AVMediaTypeVideo
+                               position:AVCaptureDevicePositionUnspecified];
+    
+    for (AVCaptureDevice *device in discoverySession.devices) {
+        CameraDevice d;
+        d.uid = [[device uniqueID] UTF8String];
+        d.name = [[device localizedName] UTF8String];
+        result.push_back(d);
+    }
+    
+    return result;
+}
+
+bool CameraCapturer::start(const std::string& device_uid, uint32_t& width, uint32_t& height, int fps, CameraFrameCallback cb) {
+    stop(); // Ensure clean state
+    
+    AVCaptureSession *session = [[AVCaptureSession alloc] init];
+    AVCaptureDevice *device = nil;
+    
+    if (device_uid.empty()) {
+        device = [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo];
+    } else {
+        device = [AVCaptureDevice deviceWithUniqueID:[NSString stringWithUTF8String:device_uid.c_str()]];
+    }
+    
+    if (!device) {
+        std::cerr << "[Camera] Requested device not found: " << device_uid << std::endl;
+        return false;
+    }
+    
+    NSError *error = nil;
+    AVCaptureDeviceInput *input = [AVCaptureDeviceInput deviceInputWithDevice:device error:&error];
+    if (error || !input) {
+        std::cerr << "[Camera] Failed to create input: " << [[error localizedDescription] UTF8String] << std::endl;
+        return false;
+    }
+    
+    if ([session canAddInput:input]) {
+        [session addInput:input];
+    } else {
+        return false;
+    }
+    
+    AVCaptureVideoDataOutput *output = [[AVCaptureVideoDataOutput alloc] init];
+    
+    // Use 32BGRA for easy conversion / preview
+    [output setVideoSettings:@{
+        (id)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_32BGRA)
+    }];
+    
+    CameraDelegate *delegate = [[CameraDelegate alloc] init];
+    [delegate setCallback:cb];
+    
+    dispatch_queue_t queue = dispatch_queue_create("com.boom.camera.queue", DISPATCH_QUEUE_SERIAL);
+    [output setSampleBufferDelegate:delegate queue:queue];
+    
+    if ([session canAddOutput:output]) {
+        [session addOutput:output];
+    } else {
+        return false;
+    }
+    
+    // Find best match for requested dimensions
+    AVCaptureDeviceFormat *bestFormat = nil;
+    int bestDiff = 9999999;
+    
+    for (AVCaptureDeviceFormat *vFormat in [device formats]) {
+        CMFormatDescriptionRef description = [vFormat formatDescription];
+        CMVideoDimensions dims = CMVideoFormatDescriptionGetDimensions(description);
+        
+        int diff = std::abs((int)dims.width - (int)width) + std::abs((int)dims.height - (int)height);
+        if (diff < bestDiff) {
+            bestDiff = diff;
+            bestFormat = vFormat;
+        }
+    }
+    
+    if (bestFormat) {
+        if ([device lockForConfiguration:nil]) {
+            device.activeFormat = bestFormat;
+            device.activeVideoMinFrameDuration = CMTimeMake(1, fps);
+            device.activeVideoMaxFrameDuration = CMTimeMake(1, fps);
+            [device unlockForConfiguration];
+            
+            CMFormatDescriptionRef description = [bestFormat formatDescription];
+            CMVideoDimensions dims = CMVideoFormatDescriptionGetDimensions(description);
+            width = dims.width;
+            height = dims.height;
+            std::cout << "[Camera] Selected format: " << width << "x" << height << " @ " << fps << "fps" << std::endl;
+        }
+    }
+    
+    [session startRunning];
+    
+    m_session = (__bridge_retained void*)session;
+    m_delegate = (__bridge_retained void*)delegate;
+    
+    return true;
+}
+
+void CameraCapturer::stop() {
+    if (m_session) {
+        AVCaptureSession *session = (__bridge_transfer AVCaptureSession*)m_session;
+        [session stopRunning];
+        m_session = nullptr;
+    }
+    if (m_delegate) {
+        CameraDelegate *delegate = (__bridge_transfer CameraDelegate*)m_delegate;
+        [delegate setCallback:nullptr];
+        m_delegate = nullptr;
+    }
+}