macosx.m 16 KB
Newer Older
Pierre's avatar
Pierre committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
/*****************************************************************************
 * voutgl.m: MacOS X OpenGL provider
 *****************************************************************************
 * Copyright (C) 2001-2009 the VideoLAN team
 * $Id$
 *
 * Authors: Colin Delacroix <colin@zoy.org>
 *          Florian G. Pflug <fgp@phlo.org>
 *          Jon Lech Johansen <jon-vl@nanocrew.net>
 *          Derk-Jan Hartman <hartman at videolan dot org>
 *          Eric Petit <titer@m0k.org>
 *          Benjamin Pracht <bigben at videolan dot org>
 *          Damien Fouilleul <damienf at videolan dot org>
 *          Pierre d'Herbemont <pdherbemont at videolan dot org>
 *
 * This program 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.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
 *****************************************************************************/

/*****************************************************************************
 * Preamble
 *****************************************************************************/

#import <Cocoa/Cocoa.h>
#import <OpenGL/OpenGL.h>

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include <vlc_common.h>
#include <vlc_plugin.h>
#include <vlc_vout_display.h>
45
#include <vlc_opengl.h>
Pierre's avatar
Pierre committed
46 47 48 49 50 51 52 53 54
#include "opengl.h"

/**
 * Forward declarations
 */
static int Open(vlc_object_t *);
static void Close(vlc_object_t *);

static picture_pool_t *Pool(vout_display_t *vd, unsigned requested_count);
55 56
static void PictureRender(vout_display_t *vd, picture_t *pic, subpicture_t *subpicture);
static void PictureDisplay(vout_display_t *vd, picture_t *pic, subpicture_t *subpicture);
Pierre's avatar
Pierre committed
57 58
static int Control (vout_display_t *vd, int query, va_list ap);

59 60 61
static int OpenglLock(vlc_gl_t *gl);
static void OpenglUnlock(vlc_gl_t *gl);
static void OpenglSwap(vlc_gl_t *gl);
Pierre's avatar
Pierre committed
62 63 64 65 66 67 68 69 70 71 72 73 74

/**
 * Module declaration
 */
vlc_module_begin ()
    /* Will be loaded even without interface module. see voutgl.m */
    set_shortname("Mac OS X")
    set_description( N_("Mac OS X OpenGL video output (requires drawable-nsobject)"))
    set_category(CAT_VIDEO)
    set_subcategory(SUBCAT_VIDEO_VOUT )
    set_capability("vout display", 300)
    set_callbacks(Open, Close)

75
    add_shortcut("macosx", "vout_macosx")
Pierre's avatar
Pierre committed
76 77 78 79 80 81 82 83 84 85 86 87 88
vlc_module_end ()

/**
 * Obj-C protocol declaration that drawable-nsobject should follow
 */
@protocol VLCOpenGLVideoViewEmbedding <NSObject>
- (void)addVoutSubview:(NSView *)view;
- (void)removeVoutSubview:(NSView *)view;
@end

@interface VLCOpenGLVideoView : NSOpenGLView
{
    vout_display_t *vd;
89
    BOOL _hasPendingReshape;
Pierre's avatar
Pierre committed
90 91
}
- (void)setVoutDisplay:(vout_display_t *)vd;
92
- (void)setVoutFlushing:(BOOL)flushing;
Pierre's avatar
Pierre committed
93
@end
Pierre's avatar
Pierre committed
94

Pierre's avatar
Pierre committed
95 96 97 98 99 100

struct vout_display_sys_t
{
    VLCOpenGLVideoView *glView;
    id<VLCOpenGLVideoViewEmbedding> container;

101
    vout_window_t *embed;
102
    vlc_gl_t gl;
103
    vout_display_opengl_t *vgl;
Pierre's avatar
Pierre committed
104

Pierre's avatar
Pierre committed
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121
    picture_pool_t *pool;
    picture_t *current;
    bool has_first_frame;
};

