opengl.c 25 KB
Newer Older
1 2 3
/*****************************************************************************
 * opengl.c: OpenGL video output
 *****************************************************************************
4
 * Copyright (C) 2004 the VideoLAN team
5 6 7 8
 * $Id$
 *
 * Authors: Cyril Deguet <asmax@videolan.org>
 *          Gildas Bazin <gbazin@videolan.org>
9
 *          Eric Petit <titer@m0k.org>
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
 *
 * 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
 *****************************************************************************/

/*****************************************************************************
 * Preamble
 *****************************************************************************/
#include <errno.h>                                                 /* ENOMEM */
#include <stdlib.h>                                      /* malloc(), free() */
#include <string.h>

#include <vlc/vlc.h>
#include <vlc/vout.h>

36
#ifdef SYS_DARWIN
37
#include <OpenGL/gl.h>
38 39 40 41 42 43 44 45 46 47 48 49 50
#include <OpenGL/glext.h>

/* On OS X, use GL_TEXTURE_RECTANGLE_EXT instead of GL_TEXTURE_2D.
   This allows sizes which are not powers of 2 */
#define VLCGL_TARGET GL_TEXTURE_RECTANGLE_EXT

/* OS X OpenGL supports YUV. Hehe. */
#define VLCGL_FORMAT GL_YCBCR_422_APPLE
#define VLCGL_TYPE   GL_UNSIGNED_SHORT_8_8_APPLE
#else

#include <GL/gl.h>
#define VLCGL_TARGET GL_TEXTURE_2D
51 52

/* RV16 */
53 54 55
#ifndef GL_UNSIGNED_SHORT_5_6_5
#define GL_UNSIGNED_SHORT_5_6_5 0x8363
#endif
56 57 58 59 60 61 62 63 64 65 66
//#define VLCGL_RGB_FORMAT GL_RGB
//#define VLCGL_RGB_TYPE GL_UNSIGNED_SHORT_5_6_5

/* RV24 */
//#define VLCGL_RGB_FORMAT GL_RGB
//#define VLCGL_RGB_TYPE GL_UNSIGNED_BYTE

/* RV32 */
#define VLCGL_RGB_FORMAT GL_RGBA
#define VLCGL_RGB_TYPE GL_UNSIGNED_BYTE

67 68 69 70 71
/* Use RGB on Win32/GLX */
#define VLCGL_FORMAT VLCGL_RGB_FORMAT
#define VLCGL_TYPE   VLCGL_RGB_TYPE
#endif

dionoea's avatar
dionoea committed
72 73 74 75
#ifndef GL_CLAMP_TO_EDGE
#   define GL_CLAMP_TO_EDGE 0x812F
#endif

76 77 78 79 80
/* OpenGL effects */
#define OPENGL_EFFECT_NONE             1
#define OPENGL_EFFECT_CUBE             2
#define OPENGL_EFFECT_TRANSPARENT_CUBE 4

81 82 83 84 85 86 87
/*****************************************************************************
 * Vout interface
 *****************************************************************************/
static int  CreateVout   ( vlc_object_t * );
static void DestroyVout  ( vlc_object_t * );
static int  Init         ( vout_thread_t * );
static void End          ( vout_thread_t * );
88 89
static int  Manage       ( vout_thread_t * );
static void Render       ( vout_thread_t *, picture_t * );
90
static void DisplayVideo ( vout_thread_t *, picture_t * );
91
static int  Control      ( vout_thread_t *, int, va_list );
92

93
static inline int GetAlignedSize( int );
94

Eric Petit's avatar
Eric Petit committed
95
static int InitTextures( vout_thread_t * );
96 97 98
static int SendEvents( vlc_object_t *, char const *,
                       vlc_value_t, vlc_value_t, void * );

99 100 101 102
/*****************************************************************************
 * Module descriptor
 *****************************************************************************/
#define SPEED_TEXT N_( "OpenGL cube rotation speed" )
103 104 105
/*****************************************************************************
 * Module descriptor
 *****************************************************************************/
zorglub's avatar
zorglub committed
106 107 108 109 110
#define SPEED_TEXT N_( "OpenGL cube rotation speed" )
#define SPEED_LONGTEXT N_( "If the OpenGL cube effect is enabled, this " \
                           "controls its rotation speed." )

