?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add explanatory comments to the #endif part of multiple inclusion guards.
[mplayer/greg.git] / libvo / vo_gl.c
blob0824e25bd19cd0c0543dca4100006bee9a8b3ffd
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <math.h>
5
6 #include "config.h"
7 #include "mp_msg.h"
8 #include "subopt-helper.h"
9 #include "video_out.h"
10 #include "video_out_internal.h"
11 #include "font_load.h"
12 #include "sub.h"
13
14 #include "gl_common.h"
15 #include "aspect.h"
16 #ifdef HAVE_NEW_GUI
17 #include "gui/interface.h"
18 #endif
19 #include "libass/ass.h"
20 #include "libass/ass_mp.h"
21
22 static const vo_info_t info =
23 {
24 "X11 (OpenGL)",
25 "gl",
26 "Arpad Gereoffy <arpi@esp-team.scene.hu>",
27 ""
28 };
29
30 const LIBVO_EXTERN(gl)
31
32 #ifdef GL_WIN32
33 static int gl_vinfo = 0;
34 static HGLRC gl_context = 0;
35 #define update_xinerama_info w32_update_xinerama_info
36 #define vo_init vo_w32_init
37 #define vo_window vo_w32_window
38 #else
39 static XVisualInfo *gl_vinfo = NULL;
40 static GLXContext gl_context = 0;
41 static int wsGLXAttrib[] = { GLX_RGBA,
42 GLX_RED_SIZE,1,
43 GLX_GREEN_SIZE,1,
44 GLX_BLUE_SIZE,1,
45 GLX_DOUBLEBUFFER,
46 None };
47 #endif
48
49 static int use_osd;
50 static int scaled_osd;
51 //! How many parts the OSD may consist of at most
52 #define MAX_OSD_PARTS 20
53 //! Textures for OSD
54 static GLuint osdtex[MAX_OSD_PARTS];
55 #ifndef FAST_OSD
56 //! Alpha textures for OSD
57 static GLuint osdatex[MAX_OSD_PARTS];
58 #endif
59 static GLuint *eosdtex;
60 static GLuint largeeosdtex[2];
61 //! Display lists that draw the OSD parts
62 static GLuint osdDispList[MAX_OSD_PARTS];
63 #ifndef FAST_OSD
64 static GLuint osdaDispList[MAX_OSD_PARTS];
65 #endif
66 static GLuint eosdDispList;
67 //! How many parts the OSD currently consists of
68 static int osdtexCnt;
69 static int eosdtexCnt;
70 static int osd_color;
71
72 static int use_aspect;
73 static int use_yuv;
74 static int lscale;
75 static int cscale;
76 static int yuvconvtype;
77 static int use_rectangle;
78 static int err_shown;
79 static uint32_t image_width;
80 static uint32_t image_height;
81 static uint32_t image_format;
82 static int many_fmts;
83 static int use_glFinish;
84 static int swap_interval;
85 static GLenum gl_target;
86 static GLint gl_texfmt;
87 static GLenum gl_format;
88 static GLenum gl_type;
89 static GLuint gl_buffer;
90 static int gl_buffersize;
91 static void *gl_bufferptr;
92 static GLuint fragprog;
93 static GLuint default_texs[22];
94 static char *custom_prog;
95 static char *custom_tex;
96 static int custom_tlin;
97 static int custom_trect;
98
99 static int int_pause;
100 static int eq_bri = 0;
101 static int eq_cont = 0;
102 static int eq_sat = 0;
103 static int eq_hue = 0;
104 static int eq_rgamma = 0;
105 static int eq_ggamma = 0;
106 static int eq_bgamma = 0;
107
108 static int texture_width;
109 static int texture_height;
110 static int mpi_flipped;
111 static int vo_flipped;
112 static int ass_border_x, ass_border_y;
113
114 static unsigned int slice_height = 1;
115
116 static void resize(int x,int y){
117 mp_msg(MSGT_VO, MSGL_V, "[gl] Resize: %dx%d\n",x,y);
118 if (WinID >= 0) {
119 int top = 0, left = 0, w = x, h = y;
120 geometry(&top, &left, &w, &h, vo_screenwidth, vo_screenheight);
121 glViewport(top, left, w, h);
122 } else
123 glViewport( 0, 0, x, y );
124
125 glMatrixMode(GL_PROJECTION);
126 glLoadIdentity();
127 if (vo_fs && use_aspect) {
128 int new_w, new_h;
129 GLdouble scale_x, scale_y;
130 aspect(&new_w, &new_h, A_ZOOM);
131 panscan_calc();
132 new_w += vo_panscan_x;
133 new_h += vo_panscan_y;
134 scale_x = (GLdouble) new_w / (GLdouble) x;
135 scale_y = (GLdouble) new_h / (GLdouble) y;
136 glScaled(scale_x, scale_y, 1);
137 ass_border_x = (vo_screenwidth - new_w) / 2;
138 ass_border_y = (vo_screenheight - new_h) / 2;
139 }
140 glOrtho(0, image_width, image_height, 0, -1,1);
141
142 glMatrixMode(GL_MODELVIEW);
143 glLoadIdentity();
144
145 if (!scaled_osd) {
146 #ifdef HAVE_FREETYPE
147 // adjust font size to display size
148 force_load_font = 1;
149 #endif
150 vo_osd_changed(OSDTYPE_OSD);
151 }
152 if (vo_fs && use_aspect && !vo_doublebuffering)
153 glClear(GL_COLOR_BUFFER_BIT);
154 }
155
156 static void texSize(int w, int h, int *texw, int *texh) {
157 if (use_rectangle) {
158 *texw = w; *texh = h;
159 } else {
160 *texw = 32;
161 while (*texw < w)
162 *texw *= 2;
163 *texh = 32;
164 while (*texh < h)
165 *texh *= 2;
166 }
167 }
168
169 //! maximum size of custom fragment program
170 #define MAX_CUSTOM_PROG_SIZE (1024 * 1024)
171 static void update_yuvconv(void) {
172 float bri = eq_bri / 100.0;
173 float cont = (eq_cont + 100) / 100.0;
174 float hue = eq_hue / 100.0 * 3.1415927;
175 float sat = (eq_sat + 100) / 100.0;
176 float rgamma = exp(log(8.0) * eq_rgamma / 100.0);
177 float ggamma = exp(log(8.0) * eq_ggamma / 100.0);
178 float bgamma = exp(log(8.0) * eq_bgamma / 100.0);
179 glSetupYUVConversion(gl_target, yuvconvtype, bri, cont, hue, sat,
180 rgamma, ggamma, bgamma,
181 texture_width, texture_height);
182 if (custom_prog) {
183 FILE *f = fopen(custom_prog, "r");
184 if (!f)
185 mp_msg(MSGT_VO, MSGL_WARN,
186 "[gl] Could not read customprog %s\n", custom_prog);
187 else {
188 char *prog = calloc(1, MAX_CUSTOM_PROG_SIZE + 1);
189 fread(prog, 1, MAX_CUSTOM_PROG_SIZE, f);
190 fclose(f);
191 loadGPUProgram(GL_FRAGMENT_PROGRAM, prog);
192 free(prog);
193 }
194 ProgramEnvParameter4f(GL_FRAGMENT_PROGRAM, 0,
195 1.0 / texture_width, 1.0 / texture_height,
196 texture_width, texture_height);
197 }
198 if (custom_tex) {
199 FILE *f = fopen(custom_tex, "r");
200 if (!f)
201 mp_msg(MSGT_VO, MSGL_WARN,
202 "[gl] Could not read customtex %s\n", custom_tex);
203 else {
204 int width, height, maxval;
205 ActiveTexture(GL_TEXTURE3);
206 if (glCreatePPMTex(custom_trect?GL_TEXTURE_RECTANGLE:GL_TEXTURE_2D, 0,
207 custom_tlin?GL_LINEAR:GL_NEAREST,
208 f, &width, &height, &maxval))
209 ProgramEnvParameter4f(GL_FRAGMENT_PROGRAM, 1,
210 1.0 / width, 1.0 / height, width, height);
211 else
212 mp_msg(MSGT_VO, MSGL_WARN,
213 "[gl] Error parsing customtex %s\n", custom_tex);
214 fclose(f);
215 ActiveTexture(GL_TEXTURE0);
216 }
217 }
218 }
219
220 /**
221 * \brief remove all OSD textures and display-lists, thus clearing it.
222 */
223 static void clearOSD(void) {
224 int i;
225 if (!osdtexCnt)
226 return;
227 glDeleteTextures(osdtexCnt, osdtex);
228 #ifndef FAST_OSD
229 glDeleteTextures(osdtexCnt, osdatex);
230 for (i = 0; i < osdtexCnt; i++)
231 glDeleteLists(osdaDispList[i], 1);
232 #endif
233 for (i = 0; i < osdtexCnt; i++)
234 glDeleteLists(osdDispList[i], 1);
235 osdtexCnt = 0;
236 }
237
238 /**
239 * \brief remove textures, display list and free memory used by EOSD
240 */
241 static void clearEOSD(void) {
242 if (eosdDispList)
243 glDeleteLists(eosdDispList, 1);
244 eosdDispList = 0;
245 if (eosdtexCnt)
246 glDeleteTextures(eosdtexCnt, eosdtex);
247 eosdtexCnt = 0;
248 free(eosdtex);
249 eosdtex = NULL;
250 }
251
252 /**
253 * \brief construct display list from ass image list
254 * \param img image list to create OSD from.
255 * A value of NULL has the same effect as clearEOSD()
256 */
257 static void genEOSD(mp_eosd_images_t *imgs) {
258 int sx, sy;
259 int tinytexcur = 0;
260 int smalltexcur = 0;
261 GLuint *curtex;
262 GLint scale_type = (scaled_osd) ? GL_LINEAR : GL_NEAREST;
263 ass_image_t *img = imgs->imgs;
264 ass_image_t *i;
265
266 if (imgs->changed == 0) // there are elements, but they are unchanged
267 return;
268 if (img && imgs->changed == 1) // there are elements, but they just moved
269 goto skip_upload;
270
271 clearEOSD();
272 if (!img)
273 return;
274 if (!largeeosdtex[0]) {
275 glGenTextures(2, largeeosdtex);
276 BindTexture(gl_target, largeeosdtex[0]);
277 glCreateClearTex(gl_target, GL_ALPHA, scale_type, 512, 512, 0);
278 BindTexture(gl_target, largeeosdtex[1]);
279 glCreateClearTex(gl_target, GL_ALPHA, scale_type, 512, 512, 0);
280 }
281 for (i = img; i; i = i->next)
282 {
283 if (i->w <= 0 || i->h <= 0 || i->stride < i->w)
284 continue;
285 if (i->w < 16 && i->h < 16 && tinytexcur < 1024)
286 tinytexcur++;
287 else if (i->w < 32 && i->h < 32 && smalltexcur < 256)
288 smalltexcur++;
289 else
290 eosdtexCnt++;
291 }
292 mp_msg(MSGT_VO, MSGL_DBG2, "EOSD counts (tiny, small, all): %i, %i, %i\n",
293 tinytexcur, smalltexcur, eosdtexCnt);
294 if (eosdtexCnt) {
295 eosdtex = calloc(eosdtexCnt, sizeof(GLuint));
296 glGenTextures(eosdtexCnt, eosdtex);
297 }
298 tinytexcur = smalltexcur = 0;
299 for (i = img, curtex = eosdtex; i; i = i->next) {
300 int x = 0, y = 0;
301 if (i->w <= 0 || i->h <= 0 || i->stride < i->w) {
302 mp_msg(MSGT_VO, MSGL_V, "Invalid dimensions OSD for part!\n");
303 continue;
304 }
305 if (i->w < 16 && i->h < 16 && tinytexcur < 1024) {
306 x = (tinytexcur & 31) << 4;
307 y = (tinytexcur >> 5) << 4;
308 BindTexture(gl_target, largeeosdtex[0]);
309 tinytexcur++;
310 } else if (i->w < 32 && i->h < 32 && smalltexcur < 256) {
311 x = (smalltexcur & 15) << 5;
312 y = (smalltexcur >> 4) << 5;
313 BindTexture(gl_target, largeeosdtex[1]);
314 smalltexcur++;
315 } else {
316 texSize(i->w, i->h, &sx, &sy);
317 BindTexture(gl_target, *curtex++);
318 glCreateClearTex(gl_target, GL_ALPHA, scale_type, sx, sy, 0);
319 }
320 glUploadTex(gl_target, GL_ALPHA, GL_UNSIGNED_BYTE, i->bitmap, i->stride,
321 x, y, i->w, i->h, 0);
322 }
323 eosdDispList = glGenLists(1);
324 skip_upload:
325 glNewList(eosdDispList, GL_COMPILE);
326 tinytexcur = smalltexcur = 0;
327 for (i = img, curtex = eosdtex; i; i = i->next) {
328 int x = 0, y = 0;
329 if (i->w <= 0 || i->h <= 0 || i->stride < i->w)
330 continue;
331 glColor4ub(i->color >> 24, (i->color >> 16) & 0xff, (i->color >> 8) & 0xff, 255 - (i->color & 0xff));
332 if (i->w < 16 && i->h < 16 && tinytexcur < 1024) {
333 x = (tinytexcur & 31) << 4;
334 y = (tinytexcur >> 5) << 4;
335 sx = sy = 512;
336 BindTexture(gl_target, largeeosdtex[0]);
337 tinytexcur++;
338 } else if (i->w < 32 && i->h < 32 && smalltexcur < 256) {
339 x = (smalltexcur & 15) << 5;
340 y = (smalltexcur >> 4) << 5;
341 sx = sy = 512;
342 BindTexture(gl_target, largeeosdtex[1]);
343 smalltexcur++;
344 } else {
345 texSize(i->w, i->h, &sx, &sy);
346 BindTexture(gl_target, *curtex++);
347 }
348 glDrawTex(i->dst_x, i->dst_y, i->w, i->h, x, y, i->w, i->h, sx, sy, use_rectangle == 1, 0, 0);
349 }
350 glEndList();
351 BindTexture(gl_target, 0);
352 }
353
354 /**
355 * \brief uninitialize OpenGL context, freeing textures, buffers etc.
356 */
357 static void uninitGl(void) {
358 int i = 0;
359 if (DeletePrograms && fragprog)
360 DeletePrograms(1, &fragprog);
361 fragprog = 0;
362 while (default_texs[i] != 0)
363 i++;
364 if (i)
365 glDeleteTextures(i, default_texs);
366 default_texs[0] = 0;
367 clearOSD();
368 clearEOSD();
369 if (largeeosdtex[0])
370 glDeleteTextures(2, largeeosdtex);
371 largeeosdtex[0] = 0;
372 if (DeleteBuffers && gl_buffer)
373 DeleteBuffers(1, &gl_buffer);
374 gl_buffer = 0; gl_buffersize = 0;
375 gl_bufferptr = NULL;
376 err_shown = 0;
377 }
378
379 /**
380 * \brief Initialize a (new or reused) OpenGL context.
381 * set global gl-related variables to their default values
382 */
383 static int initGl(uint32_t d_width, uint32_t d_height) {
384 texSize(image_width, image_height, &texture_width, &texture_height);
385
386 glDisable(GL_BLEND);
387 glDisable(GL_DEPTH_TEST);
388 glDepthMask(GL_FALSE);
389 glDisable(GL_CULL_FACE);
390 glEnable(gl_target);
391 glDrawBuffer(vo_doublebuffering?GL_BACK:GL_FRONT);
392 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
393
394 mp_msg(MSGT_VO, MSGL_V, "[gl] Creating %dx%d texture...\n",
395 texture_width, texture_height);
396
397 if (image_format == IMGFMT_YV12) {
398 int i;
399 glGenTextures(21, default_texs);
400 default_texs[21] = 0;
401 for (i = 0; i < 7; i++) {
402 ActiveTexture(GL_TEXTURE1 + i);
403 BindTexture(GL_TEXTURE_2D, default_texs[i]);
404 BindTexture(GL_TEXTURE_RECTANGLE, default_texs[i + 7]);
405 BindTexture(GL_TEXTURE_3D, default_texs[i + 14]);
406 }
407 ActiveTexture(GL_TEXTURE1);
408 glCreateClearTex(gl_target, gl_texfmt, GL_LINEAR,
409 texture_width / 2, texture_height / 2, 128);
410 ActiveTexture(GL_TEXTURE2);
411 glCreateClearTex(gl_target, gl_texfmt, GL_LINEAR,
412 texture_width / 2, texture_height / 2, 128);
413 switch (use_yuv) {
414 case YUV_CONVERSION_FRAGMENT_LOOKUP:
415 case YUV_CONVERSION_FRAGMENT_POW:
416 case YUV_CONVERSION_FRAGMENT:
417 if (!GenPrograms || !BindProgram) {
418 mp_msg(MSGT_VO, MSGL_ERR, "[gl] fragment program functions missing!\n");
419 break;
420 }
421 GenPrograms(1, &fragprog);
422 BindProgram(GL_FRAGMENT_PROGRAM, fragprog);
423 break;
424 }
425 ActiveTexture(GL_TEXTURE0);
426 BindTexture(gl_target, 0);
427 update_yuvconv();
428 }
429 glCreateClearTex(gl_target, gl_texfmt, GL_LINEAR,
430 texture_width, texture_height, 0);
431
432 resize(d_width, d_height);
433
434 glClearColor( 0.0f,0.0f,0.0f,0.0f );
435 glClear( GL_COLOR_BUFFER_BIT );
436 if (SwapInterval && swap_interval >= 0)
437 SwapInterval(swap_interval);
438 return 1;
439 }
440
441 /* connect to server, create and map window,
442 * allocate colors and (shared) memory
443 */
444 static int
445 config(uint32_t width, uint32_t height, uint32_t d_width, uint32_t d_height, uint32_t flags, char *title, uint32_t format)
446 {
447 image_height = height;
448 image_width = width;
449 image_format = format;
450 glFindFormat(format, NULL, &gl_texfmt, &gl_format, &gl_type);
451
452 int_pause = 0;
453 vo_flipped = !!(flags & VOFLAG_FLIPPING);
454
455 #ifdef HAVE_NEW_GUI
456 if (use_gui) {
457 // GUI creates and manages window for us
458 guiGetEvent(guiSetShVideo, 0);
459 #ifndef GL_WIN32
460 goto glconfig;
461 #endif
462 }
463 #endif
464 #ifdef GL_WIN32
465 if (!vo_w32_config(d_width, d_height, flags))
466 return -1;
467 #else
468 vo_mouse_autohide = 1;
469 if (WinID >= 0) {
470 vo_window = WinID ? (Window)WinID : mRootWin;
471 vo_x11_selectinput_witherr(mDisplay, vo_window,
472 StructureNotifyMask | KeyPressMask | PointerMotionMask |
473 ButtonPressMask | ButtonReleaseMask | ExposureMask);
474 goto glconfig;
475 }
476 {
477 XVisualInfo *vinfo=glXChooseVisual( mDisplay,mScreen,wsGLXAttrib );
478 if (vinfo == NULL)
479 {
480 mp_msg(MSGT_VO, MSGL_ERR, "[gl] no GLX support present\n");
481 return -1;
482 }
483
484 vo_x11_create_vo_window(vinfo, vo_dx, vo_dy, d_width, d_height, flags,
485 XCreateColormap(mDisplay, mRootWin, vinfo->visual, AllocNone),
486 "gl", title);
487 }
488 #endif
489
490 glconfig:
491 if (vo_config_count)
492 uninitGl();
493 setGlWindow(&gl_vinfo, &gl_context, vo_window);
494 initGl(vo_dwidth, vo_dheight);
495
496 return 0;
497 }
498
499 static void check_events(void)
500 {
501 int e=vo_check_events();
502 if(e&VO_EVENT_RESIZE) resize(vo_dwidth,vo_dheight);
503 if(e&VO_EVENT_EXPOSE && int_pause) flip_page();
504 }
505
506 /**
507 * Creates the textures and the display list needed for displaying
508 * an OSD part.
509 * Callback function for vo_draw_text().
510 */
511 static void create_osd_texture(int x0, int y0, int w, int h,
512 unsigned char *src, unsigned char *srca,
513 int stride)
514 {
515 // initialize to 8 to avoid special-casing on alignment
516 int sx = 8, sy = 8;
517 GLint scale_type = (scaled_osd) ? GL_LINEAR : GL_NEAREST;
518
519 if (w <= 0 || h <= 0 || stride < w) {
520 mp_msg(MSGT_VO, MSGL_V, "Invalid dimensions OSD for part!\n");
521 return;
522 }
523 texSize(w, h, &sx, &sy);
524
525 if (osdtexCnt >= MAX_OSD_PARTS) {
526 mp_msg(MSGT_VO, MSGL_ERR, "Too many OSD parts, contact the developers!\n");
527 return;
528 }
529
530 // create Textures for OSD part
531 glGenTextures(1, &osdtex[osdtexCnt]);
532 BindTexture(gl_target, osdtex[osdtexCnt]);
533 glCreateClearTex(gl_target, GL_LUMINANCE, scale_type, sx, sy, 0);
534 glUploadTex(gl_target, GL_LUMINANCE, GL_UNSIGNED_BYTE, src, stride,
535 0, 0, w, h, 0);
536
537 #ifndef FAST_OSD
538 glGenTextures(1, &osdatex[osdtexCnt]);
539 BindTexture(gl_target, osdatex[osdtexCnt]);
540 glCreateClearTex(gl_target, GL_ALPHA, scale_type, sx, sy, 255);
541 {
542 int i;
543 char *tmp = malloc(stride * h);
544 // convert alpha from weird MPlayer scale.
545 // in-place is not possible since it is reused for future OSDs
546 for (i = h * stride - 1; i >= 0; i--)
547 tmp[i] = srca[i] - 1;
548 glUploadTex(gl_target, GL_ALPHA, GL_UNSIGNED_BYTE, tmp, stride,
549 0, 0, w, h, 0);
550 free(tmp);
551 }
552 #endif
553
554 BindTexture(gl_target, 0);
555
556 // Create a list for rendering this OSD part
557 #ifndef FAST_OSD
558 osdaDispList[osdtexCnt] = glGenLists(1);
559 glNewList(osdaDispList[osdtexCnt], GL_COMPILE);
560 // render alpha
561 BindTexture(gl_target, osdatex[osdtexCnt]);
562 glDrawTex(x0, y0, w, h, 0, 0, w, h, sx, sy, use_rectangle == 1, 0, 0);
563 glEndList();
564 #endif
565 osdDispList[osdtexCnt] = glGenLists(1);
566 glNewList(osdDispList[osdtexCnt], GL_COMPILE);
567 // render OSD
568 BindTexture(gl_target, osdtex[osdtexCnt]);
569 glDrawTex(x0, y0, w, h, 0, 0, w, h, sx, sy, use_rectangle == 1, 0, 0);
570 glEndList();
571
572 osdtexCnt++;
573 }
574
575 static void draw_osd(void)
576 {
577 if (!use_osd) return;
578 if (vo_osd_changed(0)) {
579 int osd_h, osd_w;
580 clearOSD();
581 osd_w = (scaled_osd) ? image_width : vo_dwidth;
582 osd_h = (scaled_osd) ? image_height : vo_dheight;
583 vo_draw_text(osd_w, osd_h, create_osd_texture);
584 }
585 }
586
587 static void
588 flip_page(void)
589 {
590 // glEnable(GL_TEXTURE_2D);
591 // glBindTexture(GL_TEXTURE_2D, texture_id);
592
593 glColor3f(1,1,1);
594 if (image_format == IMGFMT_YV12)
595 glEnableYUVConversion(gl_target, yuvconvtype);
596 glDrawTex(0, 0, image_width, image_height,
597 0, 0, image_width, image_height,
598 texture_width, texture_height,
599 use_rectangle == 1, image_format == IMGFMT_YV12,
600 mpi_flipped ^ vo_flipped);
601 if (image_format == IMGFMT_YV12)
602 glDisableYUVConversion(gl_target, yuvconvtype);
603
604 if (osdtexCnt > 0 || eosdDispList) {
605 // set special rendering parameters
606 if (!scaled_osd) {
607 glMatrixMode(GL_PROJECTION);
608 glPushMatrix();
609 glLoadIdentity();
610 glOrtho(0, vo_dwidth, vo_dheight, 0, -1, 1);
611 }
612 glEnable(GL_BLEND);
613 if (eosdDispList) {
614 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
615 glCallList(eosdDispList);
616 }
617 if (osdtexCnt > 0) {
618 glColor4ub((osd_color >> 16) & 0xff, (osd_color >> 8) & 0xff, osd_color & 0xff, 0xff);
619 // draw OSD
620 #ifndef FAST_OSD
621 glBlendFunc(GL_ZERO, GL_SRC_ALPHA);
622 glCallLists(osdtexCnt, GL_UNSIGNED_INT, osdaDispList);
623 #endif
624 glBlendFunc(GL_ONE, GL_ONE);
625 glCallLists(osdtexCnt, GL_UNSIGNED_INT, osdDispList);
626 }
627 // set rendering parameters back to defaults
628 glDisable (GL_BLEND);
629 if (!scaled_osd)
630 glPopMatrix();
631 BindTexture(gl_target, 0);
632 }
633
634 if (use_glFinish)
635 glFinish();
636 if (vo_doublebuffering)
637 swapGlBuffers();
638 else if (!use_glFinish)
639 glFlush();
640
641 if (vo_fs && use_aspect && vo_doublebuffering)
642 glClear(GL_COLOR_BUFFER_BIT);
643 }
644
645 //static inline uint32_t draw_slice_x11(uint8_t *src[], uint32_t slice_num)
646 static int draw_slice(uint8_t *src[], int stride[], int w,int h,int x,int y)
647 {
648 mpi_flipped = (stride[0] < 0);
649 glUploadTex(gl_target, gl_format, gl_type, src[0], stride[0],
650 x, y, w, h, slice_height);
651 if (image_format == IMGFMT_YV12) {
652 ActiveTexture(GL_TEXTURE1);
653 glUploadTex(gl_target, gl_format, gl_type, src[1], stride[1],
654 x / 2, y / 2, w / 2, h / 2, slice_height);
655 ActiveTexture(GL_TEXTURE2);
656 glUploadTex(gl_target, gl_format, gl_type, src[2], stride[2],
657 x / 2, y / 2, w / 2, h / 2, slice_height);
658 ActiveTexture(GL_TEXTURE0);
659 }
660 return 0;
661 }
662
663 static uint32_t get_image(mp_image_t *mpi) {
664 if (!GenBuffers || !BindBuffer || !BufferData || !MapBuffer) {
665 if (!err_shown)
666 mp_msg(MSGT_VO, MSGL_ERR, "[gl] extensions missing for dr\n"
667 "Expect a _major_ speed penalty\n");
668 err_shown = 1;
669 return VO_FALSE;
670 }
671 if (mpi->flags & MP_IMGFLAG_READABLE) return VO_FALSE;
672 if (mpi->type == MP_IMGTYPE_IP || mpi->type == MP_IMGTYPE_IPB)
673 return VO_FALSE; // we can not provide readable buffers
674 if (!gl_buffer)
675 GenBuffers(1, &gl_buffer);
676 BindBuffer(GL_PIXEL_UNPACK_BUFFER, gl_buffer);
677 mpi->stride[0] = mpi->width * mpi->bpp / 8;
678 if (mpi->stride[0] * mpi->h > gl_buffersize) {
679 BufferData(GL_PIXEL_UNPACK_BUFFER, mpi->stride[0] * mpi->h,
680 NULL, GL_DYNAMIC_DRAW);
681 gl_buffersize = mpi->stride[0] * mpi->h;
682 }
683 if (!gl_bufferptr)
684 gl_bufferptr = MapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY);
685 mpi->planes[0] = gl_bufferptr;
686 BindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
687 if (mpi->planes[0] == NULL) {
688 if (!err_shown)
689 mp_msg(MSGT_VO, MSGL_ERR, "[gl] could not aquire buffer for dr\n"
690 "Expect a _major_ speed penalty\n");
691 err_shown = 1;
692 return VO_FALSE;
693 }
694 if (mpi->imgfmt == IMGFMT_YV12) {
695 // YV12
696 mpi->flags |= MP_IMGFLAG_COMMON_STRIDE | MP_IMGFLAG_COMMON_PLANE;
697 mpi->stride[0] = mpi->width;
698 mpi->planes[1] = mpi->planes[0] + mpi->stride[0] * mpi->height;
699 mpi->stride[1] = mpi->width >> 1;
700 mpi->planes[2] = mpi->planes[1] + mpi->stride[1] * (mpi->height >> 1);
701 mpi->stride[2] = mpi->width >> 1;
702 }
703 mpi->flags |= MP_IMGFLAG_DIRECT;
704 return VO_TRUE;
705 }
706
707 static uint32_t draw_image(mp_image_t *mpi) {
708 int slice = slice_height;
709 int stride[3] = {mpi->stride[0], mpi->stride[1], mpi->stride[2]};
710 unsigned char *planes[3] = {mpi->planes[0], mpi->planes[1], mpi->planes[2]};
711 if (mpi->flags & MP_IMGFLAG_DRAW_CALLBACK)
712 return VO_TRUE;
713 mpi_flipped = (stride[0] < 0);
714 if (mpi->flags & MP_IMGFLAG_DIRECT) {
715 intptr_t base = (intptr_t)planes[0];
716 if (mpi_flipped)
717 base += (mpi->h - 1) * stride[0];
718 planes[0] -= base;
719 planes[1] -= base;
720 planes[2] -= base;
721 BindBuffer(GL_PIXEL_UNPACK_BUFFER, gl_buffer);
722 UnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
723 gl_bufferptr = NULL;
724 slice = 0; // always "upload" full texture
725 }
726 glUploadTex(gl_target, gl_format, gl_type, planes[0], stride[0],
727 mpi->x, mpi->y, mpi->w, mpi->h, slice);
728 if (mpi->imgfmt == IMGFMT_YV12) {
729 ActiveTexture(GL_TEXTURE1);
730 glUploadTex(gl_target, gl_format, gl_type, planes[1], stride[1],
731 mpi->x / 2, mpi->y / 2, mpi->w / 2, mpi->h / 2, slice);
732 ActiveTexture(GL_TEXTURE2);
733 glUploadTex(gl_target, gl_format, gl_type, planes[2], stride[2],
734 mpi->x / 2, mpi->y / 2, mpi->w / 2, mpi->h / 2, slice);
735 ActiveTexture(GL_TEXTURE0);
736 }
737 if (mpi->flags & MP_IMGFLAG_DIRECT)
738 BindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
739 return VO_TRUE;
740 }
741
742 static int
743 draw_frame(uint8_t *src[])
744 {
745 return VO_ERROR;
746 }
747
748 static int
749 query_format(uint32_t format)
750 {
751 int caps = VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW |
752 VFCAP_FLIP |
753 VFCAP_HWSCALE_UP | VFCAP_HWSCALE_DOWN | VFCAP_ACCEPT_STRIDE;
754 if (use_osd)
755 caps |= VFCAP_OSD | VFCAP_EOSD | (scaled_osd ? 0 : VFCAP_EOSD_UNSCALED);
756 if ((format == IMGFMT_RGB24) || (format == IMGFMT_RGBA))
757 return caps;
758 if (use_yuv && format == IMGFMT_YV12)
759 return caps;
760 // HACK, otherwise we get only b&w with some filters (e.g. -vf eq)
761 // ideally MPlayer should be fixed instead not to use Y800 when it has the choice
762 if (!use_yuv && (format == IMGFMT_Y8 || format == IMGFMT_Y800))
763 return 0;
764 if (many_fmts &&
765 glFindFormat(format, NULL, NULL, NULL, NULL))
766 return caps;
767 return 0;
768 }
769
770
771 static void
772 uninit(void)
773 {
774 if ( !vo_config_count ) return;
775 uninitGl();
776 releaseGlContext(&gl_vinfo, &gl_context);
777 if (custom_prog) free(custom_prog);
778 custom_prog = NULL;
779 if (custom_tex) free(custom_tex);
780 custom_tex = NULL;
781 vo_uninit();
782 }
783
784 static opt_t subopts[] = {
785 {"manyfmts", OPT_ARG_BOOL, &many_fmts, NULL},
786 {"osd", OPT_ARG_BOOL, &use_osd, NULL},
787 {"scaled-osd", OPT_ARG_BOOL, &scaled_osd, NULL},
788 {"aspect", OPT_ARG_BOOL, &use_aspect, NULL},
789 {"slice-height", OPT_ARG_INT, &slice_height, (opt_test_f)int_non_neg},
790 {"rectangle", OPT_ARG_INT, &use_rectangle,(opt_test_f)int_non_neg},
791 {"yuv", OPT_ARG_INT, &use_yuv, (opt_test_f)int_non_neg},
792 {"lscale", OPT_ARG_INT, &lscale, (opt_test_f)int_non_neg},
793 {"cscale", OPT_ARG_INT, &cscale, (opt_test_f)int_non_neg},
794 {"glfinish", OPT_ARG_BOOL, &use_glFinish, NULL},
795 {"swapinterval", OPT_ARG_INT, &swap_interval,NULL},
796 {"customprog", OPT_ARG_MSTRZ,&custom_prog, NULL},
797 {"customtex", OPT_ARG_MSTRZ,&custom_tex, NULL},
798 {"customtlin", OPT_ARG_BOOL, &custom_tlin, NULL},
799 {"customtrect", OPT_ARG_BOOL, &custom_trect, NULL},
800 {"osdcolor", OPT_ARG_INT, &osd_color, NULL},
801 {NULL}
802 };
803
804 static int preinit(const char *arg)
805 {
806 // set defaults
807 many_fmts = 1;
808 use_osd = 1;
809 scaled_osd = 0;
810 use_aspect = 1;
811 use_yuv = 0;
812 lscale = 0;
813 cscale = 0;
814 use_rectangle = 0;
815 use_glFinish = 0;
816 swap_interval = 1;
817 slice_height = 0;
818 custom_prog = NULL;
819 custom_tex = NULL;
820 custom_tlin = 1;
821 custom_trect = 0;
822 osd_color = 0xffffff;
823 if (subopt_parse(arg, subopts) != 0) {
824 mp_msg(MSGT_VO, MSGL_FATAL,
825 "\n-vo gl command line help:\n"
826 "Example: mplayer -vo gl:slice-height=4\n"
827 "\nOptions:\n"
828 " nomanyfmts\n"
829 " Disable extended color formats for OpenGL 1.2 and later\n"
830 " slice-height=<0-...>\n"
831 " Slice size for texture transfer, 0 for whole image\n"
832 " noosd\n"
833 " Do not use OpenGL OSD code\n"
834 " noaspect\n"
835 " Do not do aspect scaling\n"
836 " rectangle=<0,1,2>\n"
837 " 0: use power-of-two textures\n"
838 " 1: use texture_rectangle\n"
839 " 2: use texture_non_power_of_two\n"
840 " glfinish\n"
841 " Call glFinish() before swapping buffers\n"
842 " swapinterval=<n>\n"
843 " Interval in displayed frames between to buffer swaps.\n"
844 " 1 is equivalent to enable VSYNC, 0 to disable VSYNC.\n"
845 " Requires GLX_SGI_swap_control support to work.\n"
846 " yuv=<n>\n"
847 " 0: use software YUV to RGB conversion.\n"
848 " 1: use register combiners (nVidia only, for older cards).\n"
849 " 2: use fragment program.\n"
850 " 3: use fragment program with gamma correction.\n"
851 " 4: use fragment program with gamma correction via lookup.\n"
852 " 5: use ATI-specific method (for older cards).\n"
853 " 6: use lookup via 3D texture.\n"
854 " lscale=<n>\n"
855 " 0: use standard bilinear scaling for luma.\n"
856 " 1: use improved bicubic scaling for luma.\n"
857 " 2: use cubic in X, linear in Y direction scaling for luma.\n"
858 " cscale=<n>\n"
859 " as lscale but for chroma (2x slower with little visible effect).\n"
860 " customprog=<filename>\n"
861 " use a custom YUV conversion program\n"
862 " customtex=<filename>\n"
863 " use a custom YUV conversion lookup texture\n"
864 " nocustomtlin\n"
865 " use GL_NEAREST scaling for customtex texture\n"
866 " customtrect\n"
867 " use texture_rectangle for customtex texture\n"
868 " osdcolor=<0xRRGGBB>\n"
869 " use the given color for the OSD\n"
870 "\n" );
871 return -1;
872 }
873 if (use_rectangle == 1)
874 gl_target = GL_TEXTURE_RECTANGLE;
875 else
876 gl_target = GL_TEXTURE_2D;
877 yuvconvtype = use_yuv | lscale << YUV_LUM_SCALER_SHIFT | cscale << YUV_CHROM_SCALER_SHIFT;
878 if (many_fmts)
879 mp_msg (MSGT_VO, MSGL_INFO, "[gl] using extended formats. "
880 "Use -vo gl:nomanyfmts if playback fails.\n");
881 mp_msg (MSGT_VO, MSGL_V, "[gl] Using %d as slice height "
882 "(0 means image height).\n", slice_height);
883 if( !vo_init() ) return -1; // Can't open X11
884
885 return 0;
886 }
887
888 static int control(uint32_t request, void *data, ...)
889 {
890 switch (request) {
891 case VOCTRL_PAUSE: return (int_pause=1);
892 case VOCTRL_RESUME: return (int_pause=0);
893 case VOCTRL_QUERY_FORMAT:
894 return query_format(*((uint32_t*)data));
895 case VOCTRL_GET_IMAGE:
896 return get_image(data);
897 case VOCTRL_DRAW_IMAGE:
898 return draw_image(data);
899 case VOCTRL_DRAW_EOSD:
900 if (!data)
901 return VO_FALSE;
902 genEOSD(data);
903 return VO_TRUE;
904 case VOCTRL_GET_EOSD_RES:
905 {
906 mp_eosd_res_t *r = data;
907 r->mt = r->mb = r->ml = r->mr = 0;
908 if (scaled_osd) {r->w = image_width; r->h = image_height;}
909 else if (vo_fs) {
910 r->w = vo_screenwidth; r->h = vo_screenheight;
911 r->ml = r->mr = ass_border_x;
912 r->mt = r->mb = ass_border_y;
913 } else {
914 r->w = vo_dwidth; r->h = vo_dheight;
915 }
916 }
917 return VO_TRUE;
918 case VOCTRL_GUISUPPORT:
919 return VO_TRUE;
920 case VOCTRL_ONTOP:
921 vo_ontop();
922 return VO_TRUE;
923 case VOCTRL_FULLSCREEN:
924 vo_fullscreen();
925 resize(vo_dwidth, vo_dheight);
926 return VO_TRUE;
927 #ifdef GL_WIN32
928 case VOCTRL_BORDER:
929 vo_w32_border();
930 return VO_TRUE;
931 #endif
932 case VOCTRL_GET_PANSCAN:
933 if (!use_aspect) return VO_NOTIMPL;
934 return VO_TRUE;
935 case VOCTRL_SET_PANSCAN:
936 if (!use_aspect) return VO_NOTIMPL;
937 resize (vo_dwidth, vo_dheight);
938 return VO_TRUE;
939 case VOCTRL_GET_EQUALIZER:
940 if (image_format == IMGFMT_YV12) {
941 va_list va;
942 int *value;
943 va_start(va, data);
944 value = va_arg(va, int *);
945 va_end(va);
946 if (strcasecmp(data, "brightness") == 0) {
947 *value = eq_bri;
948 if (use_yuv == YUV_CONVERSION_COMBINERS) break; // not supported
949 } else if (strcasecmp(data, "contrast") == 0) {
950 *value = eq_cont;
951 if (use_yuv == YUV_CONVERSION_COMBINERS) break; // not supported
952 } else if (strcasecmp(data, "saturation") == 0) {
953 *value = eq_sat;
954 } else if (strcasecmp(data, "hue") == 0) {
955 *value = eq_hue;
956 } else if (strcasecmp(data, "gamma") == 0) {
957 *value = eq_rgamma;
958 if (use_yuv == YUV_CONVERSION_COMBINERS ||
959 use_yuv == YUV_CONVERSION_FRAGMENT) break; // not supported
960 } else if (strcasecmp(data, "red_gamma") == 0) {
961 *value = eq_rgamma;
962 if (use_yuv == YUV_CONVERSION_COMBINERS ||
963 use_yuv == YUV_CONVERSION_FRAGMENT) break; // not supported
964 } else if (strcasecmp(data, "green_gamma") == 0) {
965 *value = eq_ggamma;
966 if (use_yuv == YUV_CONVERSION_COMBINERS ||
967 use_yuv == YUV_CONVERSION_FRAGMENT) break; // not supported
968 } else if (strcasecmp(data, "blue_gamma") == 0) {
969 *value = eq_bgamma;
970 if (use_yuv == YUV_CONVERSION_COMBINERS ||
971 use_yuv == YUV_CONVERSION_FRAGMENT) break; // not supported
972 }
973 return VO_TRUE;
974 }
975 break;
976 case VOCTRL_SET_EQUALIZER:
977 if (image_format == IMGFMT_YV12) {
978 va_list va;
979 int value;
980 va_start(va, data);
981 value = va_arg(va, int);
982 va_end(va);
983 if (strcasecmp(data, "brightness") == 0) {
984 eq_bri = value;
985 if (use_yuv == YUV_CONVERSION_COMBINERS) break; // not supported
986 } else if (strcasecmp(data, "contrast") == 0) {
987 eq_cont = value;
988 if (use_yuv == YUV_CONVERSION_COMBINERS) break; // not supported
989 } else if (strcasecmp(data, "saturation") == 0) {
990 eq_sat = value;
991 } else if (strcasecmp(data, "hue") == 0) {
992 eq_hue = value;
993 } else if (strcasecmp(data, "gamma") == 0) {
994 eq_rgamma = eq_ggamma = eq_bgamma = value;
995 if (use_yuv == YUV_CONVERSION_COMBINERS ||
996 use_yuv == YUV_CONVERSION_FRAGMENT) break; // not supported
997 } else if (strcasecmp(data, "red_gamma") == 0) {
998 eq_rgamma = value;
999 if (use_yuv == YUV_CONVERSION_COMBINERS ||
1000 use_yuv == YUV_CONVERSION_FRAGMENT) break; // not supported
1001 } else if (strcasecmp(data, "green_gamma") == 0) {
1002 eq_ggamma = value;
1003 if (use_yuv == YUV_CONVERSION_COMBINERS ||
1004 use_yuv == YUV_CONVERSION_FRAGMENT) break; // not supported
1005 } else if (strcasecmp(data, "blue_gamma") == 0) {
1006 eq_bgamma = value;
1007 if (use_yuv == YUV_CONVERSION_COMBINERS ||
1008 use_yuv == YUV_CONVERSION_FRAGMENT) break; // not supported
1009 }
1010 update_yuvconv();
1011 return VO_TRUE;
1012 }
1013 break;
1014 case VOCTRL_UPDATE_SCREENINFO:
1015 update_xinerama_info();
1016 return VO_TRUE;
1017 }
1018 return VO_NOTIMPL;
1019 }