static int Open(vlc_object_t *this)
{
    vout_display_t *vd = (vout_display_t *)this;
    vout_display_sys_t *sys = calloc(1, sizeof(*sys));
    NSAutoreleasePool *nsPool = nil;

    if (!sys)
        return VLC_ENOMEM;

    vd->sys = sys;
    sys->pool = NULL;
    sys->gl.sys = NULL;
122
    sys->embed = NULL;
Pierre's avatar
Pierre committed
123

Pierre's avatar
Pierre committed
124 125
    /* Get the drawable object */
    id container = var_CreateGetAddress(vd, "drawable-nsobject");
126
    if (container)
Pierre's avatar
Pierre committed
127
    {
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
        vout_display_DeleteWindow(vd, NULL);
    }
    else
    {
        vout_window_cfg_t wnd_cfg;

        memset (&wnd_cfg, 0, sizeof (wnd_cfg));
        wnd_cfg.type = VOUT_WINDOW_TYPE_NSOBJECT;
        wnd_cfg.x = var_InheritInteger (vd, "video-x");
        wnd_cfg.y = var_InheritInteger (vd, "video-y");
        wnd_cfg.width  = vd->cfg->display.width;
        wnd_cfg.height = vd->cfg->display.height;

        sys->embed = vout_display_NewWindow (vd, &wnd_cfg);
        if (sys->embed)
            container = sys->embed->handle.nsobject;

        if (!container)
        {
            msg_Dbg(vd, "No drawable-nsobject nor vout_window_t found, passing over.");
            goto error;
        }
Pierre's avatar
Pierre committed
150 151 152 153 154 155 156 157
    }

    /* This will be released in Close(), on
     * main thread, after we are done using it. */
    sys->container = [container retain];

    /* Get our main view*/
    nsPool = [[NSAutoreleasePool alloc] init];
Pierre's avatar
Pierre committed
158

159
    [VLCOpenGLVideoView performSelectorOnMainThread:@selector(getNewView:) withObject:[NSValue valueWithPointer:&sys->glView] waitUntilDone:YES];
Pierre's avatar
Pierre committed
160 161 162 163 164 165 166 167
    if (!sys->glView)
        goto error;

    [sys->glView setVoutDisplay:vd];

    /* We don't wait, that means that we'll have to be careful about releasing
     * container.
     * That's why we'll release on main thread in Close(). */
168 169 170 171 172 173
    if ([(id)container respondsToSelector:@selector(addVoutSubview:)])
        [(id)container performSelectorOnMainThread:@selector(addVoutSubview:) withObject:sys->glView waitUntilDone:NO];
    else if ([container isKindOfClass:[NSView class]])
    {
        NSView *parentView = container;
        [parentView performSelectorOnMainThread:@selector(addSubview:) withObject:sys->glView waitUntilDone:NO];
174
        [sys->glView performSelectorOnMainThread:@selector(setFrameWithValue:) withObject:[NSValue valueWithRect:[parentView bounds]] waitUntilDone:NO];
175 176 177 178 179 180 181 182
    }
    else
    {
        msg_Err(vd, "Invalid drawable-nsobject object. drawable-nsobject must either be an NSView or comply to the @protocol VLCOpenGLVideoViewEmbedding.");
        goto error;
    }


Pierre's avatar
Pierre committed
183 184 185 186 187 188 189
    [nsPool release];
    nsPool = nil;

    /* Initialize common OpenGL video display */
    sys->gl.lock = OpenglLock;
    sys->gl.unlock = OpenglUnlock;
    sys->gl.swap = OpenglSwap;
190
    sys->gl.getProcAddress = NULL;
Pierre's avatar
Pierre committed
191
    sys->gl.sys = sys;
Pierre's avatar
Pierre committed
192

193
	sys->vgl = vout_display_opengl_New(&vd->fmt, NULL, &sys->gl);
194
	if (!sys->vgl)
Pierre's avatar
Pierre committed
195 196 197 198 199 200 201 202
    {
        sys->gl.sys = NULL;
        goto error;
    }

    /* */
    vout_display_info_t info = vd->info;
    info.has_pictures_invalid = false;
Pierre's avatar
Pierre committed
203

Pierre's avatar
Pierre committed
204 205
    /* Setup vout_display_t once everything is fine */
    vd->info = info;
Pierre's avatar
Pierre committed
206

Pierre's avatar
Pierre committed
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
    vd->pool = Pool;
    vd->prepare = PictureRender;
    vd->display = PictureDisplay;
    vd->control = Control;

    /* */
    vout_display_SendEventFullscreen (vd, false);
    vout_display_SendEventDisplaySize (vd, vd->source.i_visible_width, vd->source.i_visible_height, false);

    return VLC_SUCCESS;

error:
    [nsPool release];
    Close(this);
    return VLC_EGENERIC;
}