#define EFFECT_TEXT N_("Select effect")
111 112 113
#define EFFECT_LONGTEXT N_( \
    "Allows you to select different visual effects.")

114
static char *ppsz_effects[] = {
115
        "none", "cube", "transparent-cube" };
116
static char *ppsz_effects_text[] = {
117
        N_("None"), N_("Cube"), N_("Transparent Cube") };
118

119
vlc_module_begin();
120 121 122
    set_shortname( "OpenGL" );
    set_category( CAT_VIDEO );
    set_subcategory( SUBCAT_VIDEO_VOUT );
123
    set_description( _("OpenGL video output") );
Eric Petit's avatar
Eric Petit committed
124
#ifdef SYS_DARWIN
125
    set_capability( "video output", 200 );
Eric Petit's avatar
Eric Petit committed
126
#else
127
    set_capability( "video output", 20 );
Eric Petit's avatar
Eric Petit committed
128
#endif
129
    add_shortcut( "opengl" );
zorglub's avatar
zorglub committed
130
    add_float( "opengl-cube-speed", 2.0, NULL, SPEED_TEXT,
131
                    SPEED_LONGTEXT, VLC_TRUE );
132
    set_callbacks( CreateVout, DestroyVout );
133
    add_string( "opengl-effect", "none", NULL, EFFECT_TEXT,
134
                 EFFECT_LONGTEXT, VLC_FALSE );
135
        change_string_list( ppsz_effects, ppsz_effects_text, 0 );
136 137 138 139 140 141 142 143 144 145 146 147
vlc_module_end();

/*****************************************************************************
 * vout_sys_t: video output method descriptor
 *****************************************************************************
 * This structure is part of the video output thread descriptor.
 * It describes the OpenGL specific properties of the output thread.
 *****************************************************************************/
struct vout_sys_t
{
    vout_thread_t *p_vout;

148
    uint8_t    *pp_buffer[2];
149 150 151
    int         i_index;
    int         i_tex_width;
    int         i_tex_height;
152
    GLuint      p_textures[2];
153

154
    int         i_effect;
zorglub's avatar
zorglub committed
155 156

    float       f_speed;
157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
};

/*****************************************************************************
 * CreateVout: This function allocates and initializes the OpenGL vout method.
 *****************************************************************************/
