X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fvideo_output%2Fopengl.c;h=d18e096d0e78f0f5d64e45b0989c3b4600880dba;hb=de0bf007ea2fee4a6062a0616e0ca77dae50e3a7;hp=874eb0d7f1814e9550c10d1d241fc457d126e3a4;hpb=8b1ab3581cd5f41a58dbb8b52173b1b960842797;p=vlc diff --git a/modules/video_output/opengl.c b/modules/video_output/opengl.c index 874eb0d7f1..d18e096d0e 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,420 +24,723 @@ * 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" +// Define USE_OPENGL_ES to the GL ES Version you want to select -/***************************************************************************** - * 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") ) #ifdef __APPLE__ - set_capability( "video output", 400 ) -#else - set_capability( "video output", 20 ) +# 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 - 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; +/* 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 - picture_pool_t *p_pool; - picture_t *p_current; +#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 + +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 { + vlc_gl_t *gl; - 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; + video_format_t fmt; + const vlc_chroma_description_t *chroma; - if( p_vout->pf_unlock ) - p_vout->pf_unlock( p_vout ); -} -static void OpenglSwap(vout_opengl_t *gl) + 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; + + + 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; +}; + +static inline int GetAlignedSize(unsigned size) { - vout_thread_t *p_vout = gl->sys; - p_vout->pf_swap( p_vout ); + /* Return the smallest larger or equal power of 2 */ + unsigned align = 1 << (8 * sizeof (unsigned) - clz(size)); + return ((align >> 1) == size) ? size : align; } -/***************************************************************************** - * Init: initialize the OpenGL video thread output method - *****************************************************************************/ -static int Init( vout_thread_t *p_vout ) +static bool IsLuminance16Supported(int target) { - vout_sys_t *p_sys = p_vout->p_sys; + GLuint texture; - p_sys->p_vout->pf_init( p_sys->p_vout ); + 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); - p_sys->gl.lock = OpenglLock; - p_sys->gl.unlock = OpenglUnlock; - p_sys->gl.swap = OpenglSwap; - p_sys->gl.sys = p_sys->p_vout; + glDeleteTextures(1, &texture); - 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 ); - - - if( vout_display_opengl_Init( &p_sys->vgl, &fmt, &p_sys->gl ) ) - { - I_OUTPUTPICTURES = 0; - return VLC_EGENERIC; + 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_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; + + 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; } - /* */ - 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; + 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); + } + + /* 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 + 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 + 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 + /* 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++; + } + } + + vgl->chroma = vlc_fourcc_GetChromaDescription(vgl->fmt.i_chroma); + vgl->use_multitexture = vgl->chroma->plane_count > 1; + + 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 - /* 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; + /* 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); + } + } - p_vout->fmt_out = p_vout->fmt_in; - p_vout->fmt_out.i_chroma = p_vout->output.i_chroma; + /* 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); + + 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); + } + } /* */ - 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]; + 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); - I_OUTPUTPICTURES = 1; + vlc_gl_Unlock(vgl->gl); - return VLC_SUCCESS; + /* */ + 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; } -/***************************************************************************** - * End: terminate GLX video thread output method - *****************************************************************************/ -static void End( vout_thread_t *p_vout ) +void vout_display_opengl_Delete(vout_display_opengl_t *vgl) { - vout_sys_t *p_sys = p_vout->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); +} - if( I_OUTPUTPICTURES > 0 ) - { +picture_pool_t *vout_display_opengl_GetPool(vout_display_opengl_t *vgl, unsigned requested_count) +{ + if (vgl->pool) + return vgl->pool; - if( p_sys->p_current ) - picture_Release( p_sys->p_current ); - vout_display_opengl_Clean( &p_sys->vgl ); + /* Allocate our pictures */ + picture_t *picture[VLCGL_PICTURE_MAX] = {NULL, }; + unsigned count = 0; - p_vout->p_picture[0].i_status = FREE_PICTURE; - I_OUTPUTPICTURES = 0; + 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 - /* 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 ); -} + 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); -/***************************************************************************** - * Destroy: destroy GLX video thread output method - ***************************************************************************** - * Terminate an output method created by CreateVout - *****************************************************************************/ -static void DestroyVout( vlc_object_t *p_this ) -{ - vout_thread_t *p_vout = (vout_thread_t *)p_this; - vout_sys_t *p_sys = p_vout->p_sys; + /* 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); + } + } + + vlc_gl_Unlock(vgl->gl); + + return vgl->pool; - free( p_sys ); +error: + for (unsigned i = 0; i < count; i++) + picture_Release(picture[i]); + return NULL; } -/***************************************************************************** - * 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 ) +int vout_display_opengl_Prepare(vout_display_opengl_t *vgl, + picture_t *picture, subpicture_t *subpicture) { - 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; + /* On Win32/GLX, we do this the usual way: + + Fill the buffer with new content, + + Reload the texture, + + Use the texture. -#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 ) - { - /* FIXME should we release p_current ? */ - vout_display_opengl_ResetTextures( &p_sys->vgl ); + 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; + + /* Update the texture */ + 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]); + 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); } -#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; + 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; + } + } + + 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); + 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[pixels_offset]); + } + } } + for (int i = 0; i < last_count; i++) { + if (last[i].texture) + glDeleteTextures(1, &last[i].texture); + } + free(last); - /* forward signal that autoscale toggle has changed */ - if (p_vout->i_changes & VOUT_SCALE_CHANGE ) - { - p_vout->i_changes &= ~VOUT_SCALE_CHANGE; + vlc_gl_Unlock(vgl->gl); + VLC_UNUSED(subpicture); + return VLC_SUCCESS; +} + +int vout_display_opengl_Display(vout_display_opengl_t *vgl, + const video_format_t *source) +{ + if (vlc_gl_Lock(vgl->gl)) + return VLC_EGENERIC; - p_sys->p_vout->i_changes |= VOUT_SCALE_CHANGE; + /* 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; } - /* 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; + /* 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) { + 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); } +#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); - return i_ret; -} + 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); -/***************************************************************************** - * Render: render previously calculated output - *****************************************************************************/ -static void Render( vout_thread_t *p_vout, picture_t *p_pic ) -{ - vout_sys_t *p_sys = p_vout->p_sys; + 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); - picture_t *p_next = p_sys->p_current; + 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); - if( VLCGL_TEXTURE_COUNT > 1 ) - { - /* Get the next picture to display */ - p_next = picture_pool_Get( p_sys->p_pool ); - assert( p_next ); - } + 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_current ) - { - assert( p_sys->p_current->p[0].p_pixels == p_pic->p[0].p_pixels ); + glEnd(); +#endif - /* 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. */ + if (vgl->program) + glDisable(GL_FRAGMENT_PROGRAM_ARB); + else + glDisable(vgl->tex_target); - vout_display_opengl_Prepare( &p_sys->vgl, p_sys->p_current ); - } +#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]; - if( p_sys->p_current != p_next ) { - if( p_sys->p_current ) - picture_Release( p_sys->p_current ); + glBindTexture(GL_TEXTURE_2D, glr->texture); - /* Swap the picture texture on opengl vout side. */ - p_sys->p_current = p_next; + glBegin(GL_POLYGON); - /* 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; - } + glColor4f(1.0, 1.0, 1.0, glr->alpha); - VLC_UNUSED( p_pic ); -} + glTexCoord2f(0.0, 0.0); + glVertex2f(glr->left, glr->top); -/***************************************************************************** - * DisplayVideo: displays previously rendered output - *****************************************************************************/ -static void DisplayVideo( vout_thread_t *p_vout, picture_t *p_pic ) -{ - vout_sys_t *p_sys = p_vout->p_sys; + glTexCoord2f(1.0, 0.0); + glVertex2f(glr->right, glr->top); - vout_display_opengl_Display( &p_sys->vgl, &p_vout->fmt_out ); - VLC_UNUSED( p_pic ); -} + glTexCoord2f(1.0, 1.0); + glVertex2f(glr->right, glr->bottom); -/***************************************************************************** - * 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(0.0, 1.0); + glVertex2f(glr->left, glr->bottom); - 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(); + } + glDisable(GL_BLEND); + glDisable(GL_TEXTURE_2D); +#endif -/***************************************************************************** - * 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_Swap(vgl->gl); + + vlc_gl_Unlock(vgl->gl); + return VLC_SUCCESS; }