void Close(vlc_object_t *this)
{
    vout_display_t *vd = (vout_display_t *)this;
    vout_display_sys_t *sys = vd->sys;

    [sys->glView setVoutDisplay:nil];

    var_Destroy(vd, "drawable-nsobject");
232 233 234 235 236
    if ([(id)sys->container respondsToSelector:@selector(removeVoutSubview:)])
    {
        /* This will retain sys->glView */
        [(id)sys->container performSelectorOnMainThread:@selector(removeVoutSubview:) withObject:sys->glView waitUntilDone:NO];
    }
Pierre's avatar
Pierre committed
237 238 239
    /* release on main thread as explained in Open() */
    [(id)sys->container performSelectorOnMainThread:@selector(release) withObject:nil waitUntilDone:NO];
    [sys->glView performSelectorOnMainThread:@selector(removeFromSuperview) withObject:nil waitUntilDone:NO];
Pierre's avatar
Pierre committed
240

Pierre's avatar
Pierre committed
241 242 243
    [sys->glView release];

    if (sys->gl.sys != NULL)
244
        vout_display_opengl_Delete(sys->vgl);
Pierre's avatar
Pierre committed
245

246 247
    if (sys->embed)
        vout_display_DeleteWindow(vd, sys->embed);
Pierre's avatar
Pierre committed
248 249 250 251 252 253 254 255 256 257 258 259
    free (sys);
}

/*****************************************************************************
 * vout display callbacks
 *****************************************************************************/

static picture_pool_t *Pool(vout_display_t *vd, unsigned requested_count)
{
    vout_display_sys_t *sys = vd->sys;

    if (!sys->pool)
260
        sys->pool = vout_display_opengl_GetPool (sys->vgl, requested_count);
Pierre's avatar
Pierre committed
261 262 263 264
    assert(sys->pool);
    return sys->pool;
}

265
static void PictureRender(vout_display_t *vd, picture_t *pic, subpicture_t *subpicture)
Pierre's avatar
Pierre committed
266 267 268
{

    vout_display_sys_t *sys = vd->sys;
Pierre's avatar
Pierre committed
269

270
    vout_display_opengl_Prepare( sys->vgl, pic, subpicture );
Pierre's avatar
Pierre committed
271 272
}

273
static void PictureDisplay(vout_display_t *vd, picture_t *pic, subpicture_t *subpicture)
Pierre's avatar
Pierre committed
274 275
{
    vout_display_sys_t *sys = vd->sys;
276
    [sys->glView setVoutFlushing:YES];
277
    vout_display_opengl_Display(sys->vgl, &vd->fmt );
278
    [sys->glView setVoutFlushing:NO];
Pierre's avatar
Pierre committed
279 280
    picture_Release (pic);
    sys->has_first_frame = true;
281
	(void)subpicture;
Pierre's avatar
Pierre committed
282 283 284 285 286
}

static int Control (vout_display_t *vd, int query, va_list ap)
{
    vout_display_sys_t *sys = vd->sys;
Pierre's avatar
Pierre committed
287

Pierre's avatar
Pierre committed
288 289
    switch (query)
    {
Pierre's avatar
Pierre committed
290
        case VOUT_DISPLAY_CHANGE_FULLSCREEN:
291
        case VOUT_DISPLAY_CHANGE_WINDOW_STATE:
Pierre's avatar
Pierre committed
292 293 294 295 296 297 298 299 300 301 302
        case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
        case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
        case VOUT_DISPLAY_CHANGE_ZOOM:
        case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT:
        case VOUT_DISPLAY_CHANGE_SOURCE_CROP:
        {
            /* todo */
            return VLC_EGENERIC;
        }
        case VOUT_DISPLAY_HIDE_MOUSE:
            return VLC_SUCCESS;
Pierre's avatar
Pierre committed
303

Pierre's avatar
Pierre committed
304 305
        case VOUT_DISPLAY_GET_OPENGL:
        {
306
            vlc_gl_t **gl = va_arg (ap, vlc_gl_t **);
Pierre's avatar
Pierre committed
307 308 309
            *gl = &sys->gl;
            return VLC_SUCCESS;
        }
Pierre's avatar
Pierre committed
310

Pierre's avatar
Pierre committed
311 312 313 314 315 316 317 318 319 320 321
        case VOUT_DISPLAY_RESET_PICTURES:
            assert (0);
        default:
            msg_Err (vd, "Unknown request in Mac OS X vout display");
            return VLC_EGENERIC;
    }
}

/*****************************************************************************
 * vout opengl callbacks
 *****************************************************************************/
322
static int OpenglLock(vlc_gl_t *gl)
Pierre's avatar
Pierre committed
323 324 325 326 327 328 329 330 331
{
    vout_display_sys_t *sys = (vout_display_sys_t *)gl->sys;
    NSOpenGLContext *context = [sys->glView openGLContext];
    CGLError err = CGLLockContext([context CGLContextObj]);
    if (kCGLNoError == err)
    {
        [context makeCurrentContext];
        return 0;
    }
Pierre's avatar
Pierre committed
332
    return 1;
Pierre's avatar
Pierre committed
333 334
}

