开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
voutgl.m
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：36k
源码类别：

midi

开发平台：

Unix_Linux

voutgl.m：源码内容
  1. /*****************************************************************************
  2.  * voutgl.m: MacOS X OpenGL provider
  3.  *****************************************************************************
  4.  * Copyright (C) 2001-2004, 2007-2009 the VideoLAN team
  5.  * $Id: a6e751d8bd07c838a11aaeab5f3c294951657261 $
  6.  *
  7.  * Authors: Colin Delacroix <colin@zoy.org>
  8.  *          Florian G. Pflug <fgp@phlo.org>
  9.  *          Jon Lech Johansen <jon-vl@nanocrew.net>
  10.  *          Derk-Jan Hartman <hartman at videolan dot org>
  11.  *          Eric Petit <titer@m0k.org>
  12.  *          Benjamin Pracht <bigben at videolan dot org>
  13.  *          Damien Fouilleul <damienf at videolan dot org>
  14.  *
  15.  * This program is free software; you can redistribute it and/or modify
  16.  * it under the terms of the GNU General Public License as published by
  17.  * the Free Software Foundation; either version 2 of the License, or
  18.  * (at your option) any later version.
  19.  *
  20.  * This program is distributed in the hope that it will be useful,
  21.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23.  * GNU General Public License for more details.
  24.  *
  25.  * You should have received a copy of the GNU General Public License
  26.  * along with this program; if not, write to the Free Software
  27.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  28.  *****************************************************************************/
  30. /*****************************************************************************
  31.  * Preamble
  32.  *****************************************************************************/
  33. #include <errno.h>                                                 /* ENOMEM */
  34. #include <stdlib.h>                                                /* free() */
  35. #include <string.h>
  37. #include <vlc_keys.h>
  39. #include "intf.h"
  40. #include "vout.h"
  42. #include <OpenGL/OpenGL.h>
  43. #include <OpenGL/gl.h>
  45. #include <AGL/agl.h>
  47. /*****************************************************************************
  48.  * VLCGLView interface
  49.  *****************************************************************************/
  50. @interface VLCGLView : NSOpenGLView <VLCVoutViewResetting>
  51. {
  52.     vout_thread_t * p_vout;
  53. }
  55. + (void)resetVout: (NSValue *) voutValue;
  56. - (id) initWithVout: (vout_thread_t *) p_vout;
  57. @end
  59. struct vout_sys_t
  60. {
  61.     VLCGLView         * o_glview;
  62.     VLCVoutView       * o_vout_view;
  63.     bool                b_saved_frame;
  64.     NSRect              s_frame;
  65.     bool                b_got_frame;
  67.     /* Mozilla plugin-related variables (not 64bit compatible) */
  68.     bool                b_embedded;
  69. #ifndef __x86_64__
  70.     AGLContext          agl_ctx;
  71.     AGLDrawable         agl_drawable;
  72.     int                 i_offx, i_offy;
  73.     int                 i_width, i_height;
  74.     WindowRef           theWindow;
  75.     WindowGroupRef      winGroup;
  76.     bool                b_clipped_out;
  77.     Rect                clipBounds, viewBounds;
  78. #endif
  79. };
  81. /*****************************************************************************
  82.  * Local prototypes
  83.  *****************************************************************************/
  85. static int  Init   ( vout_thread_t * p_vout );
  86. static void End    ( vout_thread_t * p_vout );
  87. static int  Manage ( vout_thread_t * p_vout );
  88. static int  Control( vout_thread_t *, int, va_list );
  89. static void Swap   ( vout_thread_t * p_vout );
  90. static int  Lock   ( vout_thread_t * p_vout );
  91. static void Unlock ( vout_thread_t * p_vout );
  93. #ifndef __x86_64__
  94. static int  aglInit   ( vout_thread_t * p_vout );
  95. static void aglEnd    ( vout_thread_t * p_vout );
  96. static int  aglManage ( vout_thread_t * p_vout );
  97. static int  aglControl( vout_thread_t *, int, va_list );
  98. static void aglSwap   ( vout_thread_t * p_vout );
  99. static int  aglLock   ( vout_thread_t * p_vout );
  100. static void aglUnlock ( vout_thread_t * p_vout );
  101. #endif
  103. int OpenVideoGL  ( vlc_object_t * p_this )
  104. {
  105.     vout_thread_t * p_vout = (vout_thread_t *) p_this;
  106.     vlc_value_t value_drawable;
  108.     if( !CGDisplayUsesOpenGLAcceleration( kCGDirectMainDisplay ) )
  109.     {
  110.         msg_Warn( p_vout, "no OpenGL hardware acceleration found. "
  111.                           "Video display might be slow" );
  112.     }
  113.     msg_Dbg( p_vout, "display is Quartz Extreme accelerated" );
  115.     p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
  116.     if( p_vout->p_sys == NULL )
  117.         return VLC_ENOMEM;
  119.     memset( p_vout->p_sys, 0, sizeof( vout_sys_t ) );
  121. #ifndef __x86_64__
  122.     var_Get( p_vout->p_libvlc, "drawable-agl", &value_drawable );
  123.     if( value_drawable.i_int != 0 )
  124.     {
  125.         static const GLint ATTRIBUTES[] = {
  126.             AGL_WINDOW,
  127.             AGL_RGBA,
  128.             AGL_NO_RECOVERY,
  129.             AGL_ACCELERATED,
  130.             AGL_DOUBLEBUFFER,
  131.             AGL_RED_SIZE,   8,
  132.             AGL_GREEN_SIZE, 8,
  133.             AGL_BLUE_SIZE,  8,
  134.             AGL_ALPHA_SIZE, 8,
  135.             AGL_DEPTH_SIZE, 24,
  136.             AGL_NONE };
  138.         AGLPixelFormat pixFormat;
  140.         p_vout->p_sys->b_embedded = true;
  142.         pixFormat = aglChoosePixelFormat(NULL, 0, ATTRIBUTES);
  143.         if( NULL == pixFormat )
  144.         {
  145.             msg_Err( p_vout, "no screen renderer available for required attributes." );
  146.             free( p_vout->p_sys );
  147.             return VLC_EGENERIC;
  148.         }
  149.  
  150.         p_vout->p_sys->agl_ctx = aglCreateContext(pixFormat, NULL);
  151.         aglDestroyPixelFormat(pixFormat);
  152.         if( NULL == p_vout->p_sys->agl_ctx )
  153.         {
  154.             msg_Err( p_vout, "cannot create AGL context." );
  155.             free( p_vout->p_sys );
  156.             return VLC_EGENERIC;
  157.         }
  158.         else
  159.         {
  160.             // tell opengl not to sync buffer swap with vertical retrace (too inefficient)
  161.             GLint param = 0;
  162.             aglSetInteger(p_vout->p_sys->agl_ctx, AGL_SWAP_INTERVAL, &param);
  163.             aglEnable(p_vout->p_sys->agl_ctx, AGL_SWAP_INTERVAL);
  164.         }
  166.         p_vout->pf_init             = aglInit;
  167.         p_vout->pf_end              = aglEnd;
  168.         p_vout->pf_manage           = aglManage;
  169.         p_vout->pf_control          = aglControl;
  170.         p_vout->pf_swap             = aglSwap;
  171.         p_vout->pf_lock             = aglLock;
  172.         p_vout->pf_unlock           = aglUnlock;
  173.     }
  174.     else
  175.     {
  176. #endif
  177.         NSAutoreleasePool *o_pool = [[NSAutoreleasePool alloc] init];
  179.         p_vout->p_sys->b_embedded = false;
  181.         [VLCGLView performSelectorOnMainThread:@selector(initVout:) withObject:[NSValue valueWithPointer:p_vout] waitUntilDone:YES];
  183.         [o_pool release];
  185.         /* Check to see if initVout: was successfull */
  186.         if( !p_vout->p_sys->o_vout_view )
  187.         {
  188.             free( p_vout->p_sys );
  189.             return VLC_EGENERIC;
  190.         }
  192.         p_vout->pf_init   = Init;
  193.         p_vout->pf_end    = End;
  194.         p_vout->pf_manage = Manage;
  195.         p_vout->pf_control= Control;
  196.         p_vout->pf_swap   = Swap;
  197.         p_vout->pf_lock   = Lock;
  198.         p_vout->pf_unlock = Unlock;
  199. #ifndef __x86_64__
  200.     }
  201. #endif
  202.     p_vout->p_sys->b_got_frame = false;
  204.     return VLC_SUCCESS;
  205. }
  207. void CloseVideoGL ( vlc_object_t * p_this )
  208. {
  209.     vout_thread_t * p_vout = (vout_thread_t *) p_this;
  211.     msg_Dbg( p_this, "Closing" );
  213. #ifndef __x86_64__
  214.     if( p_vout->p_sys->b_embedded )
  215.     {
  216.         /* If the fullscreen window is still open, close it */
  217.         if( p_vout->b_fullscreen )
  218.         {
  219.             p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
  220.             aglManage( p_vout );
  221.             var_SetBool( p_vout->p_parent, "fullscreen", false );
  222.         }
  223.         if( p_vout->p_sys->agl_ctx )
  224.         {
  225.             aglEnd( p_vout );
  226.             aglDestroyContext(p_vout->p_sys->agl_ctx);
  227.         }
  228.     }
  229.     else
  230. #endif
  231.     if(VLCIntf && vlc_object_alive (VLCIntf))
  232.     {
  233.         NSAutoreleasePool *o_pool = [[NSAutoreleasePool alloc] init];
  235.         /* Close the window */
  236.         [p_vout->p_sys->o_vout_view performSelectorOnMainThread:@selector(closeVout) withObject:NULL waitUntilDone:YES];
  238.         [o_pool release];
  239.     }
  240.     /* Clean up */
  241.     free( p_vout->p_sys );
  242. }
  244. static int Init( vout_thread_t * p_vout )
  245. {
  246.     [[p_vout->p_sys->o_glview openGLContext] makeCurrentContext];
  247.     return VLC_SUCCESS;
  248. }
  250. static void End( vout_thread_t * p_vout )
  251. {
  252.     [[p_vout->p_sys->o_glview openGLContext] makeCurrentContext];
  253. }
  255. static int Manage( vout_thread_t * p_vout )
  256. {
  257.     if( p_vout->i_changes & VOUT_ASPECT_CHANGE )
  258.     {
  259.         [p_vout->p_sys->o_glview reshape];
  260.         p_vout->i_changes &= ~VOUT_ASPECT_CHANGE;
  261.     }
  262.     if( p_vout->i_changes & VOUT_CROP_CHANGE )
  263.     {
  264.         [p_vout->p_sys->o_glview reshape];
  265.         p_vout->i_changes &= ~VOUT_CROP_CHANGE;
  266.     }
  268.     if( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE )
  269.     {
  270.         NSAutoreleasePool *o_pool = [[NSAutoreleasePool alloc] init];
  272.         p_vout->b_fullscreen = !p_vout->b_fullscreen;
  274.         if( p_vout->b_fullscreen )
  275.             [p_vout->p_sys->o_vout_view enterFullscreen];
  276.         else
  277.             [p_vout->p_sys->o_vout_view leaveFullscreen];
  279.         [o_pool release];
  281.         p_vout->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
  282.     }
  284.     if( p_vout->p_sys->o_vout_view )
  285.         [p_vout->p_sys->o_vout_view manage];
  286.     return VLC_SUCCESS;
  287. }
  289. /*****************************************************************************
  290.  * Control: control facility for the vout
  291.  *****************************************************************************/
  292. static int Control( vout_thread_t *p_vout, int i_query, va_list args )
  293. {
  294.     bool b_arg;
  296.     switch( i_query )
  297.     {
  298.         case VOUT_SET_STAY_ON_TOP:
  299.             b_arg = (bool) va_arg( args, int );
  300.             [p_vout->p_sys->o_vout_view setOnTop: b_arg];
  301.             return VLC_SUCCESS;
  303.         default:
  304.             return VLC_EGENERIC;
  305.     }
  306. }
  308. static void Swap( vout_thread_t * p_vout )
  309. {
  310.     p_vout->p_sys->b_got_frame = true;
  311.     [[p_vout->p_sys->o_glview openGLContext] flushBuffer];
  312. }
  314. static int Lock( vout_thread_t * p_vout )
  315. {
  316.     if( kCGLNoError == CGLLockContext([[p_vout->p_sys->o_glview openGLContext] CGLContextObj]) )
  317.     {
  318.         [[p_vout->p_sys->o_glview openGLContext] makeCurrentContext];
  319.         return 0;
  320.     }
  321.     return 1;
  322. }
  324. static void Unlock( vout_thread_t * p_vout )
  325. {
  326.     CGLUnlockContext([[p_vout->p_sys->o_glview openGLContext] CGLContextObj]);
  327. }
  329. /*****************************************************************************
  330.  * VLCGLView implementation
  331.  *****************************************************************************/
  332. @implementation VLCGLView
  333. + (void)initVout:(NSValue *)arg
  334. {
  335.     vout_thread_t * p_vout = [arg pointerValue];
  337.     /* Create the GL view */
  338.     p_vout->p_sys->o_glview = [[VLCGLView alloc] initWithVout: p_vout];
  339.     [p_vout->p_sys->o_glview autorelease];
  341.     /* Spawn the window */
  342.     id old_vout = p_vout->p_sys->o_vout_view;
  343.     p_vout->p_sys->o_vout_view = [[VLCVoutView voutView: p_vout
  344.                                                 subView: p_vout->p_sys->o_glview frame: nil] retain];
  345.     [old_vout release];
  346. }
  348. /* This function will reset the o_vout_view. It's useful to go fullscreen. */
  349. + (void)resetVout:(NSValue *) voutValue
  350. {
  351.     vout_thread_t * p_vout = [voutValue pointerValue];
  352.     if( p_vout->b_fullscreen )
  353.     {
  354.         /* Save window size and position */
  355.         p_vout->p_sys->s_frame.size =
  356.             [p_vout->p_sys->o_vout_view frame].size;
  357.         p_vout->p_sys->s_frame.origin =
  358.             [[p_vout->p_sys->o_vout_view voutWindow]frame].origin;
  359.         p_vout->p_sys->b_saved_frame = true;
  360.     }
  362.     [p_vout->p_sys->o_vout_view closeVout];
  364. #define o_glview p_vout->p_sys->o_glview
  365.     o_glview = [[VLCGLView alloc] initWithVout: p_vout];
  366.     [o_glview autorelease];
  367.  
  368.     if( p_vout->p_sys->b_saved_frame )
  369.     {
  370.         id old_vout = p_vout->p_sys->o_vout_view;
  371.         p_vout->p_sys->o_vout_view = [[VLCVoutView voutView: p_vout
  372.                                                     subView: o_glview
  373.                                                       frame: &p_vout->p_sys->s_frame] retain];
  374.         [old_vout release];
  375.     }
  376.     else
  377.     {
  378.         id old_vout = p_vout->p_sys->o_vout_view;
  379.         p_vout->p_sys->o_vout_view = [[VLCVoutView voutView: p_vout
  380.                                                     subView: o_glview frame: nil] retain];
  381.         [old_vout release];
  382.     }
  383. #undef o_glview
  384. }
  386. - (id) initWithVout: (vout_thread_t *) vout
  387. {
  388.     /* Must be called from main thread:
  389.      * "The NSView class is generally thread-safe, with a few exceptions. You
  390.      * should create, destroy, resize, move, and perform other operations on NSView
  391.      * objects only from the main thread of an application. Drawing from secondary
  392.      * threads is thread-safe as long as you bracket drawing calls with calls to
  393.      * lockFocusIfCanDraw and unlockFocus." Cocoa Thread Safety */
  395.     p_vout = vout;
  397.     NSOpenGLPixelFormatAttribute attribs[] =
  398.     {
  399.         NSOpenGLPFADoubleBuffer,
  400.         NSOpenGLPFAAccelerated,
  401.         NSOpenGLPFANoRecovery,
  402.         NSOpenGLPFAColorSize, 24,
  403.         NSOpenGLPFAAlphaSize, 8,
  404.         NSOpenGLPFADepthSize, 24,
  405.         NSOpenGLPFAWindow,
  406.         0
  407.     };
  409.     NSOpenGLPixelFormat * fmt = [[NSOpenGLPixelFormat alloc]
  410.         initWithAttributes: attribs];
  412.     if( !fmt )
  413.     {
  414.         msg_Warn( p_vout, "could not create OpenGL video output" );
  415.         return nil;
  416.     }
  418.     self = [super initWithFrame: NSMakeRect(0,0,10,10) pixelFormat: fmt];
  419.     [fmt release];
  421.     [[self openGLContext] makeCurrentContext];
  422.     [[self openGLContext] update];
  424.     /* Swap buffers only during the vertical retrace of the monitor.
  425.        http://developer.apple.com/documentation/GraphicsImaging/
  426.        Conceptual/OpenGL/chap5/chapter_5_section_44.html */
  427.     GLint params[] = { 1 };
  428.     CGLSetParameter( CGLGetCurrentContext(), kCGLCPSwapInterval, params );
  429.     return self;
  430. }
  432. - (BOOL)mouseDownCanMoveWindow
  433. {
  434.     return YES;
  435. }
  437. - (void) reshape
  438. {
  439.     int x, y;
  441.     Lock( p_vout );
  442.     NSRect bounds = [self bounds];
  444.     if( var_GetBool( p_vout, "macosx-stretch" ) )
  445.     {
  446.         x = bounds.size.width;
  447.         y = bounds.size.height;
  448.     }
  449.     else if( bounds.size.height * p_vout->fmt_in.i_visible_width *
  450.              p_vout->fmt_in.i_sar_num <
  451.              bounds.size.width * p_vout->fmt_in.i_visible_height *
  452.              p_vout->fmt_in.i_sar_den )
  453.     {
  454.         x = ( bounds.size.height * p_vout->fmt_in.i_visible_width *
  455.               p_vout->fmt_in.i_sar_num ) /
  456.             ( p_vout->fmt_in.i_visible_height * p_vout->fmt_in.i_sar_den);
  458.         y = bounds.size.height;
  459.     }
  460.     else
  461.     {
  462.         x = bounds.size.width;
  463.         y = ( bounds.size.width * p_vout->fmt_in.i_visible_height *
  464.               p_vout->fmt_in.i_sar_den) /
  465.             ( p_vout->fmt_in.i_visible_width * p_vout->fmt_in.i_sar_num  );
  466.     }
  468.     glViewport( ( bounds.size.width - x ) / 2,
  469.                 ( bounds.size.height - y ) / 2, x, y );
  471.     [super reshape];
  473.     if( p_vout->p_sys->b_got_frame )
  474.     {
  475.         /* Ask the opengl module to redraw */
  476.         vout_thread_t * p_parent;
  477.         p_parent = (vout_thread_t *) p_vout->p_parent;
  478.         Unlock( p_vout );
  479.         if( p_parent && p_parent->pf_display )
  480.         {
  481.             p_parent->pf_display( p_parent, NULL );
  482.         }
  483.     }
  484.     else
  485.     {
  486.         glClear( GL_COLOR_BUFFER_BIT );
  487.         Unlock( p_vout );
  488.     }
  489. }
  491. - (void) update
  492. {
  493.     Lock( p_vout );
  494.     [super update];
  495.     Unlock( p_vout );
  496. }
  498. - (void) drawRect: (NSRect) rect
  499. {
  500.     Lock( p_vout );
  501.     [[p_vout->p_sys->o_glview openGLContext] flushBuffer];
  502.     [super drawRect:rect];
  503.     Unlock( p_vout );
  504. }
  506. @end
  508. /*****************************************************************************
  509.  * embedded AGL context implementation
  510.  *****************************************************************************/
  512. #ifndef __x86_64__
  514. static void aglSetViewport( vout_thread_t *p_vout, Rect viewBounds, Rect clipBounds );
  515. static void aglReshape( vout_thread_t * p_vout );
  516. static OSStatus WindowEventHandler(EventHandlerCallRef nextHandler, EventRef event, void *userData);
  518. static int aglInit( vout_thread_t * p_vout )
  519. {
  520.     Rect viewBounds;
  521.     Rect clipBounds;
  522.  
  523.     p_vout->p_sys->agl_drawable = (AGLDrawable)
  524.             var_GetInteger( p_vout->p_libvlc, "drawable-agl" );
  525.     aglSetDrawable(p_vout->p_sys->agl_ctx, p_vout->p_sys->agl_drawable);
  527.     viewBounds.top = var_GetInteger( p_vout->p_libvlc, "drawable-view-top" );
  528.     viewBounds.left = var_GetInteger( p_vout->p_libvlc, "drawable-view-left" );
  529.     viewBounds.bottom = var_GetInteger( p_vout->p_libvlc, "drawable-view-bottom" );
  530.     viewBounds.right = var_GetInteger( p_vout->p_libvlc, "drawable-view-right" );
  531.     clipBounds.top = var_GetInteger( p_vout->p_libvlc, "drawable-clip-top" );
  532.     clipBounds.left = var_GetInteger( p_vout->p_libvlc, "drawable-clip-left" );
  533.     clipBounds.bottom = var_GetInteger( p_vout->p_libvlc, "drawable-clip-bottom" );
  534.     clipBounds.right = var_GetInteger( p_vout->p_libvlc, "drawable-clip-right" );
  536.     p_vout->p_sys->b_clipped_out = (clipBounds.top == clipBounds.bottom)
  537.                                  || (clipBounds.left == clipBounds.right);
  538.     if( ! p_vout->p_sys->b_clipped_out )
  539.     {
  540.         aglLock(p_vout);
  541.         aglSetViewport(p_vout, viewBounds, clipBounds);
  542.         aglReshape(p_vout);
  543.         aglUnlock(p_vout);
  544.     }
  545.     p_vout->p_sys->clipBounds = clipBounds;
  546.     p_vout->p_sys->viewBounds = viewBounds;
  548.     return VLC_SUCCESS;
  549. }
  551. static void aglEnd( vout_thread_t * p_vout )
  552. {
  553.     aglSetCurrentContext(NULL);
  554.     if( p_vout->p_sys->theWindow )
  555.     {
  556.         DisposeWindow( p_vout->p_sys->theWindow );
  557.         p_vout->p_sys->theWindow = NULL;
  558.     }
  559. }
  561. static void aglReshape( vout_thread_t * p_vout )
  562. {
  563.     unsigned int x, y;
  564.     unsigned int i_height = p_vout->p_sys->i_height;
  565.     unsigned int i_width  = p_vout->p_sys->i_width;
  567.     vout_PlacePicture(p_vout, i_width, i_height, &x, &y, &i_width, &i_height);
  569.     glViewport( p_vout->p_sys->i_offx + x, p_vout->p_sys->i_offy + y, i_width, i_height );
  571.     if( p_vout->p_sys->b_got_frame )
  572.     {
  573.         /* Ask the opengl module to redraw */
  574.         vout_thread_t * p_parent;
  575.         p_parent = (vout_thread_t *) p_vout->p_parent;
  576.         if( p_parent && p_parent->pf_display )
  577.         {
  578.             p_parent->pf_display( p_parent, NULL );
  579.         }
  580.     }
  581.     else
  582.     {
  583.         glClear( GL_COLOR_BUFFER_BIT );
  584.     }
  585. }
  587. /* private event class */
  588. enum
  589. {
  590.     kEventClassVLCPlugin = 'vlcp',
  591. };
  592. /* private event kinds */
  593. enum
  594. {
  595.     kEventVLCPluginShowFullscreen = 32768,
  596.     kEventVLCPluginHideFullscreen,
  597. };
  599. static void sendEventToMainThread(EventTargetRef target, UInt32 class, UInt32 kind)
  600. {
  601.     EventRef myEvent;
  602.     if( noErr == CreateEvent(NULL, class, kind, 0, kEventAttributeNone, &myEvent) )
  603.     {
  604.         if( noErr == SetEventParameter(myEvent, kEventParamPostTarget, typeEventTargetRef, sizeof(EventTargetRef), &target) )
  605.         {
  606.             PostEventToQueue(GetMainEventQueue(), myEvent, kEventPriorityStandard);
  607.         }
  608.         ReleaseEvent(myEvent);
  609.     }
  610. }
  612. static int aglManage( vout_thread_t * p_vout )
  613. {
  614.     if( p_vout->i_changes & VOUT_ASPECT_CHANGE )
  615.     {
  616.         aglLock( p_vout );
  617.         aglReshape(p_vout);
  618.         aglUnlock( p_vout );
  619.         p_vout->i_changes &= ~VOUT_ASPECT_CHANGE;
  620.     }
  621.     if( p_vout->i_changes & VOUT_CROP_CHANGE )
  622.     {
  623.         aglLock( p_vout );
  624.         aglReshape(p_vout);
  625.         aglUnlock( p_vout );
  626.         p_vout->i_changes &= ~VOUT_CROP_CHANGE;
  627.     }
  628.     if( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE )
  629.     {
  630.         aglSetDrawable(p_vout->p_sys->agl_ctx, NULL);
  631.         aglLock( p_vout );
  632.         if( p_vout->b_fullscreen )
  633.         {
  634.             /* Close the fullscreen window and resume normal drawing */
  635.             Rect viewBounds;
  636.             Rect clipBounds;
  638.             p_vout->p_sys->agl_drawable = (AGLDrawable)
  639.                     var_GetInteger( p_vout->p_libvlc, "drawable-agl" );
  641.             aglSetDrawable(p_vout->p_sys->agl_ctx, p_vout->p_sys->agl_drawable);
  643.             viewBounds.top = var_GetInteger( p_vout->p_libvlc, "drawable-view-top" );
  644.             viewBounds.left = var_GetInteger( p_vout->p_libvlc, "drawable-view-left" );
  645.             viewBounds.bottom = var_GetInteger( p_vout->p_libvlc, "drawable-view-bottom" );
  646.             viewBounds.right = var_GetInteger( p_vout->p_libvlc, "drawable-view-right" );
  647.             clipBounds.top = var_GetInteger( p_vout->p_libvlc, "drawable-clip-top" );
  648.             clipBounds.left = var_GetInteger( p_vout->p_libvlc, "drawable-clip-left" );
  649.             clipBounds.bottom = var_GetInteger( p_vout->p_libvlc, "drawable-clip-bottom" );
  650.             clipBounds.right = var_GetInteger( p_vout->p_libvlc, "drawable-clip-right" );
  652.             aglSetCurrentContext(p_vout->p_sys->agl_ctx);
  653.             aglSetViewport(p_vout, viewBounds, clipBounds);
  655.             if( p_vout->p_sys->theWindow )
  656.             {
  657.                 /* Most Carbon APIs are not thread-safe, therefore delagate some GUI visibilty
  658.                  * update to the main thread */
  659.                 sendEventToMainThread(GetWindowEventTarget(p_vout->p_sys->theWindow),
  660.                                       kEventClassVLCPlugin, kEventVLCPluginHideFullscreen);
  661.             }
  662.         }
  663.         else
  664.         {
  665.             /* Go into fullscreen */
  666.             Rect deviceRect;
  667.  
  668.             GDHandle deviceHdl = GetMainDevice();
  669.             deviceRect = (*deviceHdl)->gdRect;
  670.  
  671.             if( !p_vout->p_sys->theWindow )
  672.             {
  673.                 /* Create a window */
  674.                 WindowAttributes windowAttrs;
  676.                 windowAttrs = kWindowStandardDocumentAttributes
  677.                             | kWindowStandardHandlerAttribute
  678.                             | kWindowLiveResizeAttribute
  679.                             | kWindowNoShadowAttribute;
  680.  
  681.                 windowAttrs &= (~kWindowResizableAttribute);
  683.                 CreateNewWindow(kDocumentWindowClass, windowAttrs, &deviceRect, &p_vout->p_sys->theWindow);
  684.                 if( !p_vout->p_sys->winGroup )
  685.                 {
  686.                     CreateWindowGroup(0, &p_vout->p_sys->winGroup);
  687.                     SetWindowGroup(p_vout->p_sys->theWindow, p_vout->p_sys->winGroup);
  688.                     SetWindowGroupParent( p_vout->p_sys->winGroup, GetWindowGroupOfClass(kDocumentWindowClass) ) ;
  689.                 }
  690.  
  691.                 // Window title
  692.                 CFStringRef titleKey    = CFSTR("Fullscreen VLC media plugin");
  693.                 CFStringRef windowTitle = CFCopyLocalizedString(titleKey, NULL);
  694.                 SetWindowTitleWithCFString(p_vout->p_sys->theWindow, windowTitle);
  695.                 CFRelease(titleKey);
  696.                 CFRelease(windowTitle);
  697.  
  698.                 //Install event handler
  699.                 static const EventTypeSpec win_events[] = {
  700.                     { kEventClassMouse, kEventMouseDown },
  701.                     { kEventClassMouse, kEventMouseMoved },
  702.                     { kEventClassMouse, kEventMouseUp },
  703.                     { kEventClassWindow, kEventWindowClosed },
  704.                     { kEventClassWindow, kEventWindowBoundsChanged },
  705.                     { kEventClassCommand, kEventCommandProcess },
  706.                     { kEventClassVLCPlugin, kEventVLCPluginShowFullscreen },
  707.                     { kEventClassVLCPlugin, kEventVLCPluginHideFullscreen },
  708.                 };
  709.                 InstallWindowEventHandler (p_vout->p_sys->theWindow, NewEventHandlerUPP (WindowEventHandler), GetEventTypeCount(win_events), win_events, p_vout, NULL);
  710.             }
  711.             else
  712.             {
  713.                 /* just in case device resolution changed */
  714.                 SetWindowBounds(p_vout->p_sys->theWindow, kWindowContentRgn, &deviceRect);
  715.             }
  716.             glClear( GL_COLOR_BUFFER_BIT );
  717.             p_vout->p_sys->agl_drawable = (AGLDrawable)GetWindowPort(p_vout->p_sys->theWindow);
  718.             aglSetDrawable(p_vout->p_sys->agl_ctx, p_vout->p_sys->agl_drawable);
  719.             aglSetCurrentContext(p_vout->p_sys->agl_ctx);
  720.             aglSetViewport(p_vout, deviceRect, deviceRect);
  721.             //aglSetFullScreen(p_vout->p_sys->agl_ctx, device_width, device_height, 0, 0);
  723.             if( p_vout->p_sys->theWindow )
  724.             {
  725.                 /* Most Carbon APIs are not thread-safe, therefore delagate some GUI visibilty
  726.                  * update to the main thread */
  727.                 sendEventToMainThread(GetWindowEventTarget(p_vout->p_sys->theWindow),
  728.                                       kEventClassVLCPlugin, kEventVLCPluginShowFullscreen);
  729.             }
  730.         }
  731.         aglReshape(p_vout);
  732.         aglUnlock( p_vout );
  733.         p_vout->b_fullscreen = !p_vout->b_fullscreen;
  734.         p_vout->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
  735.     }
  736.     return VLC_SUCCESS;
  737. }
  739. static int aglControl( vout_thread_t *p_vout, int i_query, va_list args )
  740. {
  741.     switch( i_query )
  742.     {
  743.         case VOUT_SET_VIEWPORT:
  744.         {
  745.             Rect viewBounds, clipBounds;
  746.             viewBounds.top = va_arg( args, int);
  747.             viewBounds.left = va_arg( args, int);
  748.             viewBounds.bottom = va_arg( args, int);
  749.             viewBounds.right = va_arg( args, int);
  750.             clipBounds.top = va_arg( args, int);
  751.             clipBounds.left = va_arg( args, int);
  752.             clipBounds.bottom = va_arg( args, int);
  753.             clipBounds.right = va_arg( args, int);
  754.  
  755.             if( !p_vout->b_fullscreen )
  756.             {
  757.                 /*
  758.                 ** check that the clip rect is not empty, as this is used
  759.                 ** by Firefox to prevent a plugin from displaying during
  760.                 ** a scrolling event. In this case we just prevent buffers
  761.                 ** from being swapped and ignore clipping as this is less
  762.                 ** disruptive than a GL geometry change
  763.                 */
  765.                 p_vout->p_sys->b_clipped_out = (clipBounds.top == clipBounds.bottom)
  766.                                              || (clipBounds.left == clipBounds.right);
  767.                 if( ! p_vout->p_sys->b_clipped_out )
  768.                 {
  769.                     /* ignore consecutive viewport update with identical parameters */
  770.                     if( memcmp(&clipBounds, &(p_vout->p_sys->clipBounds), sizeof(clipBounds) )
  771.                      && memcmp(&viewBounds, &(p_vout->p_sys->viewBounds), sizeof(viewBounds)) )
  772.                     {
  773.                         aglLock( p_vout );
  774.                         aglSetViewport(p_vout, viewBounds, clipBounds);
  775.                         aglReshape( p_vout );
  776.                         aglUnlock( p_vout );
  777.                         p_vout->p_sys->clipBounds = clipBounds;
  778.                         p_vout->p_sys->viewBounds = viewBounds;
  779.                     }
  780.                 }
  781.             }
  782.             return VLC_SUCCESS;
  783.         }
  785.         case VOUT_REDRAW_RECT:
  786.         {
  787.             vout_thread_t * p_parent;
  788.             Rect areaBounds;
  790.             areaBounds.top = va_arg( args, int);
  791.             areaBounds.left = va_arg( args, int);
  792.             areaBounds.bottom = va_arg( args, int);
  793.             areaBounds.right = va_arg( args, int);
  795.             /* Ask the opengl module to redraw */
  796.             p_parent = (vout_thread_t *) p_vout->p_parent;
  797.             if( p_parent && p_parent->pf_display )
  798.             {
  799.                 p_parent->pf_display( p_parent, NULL );
  800.             }
  801.             return VLC_SUCCESS;
  802.         }
  804.         default:
  805.             return VLC_EGENERIC;
  806.     }
  807. }
  809. static void aglSwap( vout_thread_t * p_vout )
  810. {
  811.     if( ! p_vout->p_sys->b_clipped_out )
  812.     {
  813.         p_vout->p_sys->b_got_frame = true;
  814.         aglSwapBuffers(p_vout->p_sys->agl_ctx);
  815.     }
  816.     else
  817.     {
  818.         /* drop frame */
  819.         glFlush();
  820.     }
  821. }
  823. /* Enter this function with the p_vout locked */
  824. static void aglSetViewport( vout_thread_t *p_vout, Rect viewBounds, Rect clipBounds )
  825. {
  826.     // mozilla plugin provides coordinates based on port bounds
  827.     // however AGL coordinates are based on window structure region
  828.     // and are vertically flipped
  829.     GLint rect[4];
  830.     CGrafPtr port = (CGrafPtr)p_vout->p_sys->agl_drawable;
  831.     Rect winBounds, clientBounds;
  833.     GetWindowBounds(GetWindowFromPort(port),
  834.         kWindowStructureRgn, &winBounds);
  835.     GetWindowBounds(GetWindowFromPort(port),
  836.         kWindowContentRgn, &clientBounds);
  838.     /* update video clipping bounds in drawable */
  839.     rect[0] = (clientBounds.left-winBounds.left)
  840.             + clipBounds.left;                  // from window left edge
  841.     rect[1] = (winBounds.bottom-winBounds.top)
  842.             - (clientBounds.top-winBounds.top)
  843.             - clipBounds.bottom;                // from window bottom edge
  844.     rect[2] = clipBounds.right-clipBounds.left; // width
  845.     rect[3] = clipBounds.bottom-clipBounds.top; // height
  847.     aglSetInteger(p_vout->p_sys->agl_ctx, AGL_BUFFER_RECT, rect);
  848.     aglEnable(p_vout->p_sys->agl_ctx, AGL_BUFFER_RECT);
  850.     /* update video internal bounds in drawable */
  851.     p_vout->p_sys->i_width  = viewBounds.right-viewBounds.left;
  852.     p_vout->p_sys->i_height = viewBounds.bottom-viewBounds.top;
  853.     p_vout->p_sys->i_offx   = -clipBounds.left - viewBounds.left;
  854.     p_vout->p_sys->i_offy   = clipBounds.bottom + viewBounds.top
  855.                             - p_vout->p_sys->i_height;
  857.     aglUpdateContext(p_vout->p_sys->agl_ctx);
  858. }
  860. //default window event handler
  861. static pascal OSStatus WindowEventHandler(EventHandlerCallRef nextHandler, EventRef event, void *userData)
  862. {
  863.     OSStatus result = noErr;
  864.     UInt32 class = GetEventClass (event);
  865.     UInt32 kind = GetEventKind (event);
  866.     vout_thread_t *p_vout = (vout_thread_t *)userData;
  868.     result = CallNextEventHandler(nextHandler, event);
  869.     if(class == kEventClassCommand)
  870.     {
  871.         HICommand theHICommand;
  872.         GetEventParameter( event, kEventParamDirectObject, typeHICommand, NULL, sizeof( HICommand ), NULL, &theHICommand );
  873.  
  874.         switch ( theHICommand.commandID )
  875.         {
  876.             default:
  877.                 result = eventNotHandledErr;
  878.         }
  879.     }
  880.     else if(class == kEventClassWindow)
  881.     {
  882.         WindowRef     window;
  883.         Rect          rectPort = {0,0,0,0};
  884.  
  885.         GetEventParameter(event, kEventParamDirectObject, typeWindowRef, NULL, sizeof(WindowRef), NULL, &window);
  887.         if(window)
  888.         {
  889.             GetPortBounds(GetWindowPort(window), &rectPort);
  890.         }
  892.         switch (kind)
  893.         {
  894.             case kEventWindowClosed:
  895.             case kEventWindowZoomed:
  896.             case kEventWindowBoundsChanged:
  897.                 break;
  898.  
  899.             default:
  900.                 result = eventNotHandledErr;
  901.         }
  902.     }
  903.     else if(class == kEventClassMouse)
  904.     {
  905.         switch (kind)
  906.         {
  907.             case kEventMouseDown:
  908.             {
  909.                 UInt16     button;
  910.  
  911.                 GetEventParameter(event, kEventParamMouseButton, typeMouseButton, NULL, sizeof(button), NULL, &button);
  912.                 switch (button)
  913.                 {
  914.                     case kEventMouseButtonPrimary:
  915.                     {
  916.                         vlc_value_t val;
  918.                         var_Get( p_vout, "mouse-button-down", &val );
  919.                         val.i_int |= 1;
  920.                         var_Set( p_vout, "mouse-button-down", val );
  921.                         break;
  922.                     }
  923.                     case kEventMouseButtonSecondary:
  924.                     {
  925.                         vlc_value_t val;
  927.                         var_Get( p_vout, "mouse-button-down", &val );
  928.                         val.i_int |= 2;
  929.                         var_Set( p_vout, "mouse-button-down", val );
  930.                         break;
  931.                     }
  932.                     case kEventMouseButtonTertiary:
  933.                     {
  934.                         vlc_value_t val;
  936.                         var_Get( p_vout, "mouse-button-down", &val );
  937.                         val.i_int |= 4;
  938.                         var_Set( p_vout, "mouse-button-down", val );
  939.                         break;
  940.                     }
  941.                     default:
  942.                         result = eventNotHandledErr;
  943.                 }
  944.                 break;
  945.             }
  947.             case kEventMouseUp:
  948.             {
  949.                 UInt16     button;
  950.  
  951.                 GetEventParameter(event, kEventParamMouseButton, typeMouseButton, NULL, sizeof(button), NULL, &button);
  952.                 switch (button)
  953.                 {
  954.                     case kEventMouseButtonPrimary:
  955.                     {
  956.                         UInt32 clickCount = 0;
  957.                         GetEventParameter(event, kEventParamClickCount, typeUInt32, NULL, sizeof(clickCount), NULL, &clickCount);
  958.                         if( clickCount > 1 )
  959.                         {
  960.                             vlc_value_t val;
  962.                             val.b_bool = false;
  963.                             var_Set((vout_thread_t *) p_vout->p_parent, "fullscreen", val);
  964.                         }
  965.                         else
  966.                         {
  967.                             vlc_value_t val;
  969.                             var_SetBool( p_vout, "mouse-clicked", true );
  971.                             var_Get( p_vout, "mouse-button-down", &val );
  972.                             val.i_int &= ~1;
  973.                             var_Set( p_vout, "mouse-button-down", val );
  974.                         }
  975.                         break;
  976.                     }
  977.                     case kEventMouseButtonSecondary:
  978.                     {
  979.                         vlc_value_t val;
  981.                         var_Get( p_vout, "mouse-button-down", &val );
  982.                         val.i_int &= ~2;
  983.                         var_Set( p_vout, "mouse-button-down", val );
  984.                         break;
  985.                     }
  986.                     case kEventMouseButtonTertiary:
  987.                     {
  988.                         vlc_value_t val;
  990.                         var_Get( p_vout, "mouse-button-down", &val );
  991.                         val.i_int &= ~2;
  992.                         var_Set( p_vout, "mouse-button-down", val );
  993.                         break;
  994.                     }
  995.                     default:
  996.                         result = eventNotHandledErr;
  997.                 }
  998.                 break;
  999.             }
  1001.             case kEventMouseMoved:
  1002.             {
  1003.                 Point ml;
  1004.                 vlc_value_t val;
  1006.                 unsigned int i_x, i_y;
  1007.                 unsigned int i_height = p_vout->p_sys->i_height;
  1008.                 unsigned int i_width  = p_vout->p_sys->i_width;
  1010.                 vout_PlacePicture(p_vout, i_width, i_height, &i_x, &i_y, &i_width, &i_height);
  1012.                 GetEventParameter(event, kEventParamWindowMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &ml);
  1013.  
  1014.                 val.i_int = ( ((int)ml.h) - i_x ) *
  1015.                             p_vout->render.i_width / i_width;
  1016.                 var_Set( p_vout, "mouse-x", val );
  1018.                 val.i_int = ( ((int)ml.v) - i_y ) *
  1019.                             p_vout->render.i_height / i_height;
  1021.                 var_Set( p_vout, "mouse-y", val );
  1023.                 val.b_bool = true;
  1024.                 var_Set( p_vout, "mouse-moved", val );
  1026.                 break;
  1027.             }
  1028.  
  1029.             default:
  1030.                 result = eventNotHandledErr;
  1031.         }
  1032.     }
  1033.     else if(class == kEventClassTextInput)
  1034.     {
  1035.         switch (kind)
  1036.         {
  1037.             case kEventTextInputUnicodeForKeyEvent:
  1038.             {
  1039.                 break;
  1040.             }
  1041.             default:
  1042.                 result = eventNotHandledErr;
  1043.         }
  1044.     }
  1045.     else if(class == kEventClassVLCPlugin)
  1046.     {
  1047.         switch (kind)
  1048.         {
  1049.             case kEventVLCPluginShowFullscreen:
  1050.                 ShowWindow (p_vout->p_sys->theWindow);
  1051.                 SetSystemUIMode( kUIModeAllHidden, kUIOptionAutoShowMenuBar);
  1052.                 //CGDisplayHideCursor(kCGDirectMainDisplay);
  1053.                 break;
  1054.             case kEventVLCPluginHideFullscreen:
  1055.                 HideWindow (p_vout->p_sys->theWindow);
  1056.                 SetSystemUIMode( kUIModeNormal, 0);
  1057.                 CGDisplayShowCursor(kCGDirectMainDisplay);
  1058.                 break;
  1059.             default:
  1060.                 result = eventNotHandledErr;
  1061.                 break;
  1062.         }
  1063.     }
  1064.     return result;
  1065. }
  1067. static int aglLock( vout_thread_t * p_vout )
  1068. {
  1069. /* get the underlying CGL context */
  1070.     CGLContextObj cglContext;
  1071.     if( aglGetCGLContext(p_vout->p_sys->agl_ctx, (void**)&cglContext) )
  1072.     {
  1073.         if( kCGLNoError == CGLLockContext( cglContext ) )
  1074.         {
  1075.             aglSetCurrentContext(p_vout->p_sys->agl_ctx);
  1076.             return 0;
  1077.         }
  1078.     }
  1079.     return 1;
  1080. }
  1082. static void aglUnlock( vout_thread_t * p_vout )
  1083. {
  1084. /* get the underlying CGL context */
  1085.     CGLContextObj cglContext;
  1086.     if( aglGetCGLContext(p_vout->p_sys->agl_ctx, (void**)&cglContext) )
  1087.     {
  1088.         CGLUnlockContext( cglContext );
  1089.     }
  1090. }
  1092. #endif