video_output/opengl.c:
[vlc.git] / 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 #include <errno.h>                                                 /* ENOMEM */
31
32 #ifdef HAVE_CONFIG_H
33 # include "config.h"
34 #endif
35
36 #include <vlc/vlc.h>
37 #include <vlc_vout.h>
38
39 #ifdef __APPLE__
40 #include <OpenGL/gl.h>
41 #include <OpenGL/glext.h>
42
43 /* On OS X, use GL_TEXTURE_RECTANGLE_EXT instead of GL_TEXTURE_2D.
44    This allows sizes which are not powers of 2 */
45 #define VLCGL_TARGET GL_TEXTURE_RECTANGLE_EXT
46
47 /* OS X OpenGL supports YUV. Hehe. */
48 #define VLCGL_FORMAT GL_YCBCR_422_APPLE
49 #define VLCGL_TYPE   GL_UNSIGNED_SHORT_8_8_APPLE
50 #else
51
52 #include <GL/gl.h>
53 #define VLCGL_TARGET GL_TEXTURE_2D
54
55 /* RV16 */
56 #ifndef GL_UNSIGNED_SHORT_5_6_5
57 #define GL_UNSIGNED_SHORT_5_6_5 0x8363
58 #endif
59 //#define VLCGL_RGB_FORMAT GL_RGB
60 //#define VLCGL_RGB_TYPE GL_UNSIGNED_SHORT_5_6_5
61
62 /* RV24 */
63 //#define VLCGL_RGB_FORMAT GL_RGB
64 //#define VLCGL_RGB_TYPE GL_UNSIGNED_BYTE
65
66 /* RV32 */
67 #define VLCGL_RGB_FORMAT GL_RGBA
68 #define VLCGL_RGB_TYPE GL_UNSIGNED_BYTE
69
70 /* YUY2 */
71 #ifndef YCBCR_MESA
72 #define YCBCR_MESA 0x8757
73 #endif
74 #ifndef UNSIGNED_SHORT_8_8_MESA
75 #define UNSIGNED_SHORT_8_8_MESA 0x85BA
76 #endif
77 #define VLCGL_YUV_FORMAT YCBCR_MESA
78 #define VLCGL_YUV_TYPE UNSIGNED_SHORT_8_8_MESA
79
80 /* Use RGB on Win32/GLX */
81 #define VLCGL_FORMAT VLCGL_RGB_FORMAT
82 #define VLCGL_TYPE   VLCGL_RGB_TYPE
83 //#define VLCGL_FORMAT VLCGL_YUV_FORMAT
84 //#define VLCGL_TYPE   VLCGL_YUV_TYPE
85 #endif
86
87 #ifndef GL_CLAMP_TO_EDGE
88 #   define GL_CLAMP_TO_EDGE 0x812F
89 #endif
90
91 /* OpenGL effects */
92 #define OPENGL_EFFECT_NONE             1
93 #define OPENGL_EFFECT_CUBE             2
94 #define OPENGL_EFFECT_TRANSPARENT_CUBE 4
95 #if defined( HAVE_GL_GLU_H ) || defined( __APPLE__ )
96     #define OPENGL_MORE_EFFECT           8
97 #endif
98
99 #ifdef OPENGL_MORE_EFFECT
100     #include <math.h>
101     #ifdef __APPLE__
102         #include <OpenGL/glu.h>
103     #else
104         #include <GL/glu.h>
105     #endif
106 /* 3D MODEL */
107     #define CYLINDER 8
108     #define TORUS     16
109     #define SPHERE   32
110 /*GRID2D TRANSFORMATION */
111     #define SQUAREXY 64
112     #define SQUARER  128
113     #define ASINXY   256
114     #define ASINR    512
115     #define SINEXY   1024
116     #define SINER    2048
117     #define INIFILE     4096                    // not used, just for mark end ...
118     #define SIGN(x)     (x < 0 ? (-1) : 1)
119     #define PID2     1.570796326794896619231322
120
121     static const char *ppsz_effects[] = {
122             "none", "cube", "transparent-cube", "cylinder", "torus", "sphere","SQUAREXY","SQUARER", "ASINXY", "ASINR", "SINEXY", "SINER" };
123     static const char *ppsz_effects_text[] = {
124             N_("None"), N_("Cube"), N_("Transparent Cube"),
125             N_("Cylinder"), N_("Torus"), N_("Sphere"), N_("SQUAREXY"),N_("SQUARER"), N_("ASINXY"), N_("ASINR"), N_("SINEXY"), N_("SINER") };
126 #endif
127
128 /*****************************************************************************
129  * Vout interface
130  *****************************************************************************/
131 static int  CreateVout   ( vlc_object_t * );
132 static void DestroyVout  ( vlc_object_t * );
133 static int  Init         ( vout_thread_t * );
134 static void End          ( vout_thread_t * );
135 static int  Manage       ( vout_thread_t * );
136 static void Render       ( vout_thread_t *, picture_t * );
137 static void DisplayVideo ( vout_thread_t *, picture_t * );
138 static int  Control      ( vout_thread_t *, int, va_list );
139
140 static inline int GetAlignedSize( int );
141
142 static int InitTextures  ( vout_thread_t * );
143 static int SendEvents    ( vlc_object_t *, char const *,
144                            vlc_value_t, vlc_value_t, void * );
145
146 #ifdef OPENGL_MORE_EFFECT
147 static float Z_Compute   ( float, int, float, float );
148 static void Transform    ( int, float, float, int, int, int, int, double *, double * );
149
150 /*****************************************************************************
151  * Module descriptor
152  *****************************************************************************/
153 #define ACCURACY_TEXT N_( "OpenGL sampling accuracy " )
154 #define ACCURACY_LONGTEXT N_( "Select the accuracy of 3D object sampling(1 = min and 10 = max)" )
155 #define RADIUS_TEXT N_( "OpenGL Cylinder radius" )
156 #define RADIUS_LONGTEXT N_( "Radius of the OpenGL cylinder effect, if enabled" )
157 #define POV_X_TEXT N_("Point of view x-coordinate")
158 #define POV_X_LONGTEXT N_("Point of view (X coordinate) of the cube/cylinder "\
159                            "effect, if enabled.")
160 #define POV_Y_TEXT N_("Point of view y-coordinate")
161 #define POV_Y_LONGTEXT N_("Point of view (Y coordinate) of the cube/cylinder "\
162                            "effect, if enabled.")
163 #define POV_Z_TEXT N_("Point of view z-coordinate")
164 #define POV_Z_LONGTEXT N_("Point of view (Z coordinate) of the cube/cylinder "\
165                            "effect, if enabled.")
166 #endif
167 #define PROVIDER_TEXT N_("OpenGL Provider")
168 #define PROVIDER_LONGTEXT N_("Allows you to modify what OpenGL provider should be used")
169 #define SPEED_TEXT N_( "OpenGL cube rotation speed" )
170 #define SPEED_LONGTEXT N_( "Rotation speed of the OpenGL cube effect, if " \
171         "enabled." )
172 #define EFFECT_TEXT N_("Effect")
173 #define EFFECT_LONGTEXT N_( \
174     "Several visual OpenGL effects are available." )
175
176 #ifndef OPENGL_MORE_EFFECT
177 static const char *ppsz_effects[] = {
178         "none", "cube", "transparent-cube" };
179 static const char *ppsz_effects_text[] = {
180         N_("None"), N_("Cube"), N_("Transparent Cube") };
181 #endif
182
183 vlc_module_begin();
184     set_shortname( "OpenGL" );
185     set_category( CAT_VIDEO );
186     set_subcategory( SUBCAT_VIDEO_VOUT );
187     set_description( _("OpenGL video output") );
188 #ifdef __APPLE__
189     set_capability( "video output", 200 );
190 #else
191     set_capability( "video output", 20 );
192 #endif
193     add_shortcut( "opengl" );
194     add_float( "opengl-cube-speed", 2.0, NULL, SPEED_TEXT,
195                     SPEED_LONGTEXT, VLC_TRUE );
196 #ifdef OPENGL_MORE_EFFECT
197     add_integer_with_range( "opengl-accuracy", 4, 1, 10, NULL, ACCURACY_TEXT,
198                     ACCURACY_LONGTEXT, VLC_TRUE );
199     add_float_with_range( "opengl-pov-x", 0.0, -1.0, 1.0, NULL, POV_X_TEXT,
200                     POV_X_LONGTEXT, VLC_TRUE );
201     add_float_with_range( "opengl-pov-y", 0.0, -1.0, 1.0, NULL, POV_Y_TEXT,
202                     POV_Y_LONGTEXT, VLC_TRUE );
203     add_float_with_range( "opengl-pov-z", -1.0, -1.0, 1.0, NULL, POV_Z_TEXT,
204                     POV_Z_LONGTEXT, VLC_TRUE );
205     add_float( "opengl-cylinder-radius", -100.0, NULL, RADIUS_TEXT,
206                     RADIUS_LONGTEXT, VLC_TRUE );
207
208 #endif
209     /* Allow opengl provider plugin selection */
210     add_string( "opengl-provider", "default", NULL, PROVIDER_TEXT, 
211                     PROVIDER_LONGTEXT, VLC_TRUE );
212     set_callbacks( CreateVout, DestroyVout );
213     add_string( "opengl-effect", "none", NULL, EFFECT_TEXT,
214                  EFFECT_LONGTEXT, VLC_FALSE );
215         change_string_list( ppsz_effects, ppsz_effects_text, 0 );
216 vlc_module_end();
217
218 /*****************************************************************************
219  * vout_sys_t: video output method descriptor
220  *****************************************************************************
221  * This structure is part of the video output thread descriptor.
222  * It describes the OpenGL specific properties of the output thread.
223  *****************************************************************************/
224 struct vout_sys_t
225 {
226     vout_thread_t *p_vout;
227
228     uint8_t    *pp_buffer[2];
229     int         i_index;
230     int         i_tex_width;
231     int         i_tex_height;
232     GLuint      p_textures[2];
233
234     int         i_effect;
235
236     float       f_speed;
237     float       f_radius;
238 };
239
240 /*****************************************************************************
241  * CreateVout: This function allocates and initializes the OpenGL vout method.
242  *****************************************************************************/
243 static int CreateVout( vlc_object_t *p_this )
244 {
245     vout_thread_t *p_vout = (vout_thread_t *)p_this;
246     vout_sys_t *p_sys;
247     char * psz;
248
249     /* Allocate structure */
250     p_vout->p_sys = p_sys = malloc( sizeof( vout_sys_t ) );
251     if( p_sys == NULL )
252     {
253         msg_Err( p_vout, "out of memory" );
254         return VLC_EGENERIC;
255     }
256
257     var_Create( p_vout, "opengl-effect", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
258
259     p_sys->i_index = 0;
260 #ifdef __APPLE__
261     p_sys->i_tex_width  = p_vout->fmt_in.i_width;
262     p_sys->i_tex_height = p_vout->fmt_in.i_height;
263 #else
264     /* A texture must have a size aligned on a power of 2 */
265     p_sys->i_tex_width  = GetAlignedSize( p_vout->fmt_in.i_width );
266     p_sys->i_tex_height = GetAlignedSize( p_vout->fmt_in.i_height );
267 #endif
268
269     msg_Dbg( p_vout, "Texture size: %dx%d", p_sys->i_tex_width,
270              p_sys->i_tex_height );
271
272     /* Get window */
273     p_sys->p_vout =
274         (vout_thread_t *)vlc_object_create( p_this, VLC_OBJECT_OPENGL );
275     if( p_sys->p_vout == NULL )
276     {
277         msg_Err( p_vout, "out of memory" );
278         return VLC_ENOMEM;
279     }
280     vlc_object_attach( p_sys->p_vout, p_this );
281
282     p_sys->p_vout->i_window_width = p_vout->i_window_width;
283     p_sys->p_vout->i_window_height = p_vout->i_window_height;
284     p_sys->p_vout->b_fullscreen = p_vout->b_fullscreen;
285     p_sys->p_vout->render.i_width = p_vout->render.i_width;
286     p_sys->p_vout->render.i_height = p_vout->render.i_height;
287     p_sys->p_vout->render.i_aspect = p_vout->render.i_aspect;
288     p_sys->p_vout->fmt_render = p_vout->fmt_render;
289     p_sys->p_vout->fmt_in = p_vout->fmt_in;
290     p_sys->p_vout->b_scale = p_vout->b_scale;
291     p_sys->p_vout->i_alignment = p_vout->i_alignment;
292
293     psz = config_GetPsz( p_vout, "opengl-provider" );
294
295     msg_Dbg( p_vout, "requesting \"%s\" opengl provider",
296                       psz ? psz : "default" );
297
298     p_sys->p_vout->p_module =
299         module_Need( p_sys->p_vout, "opengl provider", psz, 0 );
300     free( psz );
301     if( p_sys->p_vout->p_module == NULL )
302     {
303         msg_Warn( p_vout, "No OpenGL provider found" );
304         vlc_object_detach( p_sys->p_vout );
305         vlc_object_destroy( p_sys->p_vout );
306         return VLC_ENOOBJ;
307     }
308
309     p_sys->f_speed = var_CreateGetFloat( p_vout, "opengl-cube-speed" );
310     p_sys->f_radius = var_CreateGetFloat( p_vout, "opengl-cylinder-radius" );
311
312     p_vout->pf_init = Init;
313     p_vout->pf_end = End;
314     p_vout->pf_manage = Manage;
315     p_vout->pf_render = Render;
316     p_vout->pf_display = DisplayVideo;
317     p_vout->pf_control = Control;
318
319     /* Forward events from the opengl provider */
320     var_Create( p_sys->p_vout, "mouse-x", VLC_VAR_INTEGER );
321     var_Create( p_sys->p_vout, "mouse-y", VLC_VAR_INTEGER );
322     var_Create( p_sys->p_vout, "mouse-moved", VLC_VAR_BOOL );
323     var_Create( p_sys->p_vout, "mouse-clicked", VLC_VAR_INTEGER );
324     var_Create( p_sys->p_vout, "mouse-button-down", VLC_VAR_INTEGER );
325     var_Create( p_sys->p_vout, "video-on-top",
326                 VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
327
328     var_AddCallback( p_sys->p_vout, "mouse-x", SendEvents, p_vout );
329     var_AddCallback( p_sys->p_vout, "mouse-y", SendEvents, p_vout );
330     var_AddCallback( p_sys->p_vout, "mouse-moved", SendEvents, p_vout );
331     var_AddCallback( p_sys->p_vout, "mouse-clicked", SendEvents, p_vout );
332     var_AddCallback( p_sys->p_vout, "mouse-button-down", SendEvents, p_vout );
333
334     return VLC_SUCCESS;
335 }
336
337 /*****************************************************************************
338  * Init: initialize the OpenGL video thread output method
339  *****************************************************************************/
340 static int Init( vout_thread_t *p_vout )
341 {
342     vout_sys_t *p_sys = p_vout->p_sys;
343     int i_pixel_pitch;
344     vlc_value_t val;
345
346     p_sys->p_vout->pf_init( p_sys->p_vout );
347
348 /* TODO: We use YCbCr on Mac which is Y422, but on OSX it seems to == YUY2. Verify */
349 #if ( defined( WORDS_BIGENDIAN ) && VLCGL_FORMAT == GL_YCBCR_422_APPLE ) || (VLCGL_FORMAT == YCBCR_MESA)
350     p_vout->output.i_chroma = VLC_FOURCC('Y','U','Y','2');
351     i_pixel_pitch = 2;
352
353 #elif (VLCGL_FORMAT == GL_YCBCR_422_APPLE)
354     p_vout->output.i_chroma = VLC_FOURCC('U','Y','V','Y');
355     i_pixel_pitch = 2;
356
357 #elif VLCGL_FORMAT == GL_RGB
358 #   if VLCGL_TYPE == GL_UNSIGNED_BYTE
359     p_vout->output.i_chroma = VLC_FOURCC('R','V','2','4');
360 #       if defined( WORDS_BIGENDIAN )
361     p_vout->output.i_rmask = 0x00ff0000;
362     p_vout->output.i_gmask = 0x0000ff00;
363     p_vout->output.i_bmask = 0x000000ff;
364 #       else
365     p_vout->output.i_rmask = 0x000000ff;
366     p_vout->output.i_gmask = 0x0000ff00;
367     p_vout->output.i_bmask = 0x00ff0000;
368 #       endif
369     i_pixel_pitch = 3;
370 #   else
371     p_vout->output.i_chroma = VLC_FOURCC('R','V','1','6');
372 #       if defined( WORDS_BIGENDIAN )
373     p_vout->output.i_rmask = 0x001f;
374     p_vout->output.i_gmask = 0x07e0;
375     p_vout->output.i_bmask = 0xf800;
376 #       else
377     p_vout->output.i_rmask = 0xf800;
378     p_vout->output.i_gmask = 0x07e0;
379     p_vout->output.i_bmask = 0x001f;
380 #       endif
381     i_pixel_pitch = 2;
382 #   endif
383 #else
384     p_vout->output.i_chroma = VLC_FOURCC('R','V','3','2');
385 #       if defined( WORDS_BIGENDIAN )
386     p_vout->output.i_rmask = 0xff000000;
387     p_vout->output.i_gmask = 0x00ff0000;
388     p_vout->output.i_bmask = 0x0000ff00;
389 #       else
390     p_vout->output.i_rmask = 0x000000ff;
391     p_vout->output.i_gmask = 0x0000ff00;
392     p_vout->output.i_bmask = 0x00ff0000;
393 #       endif
394     i_pixel_pitch = 4;
395 #endif
396
397     /* Since OpenGL can do rescaling for us, stick to the default
398      * coordinates and aspect. */
399     p_vout->output.i_width  = p_vout->render.i_width;
400     p_vout->output.i_height = p_vout->render.i_height;
401     p_vout->output.i_aspect = p_vout->render.i_aspect;
402
403     p_vout->fmt_out = p_vout->fmt_in;
404     p_vout->fmt_out.i_chroma = p_vout->output.i_chroma;
405
406     /* We know the chroma, allocate one buffer which will be used
407      * directly by the decoder */
408     p_sys->pp_buffer[0] =
409         malloc( p_sys->i_tex_width * p_sys->i_tex_height * i_pixel_pitch );
410     if( !p_sys->pp_buffer[0] )
411     {
412         msg_Err( p_vout, "out of memory" );
413         return -1;
414     }
415     p_sys->pp_buffer[1] =
416         malloc( p_sys->i_tex_width * p_sys->i_tex_height * i_pixel_pitch );
417     if( !p_sys->pp_buffer[1] )
418     {
419         msg_Err( p_vout, "out of memory" );
420         return -1;
421     }
422
423     p_vout->p_picture[0].i_planes = 1;
424     p_vout->p_picture[0].p->p_pixels = p_sys->pp_buffer[0];
425     p_vout->p_picture[0].p->i_lines = p_vout->output.i_height;
426     p_vout->p_picture[0].p->i_visible_lines = p_vout->output.i_height;
427     p_vout->p_picture[0].p->i_pixel_pitch = i_pixel_pitch;
428     p_vout->p_picture[0].p->i_pitch = p_vout->output.i_width *
429         p_vout->p_picture[0].p->i_pixel_pitch;
430     p_vout->p_picture[0].p->i_visible_pitch = p_vout->output.i_width *
431         p_vout->p_picture[0].p->i_pixel_pitch;
432
433     p_vout->p_picture[0].i_status = DESTROYED_PICTURE;
434     p_vout->p_picture[0].i_type   = DIRECT_PICTURE;
435
436     PP_OUTPUTPICTURE[ 0 ] = &p_vout->p_picture[0];
437
438     I_OUTPUTPICTURES = 1;
439
440     if( p_sys->p_vout->pf_lock &&
441         p_sys->p_vout->pf_lock( p_sys->p_vout ) )
442     {
443         msg_Warn( p_vout, "could not lock OpenGL provider" );
444         return 0;
445     }
446
447     InitTextures( p_vout );
448
449     glDisable(GL_BLEND);
450     glDisable(GL_DEPTH_TEST);
451     glDepthMask(GL_FALSE);
452     glDisable(GL_CULL_FACE);
453     glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
454     glClear( GL_COLOR_BUFFER_BIT );
455
456     /* Check if the user asked for useless visual effects */
457     var_Get( p_vout, "opengl-effect", &val );
458     if( !val.psz_string || !strcmp( val.psz_string, "none" ))
459     {
460         p_sys->i_effect = OPENGL_EFFECT_NONE;
461     }
462     else if( !strcmp( val.psz_string, "cube" ) )
463     {
464         p_sys->i_effect = OPENGL_EFFECT_CUBE;
465
466         glEnable( GL_CULL_FACE);
467     }
468     else if( !strcmp( val.psz_string, "transparent-cube" ) )
469     {
470         p_sys->i_effect = OPENGL_EFFECT_TRANSPARENT_CUBE;
471
472         glDisable( GL_DEPTH_TEST );
473         glEnable( GL_BLEND );
474         glBlendFunc( GL_SRC_ALPHA, GL_ONE );
475     }
476     else
477     {
478 #ifdef OPENGL_MORE_EFFECT
479         p_sys->i_effect = 3;
480         while (( strcmp( val.psz_string, ppsz_effects[p_sys->i_effect]) ) && (pow(2,p_sys->i_effect) < INIFILE))
481         {
482             p_sys->i_effect ++;
483         }
484         if (pow(2,p_sys->i_effect) < INIFILE)
485             p_sys->i_effect = pow(2,p_sys->i_effect);
486         else if ( strcmp( val.psz_string, ppsz_effects[p_sys->i_effect]))
487         {
488             msg_Warn( p_vout, "no valid opengl effect provided, using "
489                       "\"none\"" );
490             p_sys->i_effect = OPENGL_EFFECT_NONE;
491         }
492 #else
493         msg_Warn( p_vout, "no valid opengl effect provided, using "
494                   "\"none\"" );
495         p_sys->i_effect = OPENGL_EFFECT_NONE;
496 #endif
497     }
498     if( val.psz_string ) free( val.psz_string );
499
500     if( p_sys->i_effect & ( OPENGL_EFFECT_CUBE |
501                 OPENGL_EFFECT_TRANSPARENT_CUBE ) )
502     {
503         /* Set the perpective */
504         glMatrixMode( GL_PROJECTION );
505         glLoadIdentity();
506         glFrustum( -1.0, 1.0, -1.0, 1.0, 3.0, 20.0 );
507         glMatrixMode( GL_MODELVIEW );
508         glLoadIdentity();
509         glTranslatef( 0.0, 0.0, - 5.0 );
510     }
511 #ifdef OPENGL_MORE_EFFECT
512     else
513     {
514         /* Set the perpective */
515         glMatrixMode( GL_PROJECTION );
516         glLoadIdentity();
517         glFrustum( -1.0, 1.0, -1.0, 1.0, 3.0, 20.0 );
518         glMatrixMode( GL_MODELVIEW );
519         glLoadIdentity();
520         glTranslatef( 0.0, 0.0, -3.0 );
521
522         float f_pov_x, f_pov_y, f_pov_z;
523         f_pov_x = var_CreateGetFloat( p_vout, "opengl-pov-x");
524         f_pov_y = var_CreateGetFloat( p_vout, "opengl-pov-y");
525         f_pov_z = var_CreateGetFloat( p_vout, "opengl-pov-z");
526         gluLookAt(0, 0, 0, f_pov_x, f_pov_y, f_pov_z, 0, 1, 0);
527     }
528 #endif
529     if( p_sys->p_vout->pf_unlock )
530     {
531         p_sys->p_vout->pf_unlock( p_sys->p_vout );
532     }
533
534     return 0;
535 }
536
537 /*****************************************************************************
538  * End: terminate GLX video thread output method
539  *****************************************************************************/
540 static void End( vout_thread_t *p_vout )
541 {
542     vout_sys_t *p_sys = p_vout->p_sys;
543
544     if( p_sys->p_vout->pf_lock &&
545         p_sys->p_vout->pf_lock( p_sys->p_vout ) )
546     {
547         msg_Warn( p_vout, "could not lock OpenGL provider" );
548         return;
549     }
550
551     glFinish();
552     glFlush();
553
554     /* Free the texture buffer*/
555     glDeleteTextures( 2, p_sys->p_textures );
556     if( p_sys->pp_buffer[0] ) free( p_sys->pp_buffer[0] );
557     if( p_sys->pp_buffer[1] ) free( p_sys->pp_buffer[1] );
558
559     if( p_sys->p_vout->pf_unlock )
560     {
561         p_sys->p_vout->pf_unlock( p_sys->p_vout );
562     }
563 }
564
565 /*****************************************************************************
566  * Destroy: destroy GLX video thread output method
567  *****************************************************************************
568  * Terminate an output method created by CreateVout
569  *****************************************************************************/
570 static void DestroyVout( vlc_object_t *p_this )
571 {
572     vout_thread_t *p_vout = (vout_thread_t *)p_this;
573     vout_sys_t *p_sys = p_vout->p_sys;
574
575     module_Unneed( p_sys->p_vout, p_sys->p_vout->p_module );
576     vlc_object_detach( p_sys->p_vout );
577     vlc_object_destroy( p_sys->p_vout );
578
579     free( p_sys );
580 }
581
582 /*****************************************************************************
583  * Manage: handle Sys events
584  *****************************************************************************
585  * This function should be called regularly by video output thread. It returns
586  * a non null value if an error occurred.
587  *****************************************************************************/
588 static int Manage( vout_thread_t *p_vout )
589 {
590     vout_sys_t *p_sys = p_vout->p_sys;
591     int i_ret, i_fullscreen_change;
592
593     i_fullscreen_change = ( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE );
594
595     p_vout->fmt_out.i_x_offset = p_sys->p_vout->fmt_in.i_x_offset =
596         p_vout->fmt_in.i_x_offset;
597     p_vout->fmt_out.i_y_offset = p_sys->p_vout->fmt_in.i_y_offset =
598         p_vout->fmt_in.i_y_offset;
599     p_vout->fmt_out.i_visible_width = p_sys->p_vout->fmt_in.i_visible_width =
600         p_vout->fmt_in.i_visible_width;
601     p_vout->fmt_out.i_visible_height = p_sys->p_vout->fmt_in.i_visible_height =
602         p_vout->fmt_in.i_visible_height;
603     p_vout->fmt_out.i_aspect = p_sys->p_vout->fmt_in.i_aspect =
604         p_vout->fmt_in.i_aspect;
605     p_vout->fmt_out.i_sar_num = p_sys->p_vout->fmt_in.i_sar_num =
606         p_vout->fmt_in.i_sar_num;
607     p_vout->fmt_out.i_sar_den = p_sys->p_vout->fmt_in.i_sar_den =
608         p_vout->fmt_in.i_sar_den;
609     p_vout->output.i_aspect = p_vout->fmt_in.i_aspect;
610
611     p_sys->p_vout->i_changes = p_vout->i_changes;
612     i_ret = p_sys->p_vout->pf_manage( p_sys->p_vout );
613     p_vout->i_changes = p_sys->p_vout->i_changes;
614
615 #ifdef __APPLE__
616     if( p_sys->p_vout->pf_lock &&
617         p_sys->p_vout->pf_lock( p_sys->p_vout ) )
618     {
619         msg_Warn( p_vout, "could not lock OpenGL provider" );
620         return i_ret;
621     }
622
623     /* On OS X, we create the window and the GL view when entering
624        fullscreen - the textures have to be inited again */
625     if( i_fullscreen_change )
626     {
627         InitTextures( p_vout );
628
629         switch( p_sys->i_effect )
630         {
631             case OPENGL_EFFECT_CUBE:
632 #ifdef OPENGL_MORE_EFFECT
633             case CYLINDER:
634             case TORUS:
635             case SPHERE:
636             case SQUAREXY:
637             case SQUARER:
638             case ASINXY:
639             case ASINR:
640             case SINEXY:
641             case SINER:
642 #endif
643                 glEnable( GL_CULL_FACE );
644                 break;
645
646             case OPENGL_EFFECT_TRANSPARENT_CUBE:
647                 glDisable( GL_DEPTH_TEST );
648                 glEnable( GL_BLEND );
649                 glBlendFunc( GL_SRC_ALPHA, GL_ONE );
650                 break;
651         }
652
653         if( p_sys->i_effect & ( OPENGL_EFFECT_CUBE |
654                     OPENGL_EFFECT_TRANSPARENT_CUBE ) )
655         {
656             /* Set the perpective */
657             glMatrixMode( GL_PROJECTION );
658             glLoadIdentity();
659             glFrustum( -1.0, 1.0, -1.0, 1.0, 3.0, 20.0 );
660             glMatrixMode( GL_MODELVIEW );
661             glLoadIdentity();
662             glTranslatef( 0.0, 0.0, - 5.0 );
663         }
664 #ifdef OPENGL_MORE_EFFECT
665         else
666         {
667             glMatrixMode( GL_PROJECTION );
668             glLoadIdentity();
669             glFrustum( -1.0, 1.0, -1.0, 1.0, 3.0, 20.0 );
670             glMatrixMode( GL_MODELVIEW );
671             glLoadIdentity();
672             glTranslatef( 0.0, 0.0, -3.0 );
673  
674             float f_pov_x, f_pov_y, f_pov_z;
675             f_pov_x = var_CreateGetFloat( p_vout, "opengl-pov-x");
676             f_pov_y = var_CreateGetFloat( p_vout, "opengl-pov-y");
677             f_pov_z = var_CreateGetFloat( p_vout, "opengl-pov-z");
678             gluLookAt(0, 0, 0, f_pov_x, f_pov_y, f_pov_z, 0, 1, 0);
679         }
680 #endif
681     }
682
683     if( p_sys->p_vout->pf_unlock )
684     {
685         p_sys->p_vout->pf_unlock( p_sys->p_vout );
686     }
687 #endif
688 // to align in real time in OPENGL
689     if (p_sys->p_vout->i_alignment != p_vout->i_alignment)
690     {
691         p_vout->i_changes = VOUT_CROP_CHANGE;        //to force change
692         p_sys->p_vout->i_alignment = p_vout->i_alignment;    
693     }
694     return i_ret;
695 }
696
697 /*****************************************************************************
698  * Render: render previously calculated output
699  *****************************************************************************/
700 static void Render( vout_thread_t *p_vout, picture_t *p_pic )
701 {
702     VLC_UNUSED(p_pic);
703     vout_sys_t *p_sys = p_vout->p_sys;
704
705     /* On Win32/GLX, we do this the usual way:
706        + Fill the buffer with new content,
707        + Reload the texture,
708        + Use the texture.
709
710        On OS X with VRAM or AGP texturing, the order has to be:
711        + Reload the texture,
712        + Fill the buffer with new content,
713        + Use the texture.
714
715        (Thanks to gcc from the Arstechnica forums for the tip)
716
717        Therefore, we have to use two buffers and textures. On Win32/GLX,
718        we reload the texture to be displayed and use it right away. On
719        OS X, we first render, then reload the texture to be used next
720        time. */
721
722     if( p_sys->p_vout->pf_lock &&
723         p_sys->p_vout->pf_lock( p_sys->p_vout ) )
724     {
725         msg_Warn( p_vout, "could not lock OpenGL provider" );
726         return;
727     }
728
729 #ifdef __APPLE__
730     int i_new_index;
731     i_new_index = ( p_sys->i_index + 1 ) & 1;
732
733
734     /* Update the texture */
735     glBindTexture( VLCGL_TARGET, p_sys->p_textures[i_new_index] );
736     glTexSubImage2D( VLCGL_TARGET, 0, 0, 0,
737                      p_vout->fmt_out.i_width,
738                      p_vout->fmt_out.i_height,
739                      VLCGL_FORMAT, VLCGL_TYPE, p_sys->pp_buffer[i_new_index] );
740
741     /* Bind to the previous texture for drawing */
742     glBindTexture( VLCGL_TARGET, p_sys->p_textures[p_sys->i_index] );
743
744     /* Switch buffers */
745     p_sys->i_index = i_new_index;
746     p_pic->p->p_pixels = p_sys->pp_buffer[p_sys->i_index];
747
748 #else
749     /* Update the texture */
750     glTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0,
751                      p_vout->fmt_out.i_width,
752                      p_vout->fmt_out.i_height,
753                      VLCGL_FORMAT, VLCGL_TYPE, p_sys->pp_buffer[0] );
754 #endif
755
756     if( p_sys->p_vout->pf_unlock )
757     {
758         p_sys->p_vout->pf_unlock( p_sys->p_vout );
759     }
760 }
761
762
763 #ifdef OPENGL_MORE_EFFECT
764 /*****************************************************************************
765  *   Transform: Calculate the distorted grid coordinates
766  *****************************************************************************/
767 static void Transform( int distortion, float width, float height,int i, int j, int i_visible_width, int i_visible_height, double *ix, double *iy )
768 {
769     double x,y,xnew,ynew;
770     double r,theta,rnew,thetanew;
771
772     x = (double)i * (width / ((double)i_visible_width));
773     y = (double)j * (height / ((double)i_visible_height));
774
775     x = (2.0 * (double)x / width) - 1;
776     y = (2.0 * (double)y / height) - 1;
777     xnew = x;
778     ynew = y;
779     r = sqrt(x*x+y*y);
780     theta = atan2(y,x);
781
782     switch (distortion)
783     {
784 /* GRID2D TRANSFORMATION */
785         case SINEXY:
786             xnew = sin(PID2*x);
787             ynew = sin(PID2*y);
788             break;
789         case SINER:
790             rnew = sin(PID2*r);
791             thetanew = theta;
792             xnew = rnew * cos(thetanew);
793             ynew = rnew * sin(thetanew);
794             break;
795         case SQUAREXY:
796             xnew = x*x*SIGN(x);
797             ynew = y*y*SIGN(y);
798             break;
799         case SQUARER:
800             rnew = r*r;
801             thetanew = theta;
802             xnew = rnew * cos(thetanew);
803             ynew = rnew * sin(thetanew);
804             break;
805         case ASINXY:
806             xnew = asin(x) / PID2;
807             ynew = asin(y) / PID2;
808             break;
809         case ASINR:
810             rnew = asin(r) / PID2;
811             thetanew = theta;
812             xnew = rnew * cos(thetanew);
813             ynew = rnew * sin(thetanew);
814             break;
815 /* OTHER WAY: 3D MODEL */
816         default:
817             xnew = x;
818             ynew = y;
819     }
820
821     *ix = width * (xnew + 1) / (2.0);
822     *iy = height * (ynew + 1) / (2.0);
823 }
824
825 /*****************************************************************************
826  *   Z_Compute: Calculate the Z-coordinate
827  *****************************************************************************/
828 static float Z_Compute(float p, int distortion, float x, float y)
829 {
830     float f_z = 0.0;
831     double d_p = p / 100.0;
832
833     switch (distortion)
834     {
835 /* 3D MODEL */
836         case CYLINDER:
837             if (d_p > 0)
838                 f_z = (1 - d_p * d_p) / (2 * d_p) - sqrt(fabs((d_p * d_p + 1) / (2 * d_p) * (d_p * d_p + 1) / (2 * d_p) - x * x));
839             else
840                 f_z = (1 - d_p * d_p) / (2 * d_p) + d_p + sqrt(fabs((d_p * d_p + 1) / (2 * d_p) * (d_p * d_p + 1) / (2 * d_p) - x * x));
841             break;
842         case TORUS:
843             if (d_p > 0)
844                 f_z =  (1 - d_p * d_p) / (d_p) - sqrt(fabs((d_p * d_p + 1) / (2 * d_p) * (d_p * d_p + 1) / (2 * d_p) - x * x)) - sqrt(fabs((d_p * d_p + 1) / (2 * d_p) * (d_p * d_p + 1) / (2 * d_p) - y * y));
845             else
846                 f_z =  (1 - d_p * d_p) / (d_p) + 2 * d_p + sqrt(fabs((d_p * d_p + 1) / (2 * d_p) * (d_p * d_p + 1) / (2 * d_p) - x * x)) + sqrt(fabs((d_p * d_p + 1) / (2 * d_p) * (d_p * d_p + 1) / (2 * d_p) - y * y));
847             break;
848         case SPHERE:
849             if (d_p > 0)
850                 f_z = (1 - d_p * d_p) / (2 * d_p) - sqrt(fabs((d_p * d_p + 1) / (2 * d_p) * (d_p * d_p + 1) / (2 * d_p) - x * x - y * y));
851             else
852                 f_z = (1 - d_p * d_p) / (2 * d_p) + d_p + sqrt(fabs((d_p * d_p + 1) / (2 * d_p) * (d_p * d_p + 1) / (2 * d_p) - x * x - y * y));
853             break;
854 /* OTHER WAY: GRID2D TRANSFORMATION */
855         case SINEXY:;
856         case SINER:
857         case SQUAREXY:
858         case SQUARER:;
859         case ASINXY:
860         case ASINR:
861             f_z = 0.0;
862             break;
863         default:
864             f_z = 0.0;
865     }
866     return f_z;
867 }
868 #endif
869
870
871 /*****************************************************************************
872  * DisplayVideo: displays previously rendered output
873  *****************************************************************************/
874 static void DisplayVideo( vout_thread_t *p_vout, picture_t *p_pic )
875 {
876     VLC_UNUSED(p_pic);
877     vout_sys_t *p_sys = p_vout->p_sys;
878     float f_width, f_height, f_x, f_y;
879
880     if( p_sys->p_vout->pf_lock &&
881         p_sys->p_vout->pf_lock( p_sys->p_vout ) )
882     {
883         msg_Warn( p_vout, "could not lock OpenGL provider" );
884         return;
885     }
886
887     /* glTexCoord works differently with GL_TEXTURE_2D and
888        GL_TEXTURE_RECTANGLE_EXT */
889 #ifdef __APPLE__
890     f_x = (float)p_vout->fmt_out.i_x_offset;
891     f_y = (float)p_vout->fmt_out.i_y_offset;
892     f_width = (float)p_vout->fmt_out.i_x_offset +
893               (float)p_vout->fmt_out.i_visible_width;
894     f_height = (float)p_vout->fmt_out.i_y_offset +
895                (float)p_vout->fmt_out.i_visible_height;
896 #else
897     f_x = (float)p_vout->fmt_out.i_x_offset / p_sys->i_tex_width;
898     f_y = (float)p_vout->fmt_out.i_y_offset / p_sys->i_tex_height;
899     f_width = ( (float)p_vout->fmt_out.i_x_offset +
900                 p_vout->fmt_out.i_visible_width ) / p_sys->i_tex_width;
901     f_height = ( (float)p_vout->fmt_out.i_y_offset +
902                  p_vout->fmt_out.i_visible_height ) / p_sys->i_tex_height;
903 #endif
904
905     /* Why drawing here and not in Render()? Because this way, the
906        OpenGL providers can call pf_display to force redraw. Currently,
907        the OS X provider uses it to get a smooth window resizing */
908
909     glClear( GL_COLOR_BUFFER_BIT );
910
911     if( p_sys->i_effect == OPENGL_EFFECT_NONE )
912     {
913         glEnable( VLCGL_TARGET );
914         glBegin( GL_POLYGON );
915         glTexCoord2f( f_x, f_y ); glVertex2f( -1.0, 1.0 );
916         glTexCoord2f( f_width, f_y ); glVertex2f( 1.0, 1.0 );
917         glTexCoord2f( f_width, f_height ); glVertex2f( 1.0, -1.0 );
918         glTexCoord2f( f_x, f_height ); glVertex2f( -1.0, -1.0 );
919         glEnd();
920     }
921     else
922 #ifdef OPENGL_MORE_EFFECT
923     if ((p_sys->i_effect > OPENGL_EFFECT_TRANSPARENT_CUBE) ||
924         ((p_sys->i_effect == OPENGL_EFFECT_NONE)))
925     {
926        unsigned int i_i, i_j;
927        unsigned int i_accuracy  = config_GetInt( p_vout, "opengl-accuracy");
928        unsigned int i_n = pow(2, i_accuracy);
929        unsigned int i_n_x = (p_vout->fmt_out.i_visible_width / (i_n * 2));
930        unsigned int i_n_y = (p_vout->fmt_out.i_visible_height / i_n);
931        double d_x, d_y;
932        int i_distortion = p_sys->i_effect;
933        float f_p = p_sys->f_radius;
934  
935        glEnable( VLCGL_TARGET );
936        glBegin(GL_QUADS);
937        for (i_i = 0; i_i < p_vout->fmt_out.i_visible_width; i_i += i_n_x)
938        {
939           if ( i_i == i_n_x * i_n / 2) i_n_x += p_vout->fmt_out.i_visible_width % i_n;
940           if ((i_i == (p_vout->fmt_out.i_visible_width / i_n) * i_n / 2 + i_n_x) &&
941               (p_vout->fmt_out.i_visible_width / i_n != i_n_x))
942                 i_n_x -= p_vout->fmt_out.i_visible_width % i_n;
943
944           int i_m;
945           int i_index_max = 0;
946  
947           for (i_j = 0; i_j < p_vout->fmt_out.i_visible_height; i_j += i_n_y)
948           {
949             if ( i_j == i_n_y * i_n / 2) i_n_y += p_vout->fmt_out.i_visible_height % i_n;
950             if ((i_j == (p_vout->fmt_out.i_visible_height / i_n) * i_n / 2 + i_n_y) &&
951                 (p_vout->fmt_out.i_visible_height / i_n != i_n_y))
952                     i_n_y -= p_vout->fmt_out.i_visible_height % i_n;
953
954             for (i_m = i_index_max; i_m < i_index_max + 4; i_m++)
955             {
956                 int i_k = ((i_m % 4) == 1) || ((i_m % 4) == 2);
957                 int i_l = ((i_m % 4) == 2) || ((i_m % 4) == 3);
958
959                 Transform( i_distortion, f_width, f_height, i_i + i_k * i_n_x, i_j + i_l * i_n_y, p_vout->fmt_out.i_visible_width, p_vout->fmt_out.i_visible_height, &d_x, &d_y);
960                 glTexCoord2f(f_x + d_x, f_y + d_y);
961                 d_x =  - 1.0 + 2.0 * ((double)(i_k * i_n_x + i_i) / (double)p_vout->fmt_out.i_visible_width);
962                 d_y =    1.0 - 2.0 * (((double)i_l * i_n_y + i_j) / (double)p_vout->fmt_out.i_visible_height);
963                 glVertex3f((float)d_x, (float)d_y, Z_Compute(f_p, i_distortion, (float)d_x, (float)d_y));
964             }
965           }
966        }
967        glEnd();
968     }
969     else
970 #endif
971     {
972         glRotatef( 0.5 * p_sys->f_speed , 0.3, 0.5, 0.7 );
973
974         glEnable( VLCGL_TARGET );
975         glBegin( GL_QUADS );
976
977         /* Front */
978         glTexCoord2f( f_x, f_y ); glVertex3f( - 1.0, 1.0, 1.0 );
979         glTexCoord2f( f_x, f_height ); glVertex3f( - 1.0, - 1.0, 1.0 );
980         glTexCoord2f( f_width, f_height ); glVertex3f( 1.0, - 1.0, 1.0 );
981         glTexCoord2f( f_width, f_y ); glVertex3f( 1.0, 1.0, 1.0 );
982
983         /* Left */
984         glTexCoord2f( f_x, f_y ); glVertex3f( - 1.0, 1.0, - 1.0 );
985         glTexCoord2f( f_x, f_height ); glVertex3f( - 1.0, - 1.0, - 1.0 );
986         glTexCoord2f( f_width, f_height ); glVertex3f( - 1.0, - 1.0, 1.0 );
987         glTexCoord2f( f_width, f_y ); glVertex3f( - 1.0, 1.0, 1.0 );
988
989         /* Back */
990         glTexCoord2f( f_x, f_y ); glVertex3f( 1.0, 1.0, - 1.0 );
991         glTexCoord2f( f_x, f_height ); glVertex3f( 1.0, - 1.0, - 1.0 );
992         glTexCoord2f( f_width, f_height ); glVertex3f( - 1.0, - 1.0, - 1.0 );
993         glTexCoord2f( f_width, f_y ); glVertex3f( - 1.0, 1.0, - 1.0 );
994
995         /* Right */
996         glTexCoord2f( f_x, f_y ); glVertex3f( 1.0, 1.0, 1.0 );
997         glTexCoord2f( f_x, f_height ); glVertex3f( 1.0, - 1.0, 1.0 );
998         glTexCoord2f( f_width, f_height ); glVertex3f( 1.0, - 1.0, - 1.0 );
999         glTexCoord2f( f_width, f_y ); glVertex3f( 1.0, 1.0, - 1.0 );
1000
1001         /* Top */
1002         glTexCoord2f( f_x, f_y ); glVertex3f( - 1.0, 1.0, - 1.0 );
1003         glTexCoord2f( f_x, f_height ); glVertex3f( - 1.0, 1.0, 1.0 );
1004         glTexCoord2f( f_width, f_height ); glVertex3f( 1.0, 1.0, 1.0 );
1005         glTexCoord2f( f_width, f_y ); glVertex3f( 1.0, 1.0, - 1.0 );
1006
1007         /* Bottom */
1008         glTexCoord2f( f_x, f_y ); glVertex3f( - 1.0, - 1.0, 1.0 );
1009         glTexCoord2f( f_x, f_height ); glVertex3f( - 1.0, - 1.0, - 1.0 );
1010         glTexCoord2f( f_width, f_height ); glVertex3f( 1.0, - 1.0, - 1.0 );
1011         glTexCoord2f( f_width, f_y ); glVertex3f( 1.0, - 1.0, 1.0 );
1012         glEnd();
1013     }
1014
1015     glDisable( VLCGL_TARGET );
1016
1017     p_sys->p_vout->pf_swap( p_sys->p_vout );
1018
1019     if( p_sys->p_vout->pf_unlock )
1020     {
1021         p_sys->p_vout->pf_unlock( p_sys->p_vout );
1022     }
1023 }
1024
1025 int GetAlignedSize( int i_size )
1026 {
1027     /* Return the nearest power of 2 */
1028     int i_result = 1;
1029     while( i_result < i_size )
1030     {
1031         i_result *= 2;
1032     }
1033     return i_result;
1034 }
1035
1036 /*****************************************************************************
1037  * Control: control facility for the vout
1038  *****************************************************************************/
1039 static int Control( vout_thread_t *p_vout, int i_query, va_list args )
1040 {
1041     vout_sys_t *p_sys = p_vout->p_sys;
1042
1043     switch( i_query )
1044     {
1045     case VOUT_SNAPSHOT:
1046         return vout_vaControlDefault( p_vout, i_query, args );
1047
1048     default:
1049         if( p_sys->p_vout->pf_control )
1050             return p_sys->p_vout->pf_control( p_sys->p_vout, i_query, args );
1051         else
1052             return vout_vaControlDefault( p_vout, i_query, args );
1053     }
1054 }
1055
1056 static int InitTextures( vout_thread_t *p_vout )
1057 {
1058     vout_sys_t *p_sys = p_vout->p_sys;
1059     int i_index;
1060
1061     glDeleteTextures( 2, p_sys->p_textures );
1062     glGenTextures( 2, p_sys->p_textures );
1063
1064     for( i_index = 0; i_index < 2; i_index++ )
1065     {
1066         glBindTexture( VLCGL_TARGET, p_sys->p_textures[i_index] );
1067
1068         /* Set the texture parameters */
1069         glTexParameterf( VLCGL_TARGET, GL_TEXTURE_PRIORITY, 1.0 );
1070
1071         glTexParameteri( VLCGL_TARGET, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
1072         glTexParameteri( VLCGL_TARGET, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
1073
1074         glTexParameteri( VLCGL_TARGET, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
1075         glTexParameteri( VLCGL_TARGET, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
1076
1077         glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
1078
1079 #ifdef __APPLE__
1080         /* Tell the driver not to make a copy of the texture but to use
1081            our buffer */
1082         glEnable( GL_UNPACK_CLIENT_STORAGE_APPLE );
1083         glPixelStorei( GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE );
1084
1085 #if 0
1086         /* Use VRAM texturing */
1087         glTexParameteri( VLCGL_TARGET, GL_TEXTURE_STORAGE_HINT_APPLE,
1088                          GL_STORAGE_CACHED_APPLE );
1089 #else
1090         /* Use AGP texturing */
1091         glTexParameteri( VLCGL_TARGET, GL_TEXTURE_STORAGE_HINT_APPLE,
1092                          GL_STORAGE_SHARED_APPLE );
1093 #endif
1094 #endif
1095
1096         /* Call glTexImage2D only once, and use glTexSubImage2D later */
1097         glTexImage2D( VLCGL_TARGET, 0, 3, p_sys->i_tex_width,
1098                       p_sys->i_tex_height, 0, VLCGL_FORMAT, VLCGL_TYPE,
1099                       p_sys->pp_buffer[i_index] );
1100     }
1101
1102     return 0;
1103 }
1104
1105 /*****************************************************************************
1106  * SendEvents: forward mouse and keyboard events to the parent p_vout
1107  *****************************************************************************/
1108 static int SendEvents( vlc_object_t *p_this, char const *psz_var,
1109                        vlc_value_t oldval, vlc_value_t newval, void *_p_vout )
1110 {
1111     VLC_UNUSED(p_this); VLC_UNUSED(oldval);
1112     return var_Set( (vlc_object_t *)_p_vout, psz_var, newval );
1113 }