335
static void OpenglUnlock(vlc_gl_t *gl)
Pierre's avatar
Pierre committed
336 337 338 339 340
{
    vout_display_sys_t *sys = (vout_display_sys_t *)gl->sys;
    CGLUnlockContext([[sys->glView openGLContext] CGLContextObj]);
}

341
static void OpenglSwap(vlc_gl_t *gl)
Pierre's avatar
Pierre committed
342 343 344 345 346 347 348 349 350 351 352 353
{
    vout_display_sys_t *sys = (vout_display_sys_t *)gl->sys;
    [[sys->glView openGLContext] flushBuffer];
}

/*****************************************************************************
 * Our NSView object
 *****************************************************************************/
@implementation VLCOpenGLVideoView

#define VLCAssertMainThread() assert([[NSThread currentThread] isMainThread])

354 355 356 357 358 359
+ (void)getNewView:(NSValue *)value
{
    id *ret = [value pointerValue];
    *ret = [[self alloc] init];
}

Pierre's avatar
Pierre committed
360 361 362 363 364
/**
 * Gets called by the Open() method.
 */
- (id)init
{
365 366
    VLCAssertMainThread();

Pierre's avatar
Pierre committed
367 368 369 370 371 372 373 374 375 376 377 378 379
    /* Warning - this may be called on non main thread */

    NSOpenGLPixelFormatAttribute attribs[] =
    {
        NSOpenGLPFADoubleBuffer,
        NSOpenGLPFAAccelerated,
        NSOpenGLPFANoRecovery,
        NSOpenGLPFAColorSize, 24,
        NSOpenGLPFAAlphaSize, 8,
        NSOpenGLPFADepthSize, 24,
        NSOpenGLPFAWindow,
        0
    };
Pierre's avatar
Pierre committed
380

381
    NSOpenGLPixelFormat *fmt = [[NSOpenGLPixelFormat alloc] initWithAttributes:attribs];
Pierre's avatar
Pierre committed
382

Pierre's avatar
Pierre committed
383 384 385 386
    if (!fmt)
        return nil;

    self = [super initWithFrame:NSMakeRect(0,0,10,10) pixelFormat:fmt];
Pierre's avatar
Pierre committed
387 388
    [fmt release];

Pierre's avatar
Pierre committed
389 390 391 392 393 394 395 396
    if (!self)
        return nil;

    /* Swap buffers only during the vertical retrace of the monitor.
     http://developer.apple.com/documentation/GraphicsImaging/
     Conceptual/OpenGL/chap5/chapter_5_section_44.html */
    GLint params[] = { 1 };
    CGLSetParameter([[self openGLContext] CGLContextObj], kCGLCPSwapInterval, params);
Pierre's avatar
Pierre committed
397

398
    [self setAutoresizingMask:NSViewWidthSizable | NSViewHeightSizable];
Pierre's avatar
Pierre committed
399
    return self;
Pierre's avatar
Pierre committed
400 401
}

402 403 404
/**
 * Gets called by the Open() method.
 */
405
- (void)setFrameWithValue:(NSValue *)value
406 407 408 409
{
    [self setFrame:[value rectValue]];
}

Pierre's avatar
Pierre committed
410 411 412 413 414 415 416 417 418 419 420
/**
 * Gets called by the Close and Open methods.
 * (Non main thread).
 */
- (void)setVoutDisplay:(vout_display_t *)aVd
{
    @synchronized(self) {
        vd = aVd;
    }
}

421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448

/**
 * Gets called when the vout will aquire the lock and flush.
 * (Non main thread).
 */
- (void)setVoutFlushing:(BOOL)flushing
{
    if (!flushing)
        return;
    @synchronized(self) {
        _hasPendingReshape = NO;
    }
}

/**
 * Can -drawRect skip rendering?.
 */
- (BOOL)canSkipRendering
{
    VLCAssertMainThread();

    @synchronized(self) {
        BOOL hasFirstFrame = vd && vd->sys->has_first_frame;
        return !_hasPendingReshape && hasFirstFrame;
    }
}


Pierre's avatar
Pierre committed
449 450 451 452 453 454
/**
 * Local method that locks the gl context.
 */
- (BOOL)lockgl
{
    VLCAssertMainThread();
455 456 457 458
    NSOpenGLContext *context = [self openGLContext];
    CGLError err = CGLLockContext([context CGLContextObj]);
    if (err == kCGLNoError)
        [context makeCurrentContext];
Pierre's avatar
Pierre committed
459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478
    return err == kCGLNoError;
}

