?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Replace some Hungarian comments, thanks to Denes Balatoni for the translation.
[mplayer/greg.git] / libvo / vo_gl.c
blob9b8e55fdd5f369665dcc727c7f6a51bb7f560caa
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 vo_info_t info =
23 {
24 "X11 (OpenGL)",
25 "gl",
26 "Arpad Gereoffy <arpi@esp-team.scene.hu>",
27 ""
28 };
29
30 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 if (WinID >= 0) {
469 vo_window = WinID ? (Window)WinID : mRootWin;
470 vo_x11_selectinput_witherr(mDisplay, vo_window,
471 StructureNotifyMask | KeyPressMask | PointerMotionMask |
472 ButtonPressMask | ButtonReleaseMask | ExposureMask);
473 goto glconfig;
474 }
475 {
476 XVisualInfo *vinfo=glXChooseVisual( mDisplay,mScreen,wsGLXAttrib );
477 if (vinfo == NULL)
478 {
479 mp_msg(MSGT_VO, MSGL_ERR, "[gl] no GLX support present\n");
480 return -1;
481 }
482
483 vo_x11_create_vo_window(vinfo, vo_dx, vo_dy, d_width, d_height, flags,
484 XCreateColormap(mDisplay, mRootWin, vinfo->visual, AllocNone),
485 "gl", title);
486 }
487 #endif
488
489 glconfig:
490 if (vo_config_count)
491 uninitGl();
492 setGlWindow(&gl_vinfo, &gl_context, vo_window);
493 initGl(vo_dwidth, vo_dheight);
494
495 return 0;
496 }
497
498 static void check_events(void)
499 {
500 int e=vo_check_events();
501 if(e&VO_EVENT_RESIZE) resize(vo_dwidth,vo_dheight);
502 if(e&VO_EVENT_EXPOSE && int_pause) flip_page();
503 }
504
505 /**
506 * Creates the textures and the display list needed for displaying
507 * an OSD part.
508 * Callback function for vo_draw_text().
509 */
510 static void create_osd_texture(int x0, int y0, int w, int h,
511 unsigned char *src, unsigned char *srca,
512 int stride)
513 {
514 // initialize to 8 to avoid special-casing on alignment
515 int sx = 8, sy = 8;
516 GLint scale_type = (scaled_osd) ? GL_LINEAR : GL_NEAREST;
517
518 if (w <= 0 || h <= 0 || stride < w) {
519 mp_msg(MSGT_VO, MSGL_V, "Invalid dimensions OSD for part!\n");
520 return;
521 }
522 texSize(w, h, &sx, &sy);
523
524 if (osdtexCnt >= MAX_OSD_PARTS) {
525 mp_msg(MSGT_VO, MSGL_ERR, "Too many OSD parts, contact the developers!\n");
526 return;
527 }
528
529 // create Textures for OSD part
530 glGenTextures(1, &osdtex[osdtexCnt]);
531 BindTexture(gl_target, osdtex[osdtexCnt]);
532 glCreateClearTex(gl_target, GL_LUMINANCE, scale_type, sx, sy, 0);
533 glUploadTex(gl_target, GL_LUMINANCE, GL_UNSIGNED_BYTE, src, stride,
534 0, 0, w, h, 0);
535
536 #ifndef FAST_OSD
537 glGenTextures(1, &osdatex[osdtexCnt]);
538 BindTexture(gl_target, osdatex[osdtexCnt]);
539 glCreateClearTex(gl_target, GL_ALPHA, scale_type, sx, sy, 255);
540 {
541 int i;
542 char *tmp = malloc(stride * h);
543 // convert alpha from weird MPlayer scale.
544 // in-place is not possible since it is reused for future OSDs
545 for (i = h * stride - 1; i >= 0; i--)
546 tmp[i] = srca[i] - 1;
547 glUploadTex(gl_target, GL_ALPHA, GL_UNSIGNED_BYTE, tmp, stride,
548 0, 0, w, h, 0);
549 free(tmp);
550 }
551 #endif
552
553 BindTexture(gl_target, 0);
554
555 // Create a list for rendering this OSD part
556 #ifndef FAST_OSD
557 osdaDispList[osdtexCnt] = glGenLists(1);
558 glNewList(osdaDispList[osdtexCnt], GL_COMPILE);
559 // render alpha
560 BindTexture(gl_target, osdatex[osdtexCnt]);
561 glDrawTex(x0, y0, w, h, 0, 0, w, h, sx, sy, use_rectangle == 1, 0, 0);
562 glEndList();
563 #endif
564 osdDispList[osdtexCnt] = glGenLists(1);
565 glNewList(osdDispList[osdtexCnt], GL_COMPILE);
566 // render OSD
567 BindTexture(gl_target, osdtex[osdtexCnt]);
568 glDrawTex(x0, y0, w, h, 0, 0, w, h, sx, sy, use_rectangle == 1, 0, 0);
569 glEndList();
570
571 osdtexCnt++;
572 }
573
574 static void draw_osd(void)
575 {
576 if (!use_osd) return;
577 if (vo_osd_changed(0)) {
578 int osd_h, osd_w;
579 clearOSD();
580 osd_w = (scaled_osd) ? image_width : vo_dwidth;
581 osd_h = (scaled_osd) ? image_height : vo_dheight;
582 vo_draw_text(osd_w, osd_h, create_osd_texture);
583 }
584 }
585
586 static void
587 flip_page(void)
588 {
589 // glEnable(GL_TEXTURE_2D);
590 // glBindTexture(GL_TEXTURE_2D, texture_id);
591
592 glColor3f(1,1,1);
593 if (image_format == IMGFMT_YV12)
594 glEnableYUVConversion(gl_target, yuvconvtype);
595 glDrawTex(0, 0, image_width, image_height,
596 0, 0, image_width, image_height,
597 texture_width, texture_height,
598 use_rectangle == 1, image_format == IMGFMT_YV12,
599 mpi_flipped ^ vo_flipped);
600 if (image_format == IMGFMT_YV12)
601 glDisableYUVConversion(gl_target, yuvconvtype);
602
603 if (osdtexCnt > 0 || eosdDispList) {
604 // set special rendering parameters
605 if (!scaled_osd) {
606 glMatrixMode(GL_PROJECTION);
607 glPushMatrix();
608 glLoadIdentity();
609 glOrtho(0, vo_dwidth, vo_dheight, 0, -1, 1);
610 }
611 glEnable(GL_BLEND);
612 if (eosdDispList) {
613 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
614 glCallList(eosdDispList);
615 }
616 if (osdtexCnt > 0) {
617 glColor4ub((osd_color >> 16) & 0xff, (osd_color >> 8) & 0xff, osd_color & 0xff, 0xff);
618 // draw OSD
619 #ifndef FAST_OSD
620 glBlendFunc(GL_ZERO, GL_SRC_ALPHA);
621 glCallLists(osdtexCnt, GL_UNSIGNED_INT, osdaDispList);
622 #endif
623 glBlendFunc(GL_ONE, GL_ONE);
624 glCallLists(osdtexCnt, GL_UNSIGNED_INT, osdDispList);
625 }
626 // set rendering parameters back to defaults
627 glDisable (GL_BLEND);
628 if (!scaled_osd)
629 glPopMatrix();
630 BindTexture(gl_target, 0);
631 }
632
633 if (use_glFinish)
634 glFinish();
635 if (vo_doublebuffering)
636 swapGlBuffers();
637 else if (!use_glFinish)
638 glFlush();
639
640 if (vo_fs && use_aspect && vo_doublebuffering)
641 glClear(GL_COLOR_BUFFER_BIT);
642 }
643
644 //static inline uint32_t draw_slice_x11(uint8_t *src[], uint32_t slice_num)
645 static int draw_slice(uint8_t *src[], int stride[], int w,int h,int x,int y)
646 {
647 mpi_flipped = (stride[0] < 0);
648 glUploadTex(gl_target, gl_format, gl_type, src[0], stride[0],
649 x, y, w, h, slice_height);
650 if (image_format == IMGFMT_YV12) {
651 ActiveTexture(GL_TEXTURE1);
652 glUploadTex(gl_target, gl_format, gl_type, src[1], stride[1],
653 x / 2, y / 2, w / 2, h / 2, slice_height);
654 ActiveTexture(GL_TEXTURE2);
655 glUploadTex(gl_target, gl_format, gl_type, src[2], stride[2],
656 x / 2, y / 2, w / 2, h / 2, slice_height);
657 ActiveTexture(GL_TEXTURE0);
658 }
659 return 0;
660 }
661
662 static uint32_t get_image(mp_image_t *mpi) {
663 if (!GenBuffers || !BindBuffer || !BufferData || !MapBuffer) {
664 if (!err_shown)
665 mp_msg(MSGT_VO, MSGL_ERR, "[gl] extensions missing for dr\n"
666 "Expect a _major_ speed penalty\n");
667 err_shown = 1;
668 return VO_FALSE;
669 }
670 if (mpi->flags & MP_IMGFLAG_READABLE) return VO_FALSE;
671 if (mpi->type == MP_IMGTYPE_IP || mpi->type == MP_IMGTYPE_IPB)
672 return VO_FALSE; // we can not provide readable buffers
673 if (!gl_buffer)
674 GenBuffers(1, &gl_buffer);
675 BindBuffer(GL_PIXEL_UNPACK_BUFFER, gl_buffer);
676 mpi->stride[0] = mpi->width * mpi->bpp / 8;
677 if (mpi->stride[0] * mpi->h > gl_buffersize) {
678 BufferData(GL_PIXEL_UNPACK_BUFFER, mpi->stride[0] * mpi->h,
679 NULL, GL_DYNAMIC_DRAW);
680 gl_buffersize = mpi->stride[0] * mpi->h;
681 }
682 if (!gl_bufferptr)
683 gl_bufferptr = MapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY);
684 mpi->planes[0] = gl_bufferptr;
685 BindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
686 if (mpi->planes[0] == NULL) {
687 if (!err_shown)
688 mp_msg(MSGT_VO, MSGL_ERR, "[gl] could not aquire buffer for dr\n"
689 "Expect a _major_ speed penalty\n");
690 err_shown = 1;
691 return VO_FALSE;
692 }
693 if (mpi->imgfmt == IMGFMT_YV12) {
694 // YV12
695 mpi->flags |= MP_IMGFLAG_COMMON_STRIDE | MP_IMGFLAG_COMMON_PLANE;
696 mpi->stride[0] = mpi->width;
697 mpi->planes[1] = mpi->planes[0] + mpi->stride[0] * mpi->height;
698 mpi->stride[1] = mpi->width >> 1;
699 mpi->planes[2] = mpi->planes[1] + mpi->stride[1] * (mpi->height >> 1);
700 mpi->stride[2] = mpi->width >> 1;
701 }
702 mpi->flags |= MP_IMGFLAG_DIRECT;
703 return VO_TRUE;
704 }
705
706 static uint32_t draw_image(mp_image_t *mpi) {
707 int slice = slice_height;
708 int stride[3] = {mpi->stride[0], mpi->stride[1], mpi->stride[2]};
709 unsigned char *planes[3] = {mpi->planes[0], mpi->planes[1], mpi->planes[2]};
710 if (mpi->flags & MP_IMGFLAG_DRAW_CALLBACK)
711 return VO_TRUE;
712 mpi_flipped = (stride[0] < 0);
713 if (mpi->flags & MP_IMGFLAG_DIRECT) {
714 intptr_t base = (intptr_t)planes[0];
715 if (mpi_flipped)
716 base += (mpi->h - 1) * stride[0];
717 planes[0] -= base;
718 planes[1] -= base;
719 planes[2] -= base;
720 BindBuffer(GL_PIXEL_UNPACK_BUFFER, gl_buffer);
721 UnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
722 gl_bufferptr = NULL;
723 slice = 0; // always "upload" full texture
724 }
725 glUploadTex(gl_target, gl_format, gl_type, planes[0], stride[0],
726 mpi->x, mpi->y, mpi->w, mpi->h, slice);
727 if (mpi->imgfmt == IMGFMT_YV12) {
728 ActiveTexture(GL_TEXTURE1);
729 glUploadTex(gl_target, gl_format, gl_type, planes[1], stride[1],
730 mpi->x / 2, mpi->y / 2, mpi->w / 2, mpi->h / 2, slice);
731 ActiveTexture(GL_TEXTURE2);
732 glUploadTex(gl_target, gl_format, gl_type, planes[2], stride[2],
733 mpi->x / 2, mpi->y / 2, mpi->w / 2, mpi->h / 2, slice);
734 ActiveTexture(GL_TEXTURE0);
735 }
736 if (mpi->flags & MP_IMGFLAG_DIRECT)
737 BindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
738 return VO_TRUE;
739 }
740
741 static int
742 draw_frame(uint8_t *src[])
743 {
744 return VO_ERROR;
745 }
746
747 static int
748 query_format(uint32_t format)
749 {
750 int caps = VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW |
751 VFCAP_FLIP |
752 VFCAP_HWSCALE_UP | VFCAP_HWSCALE_DOWN | VFCAP_ACCEPT_STRIDE;
753 if (use_osd)
754 caps |= VFCAP_OSD | VFCAP_EOSD | (scaled_osd ? 0 : VFCAP_EOSD_UNSCALED);
755 if ((format == IMGFMT_RGB24) || (format == IMGFMT_RGBA))
756 return caps;
757 if (use_yuv && format == IMGFMT_YV12)
758 return caps;
759 // HACK, otherwise we get only b&w with some filters (e.g. -vf eq)
760 // ideally MPlayer should be fixed instead not to use Y800 when it has the choice
761 if (!use_yuv && (format == IMGFMT_Y8 || format == IMGFMT_Y800))
762 return 0;
763 if (many_fmts &&
764 glFindFormat(format, NULL, NULL, NULL, NULL))
765 return caps;
766 return 0;
767 }
768
769
770 static void
771 uninit(void)
772 {
773 if ( !vo_config_count ) return;
774 uninitGl();
775 releaseGlContext(&gl_vinfo, &gl_context);
776 if (custom_prog) free(custom_prog);
777 custom_prog = NULL;
778 if (custom_tex) free(custom_tex);
779 custom_tex = NULL;
780 vo_uninit();
781 }
782
783 static opt_t subopts[] = {
784 {"manyfmts", OPT_ARG_BOOL, &many_fmts, NULL},
785 {"osd", OPT_ARG_BOOL, &use_osd, NULL},
786 {"scaled-osd", OPT_ARG_BOOL, &scaled_osd, NULL},
787 {"aspect", OPT_ARG_BOOL, &use_aspect, NULL},
788 {"slice-height", OPT_ARG_INT, &slice_height, (opt_test_f)int_non_neg},
789 {"rectangle", OPT_ARG_INT, &use_rectangle,(opt_test_f)int_non_neg},
790 {"yuv", OPT_ARG_INT, &use_yuv, (opt_test_f)int_non_neg},
791 {"lscale", OPT_ARG_INT, &lscale, (opt_test_f)int_non_neg},
792 {"cscale", OPT_ARG_INT, &cscale, (opt_test_f)int_non_neg},
793 {"glfinish", OPT_ARG_BOOL, &use_glFinish, NULL},
794 {"swapinterval", OPT_ARG_INT, &swap_interval,NULL},
795 {"customprog", OPT_ARG_MSTRZ,&custom_prog, NULL},
796 {"customtex", OPT_ARG_MSTRZ,&custom_tex, NULL},
797 {"customtlin", OPT_ARG_BOOL, &custom_tlin, NULL},
798 {"customtrect", OPT_ARG_BOOL, &custom_trect, NULL},
799 {"osdcolor", OPT_ARG_INT, &osd_color, NULL},
800 {NULL}
801 };
802
803 static int preinit(const char *arg)
804 {
805 // set defaults
806 many_fmts = 1;
807 use_osd = 1;
808 scaled_osd = 0;
809 use_aspect = 1;
810 use_yuv = 0;
811 lscale = 0;
812 cscale = 0;
813 use_rectangle = 0;
814 use_glFinish = 0;
815 swap_interval = 1;
816 slice_height = 0;
817 custom_prog = NULL;
818 custom_tex = NULL;
819 custom_tlin = 1;
820 custom_trect = 0;
821 osd_color = 0xffffff;
822 if (subopt_parse(arg, subopts) != 0) {
823 mp_msg(MSGT_VO, MSGL_FATAL,
824 "\n-vo gl command line help:\n"
825 "Example: mplayer -vo gl:slice-height=4\n"
826 "\nOptions:\n"
827 " nomanyfmts\n"
828 " Disable extended color formats for OpenGL 1.2 and later\n"
829 " slice-height=<0-...>\n"
830 " Slice size for texture transfer, 0 for whole image\n"
831 " noosd\n"
832 " Do not use OpenGL OSD code\n"
833 " noaspect\n"
834 " Do not do aspect scaling\n"
835 " rectangle=<0,1,2>\n"
836 " 0: use power-of-two textures\n"
837 " 1: use texture_rectangle\n"
838 " 2: use texture_non_power_of_two\n"
839 " glfinish\n"
840 " Call glFinish() before swapping buffers\n"
841 " swapinterval=<n>\n"
842 " Interval in displayed frames between to buffer swaps.\n"
843 " 1 is equivalent to enable VSYNC, 0 to disable VSYNC.\n"
844 " Requires GLX_SGI_swap_control support to work.\n"
845 " yuv=<n>\n"
846 " 0: use software YUV to RGB conversion.\n"
847 " 1: use register combiners (nVidia only, for older cards).\n"
848 " 2: use fragment program.\n"
849 " 3: use fragment program with gamma correction.\n"
850 " 4: use fragment program with gamma correction via lookup.\n"
851 " 5: use ATI-specific method (for older cards).\n"
852 " 6: use lookup via 3D texture.\n"
853 " lscale=<n>\n"
854 " 0: use standard bilinear scaling for luma.\n"
855 " 1: use improved bicubic scaling for luma.\n"
856 " 2: use cubic in X, linear in Y direction scaling for luma.\n"
857 " cscale=<n>\n"
858 " as lscale but for chroma (2x slower with little visible effect).\n"
859 " customprog=<filename>\n"
860 " use a custom YUV conversion program\n"
861 " customtex=<filename>\n"
862 " use a custom YUV conversion lookup texture\n"
863 " nocustomtlin\n"
864 " use GL_NEAREST scaling for customtex texture\n"
865 " customtrect\n"
866 " use texture_rectangle for customtex texture\n"
867 " osdcolor=<0xRRGGBB>\n"
868 " use the given color for the OSD\n"
869 "\n" );
870 return -1;
871 }
872 if (use_rectangle == 1)
873 gl_target = GL_TEXTURE_RECTANGLE;
874 else
875 gl_target = GL_TEXTURE_2D;
876 yuvconvtype = use_yuv | lscale << YUV_LUM_SCALER_SHIFT | cscale << YUV_CHROM_SCALER_SHIFT;
877 if (many_fmts)
878 mp_msg (MSGT_VO, MSGL_INFO, "[gl] using extended formats. "
879 "Use -vo gl:nomanyfmts if playback fails.\n");
880 mp_msg (MSGT_VO, MSGL_V, "[gl] Using %d as slice height "
881 "(0 means image height).\n", slice_height);
882 if( !vo_init() ) return -1; // Can't open X11
883
884 return 0;
885 }
886
887 static int control(uint32_t request, void *data, ...)
888 {
889 switch (request) {
890 case VOCTRL_PAUSE: return (int_pause=1);
891 case VOCTRL_RESUME: return (int_pause=0);
892 case VOCTRL_QUERY_FORMAT:
893 return query_format(*((uint32_t*)data));
894 case VOCTRL_GET_IMAGE:
895 return get_image(data);
896 case VOCTRL_DRAW_IMAGE:
897 return draw_image(data);
898 case VOCTRL_DRAW_EOSD:
899 if (!data)
900 return VO_FALSE;
901 genEOSD(data);
902 return VO_TRUE;
903 case VOCTRL_GET_EOSD_RES:
904 {
905 mp_eosd_res_t *r = data;
906 r->mt = r->mb = r->ml = r->mr = 0;
907 if (scaled_osd) {r->w = image_width; r->h = image_height;}
908 else if (vo_fs) {
909 r->w = vo_screenwidth; r->h = vo_screenheight;
910 r->ml = r->mr = ass_border_x;
911 r->mt = r->mb = ass_border_y;
912 } else {
913 r->w = vo_dwidth; r->h = vo_dheight;
914 }
915 }
916 return VO_TRUE;
917 case VOCTRL_GUISUPPORT:
918 return VO_TRUE;
919 case VOCTRL_ONTOP:
920 vo_ontop();
921 return VO_TRUE;
922 case VOCTRL_FULLSCREEN:
923 vo_fullscreen();
924 resize(vo_dwidth, vo_dheight);
925 return VO_TRUE;
926 #ifdef GL_WIN32
927 case VOCTRL_BORDER:
928 vo_w32_border();
929 return VO_TRUE;
930 #endif
931 case VOCTRL_GET_PANSCAN:
932 if (!use_aspect) return VO_NOTIMPL;
933 return VO_TRUE;
934 case VOCTRL_SET_PANSCAN:
935 if (!use_aspect) return VO_NOTIMPL;
936 resize (vo_dwidth, vo_dheight);
937 return VO_TRUE;
938 case VOCTRL_GET_EQUALIZER:
939 if (image_format == IMGFMT_YV12) {
940 va_list va;
941 int *value;
942 va_start(va, data);
943 value = va_arg(va, int *);
944 va_end(va);
945 if (strcasecmp(data, "brightness") == 0) {
946 *value = eq_bri;
947 if (use_yuv == YUV_CONVERSION_COMBINERS) break; // not supported
948 } else if (strcasecmp(data, "contrast") == 0) {
949 *value = eq_cont;
950 if (use_yuv == YUV_CONVERSION_COMBINERS) break; // not supported
951 } else if (strcasecmp(data, "saturation") == 0) {
952 *value = eq_sat;
953 } else if (strcasecmp(data, "hue") == 0) {
954 *value = eq_hue;
955 } else if (strcasecmp(data, "gamma") == 0) {
956 *value = eq_rgamma;
957 if (use_yuv == YUV_CONVERSION_COMBINERS ||
958 use_yuv == YUV_CONVERSION_FRAGMENT) break; // not supported
959 } else if (strcasecmp(data, "red_gamma") == 0) {
960 *value = eq_rgamma;
961 if (use_yuv == YUV_CONVERSION_COMBINERS ||
962 use_yuv == YUV_CONVERSION_FRAGMENT) break; // not supported
963 } else if (strcasecmp(data, "green_gamma") == 0) {
964 *value = eq_ggamma;
965 if (use_yuv == YUV_CONVERSION_COMBINERS ||
966 use_yuv == YUV_CONVERSION_FRAGMENT) break; // not supported
967 } else if (strcasecmp(data, "blue_gamma") == 0) {
968 *value = eq_bgamma;
969 if (use_yuv == YUV_CONVERSION_COMBINERS ||
970 use_yuv == YUV_CONVERSION_FRAGMENT) break; // not supported
971 }
972 return VO_TRUE;
973 }
974 break;
975 case VOCTRL_SET_EQUALIZER:
976 if (image_format == IMGFMT_YV12) {
977 va_list va;
978 int value;
979 va_start(va, data);
980 value = va_arg(va, int);
981 va_end(va);
982 if (strcasecmp(data, "brightness") == 0) {
983 eq_bri = value;
984 if (use_yuv == YUV_CONVERSION_COMBINERS) break; // not supported
985 } else if (strcasecmp(data, "contrast") == 0) {
986 eq_cont = value;
987 if (use_yuv == YUV_CONVERSION_COMBINERS) break; // not supported
988 } else if (strcasecmp(data, "saturation") == 0) {
989 eq_sat = value;
990 } else if (strcasecmp(data, "hue") == 0) {
991 eq_hue = value;
992 } else if (strcasecmp(data, "gamma") == 0) {
993 eq_rgamma = eq_ggamma = eq_bgamma = value;
994 if (use_yuv == YUV_CONVERSION_COMBINERS ||
995 use_yuv == YUV_CONVERSION_FRAGMENT) break; // not supported
996 } else if (strcasecmp(data, "red_gamma") == 0) {
997 eq_rgamma = value;
998 if (use_yuv == YUV_CONVERSION_COMBINERS ||
999 use_yuv == YUV_CONVERSION_FRAGMENT) break; // not supported
1000 } else if (strcasecmp(data, "green_gamma") == 0) {
1001 eq_ggamma = value;
1002 if (use_yuv == YUV_CONVERSION_COMBINERS ||
1003 use_yuv == YUV_CONVERSION_FRAGMENT) break; // not supported
1004 } else if (strcasecmp(data, "blue_gamma") == 0) {
1005 eq_bgamma = value;
1006 if (use_yuv == YUV_CONVERSION_COMBINERS ||
1007 use_yuv == YUV_CONVERSION_FRAGMENT) break; // not supported
1008 }
1009 update_yuvconv();
1010 return VO_TRUE;
1011 }
1012 break;
1013 case VOCTRL_UPDATE_SCREENINFO:
1014 update_xinerama_info();
1015 return VO_TRUE;
1016 }
1017 return VO_NOTIMPL;
1018 }