X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fvideo_output%2Fopengl.c;h=dc6c8db9ce5623607b5735b510e767f76332179a;hb=66e45812305c60b92e2ea4ff99b130a2cb829320;hp=2cff793f71e372aa93614dd9a67deaa5e7711382;hpb=55c960749e8f91763e720ac610d5dd56f90fcde1;p=vlc diff --git a/modules/video_output/opengl.c b/modules/video_output/opengl.c index 2cff793f71..dc6c8db9ce 100644 --- a/modules/video_output/opengl.c +++ b/modules/video_output/opengl.c @@ -1,13 +1,14 @@ /***************************************************************************** - * opengl.c: OpenGL video output + * opengl.c: OpenGL and OpenGL ES output common code ***************************************************************************** - * Copyright (C) 2004 the VideoLAN team - * $Id$ + * Copyright (C) 2004-2011 VLC authors and VideoLAN + * Copyright (C) 2009, 2011 Laurent Aimar * * Authors: Cyril Deguet * Gildas Bazin * Eric Petit * Cedric Cocquebert + * Laurent Aimar * * 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 @@ -23,475 +24,474 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. *****************************************************************************/ - -/***************************************************************************** - * Preamble - *****************************************************************************/ - #ifdef HAVE_CONFIG_H # include "config.h" #endif -#include /* ENOMEM */ - #include -#include -#include +#include +#include +#include + +#include "opengl.h" +// Define USE_OPENGL_ES to the GL ES Version you want to select #ifdef __APPLE__ -#include -#include +# define PFNGLGENPROGRAMSARBPROC typeof(glGenProgramsARB)* +# define PFNGLBINDPROGRAMARBPROC typeof(glBindProgramARB)* +# define PFNGLPROGRAMSTRINGARBPROC typeof(glProgramStringARB)* +# define PFNGLDELETEPROGRAMSARBPROC typeof(glDeleteProgramsARB)* +# define PFNGLPROGRAMLOCALPARAMETER4FVARBPROC typeof(glProgramLocalParameter4fvARB)* +# define PFNGLACTIVETEXTUREARBPROC typeof(glActiveTextureARB)* +# define PFNGLMULTITEXCOORD2FARBPROC typeof(glMultiTexCoord2fARB)* +#endif -/* 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 +/* RV16 */ +#ifndef GL_UNSIGNED_SHORT_5_6_5 +# define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#endif +#ifndef GL_CLAMP_TO_EDGE +# define GL_CLAMP_TO_EDGE 0x812F +#endif -/* OS X OpenGL supports YUV. Hehe. */ -#define VLCGL_FORMAT GL_YCBCR_422_APPLE -#define VLCGL_TYPE GL_UNSIGNED_SHORT_8_8_APPLE +#if USE_OPENGL_ES +# define VLCGL_TEXTURE_COUNT 1 +# define VLCGL_PICTURE_MAX 1 #else +# define VLCGL_TEXTURE_COUNT 1 +# define VLCGL_PICTURE_MAX 128 +#endif -#include -#define VLCGL_TARGET GL_TEXTURE_2D +static const vlc_fourcc_t gl_subpicture_chromas[] = { + VLC_CODEC_RGBA, + 0 +}; -/* RV16 */ -#ifndef GL_UNSIGNED_SHORT_5_6_5 -#define GL_UNSIGNED_SHORT_5_6_5 0x8363 -#endif -//#define VLCGL_RGB_FORMAT GL_RGB -//#define VLCGL_RGB_TYPE GL_UNSIGNED_SHORT_5_6_5 +typedef struct { + GLuint texture; + unsigned format; + unsigned type; + unsigned width; + unsigned height; -/* RV24 */ -//#define VLCGL_RGB_FORMAT GL_RGB -//#define VLCGL_RGB_TYPE GL_UNSIGNED_BYTE + float alpha; -/* RV32 */ -#define VLCGL_RGB_FORMAT GL_RGBA -#define VLCGL_RGB_TYPE GL_UNSIGNED_BYTE + float top; + float left; + float bottom; + float right; +} gl_region_t; -/* YUY2 */ -#ifndef YCBCR_MESA -#define YCBCR_MESA 0x8757 -#endif -#ifndef UNSIGNED_SHORT_8_8_MESA -#define UNSIGNED_SHORT_8_8_MESA 0x85BA -#endif -#define VLCGL_YUV_FORMAT YCBCR_MESA -#define VLCGL_YUV_TYPE UNSIGNED_SHORT_8_8_MESA - -/* Use RGB on Win32/GLX */ -#define VLCGL_FORMAT VLCGL_RGB_FORMAT -#define VLCGL_TYPE VLCGL_RGB_TYPE -//#define VLCGL_FORMAT VLCGL_YUV_FORMAT -//#define VLCGL_TYPE VLCGL_YUV_TYPE -#endif +struct vout_display_opengl_t { + vlc_gl_t *gl; -#ifndef GL_CLAMP_TO_EDGE -# define GL_CLAMP_TO_EDGE 0x812F -#endif + video_format_t fmt; + const vlc_chroma_description_t *chroma; -/***************************************************************************** - * 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 * ); -static int Manage ( vout_thread_t * ); -static void Render ( vout_thread_t *, picture_t * ); -static void DisplayVideo ( vout_thread_t *, picture_t * ); -static int Control ( vout_thread_t *, int, va_list ); - -static inline int GetAlignedSize( int ); - -static int InitTextures ( vout_thread_t * ); -static int SendEvents ( vlc_object_t *, char const *, - vlc_value_t, vlc_value_t, void * ); - -#define PROVIDER_TEXT N_("OpenGL Provider") -#define PROVIDER_LONGTEXT N_("Allows you to modify what OpenGL provider should be used") - -vlc_module_begin () - set_shortname( "OpenGL" ) - set_category( CAT_VIDEO ) - set_subcategory( SUBCAT_VIDEO_VOUT ) - set_description( N_("OpenGL video output") ) -#ifdef __APPLE__ - set_capability( "video output", 200 ) -#else - set_capability( "video output", 20 ) -#endif - add_shortcut( "opengl" ) - /* Allow opengl provider plugin selection */ - add_module( "opengl-provider", "opengl provider", NULL, NULL, - PROVIDER_TEXT, PROVIDER_LONGTEXT, true ) - set_callbacks( CreateVout, DestroyVout ) -vlc_module_end () + int tex_target; + int tex_format; + int tex_internal; + int tex_type; + + int tex_width[PICTURE_PLANE_MAX]; + int tex_height[PICTURE_PLANE_MAX]; + + GLuint texture[VLCGL_TEXTURE_COUNT][PICTURE_PLANE_MAX]; + + int region_count; + gl_region_t *region; -/***************************************************************************** - * 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; - uint8_t *pp_buffer[2]; - int i_index; - int i_tex_width; - int i_tex_height; - GLuint p_textures[2]; + picture_pool_t *pool; + + GLuint program; + int local_count; + GLfloat local_value[16][4]; + + /* fragment_program */ + PFNGLGENPROGRAMSARBPROC GenProgramsARB; + PFNGLBINDPROGRAMARBPROC BindProgramARB; + PFNGLPROGRAMSTRINGARBPROC ProgramStringARB; + PFNGLDELETEPROGRAMSARBPROC DeleteProgramsARB; + PFNGLPROGRAMLOCALPARAMETER4FVARBPROC ProgramLocalParameter4fvARB; + + /* multitexture */ + bool use_multitexture; + PFNGLACTIVETEXTUREARBPROC ActiveTextureARB; + PFNGLMULTITEXCOORD2FARBPROC MultiTexCoord2fARB; }; -/***************************************************************************** - * CreateVout: This function allocates and initializes the OpenGL vout method. - *****************************************************************************/ -static int CreateVout( vlc_object_t *p_this ) +static inline int GetAlignedSize(unsigned size) { - vout_thread_t *p_vout = (vout_thread_t *)p_this; - vout_sys_t *p_sys; - char * psz; + /* Return the smallest larger or equal power of 2 */ + unsigned align = 1 << (8 * sizeof (unsigned) - clz(size)); + return ((align >> 1) == size) ? size : align; +} - /* Allocate structure */ - p_vout->p_sys = p_sys = malloc( sizeof( vout_sys_t ) ); - if( p_sys == NULL ) - return VLC_ENOMEM; +static bool IsLuminance16Supported(int target) +{ + GLuint texture; - p_sys->i_index = 0; -#ifdef __APPLE__ - p_sys->i_tex_width = p_vout->fmt_in.i_width; - p_sys->i_tex_height = p_vout->fmt_in.i_height; -#else - /* A texture must have a size aligned on a power of 2 */ - p_sys->i_tex_width = GetAlignedSize( p_vout->fmt_in.i_width ); - p_sys->i_tex_height = GetAlignedSize( p_vout->fmt_in.i_height ); -#endif + glGenTextures(1, &texture); + glBindTexture(target, texture); + glTexImage2D(target, 0, GL_LUMINANCE16, + 64, 64, 0, GL_LUMINANCE, GL_UNSIGNED_SHORT, NULL); + GLint size = 0; + glGetTexLevelParameteriv(target, 0, GL_TEXTURE_LUMINANCE_SIZE, &size); - msg_Dbg( p_vout, "Texture size: %dx%d", p_sys->i_tex_width, - p_sys->i_tex_height ); + glDeleteTextures(1, &texture); - /* Get window */ - p_sys->p_vout = - (vout_thread_t *)vlc_object_create( p_this, sizeof( vout_thread_t ) ); - if( p_sys->p_vout == NULL ) - { - free( p_sys ); - return VLC_ENOMEM; - } - vlc_object_attach( p_sys->p_vout, p_this ); - - 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; - 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; - p_sys->p_vout->fmt_render = p_vout->fmt_render; - p_sys->p_vout->fmt_in = p_vout->fmt_in; - p_sys->p_vout->b_autoscale = p_vout->b_autoscale; - p_sys->p_vout->i_zoom = p_vout->i_zoom; - p_sys->p_vout->i_alignment = p_vout->i_alignment; - var_Create( p_sys->p_vout, "video-deco", - VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); - - psz = var_CreateGetString( p_vout, "opengl-provider" ); - p_sys->p_vout->p_module = - module_need( p_sys->p_vout, "opengl provider", psz, false ); - free( psz ); - if( p_sys->p_vout->p_module == NULL ) - { - msg_Warn( p_vout, "No OpenGL provider found" ); - vlc_object_detach( p_sys->p_vout ); - vlc_object_release( p_sys->p_vout ); - free( p_sys ); - return VLC_ENOOBJ; + return size == 16; +} + +vout_display_opengl_t *vout_display_opengl_New(video_format_t *fmt, + const vlc_fourcc_t **subpicture_chromas, + vlc_gl_t *gl) +{ + vout_display_opengl_t *vgl = calloc(1, sizeof(*vgl)); + if (!vgl) + return NULL; + + vgl->gl = gl; + if (vlc_gl_Lock(vgl->gl)) { + free(vgl); + return NULL; } - p_vout->pf_init = Init; - p_vout->pf_end = End; - p_vout->pf_manage = Manage; - p_vout->pf_render = Render; - p_vout->pf_display = DisplayVideo; - p_vout->pf_control = Control; - - /* Forward events from the opengl provider */ - 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_BOOL ); - var_Create( p_sys->p_vout, "mouse-button-down", VLC_VAR_INTEGER ); - var_Create( p_sys->p_vout, "video-on-top", - VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); - var_Create( p_sys->p_vout, "autoscale", - VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); - var_Create( p_sys->p_vout, "scale", - VLC_VAR_FLOAT | VLC_VAR_DOINHERIT ); - - 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 ); - var_AddCallback( p_sys->p_vout, "mouse-button-down", SendEvents, p_vout ); - var_AddCallback( p_vout, "autoscale", SendEvents, p_sys->p_vout ); - var_AddCallback( p_vout, "scale", SendEvents, p_sys->p_vout ); + const char *extensions = (const char *)glGetString(GL_EXTENSIONS); + + /* Load extensions */ + bool supports_fp = false; + if (HasExtension(extensions, "GL_ARB_fragment_program")) { +#if !defined(MACOS_OPENGL) + vgl->GenProgramsARB = (PFNGLGENPROGRAMSARBPROC)vlc_gl_GetProcAddress(vgl->gl, "glGenProgramsARB"); + vgl->BindProgramARB = (PFNGLBINDPROGRAMARBPROC)vlc_gl_GetProcAddress(vgl->gl, "glBindProgramARB"); + vgl->ProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC)vlc_gl_GetProcAddress(vgl->gl, "glProgramStringARB"); + vgl->DeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC)vlc_gl_GetProcAddress(vgl->gl, "glDeleteProgramsARB"); + vgl->ProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)vlc_gl_GetProcAddress(vgl->gl, "glProgramLocalParameter4fvARB"); +#else + vgl->GenProgramsARB = glGenProgramsARB; + vgl->BindProgramARB = glBindProgramARB; + vgl->ProgramStringARB = glProgramStringARB; + vgl->DeleteProgramsARB = glDeleteProgramsARB; + vgl->ProgramLocalParameter4fvARB = glProgramLocalParameter4fvARB; +#endif + supports_fp = vgl->GenProgramsARB && + vgl->BindProgramARB && + vgl->ProgramStringARB && + vgl->DeleteProgramsARB && + vgl->ProgramLocalParameter4fvARB; + } - return VLC_SUCCESS; -} + bool supports_multitexture = false; + GLint max_texture_units = 0; + if (HasExtension(extensions, "GL_ARB_multitexture")) { +#if !defined(MACOS_OPENGL) + vgl->ActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)vlc_gl_GetProcAddress(vgl->gl, "glActiveTextureARB"); + vgl->MultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC)vlc_gl_GetProcAddress(vgl->gl, "glMultiTexCoord2fARB"); +#else + vgl->ActiveTextureARB = glActiveTextureARB; + vgl->MultiTexCoord2fARB = glMultiTexCoord2fARB; +#endif + supports_multitexture = vgl->ActiveTextureARB && + vgl->MultiTexCoord2fARB; + if (supports_multitexture) + glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &max_texture_units); + } -/***************************************************************************** - * 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; - int i_pixel_pitch; - - p_sys->p_vout->pf_init( p_sys->p_vout ); - -/* TODO: We use YCbCr on Mac which is Y422, but on OSX it seems to == YUY2. Verify */ -#if ( defined( WORDS_BIGENDIAN ) && VLCGL_FORMAT == GL_YCBCR_422_APPLE ) || (VLCGL_FORMAT == YCBCR_MESA) - p_vout->output.i_chroma = VLC_CODEC_YUYV; - i_pixel_pitch = 2; - -#elif (VLCGL_FORMAT == GL_YCBCR_422_APPLE) - p_vout->output.i_chroma = VLC_CODEC_UYVY; - i_pixel_pitch = 2; - -#elif VLCGL_FORMAT == GL_RGB -# if VLCGL_TYPE == GL_UNSIGNED_BYTE - p_vout->output.i_chroma = VLC_CODEC_RGB24; -# if defined( WORDS_BIGENDIAN ) - p_vout->output.i_rmask = 0x00ff0000; - p_vout->output.i_gmask = 0x0000ff00; - p_vout->output.i_bmask = 0x000000ff; -# else - p_vout->output.i_rmask = 0x000000ff; - p_vout->output.i_gmask = 0x0000ff00; - p_vout->output.i_bmask = 0x00ff0000; -# endif - i_pixel_pitch = 3; + /* Initialize with default chroma */ + vgl->fmt = *fmt; +#if USE_OPENGL_ES + vgl->fmt.i_chroma = VLC_CODEC_RGB16; +# if defined(WORDS_BIGENDIAN) + vgl->fmt.i_rmask = 0x001f; + vgl->fmt.i_gmask = 0x07e0; + vgl->fmt.i_bmask = 0xf800; # else - p_vout->output.i_chroma = VLC_CODEC_RGB16; -# if defined( WORDS_BIGENDIAN ) - p_vout->output.i_rmask = 0x001f; - p_vout->output.i_gmask = 0x07e0; - p_vout->output.i_bmask = 0xf800; -# else - p_vout->output.i_rmask = 0xf800; - p_vout->output.i_gmask = 0x07e0; - p_vout->output.i_bmask = 0x001f; -# endif - i_pixel_pitch = 2; + vgl->fmt.i_rmask = 0xf800; + vgl->fmt.i_gmask = 0x07e0; + vgl->fmt.i_bmask = 0x001f; # endif + vgl->tex_target = GL_TEXTURE_2D; + vgl->tex_format = GL_RGB; + vgl->tex_internal = GL_RGB; + vgl->tex_type = GL_UNSIGNED_SHORT_5_6_5; #else - p_vout->output.i_chroma = VLC_CODEC_RGB32; -# if defined( WORDS_BIGENDIAN ) - p_vout->output.i_rmask = 0xff000000; - p_vout->output.i_gmask = 0x00ff0000; - p_vout->output.i_bmask = 0x0000ff00; -# else - p_vout->output.i_rmask = 0x000000ff; - p_vout->output.i_gmask = 0x0000ff00; - p_vout->output.i_bmask = 0x00ff0000; -# endif - i_pixel_pitch = 4; + vgl->fmt.i_chroma = VLC_CODEC_RGB32; +# if defined(WORDS_BIGENDIAN) + vgl->fmt.i_rmask = 0xff000000; + vgl->fmt.i_gmask = 0x00ff0000; + vgl->fmt.i_bmask = 0x0000ff00; +# else + vgl->fmt.i_rmask = 0x000000ff; + vgl->fmt.i_gmask = 0x0000ff00; + vgl->fmt.i_bmask = 0x00ff0000; +# endif + vgl->tex_target = GL_TEXTURE_2D; + vgl->tex_format = GL_RGBA; + vgl->tex_internal = GL_RGBA; + vgl->tex_type = GL_UNSIGNED_BYTE; #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; - - p_vout->fmt_out = p_vout->fmt_in; - p_vout->fmt_out.i_chroma = p_vout->output.i_chroma; - - /* We know the chroma, allocate one buffer which will be used - * directly by the decoder */ - 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] ) - return -1; - p_sys->pp_buffer[1] = - malloc( p_sys->i_tex_width * p_sys->i_tex_height * i_pixel_pitch ); - if( !p_sys->pp_buffer[1] ) - return -1; - - p_vout->p_picture[0].i_planes = 1; - p_vout->p_picture[0].p->p_pixels = p_sys->pp_buffer[0]; - p_vout->p_picture[0].p->i_lines = p_vout->output.i_height; - p_vout->p_picture[0].p->i_visible_lines = p_vout->output.i_height; - p_vout->p_picture[0].p->i_pixel_pitch = i_pixel_pitch; - p_vout->p_picture[0].p->i_pitch = p_vout->output.i_width * - 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]; - - I_OUTPUTPICTURES = 1; - - 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; + /* Use YUV if possible and needed */ + bool need_fs_yuv = false; + float yuv_range_correction = 1.0; + if (supports_fp && supports_multitexture && max_texture_units >= 3 && + vlc_fourcc_IsYUV(fmt->i_chroma) && !vlc_fourcc_IsYUV(vgl->fmt.i_chroma)) { + const vlc_fourcc_t *list = vlc_fourcc_GetYUVFallback(fmt->i_chroma); + while (*list) { + const vlc_chroma_description_t *dsc = vlc_fourcc_GetChromaDescription(*list); + if (dsc && dsc->plane_count == 3 && dsc->pixel_size == 1) { + need_fs_yuv = true; + vgl->fmt = *fmt; + vgl->fmt.i_chroma = *list; + vgl->tex_format = GL_LUMINANCE; + vgl->tex_internal = GL_LUMINANCE; + vgl->tex_type = GL_UNSIGNED_BYTE; + yuv_range_correction = 1.0; + break; + } else if (dsc && dsc->plane_count == 3 && dsc->pixel_size == 2 && + IsLuminance16Supported(vgl->tex_target)) { + need_fs_yuv = true; + vgl->fmt = *fmt; + vgl->fmt.i_chroma = *list; + vgl->tex_format = GL_LUMINANCE; + vgl->tex_internal = GL_LUMINANCE16; + vgl->tex_type = GL_UNSIGNED_SHORT; + yuv_range_correction = (float)((1 << 16) - 1) / ((1 << dsc->pixel_bits) - 1); + break; + } + list++; + } } - InitTextures( p_vout ); + vgl->chroma = vlc_fourcc_GetChromaDescription(vgl->fmt.i_chroma); + vgl->use_multitexture = vgl->chroma->plane_count > 1; - glDisable(GL_BLEND); - glDisable(GL_DEPTH_TEST); - glDepthMask(GL_FALSE); - glDisable(GL_CULL_FACE); - glClearColor( 0.0f, 0.0f, 0.0f, 1.0f ); - glClear( GL_COLOR_BUFFER_BIT ); + bool supports_npot = false; +#if USE_OPENGL_ES == 2 + supports_npot = true; +#else + supports_npot |= HasExtension(extensions, "GL_APPLE_texture_2D_limited_npot") || + HasExtension(extensions, "GL_ARB_texture_non_power_of_two"); +#endif - if( p_sys->p_vout->pf_unlock ) - { - p_sys->p_vout->pf_unlock( p_sys->p_vout ); + /* Texture size */ + for (unsigned j = 0; j < vgl->chroma->plane_count; j++) { + int w = vgl->fmt.i_width * vgl->chroma->p[j].w.num / vgl->chroma->p[j].w.den; + int h = vgl->fmt.i_height * vgl->chroma->p[j].h.num / vgl->chroma->p[j].h.den; + if (supports_npot) { + vgl->tex_width[j] = w; + vgl->tex_height[j] = h; + } + else { + /* A texture must have a size aligned on a power of 2 */ + vgl->tex_width[j] = GetAlignedSize(w); + vgl->tex_height[j] = GetAlignedSize(h); + } } - return 0; -} - -/***************************************************************************** - * End: terminate GLX video thread output method - *****************************************************************************/ -static void End( vout_thread_t *p_vout ) -{ - vout_sys_t *p_sys = p_vout->p_sys; + /* Build fragment program if needed */ + vgl->program = 0; + vgl->local_count = 0; + if (supports_fp) { + char *code = NULL; + + if (need_fs_yuv) { + /* [R/G/B][Y U V O] from TV range to full range + * XXX we could also do hue/brightness/constrast/gamma + * by simply changing the coefficients + */ + const float matrix_bt601_tv2full[3][4] = { + { 1.1640, 0.0000, 1.4030, -0.7773 }, + { 1.1640, -0.3440, -0.7140, 0.4580 }, + { 1.1640, 1.7730, 0.0000, -0.9630 }, + }; + const float matrix_bt709_tv2full[3][4] = { + { 1.1640, 0.0000, 1.5701, -0.8612 }, + { 1.1640, -0.1870, -0.4664, 0.2549 }, + { 1.1640, 1.8556, 0.0000, -1.0045 }, + }; + const float (*matrix)[4] = fmt->i_height > 576 ? matrix_bt709_tv2full + : matrix_bt601_tv2full; + + /* Basic linear YUV -> RGB conversion using bilinear interpolation */ + const char *template_yuv = + "!!ARBfp1.0" + "OPTION ARB_precision_hint_fastest;" + + "TEMP src;" + "TEX src.x, fragment.texcoord[0], texture[0], 2D;" + "TEX src.%c, fragment.texcoord[1], texture[1], 2D;" + "TEX src.%c, fragment.texcoord[2], texture[2], 2D;" + + "PARAM coefficient[4] = { program.local[0..3] };" + + "TEMP tmp;" + "MAD tmp.rgb, src.xxxx, coefficient[0], coefficient[3];" + "MAD tmp.rgb, src.yyyy, coefficient[1], tmp;" + "MAD result.color.rgb, src.zzzz, coefficient[2], tmp;" + "END"; + bool swap_uv = vgl->fmt.i_chroma == VLC_CODEC_YV12 || + vgl->fmt.i_chroma == VLC_CODEC_YV9; + if (asprintf(&code, template_yuv, + swap_uv ? 'z' : 'y', + swap_uv ? 'y' : 'z') < 0) + code = NULL; + + for (int i = 0; i < 4; i++) { + float correction = i < 3 ? yuv_range_correction : 1.0; + for (int j = 0; j < 4; j++) { + vgl->local_value[vgl->local_count + i][j] = j < 3 ? correction * matrix[j][i] : 0.0; + } + } + vgl->local_count += 4; + } + if (code) { + // Here you have shaders + vgl->GenProgramsARB(1, &vgl->program); + vgl->BindProgramARB(GL_FRAGMENT_PROGRAM_ARB, vgl->program); + vgl->ProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, + GL_PROGRAM_FORMAT_ASCII_ARB, + strlen(code), (const GLbyte*)code); + if (glGetError() == GL_INVALID_OPERATION) { + /* FIXME if the program was needed for YUV, the video will be broken */ +#if 0 + GLint position; + glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &position); - 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; + const char *msg = (const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB); + fprintf(stderr, "GL_INVALID_OPERATION: error at %d: %s\n", position, msg); +#endif + vgl->DeleteProgramsARB(1, &vgl->program); + vgl->program = 0; + } + free(code); + } } - glFinish(); - glFlush(); + /* */ + glDisable(GL_BLEND); + glDisable(GL_DEPTH_TEST); + glDepthMask(GL_FALSE); + glDisable(GL_CULL_FACE); + glClearColor(0.0f, 0.0f, 0.0f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT); - /* Free the texture buffer*/ - glDeleteTextures( 2, p_sys->p_textures ); - free( p_sys->pp_buffer[0] ); - free( p_sys->pp_buffer[1] ); + vlc_gl_Unlock(vgl->gl); - if( p_sys->p_vout->pf_unlock ) - { - p_sys->p_vout->pf_unlock( p_sys->p_vout ); + /* */ + for (int i = 0; i < VLCGL_TEXTURE_COUNT; i++) { + for (int j = 0; j < PICTURE_PLANE_MAX; j++) + vgl->texture[i][j] = 0; + } + vgl->region_count = 0; + vgl->region = NULL; + vgl->pool = NULL; + + *fmt = vgl->fmt; + if (subpicture_chromas) { + *subpicture_chromas = NULL; +#if !USE_OPENGL_ES + if (supports_npot) + *subpicture_chromas = gl_subpicture_chromas; +#endif } + return vgl; } -/***************************************************************************** - * Destroy: destroy GLX video thread output method - ***************************************************************************** - * Terminate an output method created by CreateVout - *****************************************************************************/ -static void DestroyVout( vlc_object_t *p_this ) +void vout_display_opengl_Delete(vout_display_opengl_t *vgl) { - 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_release( p_sys->p_vout ); - - free( p_sys ); + /* */ + if (!vlc_gl_Lock(vgl->gl)) { + + glFinish(); + glFlush(); + for (int i = 0; i < VLCGL_TEXTURE_COUNT; i++) + glDeleteTextures(vgl->chroma->plane_count, vgl->texture[i]); + for (int i = 0; i < vgl->region_count; i++) { + if (vgl->region[i].texture) + glDeleteTextures(1, &vgl->region[i].texture); + } + free(vgl->region); + + if (vgl->program) + vgl->DeleteProgramsARB(1, &vgl->program); + + vlc_gl_Unlock(vgl->gl); + } + if (vgl->pool) + picture_pool_Delete(vgl->pool); + free(vgl); } -/***************************************************************************** - * Manage: handle Sys events - ***************************************************************************** - * This function should be called regularly by video output thread. It returns - * a non null value if an error occurred. - *****************************************************************************/ -static int Manage( vout_thread_t *p_vout ) +picture_pool_t *vout_display_opengl_GetPool(vout_display_opengl_t *vgl, unsigned requested_count) { - vout_sys_t *p_sys = p_vout->p_sys; - int i_ret, i_fullscreen_change; - - i_fullscreen_change = ( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE ); - - p_vout->fmt_out.i_x_offset = p_sys->p_vout->fmt_in.i_x_offset = - p_vout->fmt_in.i_x_offset; - p_vout->fmt_out.i_y_offset = p_sys->p_vout->fmt_in.i_y_offset = - p_vout->fmt_in.i_y_offset; - p_vout->fmt_out.i_visible_width = p_sys->p_vout->fmt_in.i_visible_width = - p_vout->fmt_in.i_visible_width; - p_vout->fmt_out.i_visible_height = p_sys->p_vout->fmt_in.i_visible_height = - p_vout->fmt_in.i_visible_height; - p_vout->fmt_out.i_aspect = p_sys->p_vout->fmt_in.i_aspect = - p_vout->fmt_in.i_aspect; - p_vout->fmt_out.i_sar_num = p_sys->p_vout->fmt_in.i_sar_num = - p_vout->fmt_in.i_sar_num; - p_vout->fmt_out.i_sar_den = p_sys->p_vout->fmt_in.i_sar_den = - p_vout->fmt_in.i_sar_den; - p_vout->output.i_aspect = p_vout->fmt_in.i_aspect; - - 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; + if (vgl->pool) + return vgl->pool; -#ifdef __APPLE__ - 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; - } - - /* 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 ); - } + /* Allocate our pictures */ + picture_t *picture[VLCGL_PICTURE_MAX] = {NULL, }; + unsigned count = 0; - if( p_sys->p_vout->pf_unlock ) - { - p_sys->p_vout->pf_unlock( p_sys->p_vout ); + for (count = 0; count < __MIN(VLCGL_PICTURE_MAX, requested_count); count++) { + picture[count] = picture_NewFromFormat(&vgl->fmt); + if (!picture[count]) + break; } + if (count <= 0) + return NULL; + + /* Wrap the pictures into a pool */ + picture_pool_configuration_t cfg; + memset(&cfg, 0, sizeof(cfg)); + cfg.picture_count = count; + cfg.picture = picture; + vgl->pool = picture_pool_NewExtended(&cfg); + if (!vgl->pool) + goto error; + + /* Allocates our textures */ + if (vlc_gl_Lock(vgl->gl)) + return vgl->pool; + + for (int i = 0; i < VLCGL_TEXTURE_COUNT; i++) { + glGenTextures(vgl->chroma->plane_count, vgl->texture[i]); + for (unsigned j = 0; j < vgl->chroma->plane_count; j++) { + if (vgl->use_multitexture) + vgl->ActiveTextureARB(GL_TEXTURE0_ARB + j); + glBindTexture(vgl->tex_target, vgl->texture[i][j]); + +#if !USE_OPENGL_ES + /* Set the texture parameters */ + glTexParameterf(vgl->tex_target, GL_TEXTURE_PRIORITY, 1.0); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); #endif -// to align in real time in OPENGL - if (p_sys->p_vout->i_alignment != p_vout->i_alignment) - { - p_vout->i_changes |= VOUT_CROP_CHANGE; //to force change - p_sys->p_vout->i_alignment = p_vout->i_alignment; - } - /* forward signal that autoscale toggle has changed */ - if (p_vout->i_changes & VOUT_SCALE_CHANGE ) - { - p_vout->i_changes &= ~VOUT_SCALE_CHANGE; + glTexParameteri(vgl->tex_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(vgl->tex_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(vgl->tex_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(vgl->tex_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); - p_sys->p_vout->i_changes |= VOUT_SCALE_CHANGE; + /* Call glTexImage2D only once, and use glTexSubImage2D later */ + glTexImage2D(vgl->tex_target, 0, + vgl->tex_internal, vgl->tex_width[j], vgl->tex_height[j], + 0, vgl->tex_format, vgl->tex_type, NULL); + } } - /* forward signal that scale has changed */ - if (p_vout->i_changes & VOUT_ZOOM_CHANGE ) - { - p_vout->i_changes &= ~VOUT_ZOOM_CHANGE; - - p_sys->p_vout->i_changes |= VOUT_ZOOM_CHANGE; - } + vlc_gl_Unlock(vgl->gl); + return vgl->pool; - return i_ret; +error: + for (unsigned i = 0; i < count; i++) + picture_Delete(picture[i]); + return NULL; } -/***************************************************************************** - * Render: render previously calculated output - *****************************************************************************/ -static void Render( vout_thread_t *p_vout, picture_t *p_pic ) +int vout_display_opengl_Prepare(vout_display_opengl_t *vgl, + picture_t *picture, subpicture_t *subpicture) { - VLC_UNUSED(p_pic); - vout_sys_t *p_sys = p_vout->p_sys; - /* On Win32/GLX, we do this the usual way: + Fill the buffer with new content, + Reload the texture, @@ -504,187 +504,242 @@ static void Render( vout_thread_t *p_vout, picture_t *p_pic ) (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. */ - - 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; - } - -#ifdef __APPLE__ - int i_new_index; - i_new_index = ( p_sys->i_index + 1 ) & 1; + Therefore on OSX, we have to use two buffers and textures and use a + lock(/unlock) managed picture pool. + */ + if (vlc_gl_Lock(vgl->gl)) + return VLC_EGENERIC; /* Update the texture */ - glBindTexture( VLCGL_TARGET, p_sys->p_textures[i_new_index] ); - glTexSubImage2D( VLCGL_TARGET, 0, 0, 0, - p_vout->fmt_out.i_width, - p_vout->fmt_out.i_height, - VLCGL_FORMAT, VLCGL_TYPE, p_sys->pp_buffer[i_new_index] ); - - /* Bind to the previous texture for drawing */ - glBindTexture( VLCGL_TARGET, p_sys->p_textures[p_sys->i_index] ); - - /* Switch buffers */ - p_sys->i_index = i_new_index; - p_pic->p->p_pixels = p_sys->pp_buffer[p_sys->i_index]; - -#else - /* Update the texture */ - glTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, - p_vout->fmt_out.i_width, - p_vout->fmt_out.i_height, - VLCGL_FORMAT, VLCGL_TYPE, p_sys->pp_buffer[0] ); -#endif + for (unsigned j = 0; j < vgl->chroma->plane_count; j++) { + const int plane = vgl->fmt.i_chroma == VLC_CODEC_YV12 && j > 0 ? (3 - j) : j; + if (vgl->use_multitexture) + vgl->ActiveTextureARB(GL_TEXTURE0_ARB + j); + glBindTexture(vgl->tex_target, vgl->texture[0][j]); + glPixelStorei(GL_UNPACK_ROW_LENGTH, picture->p[plane].i_pitch / picture->p[plane].i_pixel_pitch); + glTexSubImage2D(vgl->tex_target, 0, + 0, 0, + vgl->fmt.i_width * vgl->chroma->p[plane].w.num / vgl->chroma->p[plane].w.den, + vgl->fmt.i_height * vgl->chroma->p[plane].h.num / vgl->chroma->p[plane].h.den, + vgl->tex_format, vgl->tex_type, picture->p[plane].p_pixels); + } - if( p_sys->p_vout->pf_unlock ) - { - p_sys->p_vout->pf_unlock( p_sys->p_vout ); + int last_count = vgl->region_count; + gl_region_t *last = vgl->region; + + vgl->region_count = 0; + vgl->region = NULL; + + if (subpicture) { + + int count = 0; + for (subpicture_region_t *r = subpicture->p_region; r; r = r->p_next) + count++; + + vgl->region_count = count; + vgl->region = calloc(count, sizeof(*vgl->region)); + + if (vgl->use_multitexture) + vgl->ActiveTextureARB(GL_TEXTURE0_ARB + 0); + int i = 0; + for (subpicture_region_t *r = subpicture->p_region; r; r = r->p_next, i++) { + gl_region_t *glr = &vgl->region[i]; + + glr->format = GL_RGBA; + glr->type = GL_UNSIGNED_BYTE; + glr->width = r->fmt.i_visible_width; + glr->height = r->fmt.i_visible_height; + glr->alpha = (float)subpicture->i_alpha * r->i_alpha / 255 / 255; + glr->left = 2.0 * (r->i_x ) / subpicture->i_original_picture_width - 1.0; + glr->top = -2.0 * (r->i_y ) / subpicture->i_original_picture_height + 1.0; + glr->right = 2.0 * (r->i_x + r->fmt.i_visible_width ) / subpicture->i_original_picture_width - 1.0; + glr->bottom = -2.0 * (r->i_y + r->fmt.i_visible_height) / subpicture->i_original_picture_height + 1.0; + + glr->texture = 0; + for (int j = 0; j < last_count; j++) { + if (last[j].texture && + last[j].width == glr->width && + last[j].height == glr->height && + last[j].format == glr->format && + last[j].type == glr->type) { + glr->texture = last[j].texture; + memset(&last[j], 0, sizeof(last[j])); + break; + } + } + + if (glr->texture) { + glBindTexture(GL_TEXTURE_2D, glr->texture); + /* TODO set GL_UNPACK_ALIGNMENT */ + glPixelStorei(GL_UNPACK_ROW_LENGTH, r->p_picture->p->i_pitch / r->p_picture->p->i_pixel_pitch); + glTexSubImage2D(GL_TEXTURE_2D, 0, + 0, 0, glr->width, glr->height, + glr->format, glr->type, r->p_picture->p->p_pixels); + } else { + glGenTextures(1, &glr->texture); + glBindTexture(GL_TEXTURE_2D, glr->texture); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_PRIORITY, 1.0); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + /* TODO set GL_UNPACK_ALIGNMENT */ + glPixelStorei(GL_UNPACK_ROW_LENGTH, r->p_picture->p->i_pitch / r->p_picture->p->i_pixel_pitch); + glTexImage2D(GL_TEXTURE_2D, 0, glr->format, + glr->width, glr->height, 0, glr->format, glr->type, + r->p_picture->p->p_pixels); + } + } + } + for (int i = 0; i < last_count; i++) { + if (last[i].texture) + glDeleteTextures(1, &last[i].texture); } + free(last); + + vlc_gl_Unlock(vgl->gl); + VLC_UNUSED(subpicture); + return VLC_SUCCESS; } -/***************************************************************************** - * DisplayVideo: displays previously rendered output - *****************************************************************************/ -static void DisplayVideo( vout_thread_t *p_vout, picture_t *p_pic ) +int vout_display_opengl_Display(vout_display_opengl_t *vgl, + const video_format_t *source) { - VLC_UNUSED(p_pic); - vout_sys_t *p_sys = p_vout->p_sys; - float f_width, f_height, f_x, f_y; - - 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; - } + if (vlc_gl_Lock(vgl->gl)) + return VLC_EGENERIC; /* glTexCoord works differently with GL_TEXTURE_2D and GL_TEXTURE_RECTANGLE_EXT */ -#ifdef __APPLE__ - f_x = (float)p_vout->fmt_out.i_x_offset; - f_y = (float)p_vout->fmt_out.i_y_offset; - f_width = (float)p_vout->fmt_out.i_x_offset + - (float)p_vout->fmt_out.i_visible_width; - f_height = (float)p_vout->fmt_out.i_y_offset + - (float)p_vout->fmt_out.i_visible_height; -#else - f_x = (float)p_vout->fmt_out.i_x_offset / p_sys->i_tex_width; - f_y = (float)p_vout->fmt_out.i_y_offset / p_sys->i_tex_height; - f_width = ( (float)p_vout->fmt_out.i_x_offset + - p_vout->fmt_out.i_visible_width ) / p_sys->i_tex_width; - f_height = ( (float)p_vout->fmt_out.i_y_offset + - p_vout->fmt_out.i_visible_height ) / p_sys->i_tex_height; -#endif + float left[PICTURE_PLANE_MAX]; + float top[PICTURE_PLANE_MAX]; + float right[PICTURE_PLANE_MAX]; + float bottom[PICTURE_PLANE_MAX]; + for (unsigned j = 0; j < vgl->chroma->plane_count; j++) { + float scale_w, scale_h; + if (vgl->tex_target == GL_TEXTURE_2D) { + scale_w = (float)vgl->chroma->p[j].w.num / vgl->chroma->p[j].w.den / vgl->tex_width[j]; + scale_h = (float)vgl->chroma->p[j].h.num / vgl->chroma->p[j].h.den / vgl->tex_height[j]; + + } else { + scale_w = 1.0; + scale_h = 1.0; + } + left[j] = (source->i_x_offset + 0 ) * scale_w; + top[j] = (source->i_y_offset + 0 ) * scale_h; + right[j] = (source->i_x_offset + source->i_visible_width ) * scale_w; + bottom[j] = (source->i_y_offset + source->i_visible_height) * scale_h; + } + /* 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 */ + OpenGL providers can call vout_display_opengl_Display to force redraw.i + Currently, the OS X provider uses it to get a smooth window resizing */ - glClear( GL_COLOR_BUFFER_BIT ); + glClear(GL_COLOR_BUFFER_BIT); - glEnable( VLCGL_TARGET ); - glBegin( GL_POLYGON ); - glTexCoord2f( f_x, f_y ); glVertex2f( -1.0, 1.0 ); - glTexCoord2f( f_width, f_y ); glVertex2f( 1.0, 1.0 ); - glTexCoord2f( f_width, f_height ); glVertex2f( 1.0, -1.0 ); - glTexCoord2f( f_x, f_height ); glVertex2f( -1.0, -1.0 ); - glEnd(); + if (vgl->program) { + glEnable(GL_FRAGMENT_PROGRAM_ARB); + for (int i = 0; i < vgl->local_count; i++) + vgl->ProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, i, vgl->local_value[i]); + } else { + glEnable(vgl->tex_target); + } - glDisable( VLCGL_TARGET ); +#if USE_OPENGL_ES + static const GLfloat vertexCoord[] = { + -1.0f, -1.0f, + 1.0f, -1.0f, + -1.0f, 1.0f, + 1.0f, 1.0f, + }; + + const GLfloat textureCoord[8] = { + left[0], bottom[0], + right[0], bottom[0], + left[0], top[0], + right[0], top[0] + }; + + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + glVertexPointer(2, GL_FLOAT, 0, vertexCoord); + glTexCoordPointer(2, GL_FLOAT, 0, textureCoord); + + glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); +#else + for (unsigned j = 0; j < vgl->chroma->plane_count; j++) { + if (vgl->use_multitexture) + vgl->ActiveTextureARB(GL_TEXTURE0_ARB + j); + glBindTexture(vgl->tex_target, vgl->texture[0][j]); + } + glBegin(GL_POLYGON); - p_sys->p_vout->pf_swap( p_sys->p_vout ); + glTexCoord2f(left[0], top[0]); + for (unsigned j = 1; j < vgl->chroma->plane_count; j++) + vgl->MultiTexCoord2fARB(GL_TEXTURE0_ARB + j, left[j], top[j]); + glVertex2f(-1.0, 1.0); - if( p_sys->p_vout->pf_unlock ) - { - p_sys->p_vout->pf_unlock( p_sys->p_vout ); - } -} + glTexCoord2f(right[0], top[0]); + for (unsigned j = 1; j < vgl->chroma->plane_count; j++) + vgl->MultiTexCoord2fARB(GL_TEXTURE0_ARB + j, right[j], top[j]); + glVertex2f( 1.0, 1.0); -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; -} + glTexCoord2f(right[0], bottom[0]); + for (unsigned j = 1; j < vgl->chroma->plane_count; j++) + vgl->MultiTexCoord2fARB(GL_TEXTURE0_ARB + j, right[j], bottom[j]); + glVertex2f( 1.0, -1.0); -/***************************************************************************** - * 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; + glTexCoord2f(left[0], bottom[0]); + for (unsigned j = 1; j < vgl->chroma->plane_count; j++) + vgl->MultiTexCoord2fARB(GL_TEXTURE0_ARB + j, left[j], bottom[j]); + glVertex2f(-1.0, -1.0); - if( p_sys->p_vout->pf_control ) - return p_sys->p_vout->pf_control( p_sys->p_vout, i_query, args ); - return VLC_EGENERIC; -} + glEnd(); +#endif -static int InitTextures( vout_thread_t *p_vout ) -{ - vout_sys_t *p_sys = p_vout->p_sys; - int i_index; + if (vgl->program) + glDisable(GL_FRAGMENT_PROGRAM_ARB); + else + glDisable(vgl->tex_target); - glDeleteTextures( 2, p_sys->p_textures ); - glGenTextures( 2, p_sys->p_textures ); +#if !USE_OPENGL_ES + if (vgl->use_multitexture) + vgl->ActiveTextureARB(GL_TEXTURE0_ARB + 0); + glEnable(GL_TEXTURE_2D); + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + for (int i = 0; i < vgl->region_count; i++) { + gl_region_t *glr = &vgl->region[i]; - for( i_index = 0; i_index < 2; i_index++ ) - { - glBindTexture( VLCGL_TARGET, p_sys->p_textures[i_index] ); + glBindTexture(GL_TEXTURE_2D, glr->texture); - /* Set the texture parameters */ - glTexParameterf( VLCGL_TARGET, GL_TEXTURE_PRIORITY, 1.0 ); + glBegin(GL_POLYGON); - glTexParameteri( VLCGL_TARGET, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); - glTexParameteri( VLCGL_TARGET, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); + glColor4f(1.0, 1.0, 1.0, glr->alpha); - glTexParameteri( VLCGL_TARGET, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); - glTexParameteri( VLCGL_TARGET, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); + glTexCoord2f(0.0, 0.0); + glVertex2f(glr->left, glr->top); - glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ); + glTexCoord2f(1.0, 0.0); + glVertex2f(glr->right, glr->top); -#ifdef __APPLE__ - /* 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 ); + glTexCoord2f(1.0, 1.0); + glVertex2f(glr->right, glr->bottom); -#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 + glTexCoord2f(0.0, 1.0); + glVertex2f(glr->left, glr->bottom); - /* 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] ); + glEnd(); } + glDisable(GL_BLEND); + glDisable(GL_TEXTURE_2D); +#endif - return 0; -} + vlc_gl_Swap(vgl->gl); -/***************************************************************************** - * 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 ) -{ - VLC_UNUSED(p_this); VLC_UNUSED(oldval); - return var_Set( (vlc_object_t *)_p_vout, psz_var, newval ); + vlc_gl_Unlock(vgl->gl); + return VLC_SUCCESS; } +