/**
 * Local method that unlocks the gl context.
 */
- (void)unlockgl
{
    VLCAssertMainThread();
    CGLUnlockContext([[self openGLContext] CGLContextObj]);
}

/**
 * Local method that force a rendering of a frame.
 * This will get called if Cocoa forces us to redraw (via -drawRect).
 */
- (void)render
{
    VLCAssertMainThread();

479 480 481 482 483 484
    // We may have taken some times to take the opengl Lock.
    // Check here to see if we can just skip the frame as well.
    if ([self canSkipRendering])
        return;

    BOOL hasFirstFrame;
Pierre's avatar
Pierre committed
485
    @synchronized(self) { // vd can be accessed from multiple threads
486 487
        hasFirstFrame = vd && vd->sys->has_first_frame;
    }
Pierre's avatar
Pierre committed
488

489 490
    if (hasFirstFrame) {
        // This will lock gl.
491
        vout_display_opengl_Display( vd->sys->vgl, &vd->source );
Pierre's avatar
Pierre committed
492
    }
493 494
    else
        glClear(GL_COLOR_BUFFER_BIT);
Pierre's avatar
Pierre committed
495 496 497 498 499 500 501 502
}

/**
 * Method called by Cocoa when the view is resized.
 */
- (void)reshape
{
    VLCAssertMainThread();
Pierre's avatar
Pierre committed
503

Pierre's avatar
Pierre committed
504 505 506 507 508 509 510 511 512 513 514
    NSRect bounds = [self bounds];

    CGFloat height = bounds.size.height;
    CGFloat width = bounds.size.width;

    GLint x = width, y = height;

    @synchronized(self) {
        if (vd) {
            CGFloat videoHeight = vd->source.i_visible_height;
            CGFloat videoWidth = vd->source.i_visible_width;
Pierre's avatar
Pierre committed
515

Pierre's avatar
Pierre committed
516 517
            GLint sarNum = vd->source.i_sar_num;
            GLint sarDen = vd->source.i_sar_den;
Pierre's avatar
Pierre committed
518

Pierre's avatar
Pierre committed
519 520 521 522 523 524 525 526 527
            if (height * videoWidth * sarNum < width * videoHeight * sarDen)
            {
                x = (height * videoWidth * sarNum) / (videoHeight * sarDen);
                y = height;
            }
            else
            {
                x = width;
                y = (width * videoHeight * sarDen) / (videoWidth * sarNum);
Pierre's avatar
Pierre committed
528
            }
Pierre's avatar
Pierre committed
529 530
        }
    }
Pierre's avatar
Pierre committed
531

532 533
    if ([self lockgl]) {
        glViewport((width - x) / 2, (height - y) / 2, x, y);
534

535 536 537 538 539 540 541
        @synchronized(self) {
            // This may be cleared before -drawRect is being called,
            // in this case we'll skip the rendering.
            // This will save us for rendering two frames (or more) for nothing
            // (one by the vout, one (or more) by drawRect)
            _hasPendingReshape = YES;
        }
542

543
        [self unlockgl];
Pierre's avatar
Pierre committed
544

545 546
        [super reshape];
    }
Pierre's avatar
Pierre committed
547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570
}

/**
 * Method called by Cocoa when the view is resized or the location has changed.
 * We just need to make sure we are locking here.
 */
- (void)update
{
    VLCAssertMainThread();
    BOOL success = [self lockgl];
    if (!success)
        return;

    [super update];

    [self unlockgl];
}

/**
 * Method called by Cocoa to force redraw.
 */
- (void)drawRect:(NSRect) rect
{
    VLCAssertMainThread();
571 572 573 574

    if ([self canSkipRendering])
        return;

Pierre's avatar
Pierre committed
575 576 577 578 579 580 581 582 583
    BOOL success = [self lockgl];
    if (!success)
        return;

    [self render];

    [self unlockgl];
}

584 585 586 587 588 589 590 591 592 593 594
- (void)renewGState
{
    NSWindow *window = [self window];

    // Remove flashes with splitter view.
	if ([window respondsToSelector:@selector(disableScreenUpdatesUntilFlush)])
		[window disableScreenUpdatesUntilFlush];

    [super renewGState];
}

Pierre's avatar
Pierre committed
595 596 597 598
- (BOOL)mouseDownCanMoveWindow
{
    return YES;
}
Pierre's avatar
Pierre committed
599 600 601 602 603

- (BOOL)isOpaque
{
    return YES;
}
Pierre's avatar
Pierre committed
604
@end