VuoScreenCapture.m

Go to the documentation of this file.

 
#include "module.h"
#include "VuoScreenCapture.h"
#include"VuoGlPool.h"
 
#ifndef NS_RETURNS_INNER_POINTER
#define NS_RETURNS_INNER_POINTER
#endif
#import <AVFoundation/AVFoundation.h>
#import <OpenGL/gl.h>
 
#ifdef VUO_COMPILER
VuoModuleMetadata({
                      "title" : "VuoScreenCapture",
                      "dependencies" : [
                          "AVFoundation.framework",
                          "CoreMedia.framework",
                          "CoreVideo.framework"
                      ]
                 });
#endif
 
@class VuoScreenCaptureDelegate;
 
typedef struct
{
    CVOpenGLTextureCacheRef textureCache;           
    dispatch_queue_t queue;                         
    AVCaptureSession *session;                      
    VuoScreenCaptureDelegate *delegate;             
    void (*capturedImageTrigger)(VuoImage image);   
} VuoScreenCaptureInternal;
 
static void VuoScreenCapture_freeCallback(VuoImage imageToFree)
{
}
 
@interface VuoScreenCaptureDelegate : NSObject <AVCaptureVideoDataOutputSampleBufferDelegate>
@property VuoScreenCaptureInternal *sci;    
@end
 
@implementation VuoScreenCaptureDelegate
- (void)captureOutput:(AVCaptureOutput *)captureOutput didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer fromConnection:(AVCaptureConnection *)connection
{
    CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
 
    __block CVOpenGLTextureRef texture;
    VuoGlContext_perform(^(CGLContextObj cgl_ctx){
        CVOpenGLTextureCacheCreateTextureFromImage(NULL, _sci->textureCache, pixelBuffer, NULL, &texture);
    });
 
    VuoImage rectImage = VuoImage_makeClientOwnedGlTextureRectangle(
                CVOpenGLTextureGetName(texture),
                GL_RGB,
                CVPixelBufferGetWidth(pixelBuffer),
                CVPixelBufferGetHeight(pixelBuffer),
                VuoScreenCapture_freeCallback, NULL);
    VuoRetain(rectImage);
    VuoImage image = VuoImage_makeCopy(rectImage, CVOpenGLTextureIsFlipped(texture), 0, 0, false);
    _sci->capturedImageTrigger(image);
    CVOpenGLTextureRelease(texture);
    VuoRelease(rectImage);
 
    VuoGlContext_perform(^(CGLContextObj cgl_ctx){
        CVOpenGLTextureCacheFlush(_sci->textureCache, 0);
    });
}
@end
 
void VuoScreenCapture_free(void *p)
{
    VuoScreenCaptureInternal *sci = (VuoScreenCaptureInternal *)p;
 
    VUOLOG_PROFILE_BEGIN(mainQueue);
    dispatch_sync(dispatch_get_main_queue(), ^{
                      VUOLOG_PROFILE_END(mainQueue);
                      [sci->session stopRunning];
                  });
    dispatch_sync(sci->queue, ^{});
 
    [sci->session release];
    [sci->delegate release];
 
    if (sci->textureCache)
        VuoGlContext_perform(^(CGLContextObj cgl_ctx){
            CVOpenGLTextureCacheRelease(sci->textureCache);
        });
 
    dispatch_release(sci->queue);
}
 
VuoScreenCapture VuoScreenCapture_make(VuoScreen screen, VuoRectangle rectangle, void (*capturedImage)(VuoImage image))
{
    if ( (rectangle.center.x-rectangle.size.x/2.) >= screen.width
      || (rectangle.center.y-rectangle.size.y/2.) >= screen.height)
        return NULL;
 
    VuoScreenCaptureInternal *sci = (VuoScreenCaptureInternal *)calloc(1, sizeof(VuoScreenCaptureInternal));
    VuoRegister(sci, VuoScreenCapture_free);
 
    sci->capturedImageTrigger = capturedImage;
 
    sci->queue = dispatch_queue_create("org.vuo.VuoScreenCapture", NULL);
 
    VUOLOG_PROFILE_BEGIN(mainQueue);
    dispatch_sync(dispatch_get_main_queue(), ^{
                      VUOLOG_PROFILE_END(mainQueue);
                      sci->delegate = [VuoScreenCaptureDelegate new];
                      sci->delegate.sci = sci;
 
                      sci->session = [AVCaptureSession new];
                      sci->session.sessionPreset = AVCaptureSessionPresetPhoto;
 
                      {
                          AVCaptureScreenInput *input = [[AVCaptureScreenInput alloc] initWithDisplayID:screen.id];
                          input.minFrameDuration = CMTimeMake(1, 120);
 
                          double width = rectangle.size.x;
                          if (width < 1)
                          width = screen.width;
 
                          double height = rectangle.size.y;
                          if (height < 1)
                          height = screen.height;
 
                          input.cropRect = CGRectMake(
                          (int)(rectangle.center.x - rectangle.size.x/2.),
                          (int)(screen.height - (rectangle.center.y - rectangle.size.y/2.) - height),
                          (int)width,
                          (int)height);
                          //        input.capturesMouseClicks = YES;
                          [sci->session addInput:input];
                          [input release];
                      }
 
                      {
                          AVCaptureVideoDataOutput *output = [AVCaptureVideoDataOutput new];
                          [output setAlwaysDiscardsLateVideoFrames:YES];
                          [output setSampleBufferDelegate:sci->delegate queue:sci->queue];
                          [sci->session addOutput:output];
                          [output release];
                      }
                  });
 
    {
        CGLPixelFormatObj pf = VuoGlContext_makePlatformPixelFormat(false, false, -1);
        __block CVReturn ret;
        VuoGlContext_perform(^(CGLContextObj cgl_ctx){
            ret = CVOpenGLTextureCacheCreate(NULL, NULL, cgl_ctx, pf, NULL, &sci->textureCache);
        });
        CGLReleasePixelFormat(pf);
 
        if (ret != kCVReturnSuccess)
        {
            VUserLog("Error: Couldn't create texture cache: %d", ret);
            VuoScreenCapture_free(sci);
            return NULL;
        }
    }
 
    {
    VUOLOG_PROFILE_BEGIN(mainQueue);
    dispatch_sync(dispatch_get_main_queue(), ^{
                      VUOLOG_PROFILE_END(mainQueue);
                      [sci->session startRunning];
                  });
    }
 
    return (VuoScreenCapture)sci;
}