modules/video_output/caopengllayer.m

   1 /*****************************************************************************
   2  * caopengllayer.m: CAOpenGLLayer (Mac OS X) video output
   3  *****************************************************************************
   4  * Copyright (C) 2014-2017 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: David Fuhrmann <david dot fuhrmann at googlemail dot com>
   8  *          Felix Paul Kühne <fkuehne at videolan dot org>
   9  *          Pierre d'Herbemont <pdherbemont at videolan dot org>
  10  *
  11  * This program is free software; you can redistribute it and/or modify it
  12  * under the terms of the GNU Lesser General Public License as published by
  13  * the Free Software Foundation; either version 2.1 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  19  * GNU Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * along with this program; if not, write to the Free Software Foundation,
  23  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24  *****************************************************************************/
  25
  26 /*****************************************************************************
  27  * Preamble
  28  *****************************************************************************/
  29
  30 #ifdef HAVE_CONFIG_H
  31 # include "config.h"
  32 #endif
  33
  34 #include <vlc_common.h>
  35 #include <vlc_plugin.h>
  36 #include <vlc_vout_display.h>
  37 #include <vlc_opengl.h>
  38
  39 #import <QuartzCore/QuartzCore.h>
  40 #import <Cocoa/Cocoa.h>
  41 #import <OpenGL/OpenGL.h>
  42 #import <dlfcn.h>               /* dlsym */
  43
  44 #include "opengl/vout_helper.h"
  45
  46 #define OSX_SIERRA_AND_HIGHER (NSAppKitVersionNumber >= 1485)
  47
  48 /*****************************************************************************
  49  * Vout interface
  50  *****************************************************************************/
  51 static int  Open   (vlc_object_t *);
  52 static void Close  (vlc_object_t *);
  53
  54 vlc_module_begin()
  55     set_description(N_("Core Animation OpenGL Layer (Mac OS X)"))
  56     set_capability("vout display", 0)
  57     set_category(CAT_VIDEO)
  58     set_subcategory(SUBCAT_VIDEO_VOUT)
  59     set_callbacks(Open, Close)
  60 vlc_module_end()
  61
  62 static picture_pool_t *Pool (vout_display_t *vd, unsigned requested_count);
  63 static void PictureRender   (vout_display_t *vd, picture_t *pic, subpicture_t *subpicture);
  64 static void PictureDisplay  (vout_display_t *vd, picture_t *pic, subpicture_t *subpicture);
  65 static int Control          (vout_display_t *vd, int query, va_list ap);
  66
  67 static void *OurGetProcAddress (vlc_gl_t *gl, const char *name);
  68 static int OpenglLock         (vlc_gl_t *gl);
  69 static void OpenglUnlock       (vlc_gl_t *gl);
  70 static void OpenglSwap         (vlc_gl_t *gl);
  71
  72 @protocol VLCCoreAnimationVideoLayerEmbedding <NSObject>
  73 - (void)addVoutLayer:(CALayer *)aLayer;
  74 - (void)removeVoutLayer:(CALayer *)aLayer;
  75 - (CGSize)currentOutputSize;
  76 @end
  77
  78 @interface VLCCAOpenGLLayer : CAOpenGLLayer
  79
  80 @property (nonatomic, readwrite) vout_display_t* voutDisplay;
  81 @property (nonatomic, readwrite) CGLContextObj glContext;
  82
  83 @end
  84
  85
  86 struct vout_display_sys_t {
  87
  88     picture_pool_t *pool;
  89     picture_resource_t resource;
  90
  91     CALayer <VLCCoreAnimationVideoLayerEmbedding> *container;
  92     vout_window_t *embed;
  93     VLCCAOpenGLLayer *cgLayer;
  94
  95     vlc_gl_t *gl;
  96     vout_display_opengl_t *vgl;
  97
  98     vout_display_place_t place;
  99
 100     bool  b_frame_available;
 101 };
 102
 103 struct gl_sys
 104 {
 105     CGLContextObj locked_ctx;
 106     VLCCAOpenGLLayer *cgLayer;
 107 };
 108
 109 /*****************************************************************************
 110  * Open: This function allocates and initializes the OpenGL vout method.
 111  *****************************************************************************/
 112 static int Open (vlc_object_t *p_this)
 113 {
 114     vout_display_t *vd = (vout_display_t *)p_this;
 115     vout_display_sys_t *sys;
 116
 117     /* Allocate structure */
 118     vd->sys = sys = calloc(1, sizeof(vout_display_sys_t));
 119     if (sys == NULL)
 120         return VLC_EGENERIC;
 121
 122     @autoreleasepool {
 123         id container = var_CreateGetAddress(vd, "drawable-nsobject");
 124         if (container)
 125             vout_display_DeleteWindow(vd, NULL);
 126         else {
 127             sys->embed = vout_display_NewWindow(vd, VOUT_WINDOW_TYPE_NSOBJECT);
 128             if (sys->embed)
 129                 container = sys->embed->handle.nsobject;
 130
 131             if (!container) {
 132                 msg_Err(vd, "No drawable-nsobject found!");
 133                 goto bailout;
 134             }
 135         }
 136
 137         /* store for later, released in Close() */
 138         sys->container = [container retain];
 139
 140         [CATransaction begin];
 141         sys->cgLayer = [[VLCCAOpenGLLayer alloc] init];
 142         [sys->cgLayer setVoutDisplay:vd];
 143
 144         [sys->cgLayer performSelectorOnMainThread:@selector(display)
 145                                        withObject:nil
 146                                     waitUntilDone:YES];
 147
 148         if ([container respondsToSelector:@selector(addVoutLayer:)]) {
 149             msg_Dbg(vd, "container implements implicit protocol");
 150             [container addVoutLayer:sys->cgLayer];
 151         } else if ([container respondsToSelector:@selector(addSublayer:)] ||
 152                    [container isKindOfClass:[CALayer class]]) {
 153             msg_Dbg(vd, "container doesn't implement implicit protocol, fallback mode used");
 154             [container addSublayer:sys->cgLayer];
 155         } else {
 156             msg_Err(vd, "Provided NSObject container isn't compatible");
 157             [sys->cgLayer release];
 158             sys->cgLayer = nil;
 159             [CATransaction commit];
 160             goto bailout;
 161         }
 162         [CATransaction commit];
 163
 164         if (!sys->cgLayer)
 165             goto bailout;
 166
 167         if (![sys->cgLayer glContext])
 168             msg_Warn(vd, "we might not have an OpenGL context yet");
 169
 170         /* Initialize common OpenGL video display */
 171         sys->gl = vlc_object_create(vd, sizeof(*sys->gl));
 172         if (unlikely(!sys->gl))
 173             goto bailout;
 174         sys->gl->makeCurrent = OpenglLock;
 175         sys->gl->releaseCurrent = OpenglUnlock;
 176         sys->gl->swap = OpenglSwap;
 177         sys->gl->getProcAddress = OurGetProcAddress;
 178
 179         struct gl_sys *glsys = sys->gl->sys = malloc(sizeof(*glsys));
 180         if (!sys->gl->sys)
 181             goto bailout;
 182         glsys->locked_ctx = NULL;
 183         glsys->cgLayer = sys->cgLayer;
 184
 185         const vlc_fourcc_t *subpicture_chromas;
 186         video_format_t fmt = vd->fmt;
 187         if (!OpenglLock(sys->gl)) {
 188             sys->vgl = vout_display_opengl_New(&vd->fmt, &subpicture_chromas,
 189                                                sys->gl, &vd->cfg->viewpoint);
 190             OpenglUnlock(sys->gl);
 191         } else
 192             sys->vgl = NULL;
 193         if (!sys->vgl) {
 194             msg_Err(vd, "Error while initializing opengl display.");
 195             goto bailout;
 196         }
 197
 198         /* setup vout display */
 199         vout_display_info_t info = vd->info;
 200         info.subpicture_chromas = subpicture_chromas;
 201         vd->info = info;
 202
 203         vd->pool    = Pool;
 204         vd->prepare = PictureRender;
 205         vd->display = PictureDisplay;
 206         vd->control = Control;
 207
 208         if (OSX_SIERRA_AND_HIGHER) {
 209             /* request our screen's HDR mode (introduced in OS X 10.11, but correctly supported in 10.12 only) */
 210             if ([sys->cgLayer respondsToSelector:@selector(setWantsExtendedDynamicRangeContent:)]) {
 211                 [sys->cgLayer setWantsExtendedDynamicRangeContent:YES];
 212             }
 213         }
 214
 215         /* setup initial state */
 216         CGSize outputSize;
 217         if ([container respondsToSelector:@selector(currentOutputSize)])
 218             outputSize = [container currentOutputSize];
 219         else
 220             outputSize = [sys->container visibleRect].size;
 221         vout_display_SendEventDisplaySize(vd, (int)outputSize.width, (int)outputSize.height);
 222
 223         return VLC_SUCCESS;
 224
 225     bailout:
 226         Close(p_this);
 227         return VLC_EGENERIC;
 228     }
 229 }
 230
 231 static void Close (vlc_object_t *p_this)
 232 {
 233     vout_display_t *vd = (vout_display_t *)p_this;
 234     vout_display_sys_t *sys = vd->sys;
 235
 236     if (sys->cgLayer) {
 237         if ([sys->container respondsToSelector:@selector(removeVoutLayer:)])
 238             [sys->container removeVoutLayer:sys->cgLayer];
 239         else
 240             [sys->cgLayer removeFromSuperlayer];
 241         [sys->cgLayer release];
 242     }
 243
 244     if (sys->container)
 245         [sys->container release];
 246
 247     if (sys->embed)
 248         vout_display_DeleteWindow(vd, sys->embed);
 249
 250     if (sys->vgl != NULL && !OpenglLock(sys->gl)) {
 251         vout_display_opengl_Delete(sys->vgl);
 252         OpenglUnlock(sys->gl);
 253     }
 254
 255     if (sys->gl != NULL)
 256     {
 257         if (sys->gl->sys != NULL)
 258         {
 259             assert(((struct gl_sys *)sys->gl->sys)->locked_ctx == NULL);
 260             free(sys->gl->sys);
 261         }
 262         vlc_object_release(sys->gl);
 263     }
 264
 265     if ([sys->cgLayer glContext])
 266         CGLReleaseContext([sys->cgLayer glContext]);
 267
 268     free(sys);
 269 }
 270
 271 static picture_pool_t *Pool (vout_display_t *vd, unsigned count)
 272 {
 273     vout_display_sys_t *sys = vd->sys;
 274
 275     if (!sys->pool && !OpenglLock(sys->gl)) {
 276         sys->pool = vout_display_opengl_GetPool(sys->vgl, count);
 277         OpenglUnlock(sys->gl);
 278         assert(sys->pool);
 279     }
 280     return sys->pool;
 281 }
 282
 283 static void PictureRender (vout_display_t *vd, picture_t *pic, subpicture_t *subpicture)
 284 {
 285     vout_display_sys_t *sys = vd->sys;
 286
 287     if (pic == NULL) {
 288         msg_Warn(vd, "invalid pic, skipping frame");
 289         return;
 290     }
 291
 292     @synchronized (sys->cgLayer) {
 293         if (!OpenglLock(sys->gl)) {
 294             vout_display_opengl_Prepare(sys->vgl, pic, subpicture);
 295             OpenglUnlock(sys->gl);
 296         }
 297     }
 298 }
 299
 300 static void PictureDisplay (vout_display_t *vd, picture_t *pic, subpicture_t *subpicture)
 301 {
 302     vout_display_sys_t *sys = vd->sys;
 303
 304     @synchronized (sys->cgLayer) {
 305         sys->b_frame_available = YES;
 306
 307         /* Calling display on the non-main thread is not officially supported, but
 308          * its suggested at several places and works fine here. Flush is thread-safe
 309          * and makes sure the picture is actually displayed. */
 310         [sys->cgLayer display];
 311         [CATransaction flush];
 312     }
 313
 314     picture_Release(pic);
 315
 316     if (subpicture)
 317         subpicture_Delete(subpicture);
 318 }
 319
 320 static int Control (vout_display_t *vd, int query, va_list ap)
 321 {
 322     vout_display_sys_t *sys = vd->sys;
 323
 324     if (!vd->sys)
 325         return VLC_EGENERIC;
 326
 327     switch (query)
 328     {
 329         case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
 330         case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
 331         case VOUT_DISPLAY_CHANGE_ZOOM:
 332         case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT:
 333         case VOUT_DISPLAY_CHANGE_SOURCE_CROP:
 334         {
 335             const vout_display_cfg_t *cfg;
 336
 337             if (query == VOUT_DISPLAY_CHANGE_SOURCE_ASPECT || query == VOUT_DISPLAY_CHANGE_SOURCE_CROP) {
 338                 cfg = vd->cfg;
 339             } else {
 340                 cfg = (const vout_display_cfg_t*)va_arg (ap, const vout_display_cfg_t *);
 341             }
 342
 343             /* we always use our current frame here */
 344             vout_display_cfg_t cfg_tmp = *cfg;
 345             [CATransaction lock];
 346             CGRect bounds = [sys->cgLayer visibleRect];
 347             [CATransaction unlock];
 348             cfg_tmp.display.width = bounds.size.width;
 349             cfg_tmp.display.height = bounds.size.height;
 350
 351             /* Reverse vertical alignment as the GL tex are Y inverted */
 352             if (cfg_tmp.align.vertical == VOUT_DISPLAY_ALIGN_TOP)
 353                 cfg_tmp.align.vertical = VOUT_DISPLAY_ALIGN_BOTTOM;
 354             else if (cfg_tmp.align.vertical == VOUT_DISPLAY_ALIGN_BOTTOM)
 355                 cfg_tmp.align.vertical = VOUT_DISPLAY_ALIGN_TOP;
 356
 357             vout_display_place_t place;
 358             vout_display_PlacePicture (&place, &vd->source, &cfg_tmp, false);
 359             if (OpenglLock(sys->gl))
 360                 return VLC_EGENERIC;
 361
 362             vout_display_opengl_SetWindowAspectRatio(sys->vgl, (float)place.width / place.height);
 363             OpenglUnlock(sys->gl);
 364
 365             sys->place = place;
 366
 367             return VLC_SUCCESS;
 368         }
 369
 370         case VOUT_DISPLAY_CHANGE_VIEWPOINT:
 371         {
 372             int ret;
 373
 374             if (OpenglLock(sys->gl))
 375                 return VLC_EGENERIC;
 376
 377             ret = vout_display_opengl_SetViewpoint(sys->vgl,
 378                 &va_arg (ap, const vout_display_cfg_t* )->viewpoint);
 379             OpenglUnlock(sys->gl);
 380             return ret;
 381         }
 382
 383         case VOUT_DISPLAY_RESET_PICTURES:
 384             vlc_assert_unreachable ();
 385         default:
 386             msg_Err (vd, "Unhandled request %d", query);
 387             return VLC_EGENERIC;
 388     }
 389
 390     return VLC_SUCCESS;
 391 }
 392
 393 #pragma mark -
 394 #pragma mark OpenGL callbacks
 395
 396 static int OpenglLock (vlc_gl_t *gl)
 397 {
 398     struct gl_sys *sys = gl->sys;
 399     assert(sys->locked_ctx == NULL);
 400
 401     CGLContextObj ctx = [sys->cgLayer glContext];
 402     if(!ctx) {
 403         return 1;
 404     }
 405
 406     CGLError err = CGLLockContext(ctx);
 407     if (kCGLNoError == err) {
 408         sys->locked_ctx = ctx;
 409         CGLSetCurrentContext(ctx);
 410         return 0;
 411     }
 412     return 1;
 413 }
 414
 415 static void OpenglUnlock (vlc_gl_t *gl)
 416 {
 417     struct gl_sys *sys = gl->sys;
 418     CGLUnlockContext(sys->locked_ctx);
 419     sys->locked_ctx = NULL;
 420 }
 421
 422 static void OpenglSwap (vlc_gl_t *gl)
 423 {
 424     glFlush();
 425 }
 426
 427 static void *OurGetProcAddress (vlc_gl_t *gl, const char *name)
 428 {
 429     VLC_UNUSED(gl);
 430
 431     return dlsym(RTLD_DEFAULT, name);
 432 }
 433
 434 #pragma mark -
 435 #pragma mark CA layer
 436
 437 /*****************************************************************************
 438  * @implementation VLCCAOpenGLLayer
 439  *****************************************************************************/
 440 @implementation VLCCAOpenGLLayer
 441
 442 - (id)init {
 443
 444     self = [super init];
 445     if (self) {
 446         [CATransaction lock];
 447         self.needsDisplayOnBoundsChange = YES;
 448         self.autoresizingMask = kCALayerWidthSizable | kCALayerHeightSizable;
 449         self.asynchronous = NO;
 450         [CATransaction unlock];
 451     }
 452
 453     return self;
 454 }
 455
 456 - (void)setVoutDisplay:(vout_display_t *)aVd
 457 {
 458     _voutDisplay = aVd;
 459 }
 460
 461 - (void)resizeWithOldSuperlayerSize:(CGSize)size
 462 {
 463     [super resizeWithOldSuperlayerSize: size];
 464
 465     CGSize boundsSize = self.visibleRect.size;
 466
 467     if (_voutDisplay)
 468         vout_display_SendEventDisplaySize(_voutDisplay, boundsSize.width, boundsSize.height);
 469 }
 470
 471 - (BOOL)canDrawInCGLContext:(CGLContextObj)glContext pixelFormat:(CGLPixelFormatObj)pixelFormat forLayerTime:(CFTimeInterval)timeInterval displayTime:(const CVTimeStamp *)timeStamp
 472 {
 473     /* Only draw the frame if we have a frame that was previously rendered */
 474     if (!_voutDisplay)
 475         return false;
 476
 477     return _voutDisplay->sys->b_frame_available;
 478 }
 479
 480 - (void)drawInCGLContext:(CGLContextObj)glContext pixelFormat:(CGLPixelFormatObj)pixelFormat forLayerTime:(CFTimeInterval)timeInterval displayTime:(const CVTimeStamp *)timeStamp
 481 {
 482     if (!_voutDisplay)
 483         return;
 484     vout_display_sys_t *sys = _voutDisplay->sys;
 485
 486     if (!sys->vgl)
 487         return;
 488
 489     CGRect bounds = [self visibleRect];
 490
 491     // x / y are top left corner, but we need the lower left one
 492     glViewport (sys->place.x, bounds.size.height - (sys->place.y + sys->place.height), sys->place.width, sys->place.height);
 493
 494     // flush is also done by this method, no need to call super
 495     vout_display_opengl_Display (sys->vgl, &_voutDisplay->source);
 496     sys->b_frame_available = NO;
 497 }
 498
 499 -(CGLPixelFormatObj)copyCGLPixelFormatForDisplayMask:(uint32_t)mask
 500 {
 501     // The default is fine for this demonstration.
 502     return [super copyCGLPixelFormatForDisplayMask:mask];
 503 }
 504
 505 - (CGLContextObj)copyCGLContextForPixelFormat:(CGLPixelFormatObj)pixelFormat
 506 {
 507     // Only one opengl context is allowed for the module lifetime
 508     if(_glContext) {
 509         msg_Dbg(_voutDisplay, "Return existing context: %p", _glContext);
 510         return _glContext;
 511     }
 512
 513     CGLContextObj context = [super copyCGLContextForPixelFormat:pixelFormat];
 514
 515     // Swap buffers only during the vertical retrace of the monitor.
 516     //http://developer.apple.com/documentation/GraphicsImaging/
 517     //Conceptual/OpenGL/chap5/chapter_5_section_44.html /
 518
 519     GLint params = 1;
 520     CGLSetParameter( CGLGetCurrentContext(), kCGLCPSwapInterval,
 521                      &params );
 522
 523     @synchronized (self) {
 524         _glContext = context;
 525     }
 526
 527     return context;
 528 }
 529
 530 - (void)releaseCGLContext:(CGLContextObj)glContext
 531 {
 532     // do not release anything here, we do that when closing the module
 533 }
 534
 535 - (void)mouseButtonDown:(int)buttonNumber
 536 {
 537     @synchronized (self) {
 538         if (_voutDisplay) {
 539             if (buttonNumber == 0)
 540                 vout_display_SendEventMousePressed (_voutDisplay, MOUSE_BUTTON_LEFT);
 541             else if (buttonNumber == 1)
 542                 vout_display_SendEventMousePressed (_voutDisplay, MOUSE_BUTTON_RIGHT);
 543             else
 544                 vout_display_SendEventMousePressed (_voutDisplay, MOUSE_BUTTON_CENTER);
 545         }
 546     }
 547 }
 548
 549 - (void)mouseButtonUp:(int)buttonNumber
 550 {
 551     @synchronized (self) {
 552         if (_voutDisplay) {
 553             if (buttonNumber == 0)
 554                 vout_display_SendEventMouseReleased (_voutDisplay, MOUSE_BUTTON_LEFT);
 555             else if (buttonNumber == 1)
 556                 vout_display_SendEventMouseReleased (_voutDisplay, MOUSE_BUTTON_RIGHT);
 557             else
 558                 vout_display_SendEventMouseReleased (_voutDisplay, MOUSE_BUTTON_CENTER);
 559         }
 560     }
 561 }
 562
 563 - (void)mouseMovedToX:(double)xValue Y:(double)yValue
 564 {
 565     @synchronized (self) {
 566         if (_voutDisplay) {
 567             vout_display_SendMouseMovedDisplayCoordinates (_voutDisplay,
 568                                                            ORIENT_NORMAL,
 569                                                            xValue,
 570                                                            yValue,
 571                                                            &_voutDisplay->sys->place);
 572         }
 573     }
 574 }
 575
 576 @end