git.sesse.net Git - vlc/blob - modules/video_output/opengl.c

   1 /*****************************************************************************
   2  * opengl.c: OpenGL video output
   3  *****************************************************************************
   4  * Copyright (C) 2004 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Cyril Deguet <asmax@videolan.org>
   8  *          Gildas Bazin <gbazin@videolan.org>
   9  *          Eric Petit <titer@m0k.org>
  10  *          Cedric Cocquebert <cedric.cocquebert@supelec.fr>
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  25  *****************************************************************************/
  26
  27 /*****************************************************************************
  28  * Preamble
  29  *****************************************************************************/
  30
  31 #ifdef HAVE_CONFIG_H
  32 # include "config.h"
  33 #endif
  34
  35 #include <assert.h>
  36
  37 #include <vlc_common.h>
  38 #include <vlc_plugin.h>
  39 #include <vlc_vout.h>
  40 #include "opengl.h"
  41
  42 /*****************************************************************************
  43  * Vout interface
  44  *****************************************************************************/
  45 static int  CreateVout   ( vlc_object_t * );
  46 static void DestroyVout  ( vlc_object_t * );
  47 static int  Init         ( vout_thread_t * );
  48 static void End          ( vout_thread_t * );
  49 static int  Manage       ( vout_thread_t * );
  50 static void Render       ( vout_thread_t *, picture_t * );
  51 static void DisplayVideo ( vout_thread_t *, picture_t * );
  52 static int  Control      ( vout_thread_t *, int, va_list );
  53
  54 static int SendEvents    ( vlc_object_t *, char const *,
  55                            vlc_value_t, vlc_value_t, void * );
  56
  57 #define PROVIDER_TEXT N_("OpenGL Provider")
  58 #define PROVIDER_LONGTEXT N_("Allows you to modify what OpenGL provider should be used")
  59
  60 vlc_module_begin ()
  61     set_shortname( "OpenGL" )
  62     set_category( CAT_VIDEO )
  63     set_subcategory( SUBCAT_VIDEO_VOUT )
  64     set_description( N_("OpenGL video output") )
  65 #ifdef __APPLE__
  66     set_capability( "video output", 400 )
  67 #else
  68     set_capability( "video output", 20 )
  69 #endif
  70     add_shortcut( "opengl" )
  71     /* Allow opengl provider plugin selection */
  72     add_module( "opengl-provider", "opengl provider", NULL, NULL,
  73                 PROVIDER_TEXT, PROVIDER_LONGTEXT, true )
  74     set_callbacks( CreateVout, DestroyVout )
  75 vlc_module_end ()
  76
  77 /*****************************************************************************
  78  * vout_sys_t: video output method descriptor
  79  *****************************************************************************
  80  * This structure is part of the video output thread descriptor.
  81  * It describes the OpenGL specific properties of the output thread.
  82  *****************************************************************************/
  83 struct vout_sys_t
  84 {
  85     vout_thread_t *p_vout;
  86     vout_opengl_t gl;
  87     vout_display_opengl_t vgl;
  88
  89     picture_pool_t *p_pool;
  90     picture_t *p_current;
  91 };
  92
  93 /*****************************************************************************
  94  * CreateVout: This function allocates and initializes the OpenGL vout method.
  95  *****************************************************************************/
  96 static int CreateVout( vlc_object_t *p_this )
  97 {
  98     vout_thread_t *p_vout = (vout_thread_t *)p_this;
  99     vout_sys_t *p_sys;
 100     char * psz;
 101
 102     /* Allocate structure */
 103     p_vout->p_sys = p_sys = malloc( sizeof( vout_sys_t ) );
 104     if( p_sys == NULL )
 105         return VLC_ENOMEM;
 106
 107     /* Get window */
 108     p_sys->p_vout =
 109         (vout_thread_t *)vlc_object_create( p_this, sizeof( vout_thread_t ) );
 110     if( p_sys->p_vout == NULL )
 111     {
 112         free( p_sys );
 113         return VLC_ENOMEM;
 114     }
 115     vlc_object_attach( p_sys->p_vout, p_this );
 116
 117     p_sys->p_vout->i_window_width = p_vout->i_window_width;
 118     p_sys->p_vout->i_window_height = p_vout->i_window_height;
 119     p_sys->p_vout->b_fullscreen = p_vout->b_fullscreen;
 120     p_sys->p_vout->render.i_width = p_vout->render.i_width;
 121     p_sys->p_vout->render.i_height = p_vout->render.i_height;
 122     p_sys->p_vout->render.i_aspect = p_vout->render.i_aspect;
 123     p_sys->p_vout->fmt_render = p_vout->fmt_render;
 124     p_sys->p_vout->fmt_in = p_vout->fmt_in;
 125     p_sys->p_vout->b_autoscale = p_vout->b_autoscale;
 126     p_sys->p_vout->i_zoom = p_vout->i_zoom;
 127     p_sys->p_vout->i_alignment = p_vout->i_alignment;
 128     var_Create( p_sys->p_vout, "video-deco",
 129                 VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 130
 131     /* Forward events from the opengl provider */
 132     var_Create( p_sys->p_vout, "mouse-moved", VLC_VAR_COORDS );
 133     var_Create( p_sys->p_vout, "mouse-clicked", VLC_VAR_COORDS );
 134     var_Create( p_sys->p_vout, "mouse-button-down", VLC_VAR_INTEGER );
 135     var_Create( p_sys->p_vout, "video-on-top",
 136                 VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 137     var_Create( p_sys->p_vout, "autoscale",
 138                 VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 139     var_Create( p_sys->p_vout, "scale",
 140                 VLC_VAR_FLOAT | VLC_VAR_DOINHERIT );
 141
 142     var_AddCallback( p_sys->p_vout, "mouse-moved", SendEvents, p_vout );
 143     var_AddCallback( p_sys->p_vout, "mouse-clicked", SendEvents, p_vout );
 144     var_AddCallback( p_sys->p_vout, "mouse-button-down", SendEvents, p_vout );
 145     var_AddCallback( p_sys->p_vout, "video-on-top", SendEvents, p_vout );
 146     var_AddCallback( p_vout, "autoscale", SendEvents, p_sys->p_vout );
 147     var_AddCallback( p_vout, "scale", SendEvents, p_sys->p_vout );
 148
 149     psz = var_CreateGetString( p_vout, "opengl-provider" );
 150     p_sys->p_vout->p_module =
 151         module_need( p_sys->p_vout, "opengl provider", psz, false );
 152     free( psz );
 153     if( p_sys->p_vout->p_module == NULL )
 154     {
 155         msg_Warn( p_vout, "No OpenGL provider found" );
 156         /* no need for var_DelCallback here :-) */
 157         vlc_object_release( p_sys->p_vout );
 158         free( p_sys );
 159         return VLC_ENOOBJ;
 160     }
 161
 162     p_vout->pf_init = Init;
 163     p_vout->pf_end = End;
 164     p_vout->pf_manage = Manage;
 165     p_vout->pf_render = Render;
 166     p_vout->pf_display = DisplayVideo;
 167     p_vout->pf_control = Control;
 168
 169     return VLC_SUCCESS;
 170 }
 171
 172 static int OpenglLock(vout_opengl_t *gl)
 173 {
 174     vout_thread_t *p_vout = gl->sys;
 175
 176     if( !p_vout->pf_lock )
 177         return VLC_SUCCESS;
 178     return p_vout->pf_lock( p_vout );
 179 }
 180 static void OpenglUnlock(vout_opengl_t *gl)
 181 {
 182     vout_thread_t *p_vout = gl->sys;
 183
 184     if( p_vout->pf_unlock )
 185         p_vout->pf_unlock( p_vout );
 186 }
 187 static void OpenglSwap(vout_opengl_t *gl)
 188 {
 189     vout_thread_t *p_vout = gl->sys;
 190     p_vout->pf_swap( p_vout );
 191 }
 192
 193 /*****************************************************************************
 194  * Init: initialize the OpenGL video thread output method
 195  *****************************************************************************/
 196 static int Init( vout_thread_t *p_vout )
 197 {
 198     vout_sys_t *p_sys = p_vout->p_sys;
 199
 200     p_sys->p_vout->pf_init( p_sys->p_vout );
 201
 202     p_sys->gl.lock = OpenglLock;
 203     p_sys->gl.unlock = OpenglUnlock;
 204     p_sys->gl.swap = OpenglSwap;
 205     p_sys->gl.sys = p_sys->p_vout;
 206
 207     video_format_t fmt;
 208     video_format_Init( &fmt, 0 );
 209     video_format_Setup( &fmt,
 210                         p_vout->render.i_chroma,
 211                         p_vout->render.i_width,
 212                         p_vout->render.i_height,
 213                         p_vout->render.i_aspect * p_vout->render.i_height,
 214                         VOUT_ASPECT_FACTOR      * p_vout->render.i_width );
 215
 216
 217     if( vout_display_opengl_Init( &p_sys->vgl, &fmt, &p_sys->gl ) )
 218     {
 219         I_OUTPUTPICTURES = 0;
 220         return VLC_EGENERIC;
 221     }
 222     p_sys->p_pool = vout_display_opengl_GetPool( &p_sys->vgl );
 223     if( !p_sys->p_pool )
 224     {
 225         vout_display_opengl_Clean( &p_sys->vgl );
 226         I_OUTPUTPICTURES = 0;
 227         return VLC_EGENERIC;
 228     }
 229
 230     /* */
 231     p_vout->output.i_chroma = fmt.i_chroma;
 232     p_vout->output.i_rmask  = fmt.i_rmask;
 233     p_vout->output.i_gmask  = fmt.i_gmask;
 234     p_vout->output.i_bmask  = fmt.i_bmask;
 235
 236     /* Since OpenGL can do rescaling for us, stick to the default
 237      * coordinates and aspect. */
 238     p_vout->output.i_width  = p_vout->render.i_width;
 239     p_vout->output.i_height = p_vout->render.i_height;
 240     p_vout->output.i_aspect = p_vout->render.i_aspect;
 241
 242     p_vout->fmt_out = p_vout->fmt_in;
 243     p_vout->fmt_out.i_chroma = p_vout->output.i_chroma;
 244
 245     /* */
 246     p_sys->p_current = picture_pool_Get( p_sys->p_pool );
 247     p_vout->p_picture[0] = *p_sys->p_current;
 248     p_vout->p_picture[0].i_status = DESTROYED_PICTURE;
 249     p_vout->p_picture[0].i_type   = DIRECT_PICTURE;
 250     p_vout->p_picture[0].i_refcount = 0;
 251     p_vout->p_picture[0].p_sys = NULL;
 252     PP_OUTPUTPICTURE[0] = &p_vout->p_picture[0];
 253
 254     I_OUTPUTPICTURES = 1;
 255
 256     return VLC_SUCCESS;
 257 }
 258
 259 /*****************************************************************************
 260  * End: terminate GLX video thread output method
 261  *****************************************************************************/
 262 static void End( vout_thread_t *p_vout )
 263 {
 264     vout_sys_t *p_sys = p_vout->p_sys;
 265
 266     if( I_OUTPUTPICTURES > 0 )
 267     {
 268
 269         if( p_sys->p_current )
 270             picture_Release( p_sys->p_current );
 271         vout_display_opengl_Clean( &p_sys->vgl );
 272
 273         p_vout->p_picture[0].i_status = FREE_PICTURE;
 274         I_OUTPUTPICTURES = 0;
 275     }
 276
 277     /* We must release the opengl provider here: opengl requiere init and end
 278        to be done in the same thread */
 279     module_unneed( p_sys->p_vout, p_sys->p_vout->p_module );
 280     vlc_object_release( p_sys->p_vout );
 281 }
 282
 283 /*****************************************************************************
 284  * Destroy: destroy GLX video thread output method
 285  *****************************************************************************
 286  * Terminate an output method created by CreateVout
 287  *****************************************************************************/
 288 static void DestroyVout( vlc_object_t *p_this )
 289 {
 290     vout_thread_t *p_vout = (vout_thread_t *)p_this;
 291     vout_sys_t *p_sys = p_vout->p_sys;
 292
 293     free( p_sys );
 294 }
 295
 296 /*****************************************************************************
 297  * Manage: handle Sys events
 298  *****************************************************************************
 299  * This function should be called regularly by video output thread. It returns
 300  * a non null value if an error occurred.
 301  *****************************************************************************/
 302 static int Manage( vout_thread_t *p_vout )
 303 {
 304     vout_sys_t *p_sys = p_vout->p_sys;
 305     int i_ret, i_fullscreen_change;
 306
 307     i_fullscreen_change = ( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE );
 308
 309     p_vout->fmt_out.i_x_offset = p_sys->p_vout->fmt_in.i_x_offset =
 310         p_vout->fmt_in.i_x_offset;
 311     p_vout->fmt_out.i_y_offset = p_sys->p_vout->fmt_in.i_y_offset =
 312         p_vout->fmt_in.i_y_offset;
 313     p_vout->fmt_out.i_visible_width = p_sys->p_vout->fmt_in.i_visible_width =
 314         p_vout->fmt_in.i_visible_width;
 315     p_vout->fmt_out.i_visible_height = p_sys->p_vout->fmt_in.i_visible_height =
 316         p_vout->fmt_in.i_visible_height;
 317     p_vout->fmt_out.i_sar_num = p_sys->p_vout->fmt_in.i_sar_num =
 318         p_vout->fmt_in.i_sar_num;
 319     p_vout->fmt_out.i_sar_den = p_sys->p_vout->fmt_in.i_sar_den =
 320         p_vout->fmt_in.i_sar_den;
 321     p_vout->output.i_aspect = (int64_t)p_vout->fmt_in.i_sar_num * p_vout->fmt_in.i_width * VOUT_ASPECT_FACTOR /
 322                               p_vout->fmt_in.i_sar_den / p_vout->fmt_in.i_height;
 323
 324     p_sys->p_vout->i_changes = p_vout->i_changes;
 325     i_ret = p_sys->p_vout->pf_manage( p_sys->p_vout );
 326     p_vout->i_changes = p_sys->p_vout->i_changes;
 327
 328 #ifdef __APPLE__
 329     /* On OS X, we create the window and the GL view when entering
 330        fullscreen - the textures have to be inited again */
 331     if( i_fullscreen_change )
 332     {
 333         /* FIXME should we release p_current ? */
 334         vout_display_opengl_ResetTextures( &p_sys->vgl );
 335     }
 336 #endif
 337
 338 // to align in real time in OPENGL
 339     if (p_sys->p_vout->i_alignment != p_vout->i_alignment)
 340     {
 341         p_vout->i_changes |= VOUT_CROP_CHANGE;        //to force change
 342         p_sys->p_vout->i_alignment = p_vout->i_alignment;
 343     }
 344
 345     /* forward signal that autoscale toggle has changed */
 346     if (p_vout->i_changes & VOUT_SCALE_CHANGE )
 347     {
 348         p_vout->i_changes &= ~VOUT_SCALE_CHANGE;
 349
 350         p_sys->p_vout->i_changes |= VOUT_SCALE_CHANGE;
 351     }
 352
 353     /* forward signal that scale has changed */
 354     if (p_vout->i_changes & VOUT_ZOOM_CHANGE )
 355     {
 356         p_vout->i_changes &= ~VOUT_ZOOM_CHANGE;
 357
 358         p_sys->p_vout->i_changes |= VOUT_ZOOM_CHANGE;
 359     }
 360
 361
 362     return i_ret;
 363 }
 364
 365 /*****************************************************************************
 366  * Render: render previously calculated output
 367  *****************************************************************************/
 368 static void Render( vout_thread_t *p_vout, picture_t *p_pic )
 369 {
 370     vout_sys_t *p_sys = p_vout->p_sys;
 371
 372     picture_t *p_next = p_sys->p_current;
 373
 374     if( VLCGL_TEXTURE_COUNT > 1 )
 375     {
 376         /* Get the next picture to display */
 377         p_next = picture_pool_Get( p_sys->p_pool );
 378         assert( p_next );
 379     }
 380
 381     if( p_sys->p_current )
 382     {
 383         assert( p_sys->p_current->p[0].p_pixels == p_pic->p[0].p_pixels );
 384
 385         /* Make sure we have the prepare after the picture_pool_Get,
 386          * because picture_pool_Get() will bind the new picture texture,
 387          * and vout_display_opengl_Prepare() bind the current rendered picture
 388          * texture.
 389          * DisplayVideo() will effectively use the last binded texture. */
 390
 391         vout_display_opengl_Prepare( &p_sys->vgl, p_sys->p_current );
 392     }
 393
 394     if( p_sys->p_current != p_next ) {
 395         if( p_sys->p_current )
 396             picture_Release( p_sys->p_current );
 397
 398         /* Swap the picture texture on opengl vout side. */
 399         p_sys->p_current = p_next;
 400
 401         /* Now, switch the only picture that is being used
 402          * to render in the backend to point to our "next"
 403          * picture texture */
 404         p_pic->p[0].p_pixels = p_sys->p_current->p[0].p_pixels;
 405     }
 406
 407     VLC_UNUSED( p_pic );
 408 }
 409
 410 /*****************************************************************************
 411  * DisplayVideo: displays previously rendered output
 412  *****************************************************************************/
 413 static void DisplayVideo( vout_thread_t *p_vout, picture_t *p_pic )
 414 {
 415     vout_sys_t *p_sys = p_vout->p_sys;
 416
 417     vout_display_opengl_Display( &p_sys->vgl, &p_vout->fmt_out );
 418     VLC_UNUSED( p_pic );
 419 }
 420
 421 /*****************************************************************************
 422  * Control: control facility for the vout
 423  *****************************************************************************/
 424 static int Control( vout_thread_t *p_vout, int i_query, va_list args )
 425 {
 426     vout_sys_t *p_sys = p_vout->p_sys;
 427
 428     if( p_sys->p_vout->pf_control )
 429         return p_sys->p_vout->pf_control( p_sys->p_vout, i_query, args );
 430     return VLC_EGENERIC;
 431 }
 432
 433 /*****************************************************************************
 434  * SendEvents: forward mouse and keyboard events to the parent p_vout
 435  *****************************************************************************/
 436 static int SendEvents( vlc_object_t *p_this, char const *psz_var,
 437                        vlc_value_t oldval, vlc_value_t newval, void *_p_vout )
 438 {
 439     VLC_UNUSED(p_this); VLC_UNUSED(oldval);
 440     return var_Set( (vlc_object_t *)_p_vout, psz_var, newval );
 441 }
 442