X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fvideo_output%2Fopengl.c;h=f099f63f7fb5b736514f7df7371e4e67e8676511;hb=a8d2d402fe877607701fdd829bafd0982bfe1da9;hp=874eb0d7f1814e9550c10d1d241fc457d126e3a4;hpb=8b1ab3581cd5f41a58dbb8b52173b1b960842797;p=vlc diff --git a/modules/video_output/opengl.c b/modules/video_output/opengl.c index 874eb0d7f1..f099f63f7f 100644 --- a/modules/video_output/opengl.c +++ b/modules/video_output/opengl.c @@ -1,13 +1,15 @@ /***************************************************************************** - * opengl.c: OpenGL video output + * opengl.c: OpenGL and OpenGL ES output common code ***************************************************************************** - * Copyright (C) 2004 the VideoLAN team - * $Id$ + * Copyright (C) 2004-2012 VLC authors and VideoLAN + * Copyright (C) 2009, 2011 Laurent Aimar * * Authors: Cyril Deguet * Gildas Bazin * Eric Petit * Cedric Cocquebert + * Laurent Aimar + * Ilkka Ollakka * * 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,420 +25,933 @@ * 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 - #include -#include -#include +#include +#include +#include + #include "opengl.h" -/***************************************************************************** - * 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 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") ) +#ifndef GL_CLAMP_TO_EDGE +# define GL_CLAMP_TO_EDGE 0x812F +#endif + #ifdef __APPLE__ - set_capability( "video output", 400 ) -#else - set_capability( "video output", 20 ) +# define PFNGLGENBUFFERSPROC typeof(glGenBuffers)* +# define PFNGLBINDBUFFERPROC typeof(glBindBuffer)* +# define PFNGLDELETEBUFFERSPROC typeof(glDeleteBuffers)* +# define PFNGLBUFFERSUBDATAPROC typeof(glBufferSubData)* +# define PFNGLBUFFERDATAPROC typeof(glBufferData)* +# define PFNGLGETPROGRAMIVPROC typeof(glGetProgramiv)* +# define PFNGLGETPROGRAMINFOLOGPROC typeof(glGetProgramInfoLog)* +# define PFNGLGETSHADERIVPROC typeof(glGetShaderiv)* +# define PFNGLGETSHADERINFOLOGPROC typeof(glGetShaderInfoLog)* +# define PFNGLGETUNIFORMLOCATIONPROC typeof(glGetUniformLocation)* +# define PFNGLGETATTRIBLOCATIONPROC typeof(glGetAttribLocation)* +# define PFNGLVERTEXATTRIBPOINTERPROC typeof(glVertexAttribPointer)* +# define PFNGLENABLEVERTEXATTRIBARRAYPROC typeof(glEnableVertexAttribArray)* +# define PFNGLUNIFORM4FVPROC typeof(glUniform4fv)* +# define PFNGLUNIFORM4FPROC typeof(glUniform4f)* +# define PFNGLUNIFORM3IPROC typeof(glUniform3i)* +# define PFNGLUNIFORM1IPROC typeof(glUniform1i)* +# define PFNGLCREATESHADERPROC typeof(glCreateShader)* +# define PFNGLSHADERSOURCEPROC typeof(glShaderSource)* +# define PFNGLCOMPILESHADERPROC typeof(glCompileShader)* +# define PFNGLDETACHSHADERPROC typeof(glDetachShader)* +# define PFNGLDELETESHADERPROC typeof(glDeleteShader)* +# define PFNGLCREATEPROGRAMPROC typeof(glCreateProgram)* +# define PFNGLLINKPROGRAMPROC typeof(glLinkProgram)* +# define PFNGLUSEPROGRAMPROC typeof(glUseProgram)* +# define PFNGLDELETEPROGRAMPROC typeof(glDeleteProgram)* +# define PFNGLATTACHSHADERPROC typeof(glAttachShader)* +# define PFNGLACTIVETEXTUREPROC typeof(glActiveTexture)* +# define PFNGLCLIENTACTIVETEXTUREPROC typeof(glClientActiveTexture)* +#if USE_OPENGL_ES +# define GL_UNPACK_ROW_LENGTH 0 +# import +#endif #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 () -/***************************************************************************** - * 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; - vout_opengl_t gl; - vout_display_opengl_t vgl; +#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 - picture_pool_t *p_pool; - picture_t *p_current; +static const vlc_fourcc_t gl_subpicture_chromas[] = { + VLC_CODEC_RGBA, + 0 }; -/***************************************************************************** - * 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; - char * psz; - - /* Allocate structure */ - p_vout->p_sys = p_sys = malloc( sizeof( vout_sys_t ) ); - if( p_sys == NULL ) - return VLC_ENOMEM; - - /* 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 ); - - /* Forward events from the opengl provider */ - var_Create( p_sys->p_vout, "mouse-moved", VLC_VAR_COORDS ); - var_Create( p_sys->p_vout, "mouse-clicked", VLC_VAR_COORDS ); - 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-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_sys->p_vout, "video-on-top", SendEvents, p_vout ); - var_AddCallback( p_vout, "autoscale", SendEvents, p_sys->p_vout ); - var_AddCallback( p_vout, "scale", SendEvents, p_sys->p_vout ); - - 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" ); - /* no need for var_DelCallback here :-) */ - vlc_object_release( p_sys->p_vout ); - free( p_sys ); - return VLC_ENOOBJ; - } +typedef struct { + GLuint texture; + unsigned format; + unsigned type; + unsigned width; + unsigned height; - 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; + float alpha; - return VLC_SUCCESS; -} + float top; + float left; + float bottom; + float right; +} gl_region_t; -static int OpenglLock(vout_opengl_t *gl) -{ - vout_thread_t *p_vout = gl->sys; +struct vout_display_opengl_t { - if( !p_vout->pf_lock ) - return VLC_SUCCESS; - return p_vout->pf_lock( p_vout ); -} -static void OpenglUnlock(vout_opengl_t *gl) -{ - vout_thread_t *p_vout = gl->sys; + vlc_gl_t *gl; - if( p_vout->pf_unlock ) - p_vout->pf_unlock( p_vout ); -} -static void OpenglSwap(vout_opengl_t *gl) -{ - vout_thread_t *p_vout = gl->sys; - p_vout->pf_swap( p_vout ); -} + video_format_t fmt; + const vlc_chroma_description_t *chroma; -/***************************************************************************** - * 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 tex_target; + int tex_format; + int tex_internal; + int tex_type; - p_sys->p_vout->pf_init( p_sys->p_vout ); + int tex_width[PICTURE_PLANE_MAX]; + int tex_height[PICTURE_PLANE_MAX]; - p_sys->gl.lock = OpenglLock; - p_sys->gl.unlock = OpenglUnlock; - p_sys->gl.swap = OpenglSwap; - p_sys->gl.sys = p_sys->p_vout; + GLuint texture[VLCGL_TEXTURE_COUNT][PICTURE_PLANE_MAX]; - video_format_t fmt; - video_format_Init( &fmt, 0 ); - video_format_Setup( &fmt, - p_vout->render.i_chroma, - p_vout->render.i_width, - p_vout->render.i_height, - p_vout->render.i_aspect * p_vout->render.i_height, - VOUT_ASPECT_FACTOR * p_vout->render.i_width ); + int region_count; + gl_region_t *region; - if( vout_display_opengl_Init( &p_sys->vgl, &fmt, &p_sys->gl ) ) - { - I_OUTPUTPICTURES = 0; - return VLC_EGENERIC; - } - p_sys->p_pool = vout_display_opengl_GetPool( &p_sys->vgl ); - if( !p_sys->p_pool ) - { - vout_display_opengl_Clean( &p_sys->vgl ); - I_OUTPUTPICTURES = 0; - return VLC_EGENERIC; - } + picture_pool_t *pool; - /* */ - p_vout->output.i_chroma = fmt.i_chroma; - p_vout->output.i_rmask = fmt.i_rmask; - p_vout->output.i_gmask = fmt.i_gmask; - p_vout->output.i_bmask = fmt.i_bmask; + /* index 0 for normal and 1 for subtitle overlay */ + GLuint program[2]; + GLint shader[3]; //3. is for the common vertex shader + int local_count; + GLfloat local_value[16]; - /* 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; + /* Buffer commands */ + PFNGLGENBUFFERSPROC GenBuffers; + PFNGLBINDBUFFERPROC BindBuffer; + PFNGLDELETEBUFFERSPROC DeleteBuffers; + PFNGLBUFFERSUBDATAPROC BufferSubData; - p_vout->fmt_out = p_vout->fmt_in; - p_vout->fmt_out.i_chroma = p_vout->output.i_chroma; + PFNGLBUFFERDATAPROC BufferData; - /* */ - p_sys->p_current = picture_pool_Get( p_sys->p_pool ); - p_vout->p_picture[0] = *p_sys->p_current; - p_vout->p_picture[0].i_status = DESTROYED_PICTURE; - p_vout->p_picture[0].i_type = DIRECT_PICTURE; - p_vout->p_picture[0].i_refcount = 0; - p_vout->p_picture[0].p_sys = NULL; - PP_OUTPUTPICTURE[0] = &p_vout->p_picture[0]; + /* Shader variables commands*/ - I_OUTPUTPICTURES = 1; + PFNGLGETUNIFORMLOCATIONPROC GetUniformLocation; + PFNGLGETATTRIBLOCATIONPROC GetAttribLocation; + PFNGLVERTEXATTRIBPOINTERPROC VertexAttribPointer; + PFNGLENABLEVERTEXATTRIBARRAYPROC EnableVertexAttribArray; - return VLC_SUCCESS; -} + PFNGLUNIFORM4FVPROC Uniform4fv; + PFNGLUNIFORM4FPROC Uniform4f; + PFNGLUNIFORM3IPROC Uniform3i; + PFNGLUNIFORM1IPROC Uniform1i; -/***************************************************************************** - * End: terminate GLX video thread output method - *****************************************************************************/ -static void End( vout_thread_t *p_vout ) -{ - vout_sys_t *p_sys = p_vout->p_sys; + /* Shader command */ + PFNGLCREATESHADERPROC CreateShader; + PFNGLSHADERSOURCEPROC ShaderSource; + PFNGLCOMPILESHADERPROC CompileShader; + PFNGLDETACHSHADERPROC DetachShader; + PFNGLDELETESHADERPROC DeleteShader; - if( I_OUTPUTPICTURES > 0 ) - { + PFNGLCREATEPROGRAMPROC CreateProgram; + PFNGLLINKPROGRAMPROC LinkProgram; + PFNGLUSEPROGRAMPROC UseProgram; + PFNGLDELETEPROGRAMPROC DeleteProgram; - if( p_sys->p_current ) - picture_Release( p_sys->p_current ); - vout_display_opengl_Clean( &p_sys->vgl ); + PFNGLATTACHSHADERPROC AttachShader; - p_vout->p_picture[0].i_status = FREE_PICTURE; - I_OUTPUTPICTURES = 0; - } + /* Shader log commands */ + PFNGLGETPROGRAMIVPROC GetProgramiv; + PFNGLGETPROGRAMINFOLOGPROC GetProgramInfoLog; + PFNGLGETSHADERIVPROC GetShaderiv; + PFNGLGETSHADERINFOLOGPROC GetShaderInfoLog; + + + /* multitexture */ + PFNGLACTIVETEXTUREPROC ActiveTexture; + PFNGLCLIENTACTIVETEXTUREPROC ClientActiveTexture; + bool use_multitexture; + + /* Non-power-of-2 texture size support */ + bool supports_npot; +}; - /* We must release the opengl provider here: opengl requiere init and end - to be done in the same thread */ - module_unneed( p_sys->p_vout, p_sys->p_vout->p_module ); - vlc_object_release( p_sys->p_vout ); +static inline int GetAlignedSize(unsigned size) +{ + /* Return the smallest larger or equal power of 2 */ + unsigned align = 1 << (8 * sizeof (unsigned) - clz(size)); + return ((align >> 1) == size) ? size : align; } -/***************************************************************************** - * Destroy: destroy GLX video thread output method - ***************************************************************************** - * Terminate an output method created by CreateVout - *****************************************************************************/ -static void DestroyVout( vlc_object_t *p_this ) +#if !USE_OPENGL_ES +static bool IsLuminance16Supported(int target) { - vout_thread_t *p_vout = (vout_thread_t *)p_this; - vout_sys_t *p_sys = p_vout->p_sys; + GLuint texture; - free( p_sys ); + 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); + + glDeleteTextures(1, &texture); + + return size == 16; } +#endif -/***************************************************************************** - * 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 ) +vout_display_opengl_t *vout_display_opengl_New(video_format_t *fmt, + const vlc_fourcc_t **subpicture_chromas, + vlc_gl_t *gl) { - 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_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 = (int64_t)p_vout->fmt_in.i_sar_num * p_vout->fmt_in.i_width * VOUT_ASPECT_FACTOR / - p_vout->fmt_in.i_sar_den / p_vout->fmt_in.i_height; - - 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; + 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; + } -#ifdef __APPLE__ - /* 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 ) + if( vgl->gl->getProcAddress == NULL ) { - /* FIXME should we release p_current ? */ - vout_display_opengl_ResetTextures( &p_sys->vgl ); + fprintf(stderr, "getProcAddress not implemented, bailing out\n"); + free( vgl ); + return NULL; } + + const char *extensions = (const char *)glGetString(GL_EXTENSIONS); +#if !USE_OPENGL_ES + const unsigned char *ogl_version = glGetString(GL_VERSION); + bool supports_shaders = strverscmp((const char *)ogl_version, "2.0") >= 0; +#else + bool supports_shaders = false; +#ifdef __APPLE__ + if( kCFCoreFoundationVersionNumber >= 786. ) + supports_shaders = true; +#endif #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; + GLint max_texture_units = 0; + glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &max_texture_units); + + /* Initialize with default chroma */ + vgl->fmt = *fmt; + 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; + /* Use YUV if possible and needed */ + bool need_fs_yuv = false; + float yuv_range_correction = 1.0; + if ( max_texture_units >= 3 && supports_shaders && + 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; +#if !USE_OPENGL_ES + } 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; +#endif + } + list++; + } } - /* forward signal that autoscale toggle has changed */ - if (p_vout->i_changes & VOUT_SCALE_CHANGE ) + vgl->GenBuffers = (PFNGLGENBUFFERSPROC)vlc_gl_GetProcAddress(vgl->gl, "glGenBuffers"); + vgl->BindBuffer = (PFNGLBINDBUFFERPROC)vlc_gl_GetProcAddress(vgl->gl, "glBindBuffer"); + vgl->BufferData = (PFNGLBUFFERDATAPROC)vlc_gl_GetProcAddress(vgl->gl, "glBufferData"); + vgl->BufferSubData = (PFNGLBUFFERSUBDATAPROC)vlc_gl_GetProcAddress(vgl->gl, "glBufferSubData"); + vgl->DeleteBuffers = (PFNGLDELETEBUFFERSPROC)vlc_gl_GetProcAddress(vgl->gl, "glDeleteBuffers"); + + vgl->CreateShader = (PFNGLCREATESHADERPROC)vlc_gl_GetProcAddress(vgl->gl, "glCreateShader"); + vgl->ShaderSource = (PFNGLSHADERSOURCEPROC)vlc_gl_GetProcAddress(vgl->gl, "glShaderSource"); + vgl->CompileShader = (PFNGLCOMPILESHADERPROC)vlc_gl_GetProcAddress(vgl->gl, "glCompileShader"); + vgl->AttachShader = (PFNGLATTACHSHADERPROC)vlc_gl_GetProcAddress(vgl->gl, "glAttachShader"); + + vgl->GetProgramiv = (PFNGLGETPROGRAMIVPROC)vlc_gl_GetProcAddress(vgl->gl, "glGetProgramiv"); + vgl->GetShaderiv = (PFNGLGETSHADERIVPROC)vlc_gl_GetProcAddress(vgl->gl, "glGetShaderiv"); + vgl->GetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)vlc_gl_GetProcAddress(vgl->gl, "glGetProgramInfoLog"); + vgl->GetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)vlc_gl_GetProcAddress(vgl->gl, "glGetShaderInfoLog"); + + vgl->DetachShader = (PFNGLDETACHSHADERPROC)vlc_gl_GetProcAddress(vgl->gl, "glDetachShader"); + vgl->DeleteShader = (PFNGLDELETESHADERPROC)vlc_gl_GetProcAddress(vgl->gl, "glDeleteShader"); + + vgl->GetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)vlc_gl_GetProcAddress(vgl->gl, "glGetUniformLocation"); + vgl->GetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)vlc_gl_GetProcAddress(vgl->gl, "glGetAttribLocation"); + vgl->VertexAttribPointer= (PFNGLVERTEXATTRIBPOINTERPROC)vlc_gl_GetProcAddress(vgl->gl, "glVertexAttribPointer"); + vgl->EnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)vlc_gl_GetProcAddress(vgl->gl, "glEnableVertexAttribArray"); + vgl->Uniform4fv = (PFNGLUNIFORM4FVPROC)vlc_gl_GetProcAddress(vgl->gl,"glUniform4fv"); + vgl->Uniform4f = (PFNGLUNIFORM4FPROC)vlc_gl_GetProcAddress(vgl->gl,"glUniform4f"); + vgl->Uniform3i = (PFNGLUNIFORM3IPROC)vlc_gl_GetProcAddress(vgl->gl,"glUniform3i"); + vgl->Uniform1i = (PFNGLUNIFORM1IPROC)vlc_gl_GetProcAddress(vgl->gl,"glUniform1i"); + + vgl->CreateProgram = (PFNGLCREATEPROGRAMPROC)vlc_gl_GetProcAddress(vgl->gl, "glCreateProgram"); + vgl->LinkProgram = (PFNGLLINKPROGRAMPROC)vlc_gl_GetProcAddress(vgl->gl, "glLinkProgram"); + vgl->UseProgram = (PFNGLUSEPROGRAMPROC)vlc_gl_GetProcAddress(vgl->gl, "glUseProgram"); + vgl->DeleteProgram = (PFNGLDELETEPROGRAMPROC)vlc_gl_GetProcAddress(vgl->gl, "glDeleteProgram"); + vgl->ActiveTexture = (PFNGLACTIVETEXTUREPROC)vlc_gl_GetProcAddress(vgl->gl, "glActiveTexture"); + vgl->ClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)vlc_gl_GetProcAddress(vgl->gl, "glClientActiveTexture"); + + vgl->chroma = vlc_fourcc_GetChromaDescription(vgl->fmt.i_chroma); + vgl->use_multitexture = vgl->chroma->plane_count > 1; + vgl->supports_npot = HasExtension( extensions, "GL_ARB_texture_non_power_of_two" ) || + HasExtension( extensions, "GL_APPLE_texture_2D_limited_npot" ); + + if( !vgl->CreateShader || !vgl->ShaderSource || !vgl->CreateProgram ) { - p_vout->i_changes &= ~VOUT_SCALE_CHANGE; + fprintf(stderr, "Looks like you don't have all the opengl we need. Driver is %s, giving up\n", glGetString(GL_VERSION)); + free( vgl ); + return NULL; + } - p_sys->p_vout->i_changes |= VOUT_SCALE_CHANGE; + + /* 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( vgl->supports_npot ) + { + vgl->tex_width[j] = w; + vgl->tex_height[j] = h; + } else { + vgl->tex_width[j] = GetAlignedSize(w); + vgl->tex_height[j] = GetAlignedSize(h); + } } - /* forward signal that scale has changed */ - if (p_vout->i_changes & VOUT_ZOOM_CHANGE ) - { - p_vout->i_changes &= ~VOUT_ZOOM_CHANGE; + /* Build fragment program if needed */ + vgl->program[0] = 0; + vgl->program[1] = 0; + vgl->local_count = 0; + vgl->shader[0] = vgl->shader[1] = vgl->shader[2] = -1; + if (supports_shaders) { + char *code = NULL; + + /* [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[12] = { + 1.164383561643836, 0.0000, 1.596026785714286, -0.874202217873451 , + 1.164383561643836, -0.391762290094914, -0.812967647237771, 0.531667823499146 , + 1.164383561643836, 2.017232142857142, 0.0000, -1.085630789302022 , + }; + const float matrix_bt709_tv2full[12] = { + 1.164383561643836, 0.0000, 1.792741071428571, -0.972945075016308 , + 1.164383561643836, -0.21324861427373, -0.532909328559444, 0.301482665475862 , + 1.164383561643836, 2.112401785714286, 0.0000, -1.133402217873451 , + }; + const float (*matrix) = fmt->i_height > 576 ? matrix_bt709_tv2full + : matrix_bt601_tv2full; + + /* Basic linear YUV -> RGB conversion using bilinear interpolation */ + const char *template_glsl_yuv = + "#version 120\n" + "uniform sampler2D Texture[3];" + "uniform vec4 coefficient[4];" + "varying vec4 TexCoord0,TexCoord1,TexCoord2;" + + "void main(void) {" + " vec4 x,y,z,result;" + " x = texture2D(Texture[0], TexCoord0.st);" + " %c = texture2D(Texture[1], TexCoord1.st);" + " %c = texture2D(Texture[2], TexCoord2.st);" + + " result = x * coefficient[0] + coefficient[3];" + " result = (y * coefficient[1]) + result;" + " result = (z * coefficient[2]) + result;" + " gl_FragColor = result;" + "}"; + bool swap_uv = vgl->fmt.i_chroma == VLC_CODEC_YV12 || + vgl->fmt.i_chroma == VLC_CODEC_YV9; + if (asprintf(&code, template_glsl_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; + /* We place coefficient values for coefficient[4] in one array from matrix values. + Notice that we fill values from top down instead of left to right.*/ + for( int j = 0; j < 4; j++ ) + vgl->local_value[vgl->local_count + i*4+j] = j < 3 ? correction * matrix[j*4+i] : 0.0 ; + } + vgl->local_count += 4; + + // Basic vertex shader that we use in both cases + const char *vertexShader = + "#version 120\n" + "varying vec4 TexCoord0,TexCoord1, TexCoord2;" + "attribute vec4 MultiTexCoord0,MultiTexCoord1,MultiTexCoord2;" + "attribute vec4 vertex_position;" + "void main() {" + " TexCoord0 = MultiTexCoord0;" + " TexCoord1 = MultiTexCoord1;" + " TexCoord2 = MultiTexCoord2;" + " gl_Position = vertex_position; }"; + + // Dummy shader for text overlay + const char *helloShader = + "#version 120\n" + "uniform sampler2D Texture[3];" + "uniform vec4 fillColor;" + "varying vec4 TexCoord0,TexCoord1,TexCoord2;" + "void main()" + "{ " + " gl_FragColor = texture2D(Texture[0], TexCoord0.st)*fillColor;}"; + + vgl->shader[2] = vgl->CreateShader( GL_VERTEX_SHADER ); + vgl->ShaderSource( vgl->shader[2], 1, (const GLchar **)&vertexShader, NULL); + vgl->CompileShader( vgl->shader[2] ); + + /* Create 'dummy' shader that handles subpicture overlay for now*/ + vgl->shader[1] = vgl->CreateShader( GL_FRAGMENT_SHADER ); + vgl->ShaderSource( vgl->shader[1], 1, &helloShader, NULL); + vgl->CompileShader( vgl->shader[1] ); + vgl->program[1] = vgl->CreateProgram(); + vgl->AttachShader( vgl->program[1], vgl->shader[1]); + vgl->AttachShader( vgl->program[1], vgl->shader[2]); + vgl->LinkProgram( vgl->program[1] ); + + // Create shader from code + vgl->shader[0] = vgl->CreateShader( GL_FRAGMENT_SHADER ); + vgl->program[0] = vgl->CreateProgram(); + if( need_fs_yuv ) + { + vgl->ShaderSource( vgl->shader[0], 1, (const GLchar **)&code, NULL ); + vgl->CompileShader( vgl->shader[0]); + vgl->AttachShader( vgl->program[0], vgl->shader[0] ); + } else { + /* Use simpler shader if we don't need to to yuv -> rgb, + for example when input is allready rgb (.bmp image).*/ + vgl->AttachShader( vgl->program[0], vgl->shader[1] ); + } + vgl->AttachShader( vgl->program[0], vgl->shader[2]); + + vgl->LinkProgram( vgl->program[0] ); + + free(code); + for( GLuint i = 0; i < 2; i++ ) + { + int infoLength = 0; + int charsWritten = 0; + char *infolog; + vgl->GetProgramiv( vgl->program[i], GL_INFO_LOG_LENGTH, &infoLength ); + if( infoLength > 1 ) + { + /* If there is some message, better to check linking is ok */ + GLint link_status = GL_TRUE; + vgl->GetProgramiv( vgl->program[i], GL_LINK_STATUS, &link_status ); + + infolog = (char *)malloc(infoLength); + vgl->GetProgramInfoLog( vgl->program[i], infoLength, &charsWritten, infolog ); + fprintf(stderr, "shader program %d:%s %d\n",i,infolog,infoLength); + free(infolog); + + /* Check shaders messages too */ + for( GLuint j = 0; j < 2; j++ ) + { + vgl->GetShaderiv( vgl->shader[j], GL_INFO_LOG_LENGTH, &infoLength ); + if( infoLength > 1 ) + { + infolog = (char *)malloc(infoLength); + vgl->GetShaderInfoLog( vgl->shader[j], infoLength, &charsWritten, infolog ); + fprintf(stderr, "shader %d: %s\n",j,infolog ); + free( infolog ); + } + } + + if( link_status == GL_FALSE ) + { + fprintf( stderr, "Unable to use program %d\n", i ); + free( vgl ); + return NULL; + } + } + } + } + + /* */ + 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); + + vlc_gl_Unlock(vgl->gl); - p_sys->p_vout->i_changes |= VOUT_ZOOM_CHANGE; + /* */ + 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 = gl_subpicture_chromas; + } + return vgl; +} - return i_ret; +void vout_display_opengl_Delete(vout_display_opengl_t *vgl) +{ + /* */ + 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[0]) + { + for( int i = 0; i < 2; i++ ) + vgl->DeleteProgram( vgl->program[i] ); + for( int i = 0; i < 3; i++ ) + vgl->DeleteShader( vgl->shader[i] ); + } + + vlc_gl_Unlock(vgl->gl); + } + if (vgl->pool) + picture_pool_Delete(vgl->pool); + free(vgl); } -/***************************************************************************** - * Render: render previously calculated output - *****************************************************************************/ -static void Render( vout_thread_t *p_vout, picture_t *p_pic ) +picture_pool_t *vout_display_opengl_GetPool(vout_display_opengl_t *vgl, unsigned requested_count) { - vout_sys_t *p_sys = p_vout->p_sys; + if (vgl->pool) + return vgl->pool; - picture_t *p_next = p_sys->p_current; + /* Allocate our pictures */ + picture_t *picture[VLCGL_PICTURE_MAX] = {NULL, }; + unsigned count = 0; - if( VLCGL_TEXTURE_COUNT > 1 ) - { - /* Get the next picture to display */ - p_next = picture_pool_Get( p_sys->p_pool ); - assert( p_next ); + 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->ActiveTexture(GL_TEXTURE0 + j); + vgl->ClientActiveTexture(GL_TEXTURE0 + 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 - if( p_sys->p_current ) - { - assert( p_sys->p_current->p[0].p_pixels == p_pic->p[0].p_pixels ); - - /* Make sure we have the prepare after the picture_pool_Get, - * because picture_pool_Get() will bind the new picture texture, - * and vout_display_opengl_Prepare() bind the current rendered picture - * texture. - * DisplayVideo() will effectively use the last binded texture. */ + 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); - vout_display_opengl_Prepare( &p_sys->vgl, p_sys->p_current ); + /* 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); + } } - if( p_sys->p_current != p_next ) { - if( p_sys->p_current ) - picture_Release( p_sys->p_current ); + vlc_gl_Unlock(vgl->gl); + + return vgl->pool; + +error: + for (unsigned i = 0; i < count; i++) + picture_Release(picture[i]); + return NULL; +} + +int vout_display_opengl_Prepare(vout_display_opengl_t *vgl, + picture_t *picture, subpicture_t *subpicture) +{ + /* 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 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; - /* Swap the picture texture on opengl vout side. */ - p_sys->p_current = p_next; + /* Update the texture */ + for (unsigned j = 0; j < vgl->chroma->plane_count; j++) { + if (vgl->use_multitexture) + { + vgl->ActiveTexture(GL_TEXTURE0 + j); + vgl->ClientActiveTexture(GL_TEXTURE0 + j); + } + glBindTexture(vgl->tex_target, vgl->texture[0][j]); + glPixelStorei(GL_UNPACK_ROW_LENGTH, picture->p[j].i_pitch / picture->p[j].i_pixel_pitch); + glTexSubImage2D(vgl->tex_target, 0, + 0, 0, + vgl->fmt.i_width * vgl->chroma->p[j].w.num / vgl->chroma->p[j].w.den, + vgl->fmt.i_height * vgl->chroma->p[j].h.num / vgl->chroma->p[j].h.den, + vgl->tex_format, vgl->tex_type, picture->p[j].p_pixels); + } - /* Now, switch the only picture that is being used - * to render in the backend to point to our "next" - * picture texture */ - p_pic->p[0].p_pixels = p_sys->p_current->p[0].p_pixels; + 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->ActiveTexture(GL_TEXTURE0 + 0); + vgl->ClientActiveTexture(GL_TEXTURE0 + 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; + if(!vgl->supports_npot ) + { + glr->width = GetAlignedSize( glr->width ); + glr->height = GetAlignedSize( glr->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; + } + } + + const int pixels_offset = r->fmt.i_y_offset * r->p_picture->p->i_pitch + + r->fmt.i_x_offset * r->p_picture->p->i_pixel_pitch; + 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[pixels_offset]); + } else { + glGenTextures(1, &glr->texture); + glBindTexture(GL_TEXTURE_2D, glr->texture); +#if !USE_OPENGL_ES + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_PRIORITY, 1.0); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); +#endif + 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[pixels_offset]); + } + } } + for (int i = 0; i < last_count; i++) { + if (last[i].texture) + glDeleteTextures(1, &last[i].texture); + } + free(last); - VLC_UNUSED( p_pic ); + 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 ) +static void draw_without_shaders( vout_display_opengl_t *vgl, float *left, float *top, float *right, float *bottom ) { - vout_sys_t *p_sys = p_vout->p_sys; + 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] + }; + + for (unsigned j = 0; j < vgl->chroma->plane_count; j++) { + vgl->ActiveTexture( GL_TEXTURE0 + j ); + vgl->ClientActiveTexture( GL_TEXTURE0 + j ); + + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + + glEnable(vgl->tex_target); + + glBindTexture(vgl->tex_target, vgl->texture[0][j]); + glTexCoordPointer(2, GL_FLOAT, 0, textureCoord); + } + vgl->ActiveTexture( GL_TEXTURE0 ); + vgl->ClientActiveTexture( GL_TEXTURE0 ); + + glVertexPointer(2, GL_FLOAT, 0, vertexCoord); - vout_display_opengl_Display( &p_sys->vgl, &p_vout->fmt_out ); - VLC_UNUSED( p_pic ); + glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); + + for (unsigned j = 0; j < vgl->chroma->plane_count; j++) { + vgl->ActiveTexture( GL_TEXTURE0 + j ); + vgl->ClientActiveTexture( GL_TEXTURE0 + j ); + glDisable(vgl->tex_target); + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + glDisableClientState(GL_VERTEX_ARRAY); + } + vgl->ActiveTexture( GL_TEXTURE0 ); + vgl->ClientActiveTexture( GL_TEXTURE0 ); } -/***************************************************************************** - * Control: control facility for the vout - *****************************************************************************/ -static int Control( vout_thread_t *p_vout, int i_query, va_list args ) +static void draw_with_shaders( vout_display_opengl_t *vgl, float *left, float *top, float *right, float *bottom ) { - vout_sys_t *p_sys = p_vout->p_sys; - if( p_sys->p_vout->pf_control ) - return p_sys->p_vout->pf_control( p_sys->p_vout, i_query, args ); - return VLC_EGENERIC; + const GLfloat vertexCoord[] = { + -1.0, 1.0, + -1.0, -1.0, + 1.0, 1.0, + 1.0, -1.0, + }; + + for( unsigned j = 0; j < vgl->chroma->plane_count; j++) + { + char *attribute = NULL; + const GLfloat texCoord[] = { + left[j], top[j], + left[j], bottom[j], + right[j], top[j], + right[j], bottom[j], + }; + vgl->ActiveTexture( GL_TEXTURE0+j); + vgl->ClientActiveTexture( GL_TEXTURE0+j); + glEnable(vgl->tex_target); + glBindTexture(vgl->tex_target, vgl->texture[0][j]); + if(asprintf( &attribute, "MultiTexCoord%1d", j ) == -1 ) + return; + + vgl->EnableVertexAttribArray( vgl->GetAttribLocation(vgl->program[0], attribute ) ); + vgl->VertexAttribPointer( vgl->GetAttribLocation( vgl->program[0], attribute ), 2, GL_FLOAT, 0, 0, texCoord); + free( attribute ); + attribute = NULL; + } + vgl->ActiveTexture(GL_TEXTURE0 + 0); + vgl->ClientActiveTexture(GL_TEXTURE0 + 0); + vgl->EnableVertexAttribArray( vgl->GetAttribLocation( vgl->program[0], "vertex_position")); + vgl->VertexAttribPointer( vgl->GetAttribLocation( vgl->program[0], "vertex_position"), 2, GL_FLOAT, 0, 0, vertexCoord); + + glDrawArrays( GL_TRIANGLE_STRIP, 0, 4); } -/***************************************************************************** - * 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 ) +int vout_display_opengl_Display(vout_display_opengl_t *vgl, + const video_format_t *source) { - VLC_UNUSED(p_this); VLC_UNUSED(oldval); - return var_Set( (vlc_object_t *)_p_vout, psz_var, newval ); + if (vlc_gl_Lock(vgl->gl)) + return VLC_EGENERIC; + + /* glTexCoord works differently with GL_TEXTURE_2D and + GL_TEXTURE_RECTANGLE_EXT */ + 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 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); + + + if( vgl->program[0] ) + { + vgl->UseProgram(vgl->program[0]); + vgl->Uniform4fv( vgl->GetUniformLocation( vgl->program[0], "coefficient" ), 4, vgl->local_value); + vgl->Uniform1i( vgl->GetUniformLocation( vgl->program[0], "Texture[0]" ), 0); + vgl->Uniform1i( vgl->GetUniformLocation( vgl->program[0], "Texture[1]" ), 1); + vgl->Uniform1i( vgl->GetUniformLocation( vgl->program[0], "Texture[2]" ), 2); + draw_with_shaders( vgl, left, top ,right, bottom ); + // Change the program for overlays + vgl->UseProgram(vgl->program[1]); + vgl->Uniform1i( vgl->GetUniformLocation( vgl->program[1], "Texture[0]" ), 0); + } else { + draw_without_shaders( vgl, left, top, right, bottom ); + } + + vgl->ActiveTexture(GL_TEXTURE0 + 0); + vgl->ClientActiveTexture(GL_TEXTURE0 + 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]; + const GLfloat vertexCoord[] = { + glr->left, glr->top, + glr->left, glr->bottom, + glr->right, glr->top, + glr->right,glr->bottom, + }; + static const GLfloat textureCoord[] = { + 0.0, 0.0, + 0.0, 1.0, + 1.0, 0.0, + 1.0, 1.0, + }; + + glBindTexture(GL_TEXTURE_2D, glr->texture); + if( vgl->program[0] ) + { + vgl->Uniform4f( vgl->GetUniformLocation( vgl->program[1], "fillColor"), 1.0f, 1.0f, 1.0f, glr->alpha); + vgl->EnableVertexAttribArray( vgl->GetAttribLocation( vgl->program[1], "MultiTexCoord0") ); + vgl->VertexAttribPointer( vgl->GetAttribLocation( vgl->program[1], "MultiTexCoord0"), 2, GL_FLOAT, 0, 0, textureCoord); + vgl->EnableVertexAttribArray( vgl->GetAttribLocation( vgl->program[1], "vertex_position")); + vgl->VertexAttribPointer( vgl->GetAttribLocation( vgl->program[1], "vertex_position"), 2, GL_FLOAT, 0, 0, vertexCoord); + } + else + { + glEnableClientState(GL_VERTEX_ARRAY); + glColor4f( 1.0f, 1.0f, 1.0f, glr->alpha ); + glEnable(GL_TEXTURE_COORD_ARRAY); + glEnable(GL_VERTEX_ARRAY); + glTexCoordPointer(2, GL_FLOAT, 0, textureCoord); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + glVertexPointer(2, GL_FLOAT, 0, vertexCoord); + } + + glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 ); + + if( !vgl->program[0] ) + { + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + glDisableClientState(GL_VERTEX_ARRAY); + } + } + glDisable(GL_BLEND); + glDisable(GL_TEXTURE_2D); + + vlc_gl_Swap(vgl->gl); + + vlc_gl_Unlock(vgl->gl); + return VLC_SUCCESS; }