2 * This file is part of MPlayer.
4 * MPlayer is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * MPlayer is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License along
15 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 * You can alternatively redistribute this file and/or
19 * modify it under the terms of the GNU Lesser General Public
20 * License as published by the Free Software Foundation; either
21 * version 2.1 of the License, or (at your option) any later version.
31 #include "subopt-helper.h"
32 #include "video_out.h"
33 #include "video_out_internal.h"
34 #include "font_load.h"
37 #include "gl_common.h"
39 #include "fastmemcpy.h"
43 #ifdef CONFIG_SDL_SDL_H
50 static const vo_info_t info
=
54 "Reimar Doeffinger <Reimar.Doeffinger@gmx.de>",
58 const LIBVO_EXTERN(gl
)
61 static const vo_info_t info_nosw
=
63 "OpenGL no software rendering",
65 "Reimar Doeffinger <Reimar.Doeffinger@gmx.de>",
68 static int preinit_nosw(const char *arg
);
69 const struct vo_driver video_out_gl_nosw
=
73 .preinit
= old_vo_preinit
,
74 .config
= old_vo_config
,
75 .control
= old_vo_control
,
76 .draw_slice
= old_vo_draw_slice
,
77 .draw_osd
= old_vo_draw_osd
,
78 .flip_page
= old_vo_flip_page
,
79 .check_events
= old_vo_check_events
,
80 .uninit
= old_vo_uninit
,
81 .old_functions
= &(struct vo_old_functions
){
94 static MPGLContext glctx
;
97 static int scaled_osd
;
98 //! How many parts the OSD may consist of at most
99 #define MAX_OSD_PARTS 20
101 static GLuint osdtex
[MAX_OSD_PARTS
];
103 //! Alpha textures for OSD
104 static GLuint osdatex
[MAX_OSD_PARTS
];
106 static GLuint
*eosdtex
;
107 #define LARGE_EOSD_TEX_SIZE 512
108 #define TINYTEX_SIZE 16
109 #define TINYTEX_COLS (LARGE_EOSD_TEX_SIZE/TINYTEX_SIZE)
110 #define TINYTEX_MAX (TINYTEX_COLS*TINYTEX_COLS)
111 #define SMALLTEX_SIZE 32
112 #define SMALLTEX_COLS (LARGE_EOSD_TEX_SIZE/SMALLTEX_SIZE)
113 #define SMALLTEX_MAX (SMALLTEX_COLS*SMALLTEX_COLS)
114 static GLuint largeeosdtex
[2];
115 //! Display lists that draw the OSD parts
116 static GLuint osdDispList
[MAX_OSD_PARTS
];
118 static GLuint osdaDispList
[MAX_OSD_PARTS
];
120 static GLuint eosdDispList
;
121 //! How many parts the OSD currently consists of
122 static int osdtexCnt
;
123 static int eosdtexCnt
;
124 static int osd_color
;
126 static int use_aspect
;
127 static int use_ycbcr
;
128 #define MASK_ALL_YUV (~(1 << YUV_CONVERSION_NONE))
129 #define MASK_NOT_COMBINERS (~((1 << YUV_CONVERSION_NONE) | (1 << YUV_CONVERSION_COMBINERS)))
130 #define MASK_GAMMA_SUPPORT (MASK_NOT_COMBINERS & ~(1 << YUV_CONVERSION_FRAGMENT))
132 static int colorspace
;
133 static int levelconv
;
137 static float filter_strength
;
138 static int yuvconvtype
;
139 static int use_rectangle
;
140 static int err_shown
;
141 static uint32_t image_width
;
142 static uint32_t image_height
;
143 static uint32_t image_format
;
144 static int many_fmts
;
146 static int force_pbo
;
147 static int mesa_buffer
;
148 static int use_glFinish
;
149 static int swap_interval
;
150 static GLenum gl_target
;
151 static GLint gl_texfmt
;
152 static GLenum gl_format
;
153 static GLenum gl_type
;
154 static GLuint gl_buffer
;
155 static GLuint gl_buffer_uv
[2];
156 static int gl_buffersize
;
157 static int gl_buffersize_uv
;
158 static void *gl_bufferptr
;
159 static void *gl_bufferptr_uv
[2];
160 static int mesa_buffersize
;
161 static void *mesa_bufferptr
;
162 static GLuint fragprog
;
163 static GLuint default_texs
[22];
164 static char *custom_prog
;
165 static char *custom_tex
;
166 static int custom_tlin
;
167 static int custom_trect
;
168 static int mipmap_gen
;
169 static int stereo_mode
;
171 static int int_pause
;
172 static int eq_bri
= 0;
173 static int eq_cont
= 0;
174 static int eq_sat
= 0;
175 static int eq_hue
= 0;
176 static int eq_rgamma
= 0;
177 static int eq_ggamma
= 0;
178 static int eq_bgamma
= 0;
180 static int texture_width
;
181 static int texture_height
;
182 static int mpi_flipped
;
183 static int vo_flipped
;
184 static int ass_border_x
, ass_border_y
;
186 static unsigned int slice_height
= 1;
188 static void redraw(void);
190 static void resize(int x
,int y
){
191 mp_msg(MSGT_VO
, MSGL_V
, "[gl] Resize: %dx%d\n",x
,y
);
193 int left
= 0, top
= 0, w
= x
, h
= y
;
194 geometry(&left
, &top
, &w
, &h
, vo_dwidth
, vo_dheight
);
196 mpglViewport(left
, top
, w
, h
);
198 mpglViewport( 0, 0, x
, y
);
200 mpglMatrixMode(GL_PROJECTION
);
202 ass_border_x
= ass_border_y
= 0;
203 if (aspect_scaling() && use_aspect
) {
205 GLdouble scale_x
, scale_y
;
206 aspect(&new_w
, &new_h
, A_WINZOOM
);
207 panscan_calc_windowed();
208 new_w
+= vo_panscan_x
;
209 new_h
+= vo_panscan_y
;
210 scale_x
= (GLdouble
)new_w
/ (GLdouble
)x
;
211 scale_y
= (GLdouble
)new_h
/ (GLdouble
)y
;
212 mpglScaled(scale_x
, scale_y
, 1);
213 ass_border_x
= (vo_dwidth
- new_w
) / 2;
214 ass_border_y
= (vo_dheight
- new_h
) / 2;
216 mpglOrtho(0, image_width
, image_height
, 0, -1,1);
218 mpglMatrixMode(GL_MODELVIEW
);
222 #ifdef CONFIG_FREETYPE
223 // adjust font size to display size
226 vo_osd_changed(OSDTYPE_OSD
);
228 mpglClear(GL_COLOR_BUFFER_BIT
);
232 static void texSize(int w
, int h
, int *texw
, int *texh
) {
234 *texw
= w
; *texh
= h
;
243 if (mesa_buffer
) *texw
= (*texw
+ 63) & ~63;
244 else if (ati_hack
) *texw
= (*texw
+ 511) & ~511;
247 //! maximum size of custom fragment program
248 #define MAX_CUSTOM_PROG_SIZE (1024 * 1024)
249 static void update_yuvconv(void) {
251 float bri
= eq_bri
/ 100.0;
252 float cont
= (eq_cont
+ 100) / 100.0;
253 float hue
= eq_hue
/ 100.0 * 3.1415927;
254 float sat
= (eq_sat
+ 100) / 100.0;
255 float rgamma
= exp(log(8.0) * eq_rgamma
/ 100.0);
256 float ggamma
= exp(log(8.0) * eq_ggamma
/ 100.0);
257 float bgamma
= exp(log(8.0) * eq_bgamma
/ 100.0);
258 gl_conversion_params_t params
= {gl_target
, yuvconvtype
,
259 {colorspace
, levelconv
, bri
, cont
, hue
, sat
, rgamma
, ggamma
, bgamma
},
260 texture_width
, texture_height
, 0, 0, filter_strength
};
261 mp_get_chroma_shift(image_format
, &xs
, &ys
);
262 params
.chrom_texw
= params
.texw
>> xs
;
263 params
.chrom_texh
= params
.texh
>> ys
;
264 glSetupYUVConversion(¶ms
);
266 FILE *f
= fopen(custom_prog
, "rb");
268 mp_msg(MSGT_VO
, MSGL_WARN
,
269 "[gl] Could not read customprog %s\n", custom_prog
);
271 char *prog
= calloc(1, MAX_CUSTOM_PROG_SIZE
+ 1);
272 fread(prog
, 1, MAX_CUSTOM_PROG_SIZE
, f
);
274 loadGPUProgram(GL_FRAGMENT_PROGRAM
, prog
);
277 mpglProgramEnvParameter4f(GL_FRAGMENT_PROGRAM
, 0,
278 1.0 / texture_width
, 1.0 / texture_height
,
279 texture_width
, texture_height
);
282 FILE *f
= fopen(custom_tex
, "rb");
284 mp_msg(MSGT_VO
, MSGL_WARN
,
285 "[gl] Could not read customtex %s\n", custom_tex
);
287 int width
, height
, maxval
;
288 mpglActiveTexture(GL_TEXTURE3
);
289 if (glCreatePPMTex(custom_trect
?GL_TEXTURE_RECTANGLE
:GL_TEXTURE_2D
, 0,
290 custom_tlin
?GL_LINEAR
:GL_NEAREST
,
291 f
, &width
, &height
, &maxval
)) {
292 mpglProgramEnvParameter4f(GL_FRAGMENT_PROGRAM
, 1,
293 1.0 / width
, 1.0 / height
, width
, height
);
295 mp_msg(MSGT_VO
, MSGL_WARN
,
296 "[gl] Error parsing customtex %s\n", custom_tex
);
298 mpglActiveTexture(GL_TEXTURE0
);
304 * \brief remove all OSD textures and display-lists, thus clearing it.
306 static void clearOSD(void) {
310 mpglDeleteTextures(osdtexCnt
, osdtex
);
312 mpglDeleteTextures(osdtexCnt
, osdatex
);
313 for (i
= 0; i
< osdtexCnt
; i
++)
314 mpglDeleteLists(osdaDispList
[i
], 1);
316 for (i
= 0; i
< osdtexCnt
; i
++)
317 mpglDeleteLists(osdDispList
[i
], 1);
322 * \brief remove textures, display list and free memory used by EOSD
324 static void clearEOSD(void) {
326 mpglDeleteLists(eosdDispList
, 1);
329 mpglDeleteTextures(eosdtexCnt
, eosdtex
);
335 static inline int is_tinytex(ASS_Image
*i
, int tinytexcur
) {
336 return i
->w
< TINYTEX_SIZE
&& i
->h
< TINYTEX_SIZE
&& tinytexcur
< TINYTEX_MAX
;
339 static inline int is_smalltex(ASS_Image
*i
, int smalltexcur
) {
340 return i
->w
< SMALLTEX_SIZE
&& i
->h
< SMALLTEX_SIZE
&& smalltexcur
< SMALLTEX_MAX
;
343 static inline void tinytex_pos(int tinytexcur
, int *x
, int *y
) {
344 *x
= (tinytexcur
% TINYTEX_COLS
) * TINYTEX_SIZE
;
345 *y
= (tinytexcur
/ TINYTEX_COLS
) * TINYTEX_SIZE
;
348 static inline void smalltex_pos(int smalltexcur
, int *x
, int *y
) {
349 *x
= (smalltexcur
% SMALLTEX_COLS
) * SMALLTEX_SIZE
;
350 *y
= (smalltexcur
/ SMALLTEX_COLS
) * SMALLTEX_SIZE
;
354 * \brief construct display list from ass image list
355 * \param img image list to create OSD from.
356 * A value of NULL has the same effect as clearEOSD()
358 static void genEOSD(mp_eosd_images_t
*imgs
) {
363 GLint scale_type
= scaled_osd
? GL_LINEAR
: GL_NEAREST
;
364 ASS_Image
*img
= imgs
->imgs
;
367 if (imgs
->changed
== 0) // there are elements, but they are unchanged
369 if (img
&& imgs
->changed
== 1) // there are elements, but they just moved
375 if (!largeeosdtex
[0]) {
376 mpglGenTextures(2, largeeosdtex
);
377 mpglBindTexture(gl_target
, largeeosdtex
[0]);
378 glCreateClearTex(gl_target
, GL_ALPHA
, GL_ALPHA
, GL_UNSIGNED_BYTE
, scale_type
, LARGE_EOSD_TEX_SIZE
, LARGE_EOSD_TEX_SIZE
, 0);
379 mpglBindTexture(gl_target
, largeeosdtex
[1]);
380 glCreateClearTex(gl_target
, GL_ALPHA
, GL_ALPHA
, GL_UNSIGNED_BYTE
, scale_type
, LARGE_EOSD_TEX_SIZE
, LARGE_EOSD_TEX_SIZE
, 0);
382 for (i
= img
; i
; i
= i
->next
)
384 if (i
->w
<= 0 || i
->h
<= 0 || i
->stride
< i
->w
)
386 if (is_tinytex(i
, tinytexcur
))
388 else if (is_smalltex(i
, smalltexcur
))
393 mp_msg(MSGT_VO
, MSGL_DBG2
, "EOSD counts (tiny, small, all): %i, %i, %i\n",
394 tinytexcur
, smalltexcur
, eosdtexCnt
);
396 eosdtex
= calloc(eosdtexCnt
, sizeof(GLuint
));
397 mpglGenTextures(eosdtexCnt
, eosdtex
);
399 tinytexcur
= smalltexcur
= 0;
400 for (i
= img
, curtex
= eosdtex
; i
; i
= i
->next
) {
402 if (i
->w
<= 0 || i
->h
<= 0 || i
->stride
< i
->w
) {
403 mp_msg(MSGT_VO
, MSGL_V
, "Invalid dimensions OSD for part!\n");
406 if (is_tinytex(i
, tinytexcur
)) {
407 tinytex_pos(tinytexcur
, &x
, &y
);
408 mpglBindTexture(gl_target
, largeeosdtex
[0]);
410 } else if (is_smalltex(i
, smalltexcur
)) {
411 smalltex_pos(smalltexcur
, &x
, &y
);
412 mpglBindTexture(gl_target
, largeeosdtex
[1]);
415 texSize(i
->w
, i
->h
, &sx
, &sy
);
416 mpglBindTexture(gl_target
, *curtex
++);
417 glCreateClearTex(gl_target
, GL_ALPHA
, GL_ALPHA
, GL_UNSIGNED_BYTE
, scale_type
, sx
, sy
, 0);
419 glUploadTex(gl_target
, GL_ALPHA
, GL_UNSIGNED_BYTE
, i
->bitmap
, i
->stride
,
420 x
, y
, i
->w
, i
->h
, 0);
422 eosdDispList
= mpglGenLists(1);
424 mpglNewList(eosdDispList
, GL_COMPILE
);
425 tinytexcur
= smalltexcur
= 0;
426 for (i
= img
, curtex
= eosdtex
; i
; i
= i
->next
) {
428 if (i
->w
<= 0 || i
->h
<= 0 || i
->stride
< i
->w
)
430 mpglColor4ub(i
->color
>> 24, (i
->color
>> 16) & 0xff, (i
->color
>> 8) & 0xff, 255 - (i
->color
& 0xff));
431 if (is_tinytex(i
, tinytexcur
)) {
432 tinytex_pos(tinytexcur
, &x
, &y
);
433 sx
= sy
= LARGE_EOSD_TEX_SIZE
;
434 mpglBindTexture(gl_target
, largeeosdtex
[0]);
436 } else if (is_smalltex(i
, smalltexcur
)) {
437 smalltex_pos(smalltexcur
, &x
, &y
);
438 sx
= sy
= LARGE_EOSD_TEX_SIZE
;
439 mpglBindTexture(gl_target
, largeeosdtex
[1]);
442 texSize(i
->w
, i
->h
, &sx
, &sy
);
443 mpglBindTexture(gl_target
, *curtex
++);
445 glDrawTex(i
->dst_x
, i
->dst_y
, i
->w
, i
->h
, x
, y
, i
->w
, i
->h
, sx
, sy
, use_rectangle
== 1, 0, 0);
448 mpglBindTexture(gl_target
, 0);
452 * \brief uninitialize OpenGL context, freeing textures, buffers etc.
454 static void uninitGl(void) {
456 if (mpglDeletePrograms
&& fragprog
)
457 mpglDeletePrograms(1, &fragprog
);
459 while (default_texs
[i
] != 0)
462 mpglDeleteTextures(i
, default_texs
);
467 mpglDeleteTextures(2, largeeosdtex
);
469 if (mpglDeleteBuffers
&& gl_buffer
)
470 mpglDeleteBuffers(1, &gl_buffer
);
471 gl_buffer
= 0; gl_buffersize
= 0;
473 if (mpglDeleteBuffers
&& gl_buffer_uv
[0])
474 mpglDeleteBuffers(2, gl_buffer_uv
);
475 gl_buffer_uv
[0] = gl_buffer_uv
[1] = 0; gl_buffersize_uv
= 0;
476 gl_bufferptr_uv
[0] = gl_bufferptr_uv
[1] = 0;
479 mpglFreeMemoryMESA(mDisplay
, mScreen
, mesa_bufferptr
);
481 mesa_bufferptr
= NULL
;
485 static int isSoftwareGl(void)
487 const char *renderer
= mpglGetString(GL_RENDERER
);
488 return !renderer
|| strcmp(renderer
, "Software Rasterizer") == 0;
491 static void autodetectGlExtensions(void) {
492 const char *extensions
= mpglGetString(GL_EXTENSIONS
);
493 const char *vendor
= mpglGetString(GL_VENDOR
);
494 const char *version
= mpglGetString(GL_VERSION
);
495 const char *renderer
= mpglGetString(GL_RENDERER
);
496 int is_ati
= vendor
&& strstr(vendor
, "ATI") != NULL
;
497 int ati_broken_pbo
= 0;
498 mp_msg(MSGT_VO
, MSGL_V
, "[gl] Running on OpenGL '%s' by '%s', version '%s'\n", renderer
, vendor
, version
);
499 if (is_ati
&& strncmp(version
, "2.1.", 4) == 0) {
500 int ver
= atoi(version
+ 4);
501 mp_msg(MSGT_VO
, MSGL_V
, "[gl] Detected ATI driver version: %i\n", ver
);
502 ati_broken_pbo
= ver
&& ver
< 8395;
504 if (ati_hack
== -1) ati_hack
= ati_broken_pbo
;
505 if (force_pbo
== -1) {
507 if (extensions
&& strstr(extensions
, "_pixel_buffer_object"))
510 if (use_rectangle
== -1) {
513 // if (strstr(extensions, "_texture_non_power_of_two"))
514 if (strstr(extensions
, "_texture_rectangle"))
515 use_rectangle
= renderer
&& strstr(renderer
, "Mesa DRI R200") ? 1 : 0;
519 use_osd
= mpglBindTexture
!= NULL
;
521 use_yuv
= glAutodetectYUVConversion();
522 if (is_ati
&& (lscale
== 1 || lscale
== 2 || cscale
== 1 || cscale
== 2))
523 mp_msg(MSGT_VO
, MSGL_WARN
, "[gl] Selected scaling mode may be broken on ATI cards.\n"
524 "Tell _them_ to fix GL_REPEAT if you have issues.\n");
525 mp_msg(MSGT_VO
, MSGL_V
, "[gl] Settings after autodetection: ati-hack = %i, force-pbo = %i, rectangle = %i, yuv = %i\n",
526 ati_hack
, force_pbo
, use_rectangle
, use_yuv
);
530 * \brief Initialize a (new or reused) OpenGL context.
531 * set global gl-related variables to their default values
533 static int initGl(uint32_t d_width
, uint32_t d_height
) {
534 int scale_type
= mipmap_gen
? GL_LINEAR_MIPMAP_NEAREST
: GL_LINEAR
;
535 autodetectGlExtensions();
536 gl_target
= use_rectangle
== 1 ? GL_TEXTURE_RECTANGLE
: GL_TEXTURE_2D
;
537 yuvconvtype
= use_yuv
| lscale
<< YUV_LUM_SCALER_SHIFT
| cscale
<< YUV_CHROM_SCALER_SHIFT
;
539 texSize(image_width
, image_height
, &texture_width
, &texture_height
);
541 mpglDisable(GL_BLEND
);
542 mpglDisable(GL_DEPTH_TEST
);
543 mpglDepthMask(GL_FALSE
);
544 mpglDisable(GL_CULL_FACE
);
545 mpglEnable(gl_target
);
546 mpglDrawBuffer(vo_doublebuffering
?GL_BACK
:GL_FRONT
);
547 mpglTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_MODULATE
);
549 mp_msg(MSGT_VO
, MSGL_V
, "[gl] Creating %dx%d texture...\n",
550 texture_width
, texture_height
);
552 glCreateClearTex(gl_target
, gl_texfmt
, gl_format
, gl_type
, scale_type
,
553 texture_width
, texture_height
, 0);
555 mpglTexParameteri(gl_target
, GL_GENERATE_MIPMAP
, GL_TRUE
);
560 mp_get_chroma_shift(image_format
, &xs
, &ys
);
561 mpglGenTextures(21, default_texs
);
562 default_texs
[21] = 0;
563 for (i
= 0; i
< 7; i
++) {
564 mpglActiveTexture(GL_TEXTURE1
+ i
);
565 mpglBindTexture(GL_TEXTURE_2D
, default_texs
[i
]);
566 mpglBindTexture(GL_TEXTURE_RECTANGLE
, default_texs
[i
+ 7]);
567 mpglBindTexture(GL_TEXTURE_3D
, default_texs
[i
+ 14]);
569 mpglActiveTexture(GL_TEXTURE1
);
570 glCreateClearTex(gl_target
, gl_texfmt
, gl_format
, gl_type
, scale_type
,
571 texture_width
>> xs
, texture_height
>> ys
, 128);
573 mpglTexParameteri(gl_target
, GL_GENERATE_MIPMAP
, GL_TRUE
);
574 mpglActiveTexture(GL_TEXTURE2
);
575 glCreateClearTex(gl_target
, gl_texfmt
, gl_format
, gl_type
, scale_type
,
576 texture_width
>> xs
, texture_height
>> ys
, 128);
578 mpglTexParameteri(gl_target
, GL_GENERATE_MIPMAP
, GL_TRUE
);
579 mpglActiveTexture(GL_TEXTURE0
);
580 mpglBindTexture(gl_target
, 0);
582 if (is_yuv
|| custom_prog
)
584 if ((MASK_NOT_COMBINERS
& (1 << use_yuv
)) || custom_prog
) {
585 if (!mpglGenPrograms
|| !mpglBindProgram
) {
586 mp_msg(MSGT_VO
, MSGL_ERR
, "[gl] fragment program functions missing!\n");
588 mpglGenPrograms(1, &fragprog
);
589 mpglBindProgram(GL_FRAGMENT_PROGRAM
, fragprog
);
595 resize(d_width
, d_height
);
597 mpglClearColor( 0.0f
,0.0f
,0.0f
,0.0f
);
598 mpglClear( GL_COLOR_BUFFER_BIT
);
599 if (mpglSwapInterval
&& swap_interval
>= 0)
600 mpglSwapInterval(swap_interval
);
604 static int create_window(uint32_t d_width
, uint32_t d_height
, uint32_t flags
, const char *title
)
606 #ifdef CONFIG_GL_WIN32
607 if (glctx
.type
== GLTYPE_W32
&& !vo_w32_config(d_width
, d_height
, flags
))
611 if (glctx
.type
== GLTYPE_X11
) {
612 static int default_glx_attribs
[] = {
613 GLX_RGBA
, GLX_RED_SIZE
, 1, GLX_GREEN_SIZE
, 1, GLX_BLUE_SIZE
, 1,
614 GLX_DOUBLEBUFFER
, None
616 static int stereo_glx_attribs
[] = {
617 GLX_RGBA
, GLX_RED_SIZE
, 1, GLX_GREEN_SIZE
, 1, GLX_BLUE_SIZE
, 1,
618 GLX_DOUBLEBUFFER
, GLX_STEREO
, None
620 XVisualInfo
*vinfo
= NULL
;
621 if (stereo_mode
== GL_3D_QUADBUFFER
) {
622 vinfo
= glXChooseVisual(mDisplay
, mScreen
, stereo_glx_attribs
);
624 mp_msg(MSGT_VO
, MSGL_ERR
, "[gl] Could not find a stereo visual, "
625 "3D will probably not work!\n");
628 vinfo
= glXChooseVisual(mDisplay
, mScreen
, default_glx_attribs
);
630 mp_msg(MSGT_VO
, MSGL_ERR
, "[gl] no GLX support present\n");
633 mp_msg(MSGT_VO
, MSGL_V
, "[gl] GLX chose visual with ID 0x%x\n", (int)vinfo
->visualid
);
635 vo_x11_create_vo_window(vinfo
, vo_dx
, vo_dy
, d_width
, d_height
, flags
,
636 XCreateColormap(mDisplay
, mRootWin
, vinfo
->visual
, AllocNone
),
641 if (glctx
.type
== GLTYPE_SDL
) {
642 SDL_WM_SetCaption(title
, NULL
);
644 vo_dheight
= d_height
;
650 /* connect to server, create and map window,
651 * allocate colors and (shared) memory
654 config(uint32_t width
, uint32_t height
, uint32_t d_width
, uint32_t d_height
, uint32_t flags
, char *title
, uint32_t format
)
657 image_height
= height
;
659 image_format
= format
;
660 is_yuv
= mp_get_chroma_shift(image_format
, &xs
, &ys
) > 0;
661 is_yuv
|= (xs
<< 8) | (ys
<< 16);
662 glFindFormat(format
, NULL
, &gl_texfmt
, &gl_format
, &gl_type
);
664 vo_flipped
= !!(flags
& VOFLAG_FLIPPING
);
666 if (create_window(d_width
, d_height
, flags
, title
) < 0)
671 if (glctx
.setGlWindow(&glctx
) == SET_WINDOW_FAILED
)
673 if (mesa_buffer
&& !mpglAllocateMemoryMESA
) {
674 mp_msg(MSGT_VO
, MSGL_ERR
, "Can not enable mesa-buffer because AllocateMemoryMESA was not found\n");
677 initGl(vo_dwidth
, vo_dheight
);
682 static void check_events(void)
684 int e
=glctx
.check_events();
685 if(e
&VO_EVENT_REINIT
) {
687 initGl(vo_dwidth
, vo_dheight
);
689 if(e
&VO_EVENT_RESIZE
) resize(vo_dwidth
,vo_dheight
);
690 if(e
&VO_EVENT_EXPOSE
&& int_pause
) redraw();
694 * Creates the textures and the display list needed for displaying
696 * Callback function for vo_draw_text().
698 static void create_osd_texture(int x0
, int y0
, int w
, int h
,
699 unsigned char *src
, unsigned char *srca
,
702 // initialize to 8 to avoid special-casing on alignment
704 GLint scale_type
= scaled_osd
? GL_LINEAR
: GL_NEAREST
;
706 if (w
<= 0 || h
<= 0 || stride
< w
) {
707 mp_msg(MSGT_VO
, MSGL_V
, "Invalid dimensions OSD for part!\n");
710 texSize(w
, h
, &sx
, &sy
);
712 if (osdtexCnt
>= MAX_OSD_PARTS
) {
713 mp_msg(MSGT_VO
, MSGL_ERR
, "Too many OSD parts, contact the developers!\n");
717 // create Textures for OSD part
718 mpglGenTextures(1, &osdtex
[osdtexCnt
]);
719 mpglBindTexture(gl_target
, osdtex
[osdtexCnt
]);
720 glCreateClearTex(gl_target
, GL_LUMINANCE
, GL_LUMINANCE
, GL_UNSIGNED_BYTE
, scale_type
, sx
, sy
, 0);
721 glUploadTex(gl_target
, GL_LUMINANCE
, GL_UNSIGNED_BYTE
, src
, stride
,
725 mpglGenTextures(1, &osdatex
[osdtexCnt
]);
726 mpglBindTexture(gl_target
, osdatex
[osdtexCnt
]);
727 glCreateClearTex(gl_target
, GL_ALPHA
, GL_ALPHA
, GL_UNSIGNED_BYTE
, scale_type
, sx
, sy
, 0);
730 char *tmp
= malloc(stride
* h
);
731 // convert alpha from weird MPlayer scale.
732 // in-place is not possible since it is reused for future OSDs
733 for (i
= h
* stride
- 1; i
>= 0; i
--)
735 glUploadTex(gl_target
, GL_ALPHA
, GL_UNSIGNED_BYTE
, tmp
, stride
,
741 mpglBindTexture(gl_target
, 0);
743 // Create a list for rendering this OSD part
745 osdaDispList
[osdtexCnt
] = mpglGenLists(1);
746 mpglNewList(osdaDispList
[osdtexCnt
], GL_COMPILE
);
748 mpglBindTexture(gl_target
, osdatex
[osdtexCnt
]);
749 glDrawTex(x0
, y0
, w
, h
, 0, 0, w
, h
, sx
, sy
, use_rectangle
== 1, 0, 0);
752 osdDispList
[osdtexCnt
] = mpglGenLists(1);
753 mpglNewList(osdDispList
[osdtexCnt
], GL_COMPILE
);
755 mpglBindTexture(gl_target
, osdtex
[osdtexCnt
]);
756 glDrawTex(x0
, y0
, w
, h
, 0, 0, w
, h
, sx
, sy
, use_rectangle
== 1, 0, 0);
763 * \param type bit 0: render OSD, bit 1: render EOSD
765 static void do_render_osd(int type
) {
766 if (((type
& 1) && osdtexCnt
> 0) || ((type
& 2) && eosdDispList
)) {
767 // set special rendering parameters
769 mpglMatrixMode(GL_PROJECTION
);
772 mpglOrtho(0, vo_dwidth
, vo_dheight
, 0, -1, 1);
774 mpglEnable(GL_BLEND
);
775 if ((type
& 2) && eosdDispList
) {
776 mpglBlendFunc(GL_SRC_ALPHA
, GL_ONE_MINUS_SRC_ALPHA
);
777 mpglCallList(eosdDispList
);
779 if ((type
& 1) && osdtexCnt
> 0) {
780 mpglColor4ub((osd_color
>> 16) & 0xff, (osd_color
>> 8) & 0xff, osd_color
& 0xff, 0xff - (osd_color
>> 24));
783 mpglBlendFunc(GL_ZERO
, GL_ONE_MINUS_SRC_ALPHA
);
784 mpglCallLists(osdtexCnt
, GL_UNSIGNED_INT
, osdaDispList
);
786 mpglBlendFunc(GL_SRC_ALPHA
, GL_ONE
);
787 mpglCallLists(osdtexCnt
, GL_UNSIGNED_INT
, osdDispList
);
789 // set rendering parameters back to defaults
790 mpglDisable(GL_BLEND
);
793 mpglBindTexture(gl_target
, 0);
797 static void draw_osd(void)
799 if (!use_osd
) return;
800 if (vo_osd_changed(0)) {
803 osd_w
= scaled_osd
? image_width
: vo_dwidth
;
804 osd_h
= scaled_osd
? image_height
: vo_dheight
;
805 vo_draw_text_ext(osd_w
, osd_h
, ass_border_x
, ass_border_y
, ass_border_x
, ass_border_y
,
806 image_width
, image_height
, create_osd_texture
);
808 if (vo_doublebuffering
) do_render_osd(1);
811 static void do_render(void) {
812 // Enable(GL_TEXTURE_2D);
813 // BindTexture(GL_TEXTURE_2D, texture_id);
816 if (is_yuv
|| custom_prog
)
817 glEnableYUVConversion(gl_target
, yuvconvtype
);
819 glEnable3DLeft(stereo_mode
);
820 glDrawTex(0, 0, image_width
, image_height
,
821 0, 0, image_width
>> 1, image_height
,
822 texture_width
, texture_height
,
823 use_rectangle
== 1, is_yuv
,
824 mpi_flipped
^ vo_flipped
);
825 glEnable3DRight(stereo_mode
);
826 glDrawTex(0, 0, image_width
, image_height
,
827 image_width
>> 1, 0, image_width
>> 1, image_height
,
828 texture_width
, texture_height
,
829 use_rectangle
== 1, is_yuv
,
830 mpi_flipped
^ vo_flipped
);
831 glDisable3D(stereo_mode
);
833 glDrawTex(0, 0, image_width
, image_height
,
834 0, 0, image_width
, image_height
,
835 texture_width
, texture_height
,
836 use_rectangle
== 1, is_yuv
,
837 mpi_flipped
^ vo_flipped
);
839 if (is_yuv
|| custom_prog
)
840 glDisableYUVConversion(gl_target
, yuvconvtype
);
843 static void flip_page(void) {
844 if (vo_doublebuffering
) {
845 if (use_glFinish
) mpglFinish();
846 glctx
.swapGlBuffers(&glctx
);
847 if (aspect_scaling() && use_aspect
)
848 mpglClear(GL_COLOR_BUFFER_BIT
);
852 if (use_glFinish
) mpglFinish();
857 static void redraw(void) {
858 if (vo_doublebuffering
) { do_render(); do_render_osd(3); }
862 static int draw_slice(uint8_t *src
[], int stride
[], int w
,int h
,int x
,int y
)
864 mpi_flipped
= stride
[0] < 0;
865 glUploadTex(gl_target
, gl_format
, gl_type
, src
[0], stride
[0],
866 x
, y
, w
, h
, slice_height
);
869 mp_get_chroma_shift(image_format
, &xs
, &ys
);
870 mpglActiveTexture(GL_TEXTURE1
);
871 glUploadTex(gl_target
, gl_format
, gl_type
, src
[1], stride
[1],
872 x
>> xs
, y
>> ys
, w
>> xs
, h
>> ys
, slice_height
);
873 mpglActiveTexture(GL_TEXTURE2
);
874 glUploadTex(gl_target
, gl_format
, gl_type
, src
[2], stride
[2],
875 x
>> xs
, y
>> ys
, w
>> xs
, h
>> ys
, slice_height
);
876 mpglActiveTexture(GL_TEXTURE0
);
881 static uint32_t get_image(mp_image_t
*mpi
) {
883 if (!mpglGenBuffers
|| !mpglBindBuffer
|| !mpglBufferData
|| !mpglMapBuffer
) {
885 mp_msg(MSGT_VO
, MSGL_ERR
, "[gl] extensions missing for dr\n"
886 "Expect a _major_ speed penalty\n");
890 if (mpi
->flags
& MP_IMGFLAG_READABLE
) return VO_FALSE
;
891 if (mpi
->type
!= MP_IMGTYPE_STATIC
&& mpi
->type
!= MP_IMGTYPE_TEMP
&&
892 (mpi
->type
!= MP_IMGTYPE_NUMBERED
|| mpi
->number
))
894 if (mesa_buffer
) mpi
->width
= texture_width
;
896 mpi
->width
= texture_width
;
897 mpi
->height
= texture_height
;
899 mpi
->stride
[0] = mpi
->width
* mpi
->bpp
/ 8;
900 needed_size
= mpi
->stride
[0] * mpi
->height
;
903 if (mesa_bufferptr
&& needed_size
> mesa_buffersize
) {
904 mpglFreeMemoryMESA(mDisplay
, mScreen
, mesa_bufferptr
);
905 mesa_bufferptr
= NULL
;
908 mesa_bufferptr
= mpglAllocateMemoryMESA(mDisplay
, mScreen
, needed_size
, 0, 1.0, 1.0);
909 mesa_buffersize
= needed_size
;
911 mpi
->planes
[0] = mesa_bufferptr
;
914 mpglGenBuffers(1, &gl_buffer
);
915 mpglBindBuffer(GL_PIXEL_UNPACK_BUFFER
, gl_buffer
);
916 if (needed_size
> gl_buffersize
) {
917 gl_buffersize
= needed_size
;
918 mpglBufferData(GL_PIXEL_UNPACK_BUFFER
, gl_buffersize
,
919 NULL
, GL_DYNAMIC_DRAW
);
922 gl_bufferptr
= mpglMapBuffer(GL_PIXEL_UNPACK_BUFFER
, GL_WRITE_ONLY
);
923 mpi
->planes
[0] = gl_bufferptr
;
924 mpglBindBuffer(GL_PIXEL_UNPACK_BUFFER
, 0);
926 if (!mpi
->planes
[0]) {
928 mp_msg(MSGT_VO
, MSGL_ERR
, "[gl] could not acquire buffer for dr\n"
929 "Expect a _major_ speed penalty\n");
936 mp_get_chroma_shift(image_format
, &xs
, &ys
);
937 mpi
->flags
|= MP_IMGFLAG_COMMON_STRIDE
| MP_IMGFLAG_COMMON_PLANE
;
938 mpi
->stride
[0] = mpi
->width
;
939 mpi
->planes
[1] = mpi
->planes
[0] + mpi
->stride
[0] * mpi
->height
;
940 mpi
->stride
[1] = mpi
->width
>> xs
;
941 mpi
->planes
[2] = mpi
->planes
[1] + mpi
->stride
[1] * (mpi
->height
>> ys
);
942 mpi
->stride
[2] = mpi
->width
>> xs
;
943 if (ati_hack
&& !mesa_buffer
) {
944 mpi
->flags
&= ~MP_IMGFLAG_COMMON_PLANE
;
945 if (!gl_buffer_uv
[0]) mpglGenBuffers(2, gl_buffer_uv
);
946 if (mpi
->stride
[1] * mpi
->height
> gl_buffersize_uv
) {
947 mpglBindBuffer(GL_PIXEL_UNPACK_BUFFER
, gl_buffer_uv
[0]);
948 mpglBufferData(GL_PIXEL_UNPACK_BUFFER
, mpi
->stride
[1] * mpi
->height
,
949 NULL
, GL_DYNAMIC_DRAW
);
950 mpglBindBuffer(GL_PIXEL_UNPACK_BUFFER
, gl_buffer_uv
[1]);
951 mpglBufferData(GL_PIXEL_UNPACK_BUFFER
, mpi
->stride
[1] * mpi
->height
,
952 NULL
, GL_DYNAMIC_DRAW
);
953 gl_buffersize_uv
= mpi
->stride
[1] * mpi
->height
;
955 if (!gl_bufferptr_uv
[0]) {
956 mpglBindBuffer(GL_PIXEL_UNPACK_BUFFER
, gl_buffer_uv
[0]);
957 gl_bufferptr_uv
[0] = mpglMapBuffer(GL_PIXEL_UNPACK_BUFFER
, GL_WRITE_ONLY
);
958 mpglBindBuffer(GL_PIXEL_UNPACK_BUFFER
, gl_buffer_uv
[1]);
959 gl_bufferptr_uv
[1] = mpglMapBuffer(GL_PIXEL_UNPACK_BUFFER
, GL_WRITE_ONLY
);
961 mpi
->planes
[1] = gl_bufferptr_uv
[0];
962 mpi
->planes
[2] = gl_bufferptr_uv
[1];
965 mpi
->flags
|= MP_IMGFLAG_DIRECT
;
969 static void clear_border(uint8_t *dst
, int start
, int stride
, int height
, int full_height
, int value
) {
970 int right_border
= stride
- start
;
971 int bottom_border
= full_height
- height
;
973 memset(dst
+ start
, value
, right_border
);
977 if (bottom_border
> 0)
978 memset(dst
, value
, stride
* bottom_border
);
981 static uint32_t draw_image(mp_image_t
*mpi
) {
982 int slice
= slice_height
;
984 unsigned char *planes
[3];
985 mp_image_t mpi2
= *mpi
;
986 int w
= mpi
->w
, h
= mpi
->h
;
987 if (mpi
->flags
& MP_IMGFLAG_DRAW_CALLBACK
)
989 mpi2
.flags
= 0; mpi2
.type
= MP_IMGTYPE_TEMP
;
990 mpi2
.width
= mpi2
.w
; mpi2
.height
= mpi2
.h
;
991 if (force_pbo
&& !(mpi
->flags
& MP_IMGFLAG_DIRECT
) && !gl_bufferptr
&& get_image(&mpi2
) == VO_TRUE
) {
992 int bpp
= is_yuv
? 8 : mpi
->bpp
;
994 mp_get_chroma_shift(image_format
, &xs
, &ys
);
995 memcpy_pic(mpi2
.planes
[0], mpi
->planes
[0], mpi
->w
* bpp
/ 8, mpi
->h
, mpi2
.stride
[0], mpi
->stride
[0]);
997 memcpy_pic(mpi2
.planes
[1], mpi
->planes
[1], mpi
->w
>> xs
, mpi
->h
>> ys
, mpi2
.stride
[1], mpi
->stride
[1]);
998 memcpy_pic(mpi2
.planes
[2], mpi
->planes
[2], mpi
->w
>> xs
, mpi
->h
>> ys
, mpi2
.stride
[2], mpi
->stride
[2]);
1000 if (ati_hack
) { // since we have to do a full upload we need to clear the borders
1001 clear_border(mpi2
.planes
[0], mpi
->w
* bpp
/ 8, mpi2
.stride
[0], mpi
->h
, mpi2
.height
, 0);
1003 clear_border(mpi2
.planes
[1], mpi
->w
>> xs
, mpi2
.stride
[1], mpi
->h
>> ys
, mpi2
.height
>> ys
, 128);
1004 clear_border(mpi2
.planes
[2], mpi
->w
>> xs
, mpi2
.stride
[2], mpi
->h
>> ys
, mpi2
.height
>> ys
, 128);
1009 stride
[0] = mpi
->stride
[0]; stride
[1] = mpi
->stride
[1]; stride
[2] = mpi
->stride
[2];
1010 planes
[0] = mpi
->planes
[0]; planes
[1] = mpi
->planes
[1]; planes
[2] = mpi
->planes
[2];
1011 mpi_flipped
= stride
[0] < 0;
1012 if (mpi
->flags
& MP_IMGFLAG_DIRECT
) {
1014 mpglPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE
, 1);
1017 intptr_t base
= (intptr_t)planes
[0];
1018 if (ati_hack
) { w
= texture_width
; h
= texture_height
; }
1020 base
+= (mpi
->h
- 1) * stride
[0];
1024 mpglBindBuffer(GL_PIXEL_UNPACK_BUFFER
, gl_buffer
);
1025 mpglUnmapBuffer(GL_PIXEL_UNPACK_BUFFER
);
1026 gl_bufferptr
= NULL
;
1027 if (!(mpi
->flags
& MP_IMGFLAG_COMMON_PLANE
))
1028 planes
[0] = planes
[1] = planes
[2] = NULL
;
1030 slice
= 0; // always "upload" full texture
1032 glUploadTex(gl_target
, gl_format
, gl_type
, planes
[0], stride
[0],
1033 mpi
->x
, mpi
->y
, w
, h
, slice
);
1036 mp_get_chroma_shift(image_format
, &xs
, &ys
);
1037 if ((mpi
->flags
& MP_IMGFLAG_DIRECT
) && !(mpi
->flags
& MP_IMGFLAG_COMMON_PLANE
)) {
1038 mpglBindBuffer(GL_PIXEL_UNPACK_BUFFER
, gl_buffer_uv
[0]);
1039 mpglUnmapBuffer(GL_PIXEL_UNPACK_BUFFER
);
1040 gl_bufferptr_uv
[0] = NULL
;
1042 mpglActiveTexture(GL_TEXTURE1
);
1043 glUploadTex(gl_target
, gl_format
, gl_type
, planes
[1], stride
[1],
1044 mpi
->x
>> xs
, mpi
->y
>> ys
, w
>> xs
, h
>> ys
, slice
);
1045 if ((mpi
->flags
& MP_IMGFLAG_DIRECT
) && !(mpi
->flags
& MP_IMGFLAG_COMMON_PLANE
)) {
1046 mpglBindBuffer(GL_PIXEL_UNPACK_BUFFER
, gl_buffer_uv
[1]);
1047 mpglUnmapBuffer(GL_PIXEL_UNPACK_BUFFER
);
1048 gl_bufferptr_uv
[1] = NULL
;
1050 mpglActiveTexture(GL_TEXTURE2
);
1051 glUploadTex(gl_target
, gl_format
, gl_type
, planes
[2], stride
[2],
1052 mpi
->x
>> xs
, mpi
->y
>> ys
, w
>> xs
, h
>> ys
, slice
);
1053 mpglActiveTexture(GL_TEXTURE0
);
1055 if (mpi
->flags
& MP_IMGFLAG_DIRECT
) {
1056 if (mesa_buffer
) mpglPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE
, 0);
1057 else mpglBindBuffer(GL_PIXEL_UNPACK_BUFFER
, 0);
1060 if (vo_doublebuffering
) do_render();
1065 draw_frame(uint8_t *src
[])
1071 query_format(uint32_t format
)
1073 int caps
= VFCAP_CSP_SUPPORTED
| VFCAP_CSP_SUPPORTED_BY_HW
|
1075 VFCAP_HWSCALE_UP
| VFCAP_HWSCALE_DOWN
| VFCAP_ACCEPT_STRIDE
;
1077 caps
|= VFCAP_OSD
| VFCAP_EOSD
| (scaled_osd
? 0 : VFCAP_EOSD_UNSCALED
);
1078 if (format
== IMGFMT_RGB24
|| format
== IMGFMT_RGBA
)
1080 if (use_yuv
&& mp_get_chroma_shift(format
, NULL
, NULL
) &&
1081 (IMGFMT_IS_YUVP16_NE(format
) || !IMGFMT_IS_YUVP16(format
)))
1083 // HACK, otherwise we get only b&w with some filters (e.g. -vf eq)
1084 // ideally MPlayer should be fixed instead not to use Y800 when it has the choice
1085 if (!use_yuv
&& (format
== IMGFMT_Y8
|| format
== IMGFMT_Y800
))
1087 if (!use_ycbcr
&& (format
== IMGFMT_UYVY
|| format
== IMGFMT_YUY2
))
1090 glFindFormat(format
, NULL
, NULL
, NULL
, NULL
))
1100 if (custom_prog
) free(custom_prog
);
1102 if (custom_tex
) free(custom_tex
);
1104 uninit_mpglcontext(&glctx
);
1107 static int valid_csp(void *p
)
1110 return *csp
>= -1 && *csp
< MP_CSP_COUNT
;
1113 static int valid_csp_lvl(void *p
)
1116 return *lvl
>= -1 && *lvl
< MP_CSP_LEVELCONV_COUNT
;
1119 static const opt_t subopts
[] = {
1120 {"manyfmts", OPT_ARG_BOOL
, &many_fmts
, NULL
},
1121 {"osd", OPT_ARG_BOOL
, &use_osd
, NULL
},
1122 {"scaled-osd", OPT_ARG_BOOL
, &scaled_osd
, NULL
},
1123 {"aspect", OPT_ARG_BOOL
, &use_aspect
, NULL
},
1124 {"ycbcr", OPT_ARG_BOOL
, &use_ycbcr
, NULL
},
1125 {"slice-height", OPT_ARG_INT
, &slice_height
, int_non_neg
},
1126 {"rectangle", OPT_ARG_INT
, &use_rectangle
,int_non_neg
},
1127 {"yuv", OPT_ARG_INT
, &use_yuv
, int_non_neg
},
1128 {"colorspace", OPT_ARG_INT
, &colorspace
, valid_csp
},
1129 {"levelconv", OPT_ARG_INT
, &levelconv
, valid_csp_lvl
},
1130 {"lscale", OPT_ARG_INT
, &lscale
, int_non_neg
},
1131 {"cscale", OPT_ARG_INT
, &cscale
, int_non_neg
},
1132 {"filter-strength", OPT_ARG_FLOAT
, &filter_strength
, NULL
},
1133 {"ati-hack", OPT_ARG_BOOL
, &ati_hack
, NULL
},
1134 {"force-pbo", OPT_ARG_BOOL
, &force_pbo
, NULL
},
1135 {"mesa-buffer", OPT_ARG_BOOL
, &mesa_buffer
, NULL
},
1136 {"glfinish", OPT_ARG_BOOL
, &use_glFinish
, NULL
},
1137 {"swapinterval", OPT_ARG_INT
, &swap_interval
,NULL
},
1138 {"customprog", OPT_ARG_MSTRZ
,&custom_prog
, NULL
},
1139 {"customtex", OPT_ARG_MSTRZ
,&custom_tex
, NULL
},
1140 {"customtlin", OPT_ARG_BOOL
, &custom_tlin
, NULL
},
1141 {"customtrect", OPT_ARG_BOOL
, &custom_trect
, NULL
},
1142 {"mipmapgen", OPT_ARG_BOOL
, &mipmap_gen
, NULL
},
1143 {"osdcolor", OPT_ARG_INT
, &osd_color
, NULL
},
1144 {"stereo", OPT_ARG_INT
, &stereo_mode
, NULL
},
1148 static int preinit_internal(const char *arg
, int allow_sw
)
1151 enum MPGLType gltype
= GLTYPE_AUTO
;
1162 filter_strength
= 0.5;
1175 osd_color
= 0xffffff;
1177 if (subopt_parse(arg
, subopts
) != 0) {
1178 mp_msg(MSGT_VO
, MSGL_FATAL
,
1179 "\n-vo gl command line help:\n"
1180 "Example: mplayer -vo gl:slice-height=4\n"
1183 " Disable extended color formats for OpenGL 1.2 and later\n"
1184 " slice-height=<0-...>\n"
1185 " Slice size for texture transfer, 0 for whole image\n"
1187 " Do not use OpenGL OSD code\n"
1189 " Render OSD at movie resolution and scale it\n"
1191 " Do not do aspect scaling\n"
1192 " rectangle=<0,1,2>\n"
1193 " 0: use power-of-two textures\n"
1194 " 1: use texture_rectangle\n"
1195 " 2: use texture_non_power_of_two\n"
1197 " Workaround ATI bug with PBOs\n"
1199 " Force use of PBO even if this involves an extra memcpy\n"
1201 " Call glFinish() before swapping buffers\n"
1202 " swapinterval=<n>\n"
1203 " Interval in displayed frames between to buffer swaps.\n"
1204 " 1 is equivalent to enable VSYNC, 0 to disable VSYNC.\n"
1205 " Requires GLX_SGI_swap_control support to work.\n"
1207 " also try to use the GL_MESA_ycbcr_texture extension\n"
1209 " 0: use software YUV to RGB conversion.\n"
1210 " 1: use register combiners (nVidia only, for older cards).\n"
1211 " 2: use fragment program.\n"
1212 " 3: use fragment program with gamma correction.\n"
1213 " 4: use fragment program with gamma correction via lookup.\n"
1214 " 5: use ATI-specific method (for older cards).\n"
1215 " 6: use lookup via 3D texture.\n"
1217 " 0: MPlayer's default YUV to RGB conversion\n"
1218 " 1: YUV to RGB according to BT.601\n"
1219 " 2: YUV to RGB according to BT.709\n"
1220 " 3: YUV to RGB according to SMPT-240M\n"
1221 " 4: YUV to RGB according to EBU\n"
1224 " 0: YUV to RGB converting TV to PC levels\n"
1225 " 1: YUV to RGB converting PC to TV levels\n"
1226 " 2: YUV to RGB without converting levels\n"
1228 " 0: use standard bilinear scaling for luma.\n"
1229 " 1: use improved bicubic scaling for luma.\n"
1230 " 2: use cubic in X, linear in Y direction scaling for luma.\n"
1231 " 3: as 1 but without using a lookup texture.\n"
1232 " 4: experimental unsharp masking (sharpening).\n"
1233 " 5: experimental unsharp masking (sharpening) with larger radius.\n"
1235 " as lscale but for chroma (2x slower with little visible effect).\n"
1236 " filter-strength=<value>\n"
1237 " set the effect strength for some lscale/cscale filters\n"
1238 " customprog=<filename>\n"
1239 " use a custom YUV conversion program\n"
1240 " customtex=<filename>\n"
1241 " use a custom YUV conversion lookup texture\n"
1243 " use GL_NEAREST scaling for customtex texture\n"
1245 " use texture_rectangle for customtex texture\n"
1247 " generate mipmaps for the video image (use with TXB in customprog)\n"
1248 " osdcolor=<0xAARRGGBB>\n"
1249 " use the given color for the OSD\n"
1251 " 0: normal display\n"
1252 " 1: side-by-side to red-cyan stereo\n"
1253 " 2: side-by-side to green-magenta stereo\n"
1254 " 3: side-by-side to quadbuffer stereo\n"
1258 if (!init_mpglcontext(&glctx
, gltype
))
1260 if (use_yuv
== -1 || !allow_sw
) {
1261 if (create_window(320, 200, VOFLAG_HIDDEN
, NULL
) < 0)
1263 if (glctx
.setGlWindow(&glctx
) == SET_WINDOW_FAILED
)
1265 if (!allow_sw
&& isSoftwareGl())
1267 autodetectGlExtensions();
1270 mp_msg(MSGT_VO
, MSGL_INFO
, "[gl] using extended formats. "
1271 "Use -vo gl:nomanyfmts if playback fails.\n");
1272 mp_msg(MSGT_VO
, MSGL_V
, "[gl] Using %d as slice height "
1273 "(0 means image height).\n", slice_height
);
1282 static int preinit(const char *arg
)
1284 return preinit_internal(arg
, 1);
1287 static int preinit_nosw(const char *arg
)
1289 return preinit_internal(arg
, 0);
1292 static const struct {
1297 {"brightness", &eq_bri
, MASK_NOT_COMBINERS
},
1298 {"contrast", &eq_cont
, MASK_NOT_COMBINERS
},
1299 {"saturation", &eq_sat
, MASK_ALL_YUV
},
1300 {"hue", &eq_hue
, MASK_ALL_YUV
},
1301 {"gamma", &eq_rgamma
, MASK_GAMMA_SUPPORT
},
1302 {"red_gamma", &eq_rgamma
, MASK_GAMMA_SUPPORT
},
1303 {"green_gamma", &eq_ggamma
, MASK_GAMMA_SUPPORT
},
1304 {"blue_gamma", &eq_bgamma
, MASK_GAMMA_SUPPORT
},
1308 static int control(uint32_t request
, void *data
)
1313 int_pause
= (request
== VOCTRL_PAUSE
);
1315 case VOCTRL_QUERY_FORMAT
:
1316 return query_format(*(uint32_t*)data
);
1317 case VOCTRL_GET_IMAGE
:
1318 return get_image(data
);
1319 case VOCTRL_DRAW_IMAGE
:
1320 return draw_image(data
);
1321 case VOCTRL_DRAW_EOSD
:
1325 if (vo_doublebuffering
) do_render_osd(2);
1327 case VOCTRL_GET_EOSD_RES
:
1329 mp_eosd_res_t
*r
= data
;
1330 r
->w
= vo_dwidth
; r
->h
= vo_dheight
;
1331 r
->mt
= r
->mb
= r
->ml
= r
->mr
= 0;
1332 if (scaled_osd
) {r
->w
= image_width
; r
->h
= image_height
;}
1333 else if (aspect_scaling()) {
1334 r
->ml
= r
->mr
= ass_border_x
;
1335 r
->mt
= r
->mb
= ass_border_y
;
1342 case VOCTRL_FULLSCREEN
:
1344 resize(vo_dwidth
, vo_dheight
);
1348 resize(vo_dwidth
, vo_dheight
);
1350 case VOCTRL_GET_PANSCAN
:
1351 if (!use_aspect
) return VO_NOTIMPL
;
1353 case VOCTRL_SET_PANSCAN
:
1354 if (!use_aspect
) return VO_NOTIMPL
;
1355 resize(vo_dwidth
, vo_dheight
);
1357 case VOCTRL_GET_EQUALIZER
:
1359 struct voctrl_get_equalizer_args
*args
= data
;
1361 for (i
= 0; eq_map
[i
].name
; i
++)
1362 if (strcmp(args
->name
, eq_map
[i
].name
) == 0) break;
1363 if (!(eq_map
[i
].supportmask
& (1 << use_yuv
)))
1365 *args
->valueptr
= *eq_map
[i
].value
;
1369 case VOCTRL_SET_EQUALIZER
:
1371 struct voctrl_set_equalizer_args
*args
= data
;
1373 for (i
= 0; eq_map
[i
].name
; i
++)
1374 if (strcmp(args
->name
, eq_map
[i
].name
) == 0) break;
1375 if (!(eq_map
[i
].supportmask
& (1 << use_yuv
)))
1377 *eq_map
[i
].value
= args
->value
;
1382 case VOCTRL_UPDATE_SCREENINFO
:
1383 glctx
.update_xinerama_info();
1385 case VOCTRL_REDRAW_OSD
:
1386 if (vo_doublebuffering
)
1389 if (vo_doublebuffering
)