static int CreateVout( vlc_object_t *p_this )
{
    vout_thread_t *p_vout = (vout_thread_t *)p_this;
    vout_sys_t *p_sys;

    /* Allocate structure */
    p_vout->p_sys = p_sys = malloc( sizeof( vout_sys_t ) );
    if( p_sys == NULL )
    {
        msg_Err( p_vout, "out of memory" );
        return VLC_EGENERIC;
    }

175
    var_Create( p_vout, "opengl-effect", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
176

177
    p_sys->i_index = 0;
178 179 180 181
#ifdef SYS_DARWIN
    p_sys->i_tex_width  = p_vout->render.i_width;
    p_sys->i_tex_height = p_vout->render.i_height;
#else
182 183 184
    /* A texture must have a size aligned on a power of 2 */
    p_sys->i_tex_width  = GetAlignedSize( p_vout->render.i_width );
    p_sys->i_tex_height = GetAlignedSize( p_vout->render.i_height );
185
#endif
186 187 188 189 190 191 192 193 194 195 196 197

    msg_Dbg( p_vout, "Texture size: %dx%d", p_sys->i_tex_width,
             p_sys->i_tex_height );

    /* Get window */
    p_sys->p_vout =
        (vout_thread_t *)vlc_object_create( p_this, VLC_OBJECT_OPENGL );
    if( p_sys->p_vout == NULL )
    {
        msg_Err( p_vout, "out of memory" );
        return VLC_ENOMEM;
    }
198
    vlc_object_attach( p_sys->p_vout, p_this );
199 200 201 202

    p_sys->p_vout->i_window_width = p_vout->i_window_width;
    p_sys->p_vout->i_window_height = p_vout->i_window_height;
    p_sys->p_vout->b_fullscreen = p_vout->b_fullscreen;
203 204 205
    p_sys->p_vout->render.i_width = p_vout->render.i_width;
    p_sys->p_vout->render.i_height = p_vout->render.i_height;
    p_sys->p_vout->render.i_aspect = p_vout->render.i_aspect;
206 207
    p_sys->p_vout->b_scale = p_vout->b_scale;
    p_sys->p_vout->i_alignment = p_vout->i_alignment;
208 209 210 211 212

    p_sys->p_vout->p_module =
        module_Need( p_sys->p_vout, "opengl provider", NULL, 0 );
    if( p_sys->p_vout->p_module == NULL )
    {
Eric Petit's avatar
Eric Petit committed
213
        msg_Warn( p_vout, "No OpenGL provider found" );
214
        vlc_object_detach( p_sys->p_vout );
215 216 217 218
        vlc_object_destroy( p_sys->p_vout );
        return VLC_ENOOBJ;
    }

zorglub's avatar
zorglub committed
219 220
    p_sys->f_speed = var_CreateGetFloat( p_vout, "opengl-cube-speed" );

221 222
    p_vout->pf_init = Init;
    p_vout->pf_end = End;
223
    p_vout->pf_manage = Manage;
224 225
    p_vout->pf_render = Render;
    p_vout->pf_display = DisplayVideo;
226
    p_vout->pf_control = Control;
227

228
    /* Forward events from the opengl provider */
Eric Petit's avatar
Eric Petit committed
229 230 231 232
    var_Create( p_sys->p_vout, "mouse-x", VLC_VAR_INTEGER );
    var_Create( p_sys->p_vout, "mouse-y", VLC_VAR_INTEGER );
    var_Create( p_sys->p_vout, "mouse-moved", VLC_VAR_BOOL );
    var_Create( p_sys->p_vout, "mouse-clicked", VLC_VAR_INTEGER );
233
    var_Create( p_sys->p_vout, "mouse-button-down", VLC_VAR_INTEGER );
234 235
    var_Create( p_sys->p_vout, "video-on-top",
                VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
Eric Petit's avatar
Eric Petit committed
236

237 238 239 240
    var_AddCallback( p_sys->p_vout, "mouse-x", SendEvents, p_vout );
    var_AddCallback( p_sys->p_vout, "mouse-y", SendEvents, p_vout );
    var_AddCallback( p_sys->p_vout, "mouse-moved", SendEvents, p_vout );
    var_AddCallback( p_sys->p_vout, "mouse-clicked", SendEvents, p_vout );
241
    var_AddCallback( p_sys->p_vout, "mouse-button-down", SendEvents, p_vout );
242

243 244 245 246 247 248 249 250 251
    return VLC_SUCCESS;
}

/*****************************************************************************
 * Init: initialize the OpenGL video thread output method
 *****************************************************************************/
static int Init( vout_thread_t *p_vout )
{
    vout_sys_t *p_sys = p_vout->p_sys;
Eric Petit's avatar
Eric Petit committed
252
    int i_pixel_pitch;
253
    vlc_value_t val;
254

255 256
    p_sys->p_vout->pf_init( p_sys->p_vout );

257 258 259 260 261 262 263
#ifdef SYS_DARWIN
    p_vout->output.i_chroma = VLC_FOURCC('Y','U','Y','2');
    p_vout->output.i_rmask = 0x00ff0000;
    p_vout->output.i_gmask = 0x0000ff00;
    p_vout->output.i_bmask = 0x000000ff;
    i_pixel_pitch = 2;
#else
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
#if VLCGL_RGB_FORMAT == GL_RGB
#   if VLCGL_RGB_TYPE == GL_UNSIGNED_BYTE
    p_vout->output.i_chroma = VLC_FOURCC('R','V','2','4');
    p_vout->output.i_rmask = 0x000000ff;
    p_vout->output.i_gmask = 0x0000ff00;
    p_vout->output.i_bmask = 0x00ff0000;
    i_pixel_pitch = 3;
#   else
    p_vout->output.i_chroma = VLC_FOURCC('R','V','1','6');
    p_vout->output.i_rmask = 0xf800;
    p_vout->output.i_gmask = 0x07e0;
    p_vout->output.i_bmask = 0x001f;
    i_pixel_pitch = 2;
#   endif
#else
    p_vout->output.i_chroma = VLC_FOURCC('R','V','3','2');
    p_vout->output.i_rmask = 0x000000ff;
    p_vout->output.i_gmask = 0x0000ff00;
    p_vout->output.i_bmask = 0x00ff0000;
    i_pixel_pitch = 4;
284
#endif
285 286 287 288 289 290 291 292
#endif

    /* Since OpenGL can do rescaling for us, stick to the default
     * coordinates and aspect. */
    p_vout->output.i_width  = p_vout->render.i_width;
    p_vout->output.i_height = p_vout->render.i_height;
    p_vout->output.i_aspect = p_vout->render.i_aspect;

293
    /* We know the chroma, allocate one buffer which will be used
294
     * directly by the decoder */
295 296 297 298 299 300 301 302
    p_sys->pp_buffer[0] =
        malloc( p_sys->i_tex_width * p_sys->i_tex_height * i_pixel_pitch );
    if( !p_sys->pp_buffer[0] )
    {
        msg_Err( p_vout, "Out of memory" );
        return -1;
    }
    p_sys->pp_buffer[1] =
303
        malloc( p_sys->i_tex_width * p_sys->i_tex_height * i_pixel_pitch );
304
    if( !p_sys->pp_buffer[1] )
305 306 307 308 309
    {
        msg_Err( p_vout, "Out of memory" );
        return -1;
    }

310 311
    p_vout->p_picture[0].i_planes = 1;
    p_vout->p_picture[0].p->p_pixels = p_sys->pp_buffer[0];
312
    p_vout->p_picture[0].p->i_lines = p_vout->output.i_height;
313
    p_vout->p_picture[0].p->i_visible_lines = p_vout->output.i_height;
314
    p_vout->p_picture[0].p->i_pixel_pitch = i_pixel_pitch;
315
    p_vout->p_picture[0].p->i_pitch = p_vout->output.i_width *
316 317 318 319 320 321 322 323
        p_vout->p_picture[0].p->i_pixel_pitch;
    p_vout->p_picture[0].p->i_visible_pitch = p_vout->output.i_width *
        p_vout->p_picture[0].p->i_pixel_pitch;

    p_vout->p_picture[0].i_status = DESTROYED_PICTURE;
    p_vout->p_picture[0].i_type   = DIRECT_PICTURE;

    PP_OUTPUTPICTURE[ 0 ] = &p_vout->p_picture[0];
324

325
    I_OUTPUTPICTURES = 1;
326

327 328 329 330 331 332 333
    if( p_sys->p_vout->pf_lock &&
        p_sys->p_vout->pf_lock( p_sys->p_vout ) )
    {
        msg_Warn( p_vout, "could not lock OpenGL provider" );
        return 0;
    }

Eric Petit's avatar
Eric Petit committed
334
    InitTextures( p_vout );
335

336 337 338 339 340 341
    glDisable(GL_BLEND);
    glDisable(GL_DEPTH_TEST);
    glDepthMask(GL_FALSE);
    glDisable(GL_CULL_FACE);
    glClear( GL_COLOR_BUFFER_BIT );

342 343 344 345 346 347 348
    /* Check if the user asked for useless visual effects */
    var_Get( p_vout, "opengl-effect", &val );
    if( !val.psz_string || !strcmp( val.psz_string, "none" ))
    {
        p_sys->i_effect = OPENGL_EFFECT_NONE;
    }
    else if( !strcmp( val.psz_string, "cube" ) )
349
    {
350 351
        p_sys->i_effect = OPENGL_EFFECT_CUBE;

352
        glEnable( GL_CULL_FACE);
353 354 355 356 357
        //glEnable( GL_DEPTH_TEST );
    }
    else if( !strcmp( val.psz_string, "transparent-cube" ) )
    {
        p_sys->i_effect = OPENGL_EFFECT_TRANSPARENT_CUBE;
358

359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
        glDisable( GL_DEPTH_TEST );
        glEnable( GL_BLEND );
        glBlendFunc( GL_SRC_ALPHA, GL_ONE );
    }
    else
    {
        msg_Warn( p_vout, "no valid opengl effect provided, using "
                  "\"none\"" );
        p_sys->i_effect = OPENGL_EFFECT_NONE;
    }
    if( val.psz_string ) free( val.psz_string );

    if( p_sys->i_effect & ( OPENGL_EFFECT_CUBE |
                OPENGL_EFFECT_TRANSPARENT_CUBE ) )
    {
374 375 376 377 378 379 380 381 382
        /* Set the perpective */
        glMatrixMode( GL_PROJECTION );
        glLoadIdentity();
        glFrustum( -1.0, 1.0, -1.0, 1.0, 3.0, 20.0 );
        glMatrixMode( GL_MODELVIEW );
        glLoadIdentity();
        glTranslatef( 0.0, 0.0, - 5.0 );
    }

383 384 385 386 387
    if( p_sys->p_vout->pf_unlock )
    {
        p_sys->p_vout->pf_unlock( p_sys->p_vout );
    }

388 389 390 391 392 393 394 395
    return 0;
}

/*****************************************************************************
 * End: terminate GLX video thread output method
 *****************************************************************************/
static void End( vout_thread_t *p_vout )
{
396 397 398 399 400 401 402 403 404
    vout_sys_t *p_sys = p_vout->p_sys;

    if( p_sys->p_vout->pf_lock &&
        p_sys->p_vout->pf_lock( p_sys->p_vout ) )
    {
        msg_Warn( p_vout, "could not lock OpenGL provider" );
        return;
    }

405 406
    glFinish();
    glFlush();
407 408 409 410 411

    if( p_sys->p_vout->pf_unlock )
    {
        p_sys->p_vout->pf_unlock( p_sys->p_vout );
    }
412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428
}

/*****************************************************************************
 * Destroy: destroy GLX video thread output method
 *****************************************************************************
 * Terminate an output method created by CreateVout
 *****************************************************************************/
static void DestroyVout( vlc_object_t *p_this )
{
    vout_thread_t *p_vout = (vout_thread_t *)p_this;
    vout_sys_t *p_sys = p_vout->p_sys;

    module_Unneed( p_sys->p_vout, p_sys->p_vout->p_module );
    vlc_object_detach( p_sys->p_vout );
    vlc_object_destroy( p_sys->p_vout );

    /* Free the texture buffer*/
429 430
    if( p_sys->pp_buffer[0] ) free( p_sys->pp_buffer[0] );
    if( p_sys->pp_buffer[1] ) free( p_sys->pp_buffer[1] );
431 432 433 434

    free( p_sys );
}

435 436 437 438
/*****************************************************************************
 * Manage: handle Sys events
 *****************************************************************************
 * This function should be called regularly by video output thread. It returns
Sam Hocevar's avatar
Sam Hocevar committed
439
 * a non null value if an error occurred.
440 441 442 443
 *****************************************************************************/
static int Manage( vout_thread_t *p_vout )
{
    vout_sys_t *p_sys = p_vout->p_sys;
Eric Petit's avatar
Eric Petit committed
444 445 446 447 448 449 450 451 452
    int i_ret, i_fullscreen_change;

    i_fullscreen_change = ( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE );

    p_sys->p_vout->i_changes = p_vout->i_changes;
    i_ret = p_sys->p_vout->pf_manage( p_sys->p_vout );
    p_vout->i_changes = p_sys->p_vout->i_changes;

#ifdef SYS_DARWIN
453 454 455 456 457 458 459
    if( p_sys->p_vout->pf_lock &&
        p_sys->p_vout->pf_lock( p_sys->p_vout ) )
    {
        msg_Warn( p_vout, "could not lock OpenGL provider" );
        return i_ret;
    }

Eric Petit's avatar
Eric Petit committed
460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
    /* On OS X, we create the window and the GL view when entering
       fullscreen - the textures have to be inited again */
    if( i_fullscreen_change )
    {
        InitTextures( p_vout );

        switch( p_sys->i_effect )
        {
            case OPENGL_EFFECT_CUBE:
                glEnable( GL_CULL_FACE );
                break;

            case OPENGL_EFFECT_TRANSPARENT_CUBE:
                glDisable( GL_DEPTH_TEST );
                glEnable( GL_BLEND );
                glBlendFunc( GL_SRC_ALPHA, GL_ONE );
                break;
        }

        if( p_sys->i_effect & ( OPENGL_EFFECT_CUBE |
                    OPENGL_EFFECT_TRANSPARENT_CUBE ) )
        {
            /* Set the perpective */
            glMatrixMode( GL_PROJECTION );
            glLoadIdentity();
            glFrustum( -1.0, 1.0, -1.0, 1.0, 3.0, 20.0 );
            glMatrixMode( GL_MODELVIEW );
            glLoadIdentity();
            glTranslatef( 0.0, 0.0, - 5.0 );
        }
    }
491 492 493 494 495

    if( p_sys->p_vout->pf_unlock )
    {
        p_sys->p_vout->pf_unlock( p_sys->p_vout );
    }
Eric Petit's avatar
Eric Petit committed
496 497 498
#endif

    return i_ret;
499 500
}

501 502 503 504 505 506
/*****************************************************************************
 * Render: render previously calculated output
 *****************************************************************************/
static void Render( vout_thread_t *p_vout, picture_t *p_pic )
{
    vout_sys_t *p_sys = p_vout->p_sys;
507

508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524
    /* On Win32/GLX, we do this the usual way:
       + Fill the buffer with new content,
       + Reload the texture,
       + Use the texture.

       On OS X with VRAM or AGP texturing, the order has to be:
       + Reload the texture,
       + Fill the buffer with new content,
       + Use the texture.

       (Thanks to gcc from the Arstechnica forums for the tip)

       Therefore, we have to use two buffers and textures. On Win32/GLX,
       we reload the texture to be displayed and use it right away. On
       OS X, we first render, then reload the texture to be used next
       time. */

525 526 527 528 529 530 531
    if( p_sys->p_vout->pf_lock &&
        p_sys->p_vout->pf_lock( p_sys->p_vout ) )
    {
        msg_Warn( p_vout, "could not lock OpenGL provider" );
        return;
    }

532
#ifdef SYS_DARWIN
533 534 535
    int i_new_index;
    i_new_index = ( p_sys->i_index + 1 ) & 1;

536

537 538 539 540 541 542 543
    /* Update the texture */
    glBindTexture( VLCGL_TARGET, p_sys->p_textures[i_new_index] );
    glTexSubImage2D( VLCGL_TARGET, 0, 0, 0, p_sys->i_tex_width,
                     p_sys->i_tex_height, VLCGL_FORMAT, VLCGL_TYPE,
                     p_sys->pp_buffer[i_new_index] );

    /* Bind to the previous texture for drawing */
544 545
    glBindTexture( VLCGL_TARGET, p_sys->p_textures[p_sys->i_index] );

546 547 548 549 550
    /* Switch buffers */
    p_sys->i_index = i_new_index;
    p_pic->p->p_pixels = p_sys->pp_buffer[p_sys->i_index];

#else
551 552 553
    /* Update the texture */
    glTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0,
                     p_vout->render.i_width, p_vout->render.i_height,
554
                     VLCGL_RGB_FORMAT, VLCGL_RGB_TYPE, p_sys->pp_buffer[0] );
555
#endif
556 557 558 559 560

    if( p_sys->p_vout->pf_unlock )
    {
        p_sys->p_vout->pf_unlock( p_sys->p_vout );
    }
561 562 563 564 565 566 567 568 569 570
}

/*****************************************************************************
 * DisplayVideo: displays previously rendered output
 *****************************************************************************/
static void DisplayVideo( vout_thread_t *p_vout, picture_t *p_pic )
{
    vout_sys_t *p_sys = p_vout->p_sys;
    float f_width, f_height;

571 572 573 574 575 576 577
    if( p_sys->p_vout->pf_lock &&
        p_sys->p_vout->pf_lock( p_sys->p_vout ) )
    {
        msg_Warn( p_vout, "could not lock OpenGL provider" );
        return;
    }

578 579 580 581 582 583 584 585 586 587 588 589 590 591 592
    /* glTexCoord works differently with GL_TEXTURE_2D and
       GL_TEXTURE_RECTANGLE_EXT */
#ifdef SYS_DARWIN
    f_width = (float)p_vout->output.i_width;
    f_height = (float)p_vout->output.i_height;
#else
    f_width = (float)p_vout->output.i_width / p_sys->i_tex_width;
    f_height = (float)p_vout->output.i_height / p_sys->i_tex_height;
#endif

    /* Why drawing here and not in Render()? Because this way, the
       OpenGL providers can call pf_display to force redraw. Currently,
       the OS X provider uses it to get a smooth window resizing */

    glClear( GL_COLOR_BUFFER_BIT );
593

594
    if( p_sys->i_effect == OPENGL_EFFECT_NONE )
595
    {
596
        glEnable( VLCGL_TARGET );
597
        glBegin( GL_POLYGON );
hartman's avatar
hartman committed
598 599 600 601
        glTexCoord2f( 0.0, 0.0 ); glVertex2f( -1.0, 1.0 );
        glTexCoord2f( f_width, 0.0 ); glVertex2f( 1.0, 1.0 );
        glTexCoord2f( f_width, f_height ); glVertex2f( 1.0, -1.0 );
        glTexCoord2f( 0.0, f_height ); glVertex2f( -1.0, -1.0 );
602 603 604 605
        glEnd();
    }
    else
    {
zorglub's avatar
zorglub committed
606
        glRotatef( 0.5 * p_sys->f_speed , 0.3, 0.5, 0.7 );
607

608
        glEnable( VLCGL_TARGET );
609 610 611
        glBegin( GL_QUADS );

        /* Front */
hartman's avatar
hartman committed
612 613 614 615
        glTexCoord2f( 0, 0 ); glVertex3f( - 1.0, 1.0, 1.0 );
        glTexCoord2f( 0, f_height ); glVertex3f( - 1.0, - 1.0, 1.0 );
        glTexCoord2f( f_width, f_height ); glVertex3f( 1.0, - 1.0, 1.0 );
        glTexCoord2f( f_width, 0 ); glVertex3f( 1.0, 1.0, 1.0 );
616 617

        /* Left */
hartman's avatar
hartman committed
618 619 620 621
        glTexCoord2f( 0, 0 ); glVertex3f( - 1.0, 1.0, - 1.0 );
        glTexCoord2f( 0, f_height ); glVertex3f( - 1.0, - 1.0, - 1.0 );
        glTexCoord2f( f_width, f_height ); glVertex3f( - 1.0, - 1.0, 1.0 );
        glTexCoord2f( f_width, 0 ); glVertex3f( - 1.0, 1.0, 1.0 );
622 623

        /* Back */
hartman's avatar
hartman committed
624 625 626 627
        glTexCoord2f( 0, 0 ); glVertex3f( 1.0, 1.0, - 1.0 );
        glTexCoord2f( 0, f_height ); glVertex3f( 1.0, - 1.0, - 1.0 );
        glTexCoord2f( f_width, f_height ); glVertex3f( - 1.0, - 1.0, - 1.0 );
        glTexCoord2f( f_width, 0 ); glVertex3f( - 1.0, 1.0, - 1.0 );
628 629

        /* Right */
hartman's avatar
hartman committed
630 631 632 633
        glTexCoord2f( 0, 0 ); glVertex3f( 1.0, 1.0, 1.0 );
        glTexCoord2f( 0, f_height ); glVertex3f( 1.0, - 1.0, 1.0 );
        glTexCoord2f( f_width, f_height ); glVertex3f( 1.0, - 1.0, - 1.0 );
        glTexCoord2f( f_width, 0 ); glVertex3f( 1.0, 1.0, - 1.0 );
634 635

        /* Top */
hartman's avatar
hartman committed
636 637 638 639 640 641 642 643 644 645
        glTexCoord2f( 0, 0 ); glVertex3f( - 1.0, 1.0, - 1.0 );
        glTexCoord2f( 0, f_height ); glVertex3f( - 1.0, 1.0, 1.0 );
        glTexCoord2f( f_width, f_height ); glVertex3f( 1.0, 1.0, 1.0 );
        glTexCoord2f( f_width, 0 ); glVertex3f( 1.0, 1.0, - 1.0 );

        /* Bottom */
        glTexCoord2f( 0, 0 ); glVertex3f( - 1.0, - 1.0, 1.0 );
        glTexCoord2f( 0, f_height ); glVertex3f( - 1.0, - 1.0, - 1.0 );
        glTexCoord2f( f_width, f_height ); glVertex3f( 1.0, - 1.0, - 1.0 );
        glTexCoord2f( f_width, 0 ); glVertex3f( 1.0, - 1.0, 1.0 );
646 647 648
        glEnd();
    }

649 650
    glDisable( VLCGL_TARGET );

651
    p_sys->p_vout->pf_swap( p_sys->p_vout );
652 653 654 655 656

    if( p_sys->p_vout->pf_unlock )
    {
        p_sys->p_vout->pf_unlock( p_sys->p_vout );
    }
657 658 659 660 661 662 663 664 665 666 667 668
}

int GetAlignedSize( int i_size )
{
    /* Return the nearest power of 2 */
    int i_result = 1;
    while( i_result < i_size )
    {
        i_result *= 2;
    }
    return i_result;
}
669 670 671 672 673 674 675 676

/*****************************************************************************
 * Control: control facility for the vout
 *****************************************************************************/
static int Control( vout_thread_t *p_vout, int i_query, va_list args )
{
    vout_sys_t *p_sys = p_vout->p_sys;

677 678 679
    switch( i_query )
    {
    case VOUT_SNAPSHOT:
680
        return vout_vaControlDefault( p_vout, i_query, args );
681 682 683 684 685 686 687

    default:
        if( p_sys->p_vout->pf_control )
            return p_sys->p_vout->pf_control( p_sys->p_vout, i_query, args );
        else
            return vout_vaControlDefault( p_vout, i_query, args );
    }
688
}
689

Eric Petit's avatar
Eric Petit committed
690 691 692 693 694 695 696 697 698 699 700 701 702 703 704
static int InitTextures( vout_thread_t *p_vout )
{
    vout_sys_t *p_sys = p_vout->p_sys;
    int i_index;

    glDeleteTextures( 2, p_sys->p_textures );
    glGenTextures( 2, p_sys->p_textures );

    for( i_index = 0; i_index < 2; i_index++ )
    {
        glBindTexture( VLCGL_TARGET, p_sys->p_textures[i_index] );
    
        /* Set the texture parameters */
        glTexParameterf( VLCGL_TARGET, GL_TEXTURE_PRIORITY, 1.0 );
    
705 706
        glTexParameteri( VLCGL_TARGET, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
        glTexParameteri( VLCGL_TARGET, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
707 708 709 710
        
        glTexParameteri( VLCGL_TARGET, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
        glTexParameteri( VLCGL_TARGET, GL_TEXTURE_MIN_FILTER, GL_LINEAR );

Eric Petit's avatar
Eric Petit committed
711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738
        glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );

#ifdef SYS_DARWIN
        /* Tell the driver not to make a copy of the texture but to use
           our buffer */
        glEnable( GL_UNPACK_CLIENT_STORAGE_APPLE );
        glPixelStorei( GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE );
    
#if 0
        /* Use VRAM texturing */
        glTexParameteri( VLCGL_TARGET, GL_TEXTURE_STORAGE_HINT_APPLE,
                         GL_STORAGE_CACHED_APPLE );
#else
        /* Use AGP texturing */
        glTexParameteri( VLCGL_TARGET, GL_TEXTURE_STORAGE_HINT_APPLE,
                         GL_STORAGE_SHARED_APPLE );
#endif
#endif

        /* Call glTexImage2D only once, and use glTexSubImage2D later */
        glTexImage2D( VLCGL_TARGET, 0, 3, p_sys->i_tex_width,
                      p_sys->i_tex_height, 0, VLCGL_FORMAT, VLCGL_TYPE,
                      p_sys->pp_buffer[i_index] );
    }

    return 0;
}

739 740 741 742 743 744 745 746
/*****************************************************************************
 * SendEvents: forward mouse and keyboard events to the parent p_vout
 *****************************************************************************/
static int SendEvents( vlc_object_t *p_this, char const *psz_var,
                       vlc_value_t oldval, vlc_value_t newval, void *_p_vout )
{
    return var_Set( (vlc_object_t *)_p_vout, psz_var, newval );
}